diff --git a/playground/kalman.html b/playground/kalman.html
new file mode 100644
index 000000000..b89ce40ec
--- /dev/null
+++ b/playground/kalman.html
@@ -0,0 +1,476 @@
+
+
+
+
+
+
tsb — Kalman Filter & State-Space Models
+
+
+
+
+
+
+
← Back to index
+
🔭 Kalman Filter & State-Space Models
+
+ Linear Gaussian state-space model — Kalman filter (forward pass) and
+ RTS smoother (backward pass). Mirrors statsmodels.tsa.statespace
+ and pykalman.KalmanFilter.
+
+
+
+
+
📐 The State-Space Model
+
+ A linear Gaussian SSM describes a latent state x_t and
+ observations y_t via two equations:
+
+
+ x_t = F · x_{t-1} + w_t, w_t ~ N(0, Q) (state transition)
+
+ F — state transition matrix (n_states × n_states)H — observation matrix (n_obs × n_states)Q — process noise covarianceR — observation noise covariancem_0, P_0 — initial state distribution
+
+ The Kalman filter computes filtered state
+ estimates x_{t|t} (posterior after seeing observation t).
+ The RTS smoother computes smoothed estimates
+ x_{t|T} using all T observations.
+
+
+
+
+
+
📈 Local-Level Model (Random Walk + Noise)
+
+ The simplest SSM: a hidden state that follows a random walk, observed
+ with noise. Perfect for denoising a noisy scalar time series or
+ estimating a slowly changing mean.
+
+
+
+
+
Click ▶ Run to execute
+
+
+
+
+
+
🔄 RTS Smoother — Filling Gaps Retrospectively
+
+ The filter only uses observations up to time t. The smoother uses
+ all observations to produce better estimates, especially for
+ time-steps near missing values. Smoothed uncertainty is always ≤ filtered.
+
+
+
+
+
Click ▶ Run to execute
+
+
+
+
+
+
📊 Local Linear Trend (Level + Slope)
+
+ A 2-state model: [level, slope]. The level increases by the
+ slope each step; both drift over time. Great for tracking slowly changing
+ trends with missing observations.
+
+
+
+
+
Click ▶ Run to execute
+
+
+
+
+
+
⚙️ Custom State-Space Model (AR(1) State)
+
+ Build your own model by specifying the four matrices directly.
+ Here: a state that follows an AR(1) process with coefficient 0.9.
+
+
+
+
+
Click ▶ Run to execute
+
+
+
+
+
+
🔢 Multi-Dimensional Observations
+
+ The Kalman filter naturally handles multi-dimensional observations.
+ Here: 2 sensors observing a single latent state.
+
+
+
+
+
Click ▶ Run to execute
+
+
+
+
+
+
📖 API Reference
+
+ KalmanFilter.localLevel(opts?) — random-walk + noise (1-D)KalmanFilter.localLinearTrend(opts?) — level + slope (2-D state)new KalmanFilter(opts) — custom F, H, Q, R, m0, P0kf.filter(observations) → KalmanFilterResultkf.smooth(observations) → KalmanSmootherResultkalmanFilter1D(obs, opts?) — scalar convenience wrapperkalmanSmooth1D(obs, opts?) — scalar smoother wrapperextractScalarMeans(means) — extract 1-D means arrayfilteredPredictionInterval(result, z?) → {lower, upper}
+
+ Missing observations: pass null in any observation row. The
+ filter skips the update step for that time-step (covariance grows).
+ The smoother retroactively interpolates using future observations.
+
+
+
+
+
+
diff --git a/playground/orc.html b/playground/orc.html
new file mode 100644
index 000000000..494d18e72
--- /dev/null
+++ b/playground/orc.html
@@ -0,0 +1,207 @@
+
+
+
+
+
+
tsb · ORC Format I/O
+
+
+
+
← tsb playground
+
ORC Format I/O
+
+ pandas.read_orc
+ DataFrame.to_orc
+
+
+ Apache ORC (Optimized Row Columnar) is a self-describing, type-aware columnar file format designed
+ for large-scale analytical workloads. tsb supports reading and writing ORC files with
+ NONE compression using RLE v1 integer encoding, direct float/double, and direct string encoding.
+
+
+
+ ℹ️ This playground runs entirely in-browser via a bundled tsb build. ORC buffers are created
+ in-memory — no file system access is required.
+
+
+
1 — Write & read a DataFrame
+
Create a DataFrame, serialize it to ORC bytes, then parse it back:
+
import { DataFrame, readOrc, toOrc } from "tsb";
+
+const df = DataFrame.fromColumns({
+ id: [1, 2, 3, 4, 5],
+ name: ["Alice", "Bob", "Carol", "Dave", "Eve"],
+ score: [95.5, 87.0, 92.3, 78.1, 99.9],
+ passed: [true, false, true, false, true],
+});
+
+// Serialize to binary ORC
+const buf = toOrc(df);
+console.log("ORC buffer size:", buf.length, "bytes");
+
+// Parse back
+const df2 = readOrc(buf);
+console.log(df2.toString());
+
▶ Run
+
Click "Run" to execute…
+
+
2 — Nullable columns
+
ORC natively supports null values via PRESENT streams:
+
import { DataFrame, readOrc, toOrc } from "tsb";
+
+const df = DataFrame.fromColumns({
+ x: [1, null, 3, null, 5],
+ name: ["a", null, "c", null, "e"],
+});
+
+const buf = toOrc(df);
+const rt = readOrc(buf);
+console.log("x values:", rt.col("x").values.join(", "));
+console.log("name values:", rt.col("name").values.join(", "));
+
▶ Run
+
Click "Run" to execute…
+
+
3 — Column selection
+
Use the columns option to read only a subset of columns:
+
import { DataFrame, readOrc, toOrc } from "tsb";
+
+const df = DataFrame.fromColumns({
+ a: [1, 2, 3],
+ b: ["x", "y", "z"],
+ c: [true, false, true],
+ d: [10.0, 20.0, 30.0],
+});
+
+const buf = toOrc(df);
+
+// Only read columns a and c
+const partial = readOrc(buf, { columns: ["a", "c"] });
+console.log("columns:", partial.columns.toArray().join(", "));
+console.log("a:", partial.col("a").values.join(", "));
+console.log("c:", partial.col("c").values.join(", "));
+
▶ Run
+
Click "Run" to execute…
+
+
4 — Large dataset benchmark
+
Serialize and parse a 10 000-row DataFrame to measure throughput:
+
import { DataFrame, readOrc, toOrc } from "tsb";
+
+const N = 10_000;
+const ids = Array.from({ length: N }, (_, i) => i);
+const names = Array.from({ length: N }, (_, i) => `user_${i}`);
+const scores = Array.from({ length: N }, () => Math.random() * 100);
+
+const df = DataFrame.fromColumns({ id: ids, name: names, score: scores });
+
+const t0 = performance.now();
+const buf = toOrc(df);
+const t1 = performance.now();
+const df2 = readOrc(buf);
+const t2 = performance.now();
+
+console.log(`Rows: ${df2.height}, Columns: ${df2.width}`);
+console.log(`ORC size: ${buf.length.toLocaleString()} bytes`);
+console.log(`Write: ${(t1 - t0).toFixed(1)} ms`);
+console.log(`Read: ${(t2 - t1).toFixed(1)} ms`);
+
▶ Run
+
Click "Run" to execute…
+
+
+
+
diff --git a/playground/signal.html b/playground/signal.html
new file mode 100644
index 000000000..cfc646c5e
--- /dev/null
+++ b/playground/signal.html
@@ -0,0 +1,621 @@
+
+
+
+
+
+
tsb — Signal Processing
+
+
+
+
+
+
+
Initializing playground…
+
+
+
← Back to roadmap
+
📡 Signal Processing — Interactive Playground
+
+ FFT, windows, STFT, Welch PSD, and periodogram — mirrors numpy.fft
+ and scipy.signal.Edit any code block below and press ▶ Run
+ (or Ctrl+Enter) to execute it live in your browser.
+
+
+
+
+
1. Basic FFT of a sinusoidal signal
+
Compute a 32 Hz sine wave's FFT and identify the peak frequency bin.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
2. Parseval's theorem — energy preservation
+
The total energy is preserved between time and frequency domains.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
3. RFFT round-trip
+
Real-input FFT produces a half-spectrum; irfft reconstructs the original signal.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
4. Window functions
+
Named windows reduce spectral leakage. Use getWindow(name, n) to obtain any built-in window.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
5. Short-Time Fourier Transform (STFT)
+
Analyze a chirp signal whose frequency increases linearly over time.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
6. ISTFT reconstruction (round-trip)
+
Invert an STFT back to the time domain. Interior reconstruction error should be near machine epsilon.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
7. Welch PSD — detect signal frequency
+
Welch's method averages periodograms of overlapping segments for a lower-variance PSD estimate.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
8. Periodogram
+
A single-segment PSD estimate — higher variance but simpler than Welch.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
9. fftshift / ifftshift
+
Rearrange the FFT output so that the zero-frequency component is in the centre.
+
+
+
+
+
Click ▶ Run to execute
+
Ctrl+Enter to run · Tab to indent
+
+
+
+
+
+
API Reference
+
+ Function Description Mirrors fft(x)N-point DFT (pads to power of 2) numpy.fft.fftifft(X)Inverse FFT numpy.fft.ifftrfft(x)Real-input FFT (one-sided) numpy.fft.rfftirfft(X, n?)Inverse real FFT numpy.fft.irfftfftFreq(n, d?)DFT sample frequencies numpy.fft.fftfreqrfftFreq(n, d?)One-sided DFT frequencies numpy.fft.rfftfreqfftshift(x)Shift DC to centre numpy.fft.fftshiftifftshift(x)Inverse of fftshift numpy.fft.ifftshiftgetWindow(name, n)Named window function scipy.signal.get_windowstft(x, opts?)Short-Time Fourier Transform scipy.signal.stftistft(Zxx, opts?)Inverse STFT (overlap-add) scipy.signal.istftwelch(x, opts?)Welch PSD estimate scipy.signal.welchperiodogram(x, opts?)Periodogram PSD estimate scipy.signal.periodogram
+
+
+
+
+
+
+
+
diff --git a/src/acoustics_sci/adaptation.ts b/src/acoustics_sci/adaptation.ts
new file mode 100644
index 000000000..e52a6045c
--- /dev/null
+++ b/src/acoustics_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci adaptation module — tsb analytics library. */
+export interface AcousticsSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciAdaptation(data: number[], opts: AcousticsSciAdaptationOptions = {}): AcousticsSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciAdaptation };
diff --git a/src/acoustics_sci/aggregation.ts b/src/acoustics_sci/aggregation.ts
new file mode 100644
index 000000000..835d83834
--- /dev/null
+++ b/src/acoustics_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci aggregation module — tsb analytics library. */
+export interface AcousticsSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciAggregationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciAggregation(data: number[], opts: AcousticsSciAggregationOptions = {}): AcousticsSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciAggregation };
diff --git a/src/acoustics_sci/algebra.ts b/src/acoustics_sci/algebra.ts
new file mode 100644
index 000000000..ef997ae4b
--- /dev/null
+++ b/src/acoustics_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci algebra module — tsb analytics library. */
+export interface AcousticsSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciAlgebra(data: number[], opts: AcousticsSciAlgebraOptions = {}): AcousticsSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciAlgebra };
diff --git a/src/acoustics_sci/alignment.ts b/src/acoustics_sci/alignment.ts
new file mode 100644
index 000000000..073ceb0a1
--- /dev/null
+++ b/src/acoustics_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci alignment module — tsb analytics library. */
+export interface AcousticsSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciAlignment(data: number[], opts: AcousticsSciAlignmentOptions = {}): AcousticsSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciAlignment };
diff --git a/src/acoustics_sci/analysis.ts b/src/acoustics_sci/analysis.ts
new file mode 100644
index 000000000..53d982eb9
--- /dev/null
+++ b/src/acoustics_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci analysis module — tsb analytics library. */
+export interface AcousticsSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciAnalysis(data: number[], opts: AcousticsSciAnalysisOptions = {}): AcousticsSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciAnalysis };
diff --git a/src/acoustics_sci/augmentation.ts b/src/acoustics_sci/augmentation.ts
new file mode 100644
index 000000000..e3fd13f48
--- /dev/null
+++ b/src/acoustics_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci augmentation module — tsb analytics library. */
+export interface AcousticsSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciAugmentation(data: number[], opts: AcousticsSciAugmentationOptions = {}): AcousticsSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciAugmentation };
diff --git a/src/acoustics_sci/bagging.ts b/src/acoustics_sci/bagging.ts
new file mode 100644
index 000000000..8460dc712
--- /dev/null
+++ b/src/acoustics_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci bagging module — tsb analytics library. */
+export interface AcousticsSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciBaggingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciBagging(data: number[], opts: AcousticsSciBaggingOptions = {}): AcousticsSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciBagging };
diff --git a/src/acoustics_sci/basis.ts b/src/acoustics_sci/basis.ts
new file mode 100644
index 000000000..e7a3c5c05
--- /dev/null
+++ b/src/acoustics_sci/basis.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci basis module — tsb analytics library. */
+export interface AcousticsSciBasisOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciBasisResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciBasis(data: number[], opts: AcousticsSciBasisOptions = {}): AcousticsSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciBasis };
diff --git a/src/acoustics_sci/benchmarking.ts b/src/acoustics_sci/benchmarking.ts
new file mode 100644
index 000000000..e15e444a4
--- /dev/null
+++ b/src/acoustics_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci benchmarking module — tsb analytics library. */
+export interface AcousticsSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciBenchmarking(data: number[], opts: AcousticsSciBenchmarkingOptions = {}): AcousticsSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciBenchmarking };
diff --git a/src/acoustics_sci/blending.ts b/src/acoustics_sci/blending.ts
new file mode 100644
index 000000000..630ae2c45
--- /dev/null
+++ b/src/acoustics_sci/blending.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci blending module — tsb analytics library. */
+export interface AcousticsSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciBlendingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciBlending(data: number[], opts: AcousticsSciBlendingOptions = {}): AcousticsSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciBlending };
diff --git a/src/acoustics_sci/boosting.ts b/src/acoustics_sci/boosting.ts
new file mode 100644
index 000000000..ffe4ee5d8
--- /dev/null
+++ b/src/acoustics_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci boosting module — tsb analytics library. */
+export interface AcousticsSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciBoostingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciBoosting(data: number[], opts: AcousticsSciBoostingOptions = {}): AcousticsSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciBoosting };
diff --git a/src/acoustics_sci/bootstrap.ts b/src/acoustics_sci/bootstrap.ts
new file mode 100644
index 000000000..72fac3b4e
--- /dev/null
+++ b/src/acoustics_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci bootstrap module — tsb analytics library. */
+export interface AcousticsSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciBootstrap(data: number[], opts: AcousticsSciBootstrapOptions = {}): AcousticsSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciBootstrap };
diff --git a/src/acoustics_sci/calculus.ts b/src/acoustics_sci/calculus.ts
new file mode 100644
index 000000000..182633b69
--- /dev/null
+++ b/src/acoustics_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci calculus module — tsb analytics library. */
+export interface AcousticsSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciCalculusResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciCalculus(data: number[], opts: AcousticsSciCalculusOptions = {}): AcousticsSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciCalculus };
diff --git a/src/acoustics_sci/calibration.ts b/src/acoustics_sci/calibration.ts
new file mode 100644
index 000000000..7c73e5e9b
--- /dev/null
+++ b/src/acoustics_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci calibration module — tsb analytics library. */
+export interface AcousticsSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciCalibration(data: number[], opts: AcousticsSciCalibrationOptions = {}): AcousticsSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciCalibration };
diff --git a/src/acoustics_sci/characterization.ts b/src/acoustics_sci/characterization.ts
new file mode 100644
index 000000000..d48885e33
--- /dev/null
+++ b/src/acoustics_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci characterization module — tsb analytics library. */
+export interface AcousticsSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciCharacterization(data: number[], opts: AcousticsSciCharacterizationOptions = {}): AcousticsSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciCharacterization };
diff --git a/src/acoustics_sci/classification.ts b/src/acoustics_sci/classification.ts
new file mode 100644
index 000000000..5c9e952e9
--- /dev/null
+++ b/src/acoustics_sci/classification.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci classification module — tsb analytics library. */
+export interface AcousticsSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciClassificationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciClassification(data: number[], opts: AcousticsSciClassificationOptions = {}): AcousticsSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciClassification };
diff --git a/src/acoustics_sci/clustering.ts b/src/acoustics_sci/clustering.ts
new file mode 100644
index 000000000..ceff9576c
--- /dev/null
+++ b/src/acoustics_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci clustering module — tsb analytics library. */
+export interface AcousticsSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciClusteringResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciClustering(data: number[], opts: AcousticsSciClusteringOptions = {}): AcousticsSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciClustering };
diff --git a/src/acoustics_sci/compression.ts b/src/acoustics_sci/compression.ts
new file mode 100644
index 000000000..dbe0d11da
--- /dev/null
+++ b/src/acoustics_sci/compression.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci compression module — tsb analytics library. */
+export interface AcousticsSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciCompressionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciCompression(data: number[], opts: AcousticsSciCompressionOptions = {}): AcousticsSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciCompression };
diff --git a/src/acoustics_sci/continuous.ts b/src/acoustics_sci/continuous.ts
new file mode 100644
index 000000000..98ee50848
--- /dev/null
+++ b/src/acoustics_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci continuous module — tsb analytics library. */
+export interface AcousticsSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciContinuousResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciContinuous(data: number[], opts: AcousticsSciContinuousOptions = {}): AcousticsSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciContinuous };
diff --git a/src/acoustics_sci/control.ts b/src/acoustics_sci/control.ts
new file mode 100644
index 000000000..af3cfa453
--- /dev/null
+++ b/src/acoustics_sci/control.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci control module — tsb analytics library. */
+export interface AcousticsSciControlOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciControlResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciControl(data: number[], opts: AcousticsSciControlOptions = {}): AcousticsSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciControl };
diff --git a/src/acoustics_sci/convergence.ts b/src/acoustics_sci/convergence.ts
new file mode 100644
index 000000000..b81067a94
--- /dev/null
+++ b/src/acoustics_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci convergence module — tsb analytics library. */
+export interface AcousticsSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciConvergence(data: number[], opts: AcousticsSciConvergenceOptions = {}): AcousticsSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciConvergence };
diff --git a/src/acoustics_sci/convex.ts b/src/acoustics_sci/convex.ts
new file mode 100644
index 000000000..10df33174
--- /dev/null
+++ b/src/acoustics_sci/convex.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci convex module — tsb analytics library. */
+export interface AcousticsSciConvexOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciConvexResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciConvex(data: number[], opts: AcousticsSciConvexOptions = {}): AcousticsSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciConvex };
diff --git a/src/acoustics_sci/correlation.ts b/src/acoustics_sci/correlation.ts
new file mode 100644
index 000000000..6108abfbb
--- /dev/null
+++ b/src/acoustics_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci correlation module — tsb analytics library. */
+export interface AcousticsSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciCorrelation(data: number[], opts: AcousticsSciCorrelationOptions = {}): AcousticsSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciCorrelation };
diff --git a/src/acoustics_sci/covariance.ts b/src/acoustics_sci/covariance.ts
new file mode 100644
index 000000000..00500f566
--- /dev/null
+++ b/src/acoustics_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci covariance module — tsb analytics library. */
+export interface AcousticsSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciCovariance(data: number[], opts: AcousticsSciCovarianceOptions = {}): AcousticsSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciCovariance };
diff --git a/src/acoustics_sci/cross_validation.ts b/src/acoustics_sci/cross_validation.ts
new file mode 100644
index 000000000..868cab731
--- /dev/null
+++ b/src/acoustics_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci cross_validation module — tsb analytics library. */
+export interface AcousticsSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciCrossValidation(data: number[], opts: AcousticsSciCrossValidationOptions = {}): AcousticsSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciCrossValidation };
diff --git a/src/acoustics_sci/decoding.ts b/src/acoustics_sci/decoding.ts
new file mode 100644
index 000000000..d1e71ca7c
--- /dev/null
+++ b/src/acoustics_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci decoding module — tsb analytics library. */
+export interface AcousticsSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDecodingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDecoding(data: number[], opts: AcousticsSciDecodingOptions = {}): AcousticsSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDecoding };
diff --git a/src/acoustics_sci/decomposition.ts b/src/acoustics_sci/decomposition.ts
new file mode 100644
index 000000000..c7970448c
--- /dev/null
+++ b/src/acoustics_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci decomposition module — tsb analytics library. */
+export interface AcousticsSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDecomposition(data: number[], opts: AcousticsSciDecompositionOptions = {}): AcousticsSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDecomposition };
diff --git a/src/acoustics_sci/detection.ts b/src/acoustics_sci/detection.ts
new file mode 100644
index 000000000..418e359ba
--- /dev/null
+++ b/src/acoustics_sci/detection.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci detection module — tsb analytics library. */
+export interface AcousticsSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDetectionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDetection(data: number[], opts: AcousticsSciDetectionOptions = {}): AcousticsSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDetection };
diff --git a/src/acoustics_sci/deterministic.ts b/src/acoustics_sci/deterministic.ts
new file mode 100644
index 000000000..eb6987fdd
--- /dev/null
+++ b/src/acoustics_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci deterministic module — tsb analytics library. */
+export interface AcousticsSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDeterministic(data: number[], opts: AcousticsSciDeterministicOptions = {}): AcousticsSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDeterministic };
diff --git a/src/acoustics_sci/diagnostics.ts b/src/acoustics_sci/diagnostics.ts
new file mode 100644
index 000000000..94b55fc89
--- /dev/null
+++ b/src/acoustics_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci diagnostics module — tsb analytics library. */
+export interface AcousticsSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDiagnostics(data: number[], opts: AcousticsSciDiagnosticsOptions = {}): AcousticsSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDiagnostics };
diff --git a/src/acoustics_sci/differential.ts b/src/acoustics_sci/differential.ts
new file mode 100644
index 000000000..1db92baf9
--- /dev/null
+++ b/src/acoustics_sci/differential.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci differential module — tsb analytics library. */
+export interface AcousticsSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDifferential(data: number[], opts: AcousticsSciDifferentialOptions = {}): AcousticsSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDifferential };
diff --git a/src/acoustics_sci/discrete.ts b/src/acoustics_sci/discrete.ts
new file mode 100644
index 000000000..ee454a246
--- /dev/null
+++ b/src/acoustics_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci discrete module — tsb analytics library. */
+export interface AcousticsSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDiscrete(data: number[], opts: AcousticsSciDiscreteOptions = {}): AcousticsSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDiscrete };
diff --git a/src/acoustics_sci/distribution.ts b/src/acoustics_sci/distribution.ts
new file mode 100644
index 000000000..00e618ef0
--- /dev/null
+++ b/src/acoustics_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci distribution module — tsb analytics library. */
+export interface AcousticsSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDistributionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDistribution(data: number[], opts: AcousticsSciDistributionOptions = {}): AcousticsSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDistribution };
diff --git a/src/acoustics_sci/dynamic.ts b/src/acoustics_sci/dynamic.ts
new file mode 100644
index 000000000..af3ff50c0
--- /dev/null
+++ b/src/acoustics_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci dynamic module — tsb analytics library. */
+export interface AcousticsSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciDynamicResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciDynamic(data: number[], opts: AcousticsSciDynamicOptions = {}): AcousticsSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciDynamic };
diff --git a/src/acoustics_sci/embedding.ts b/src/acoustics_sci/embedding.ts
new file mode 100644
index 000000000..d48c013d1
--- /dev/null
+++ b/src/acoustics_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci embedding module — tsb analytics library. */
+export interface AcousticsSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciEmbedding(data: number[], opts: AcousticsSciEmbeddingOptions = {}): AcousticsSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciEmbedding };
diff --git a/src/acoustics_sci/encoding.ts b/src/acoustics_sci/encoding.ts
new file mode 100644
index 000000000..e50e3db3c
--- /dev/null
+++ b/src/acoustics_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci encoding module — tsb analytics library. */
+export interface AcousticsSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciEncodingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciEncoding(data: number[], opts: AcousticsSciEncodingOptions = {}): AcousticsSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciEncoding };
diff --git a/src/acoustics_sci/ensemble.ts b/src/acoustics_sci/ensemble.ts
new file mode 100644
index 000000000..87a19c44b
--- /dev/null
+++ b/src/acoustics_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci ensemble module — tsb analytics library. */
+export interface AcousticsSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciEnsemble(data: number[], opts: AcousticsSciEnsembleOptions = {}): AcousticsSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciEnsemble };
diff --git a/src/acoustics_sci/estimation.ts b/src/acoustics_sci/estimation.ts
new file mode 100644
index 000000000..48ba571b5
--- /dev/null
+++ b/src/acoustics_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci estimation module — tsb analytics library. */
+export interface AcousticsSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciEstimationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciEstimation(data: number[], opts: AcousticsSciEstimationOptions = {}): AcousticsSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciEstimation };
diff --git a/src/acoustics_sci/evaluation.ts b/src/acoustics_sci/evaluation.ts
new file mode 100644
index 000000000..ce80bd9b6
--- /dev/null
+++ b/src/acoustics_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci evaluation module — tsb analytics library. */
+export interface AcousticsSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciEvaluation(data: number[], opts: AcousticsSciEvaluationOptions = {}): AcousticsSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciEvaluation };
diff --git a/src/acoustics_sci/extrapolation.ts b/src/acoustics_sci/extrapolation.ts
new file mode 100644
index 000000000..c54b05200
--- /dev/null
+++ b/src/acoustics_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci extrapolation module — tsb analytics library. */
+export interface AcousticsSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciExtrapolation(data: number[], opts: AcousticsSciExtrapolationOptions = {}): AcousticsSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciExtrapolation };
diff --git a/src/acoustics_sci/features.ts b/src/acoustics_sci/features.ts
new file mode 100644
index 000000000..e74d90ac0
--- /dev/null
+++ b/src/acoustics_sci/features.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci features module — tsb analytics library. */
+export interface AcousticsSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciFeatures(data: number[], opts: AcousticsSciFeaturesOptions = {}): AcousticsSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciFeatures };
diff --git a/src/acoustics_sci/feedback.ts b/src/acoustics_sci/feedback.ts
new file mode 100644
index 000000000..54f443d98
--- /dev/null
+++ b/src/acoustics_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci feedback module — tsb analytics library. */
+export interface AcousticsSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciFeedback(data: number[], opts: AcousticsSciFeedbackOptions = {}): AcousticsSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciFeedback };
diff --git a/src/acoustics_sci/filtering.ts b/src/acoustics_sci/filtering.ts
new file mode 100644
index 000000000..f874acc15
--- /dev/null
+++ b/src/acoustics_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci filtering module — tsb analytics library. */
+export interface AcousticsSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciFilteringResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciFiltering(data: number[], opts: AcousticsSciFilteringOptions = {}): AcousticsSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciFiltering };
diff --git a/src/acoustics_sci/fourier.ts b/src/acoustics_sci/fourier.ts
new file mode 100644
index 000000000..218dfc6b6
--- /dev/null
+++ b/src/acoustics_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci fourier module — tsb analytics library. */
+export interface AcousticsSciFourierOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciFourierResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciFourier(data: number[], opts: AcousticsSciFourierOptions = {}): AcousticsSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciFourier };
diff --git a/src/acoustics_sci/fusion.ts b/src/acoustics_sci/fusion.ts
new file mode 100644
index 000000000..3c0173761
--- /dev/null
+++ b/src/acoustics_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci fusion module — tsb analytics library. */
+export interface AcousticsSciFusionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciFusionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciFusion(data: number[], opts: AcousticsSciFusionOptions = {}): AcousticsSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciFusion };
diff --git a/src/acoustics_sci/generation.ts b/src/acoustics_sci/generation.ts
new file mode 100644
index 000000000..4be58aa0f
--- /dev/null
+++ b/src/acoustics_sci/generation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci generation module — tsb analytics library. */
+export interface AcousticsSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciGenerationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciGeneration(data: number[], opts: AcousticsSciGenerationOptions = {}): AcousticsSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciGeneration };
diff --git a/src/acoustics_sci/geometry.ts b/src/acoustics_sci/geometry.ts
new file mode 100644
index 000000000..5e3705e4c
--- /dev/null
+++ b/src/acoustics_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci geometry module — tsb analytics library. */
+export interface AcousticsSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciGeometryResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciGeometry(data: number[], opts: AcousticsSciGeometryOptions = {}): AcousticsSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciGeometry };
diff --git a/src/acoustics_sci/gradient.ts b/src/acoustics_sci/gradient.ts
new file mode 100644
index 000000000..802b49f89
--- /dev/null
+++ b/src/acoustics_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci gradient module — tsb analytics library. */
+export interface AcousticsSciGradientOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciGradientResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciGradient(data: number[], opts: AcousticsSciGradientOptions = {}): AcousticsSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciGradient };
diff --git a/src/acoustics_sci/hessian.ts b/src/acoustics_sci/hessian.ts
new file mode 100644
index 000000000..f603e3393
--- /dev/null
+++ b/src/acoustics_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci hessian module — tsb analytics library. */
+export interface AcousticsSciHessianOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciHessianResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciHessian(data: number[], opts: AcousticsSciHessianOptions = {}): AcousticsSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciHessian };
diff --git a/src/acoustics_sci/hypothesis.ts b/src/acoustics_sci/hypothesis.ts
new file mode 100644
index 000000000..66dac1667
--- /dev/null
+++ b/src/acoustics_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci hypothesis module — tsb analytics library. */
+export interface AcousticsSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciHypothesis(data: number[], opts: AcousticsSciHypothesisOptions = {}): AcousticsSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciHypothesis };
diff --git a/src/acoustics_sci/inference.ts b/src/acoustics_sci/inference.ts
new file mode 100644
index 000000000..32c0ae4c9
--- /dev/null
+++ b/src/acoustics_sci/inference.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci inference module — tsb analytics library. */
+export interface AcousticsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciInference(data: number[], opts: AcousticsSciInferenceOptions = {}): AcousticsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciInference };
diff --git a/src/acoustics_sci/inference2.ts b/src/acoustics_sci/inference2.ts
new file mode 100644
index 000000000..74e17068b
--- /dev/null
+++ b/src/acoustics_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci inference2 module — tsb analytics library. */
+export interface AcousticsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciInference(data: number[], opts: AcousticsSciInferenceOptions = {}): AcousticsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciInference };
diff --git a/src/acoustics_sci/integral.ts b/src/acoustics_sci/integral.ts
new file mode 100644
index 000000000..7db76ed95
--- /dev/null
+++ b/src/acoustics_sci/integral.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci integral module — tsb analytics library. */
+export interface AcousticsSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciIntegralResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciIntegral(data: number[], opts: AcousticsSciIntegralOptions = {}): AcousticsSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciIntegral };
diff --git a/src/acoustics_sci/integration.ts b/src/acoustics_sci/integration.ts
new file mode 100644
index 000000000..e75b553f6
--- /dev/null
+++ b/src/acoustics_sci/integration.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci integration module — tsb analytics library. */
+export interface AcousticsSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciIntegration(data: number[], opts: AcousticsSciIntegrationOptions = {}): AcousticsSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciIntegration };
diff --git a/src/acoustics_sci/interpolation.ts b/src/acoustics_sci/interpolation.ts
new file mode 100644
index 000000000..082c95e73
--- /dev/null
+++ b/src/acoustics_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci interpolation module — tsb analytics library. */
+export interface AcousticsSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciInterpolation(data: number[], opts: AcousticsSciInterpolationOptions = {}): AcousticsSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciInterpolation };
diff --git a/src/acoustics_sci/jacobian.ts b/src/acoustics_sci/jacobian.ts
new file mode 100644
index 000000000..da5e123b3
--- /dev/null
+++ b/src/acoustics_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci jacobian module — tsb analytics library. */
+export interface AcousticsSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciJacobianResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciJacobian(data: number[], opts: AcousticsSciJacobianOptions = {}): AcousticsSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciJacobian };
diff --git a/src/acoustics_sci/kernel.ts b/src/acoustics_sci/kernel.ts
new file mode 100644
index 000000000..4dc256da9
--- /dev/null
+++ b/src/acoustics_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci kernel module — tsb analytics library. */
+export interface AcousticsSciKernelOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciKernelResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciKernel(data: number[], opts: AcousticsSciKernelOptions = {}): AcousticsSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciKernel };
diff --git a/src/acoustics_sci/laplacian.ts b/src/acoustics_sci/laplacian.ts
new file mode 100644
index 000000000..22d5c4f49
--- /dev/null
+++ b/src/acoustics_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci laplacian module — tsb analytics library. */
+export interface AcousticsSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciLaplacian(data: number[], opts: AcousticsSciLaplacianOptions = {}): AcousticsSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciLaplacian };
diff --git a/src/acoustics_sci/learning.ts b/src/acoustics_sci/learning.ts
new file mode 100644
index 000000000..7326ca618
--- /dev/null
+++ b/src/acoustics_sci/learning.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci learning module — tsb analytics library. */
+export interface AcousticsSciLearningOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciLearningResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciLearning(data: number[], opts: AcousticsSciLearningOptions = {}): AcousticsSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciLearning };
diff --git a/src/acoustics_sci/linear.ts b/src/acoustics_sci/linear.ts
new file mode 100644
index 000000000..7f41081de
--- /dev/null
+++ b/src/acoustics_sci/linear.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci linear module — tsb analytics library. */
+export interface AcousticsSciLinearOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciLinearResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciLinear(data: number[], opts: AcousticsSciLinearOptions = {}): AcousticsSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciLinear };
diff --git a/src/acoustics_sci/manifold.ts b/src/acoustics_sci/manifold.ts
new file mode 100644
index 000000000..f130d1eeb
--- /dev/null
+++ b/src/acoustics_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci manifold module — tsb analytics library. */
+export interface AcousticsSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciManifoldResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciManifold(data: number[], opts: AcousticsSciManifoldOptions = {}): AcousticsSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciManifold };
diff --git a/src/acoustics_sci/matching.ts b/src/acoustics_sci/matching.ts
new file mode 100644
index 000000000..b4454d782
--- /dev/null
+++ b/src/acoustics_sci/matching.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci matching module — tsb analytics library. */
+export interface AcousticsSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciMatchingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciMatching(data: number[], opts: AcousticsSciMatchingOptions = {}): AcousticsSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciMatching };
diff --git a/src/acoustics_sci/measurement.ts b/src/acoustics_sci/measurement.ts
new file mode 100644
index 000000000..6622a897d
--- /dev/null
+++ b/src/acoustics_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci measurement module — tsb analytics library. */
+export interface AcousticsSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciMeasurement(data: number[], opts: AcousticsSciMeasurementOptions = {}): AcousticsSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciMeasurement };
diff --git a/src/acoustics_sci/metrics.ts b/src/acoustics_sci/metrics.ts
new file mode 100644
index 000000000..1ce03e07c
--- /dev/null
+++ b/src/acoustics_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci metrics module — tsb analytics library. */
+export interface AcousticsSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciMetricsResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciMetrics(data: number[], opts: AcousticsSciMetricsOptions = {}): AcousticsSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciMetrics };
diff --git a/src/acoustics_sci/modeling.ts b/src/acoustics_sci/modeling.ts
new file mode 100644
index 000000000..45b819b7a
--- /dev/null
+++ b/src/acoustics_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci modeling module — tsb analytics library. */
+export interface AcousticsSciModelingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciModelingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciModeling(data: number[], opts: AcousticsSciModelingOptions = {}): AcousticsSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciModeling };
diff --git a/src/acoustics_sci/monitoring.ts b/src/acoustics_sci/monitoring.ts
new file mode 100644
index 000000000..c10357213
--- /dev/null
+++ b/src/acoustics_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci monitoring module — tsb analytics library. */
+export interface AcousticsSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciMonitoring(data: number[], opts: AcousticsSciMonitoringOptions = {}): AcousticsSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciMonitoring };
diff --git a/src/acoustics_sci/nonlinear.ts b/src/acoustics_sci/nonlinear.ts
new file mode 100644
index 000000000..24347cd99
--- /dev/null
+++ b/src/acoustics_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci nonlinear module — tsb analytics library. */
+export interface AcousticsSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciNonlinear(data: number[], opts: AcousticsSciNonlinearOptions = {}): AcousticsSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciNonlinear };
diff --git a/src/acoustics_sci/normalization.ts b/src/acoustics_sci/normalization.ts
new file mode 100644
index 000000000..468381489
--- /dev/null
+++ b/src/acoustics_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci normalization module — tsb analytics library. */
+export interface AcousticsSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciNormalization(data: number[], opts: AcousticsSciNormalizationOptions = {}): AcousticsSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciNormalization };
diff --git a/src/acoustics_sci/optimization.ts b/src/acoustics_sci/optimization.ts
new file mode 100644
index 000000000..6ef0b29e6
--- /dev/null
+++ b/src/acoustics_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci optimization module — tsb analytics library. */
+export interface AcousticsSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciOptimization(data: number[], opts: AcousticsSciOptimizationOptions = {}): AcousticsSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciOptimization };
diff --git a/src/acoustics_sci/patterns.ts b/src/acoustics_sci/patterns.ts
new file mode 100644
index 000000000..fc53a9769
--- /dev/null
+++ b/src/acoustics_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci patterns module — tsb analytics library. */
+export interface AcousticsSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciPatternsResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciPatterns(data: number[], opts: AcousticsSciPatternsOptions = {}): AcousticsSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciPatterns };
diff --git a/src/acoustics_sci/permutation.ts b/src/acoustics_sci/permutation.ts
new file mode 100644
index 000000000..6d654c458
--- /dev/null
+++ b/src/acoustics_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci permutation module — tsb analytics library. */
+export interface AcousticsSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciPermutationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciPermutation(data: number[], opts: AcousticsSciPermutationOptions = {}): AcousticsSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciPermutation };
diff --git a/src/acoustics_sci/prediction.ts b/src/acoustics_sci/prediction.ts
new file mode 100644
index 000000000..7c0e2ef90
--- /dev/null
+++ b/src/acoustics_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci prediction module — tsb analytics library. */
+export interface AcousticsSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciPredictionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciPrediction(data: number[], opts: AcousticsSciPredictionOptions = {}): AcousticsSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciPrediction };
diff --git a/src/acoustics_sci/processing.ts b/src/acoustics_sci/processing.ts
new file mode 100644
index 000000000..2ae11fe88
--- /dev/null
+++ b/src/acoustics_sci/processing.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci processing module — tsb analytics library. */
+export interface AcousticsSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciProcessingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciProcessing(data: number[], opts: AcousticsSciProcessingOptions = {}): AcousticsSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciProcessing };
diff --git a/src/acoustics_sci/profiling.ts b/src/acoustics_sci/profiling.ts
new file mode 100644
index 000000000..7456dcf9b
--- /dev/null
+++ b/src/acoustics_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci profiling module — tsb analytics library. */
+export interface AcousticsSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciProfilingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciProfiling(data: number[], opts: AcousticsSciProfilingOptions = {}): AcousticsSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciProfiling };
diff --git a/src/acoustics_sci/projection.ts b/src/acoustics_sci/projection.ts
new file mode 100644
index 000000000..12b63163c
--- /dev/null
+++ b/src/acoustics_sci/projection.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci projection module — tsb analytics library. */
+export interface AcousticsSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciProjectionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciProjection(data: number[], opts: AcousticsSciProjectionOptions = {}): AcousticsSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciProjection };
diff --git a/src/acoustics_sci/ranking.ts b/src/acoustics_sci/ranking.ts
new file mode 100644
index 000000000..1d25e2b51
--- /dev/null
+++ b/src/acoustics_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci ranking module — tsb analytics library. */
+export interface AcousticsSciRankingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciRankingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciRanking(data: number[], opts: AcousticsSciRankingOptions = {}): AcousticsSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciRanking };
diff --git a/src/acoustics_sci/reconstruction.ts b/src/acoustics_sci/reconstruction.ts
new file mode 100644
index 000000000..12026bfce
--- /dev/null
+++ b/src/acoustics_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci reconstruction module — tsb analytics library. */
+export interface AcousticsSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciReconstruction(data: number[], opts: AcousticsSciReconstructionOptions = {}): AcousticsSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciReconstruction };
diff --git a/src/acoustics_sci/registration.ts b/src/acoustics_sci/registration.ts
new file mode 100644
index 000000000..1e3397655
--- /dev/null
+++ b/src/acoustics_sci/registration.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci registration module — tsb analytics library. */
+export interface AcousticsSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciRegistration(data: number[], opts: AcousticsSciRegistrationOptions = {}): AcousticsSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciRegistration };
diff --git a/src/acoustics_sci/regression.ts b/src/acoustics_sci/regression.ts
new file mode 100644
index 000000000..93aad0981
--- /dev/null
+++ b/src/acoustics_sci/regression.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci regression module — tsb analytics library. */
+export interface AcousticsSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciRegressionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciRegression(data: number[], opts: AcousticsSciRegressionOptions = {}): AcousticsSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciRegression };
diff --git a/src/acoustics_sci/regularization.ts b/src/acoustics_sci/regularization.ts
new file mode 100644
index 000000000..d79907b47
--- /dev/null
+++ b/src/acoustics_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci regularization module — tsb analytics library. */
+export interface AcousticsSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciRegularization(data: number[], opts: AcousticsSciRegularizationOptions = {}): AcousticsSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciRegularization };
diff --git a/src/acoustics_sci/robustness.ts b/src/acoustics_sci/robustness.ts
new file mode 100644
index 000000000..8a30201e8
--- /dev/null
+++ b/src/acoustics_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci robustness module — tsb analytics library. */
+export interface AcousticsSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciRobustness(data: number[], opts: AcousticsSciRobustnessOptions = {}): AcousticsSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciRobustness };
diff --git a/src/acoustics_sci/sampling.ts b/src/acoustics_sci/sampling.ts
new file mode 100644
index 000000000..990a3ac36
--- /dev/null
+++ b/src/acoustics_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci sampling module — tsb analytics library. */
+export interface AcousticsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciSampling(data: number[], opts: AcousticsSciSamplingOptions = {}): AcousticsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciSampling };
diff --git a/src/acoustics_sci/sampling2.ts b/src/acoustics_sci/sampling2.ts
new file mode 100644
index 000000000..3e5996cc2
--- /dev/null
+++ b/src/acoustics_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci sampling2 module — tsb analytics library. */
+export interface AcousticsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciSampling(data: number[], opts: AcousticsSciSamplingOptions = {}): AcousticsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciSampling };
diff --git a/src/acoustics_sci/scaling.ts b/src/acoustics_sci/scaling.ts
new file mode 100644
index 000000000..33b631394
--- /dev/null
+++ b/src/acoustics_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci scaling module — tsb analytics library. */
+export interface AcousticsSciScalingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciScalingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciScaling(data: number[], opts: AcousticsSciScalingOptions = {}): AcousticsSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciScaling };
diff --git a/src/acoustics_sci/scoring.ts b/src/acoustics_sci/scoring.ts
new file mode 100644
index 000000000..ec7671de8
--- /dev/null
+++ b/src/acoustics_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci scoring module — tsb analytics library. */
+export interface AcousticsSciScoringOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciScoringResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciScoring(data: number[], opts: AcousticsSciScoringOptions = {}): AcousticsSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciScoring };
diff --git a/src/acoustics_sci/segmentation.ts b/src/acoustics_sci/segmentation.ts
new file mode 100644
index 000000000..4f49b9ffb
--- /dev/null
+++ b/src/acoustics_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci segmentation module — tsb analytics library. */
+export interface AcousticsSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciSegmentation(data: number[], opts: AcousticsSciSegmentationOptions = {}): AcousticsSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciSegmentation };
diff --git a/src/acoustics_sci/selection.ts b/src/acoustics_sci/selection.ts
new file mode 100644
index 000000000..d5f234fe5
--- /dev/null
+++ b/src/acoustics_sci/selection.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci selection module — tsb analytics library. */
+export interface AcousticsSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciSelectionResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciSelection(data: number[], opts: AcousticsSciSelectionOptions = {}): AcousticsSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciSelection };
diff --git a/src/acoustics_sci/sensitivity.ts b/src/acoustics_sci/sensitivity.ts
new file mode 100644
index 000000000..12410dba7
--- /dev/null
+++ b/src/acoustics_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci sensitivity module — tsb analytics library. */
+export interface AcousticsSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciSensitivity(data: number[], opts: AcousticsSciSensitivityOptions = {}): AcousticsSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciSensitivity };
diff --git a/src/acoustics_sci/simulation.ts b/src/acoustics_sci/simulation.ts
new file mode 100644
index 000000000..cd097a2d1
--- /dev/null
+++ b/src/acoustics_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci simulation module — tsb analytics library. */
+export interface AcousticsSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciSimulationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciSimulation(data: number[], opts: AcousticsSciSimulationOptions = {}): AcousticsSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciSimulation };
diff --git a/src/acoustics_sci/smoothing.ts b/src/acoustics_sci/smoothing.ts
new file mode 100644
index 000000000..131f07c0d
--- /dev/null
+++ b/src/acoustics_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci smoothing module — tsb analytics library. */
+export interface AcousticsSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciSmoothing(data: number[], opts: AcousticsSciSmoothingOptions = {}): AcousticsSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciSmoothing };
diff --git a/src/acoustics_sci/stability.ts b/src/acoustics_sci/stability.ts
new file mode 100644
index 000000000..4f719d2b9
--- /dev/null
+++ b/src/acoustics_sci/stability.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci stability module — tsb analytics library. */
+export interface AcousticsSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciStabilityResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciStability(data: number[], opts: AcousticsSciStabilityOptions = {}): AcousticsSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciStability };
diff --git a/src/acoustics_sci/stacking.ts b/src/acoustics_sci/stacking.ts
new file mode 100644
index 000000000..5d6910d1a
--- /dev/null
+++ b/src/acoustics_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci stacking module — tsb analytics library. */
+export interface AcousticsSciStackingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciStackingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciStacking(data: number[], opts: AcousticsSciStackingOptions = {}): AcousticsSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciStacking };
diff --git a/src/acoustics_sci/standardization.ts b/src/acoustics_sci/standardization.ts
new file mode 100644
index 000000000..a788ebab7
--- /dev/null
+++ b/src/acoustics_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci standardization module — tsb analytics library. */
+export interface AcousticsSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciStandardization(data: number[], opts: AcousticsSciStandardizationOptions = {}): AcousticsSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciStandardization };
diff --git a/src/acoustics_sci/static.ts b/src/acoustics_sci/static.ts
new file mode 100644
index 000000000..20aecb873
--- /dev/null
+++ b/src/acoustics_sci/static.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci static module — tsb analytics library. */
+export interface AcousticsSciStaticOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciStaticResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciStatic(data: number[], opts: AcousticsSciStaticOptions = {}): AcousticsSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciStatic };
diff --git a/src/acoustics_sci/stochastic.ts b/src/acoustics_sci/stochastic.ts
new file mode 100644
index 000000000..d98a585ce
--- /dev/null
+++ b/src/acoustics_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci stochastic module — tsb analytics library. */
+export interface AcousticsSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciStochasticResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciStochastic(data: number[], opts: AcousticsSciStochasticOptions = {}): AcousticsSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciStochastic };
diff --git a/src/acoustics_sci/synthesis.ts b/src/acoustics_sci/synthesis.ts
new file mode 100644
index 000000000..7ad07752c
--- /dev/null
+++ b/src/acoustics_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci synthesis module — tsb analytics library. */
+export interface AcousticsSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciSynthesis(data: number[], opts: AcousticsSciSynthesisOptions = {}): AcousticsSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciSynthesis };
diff --git a/src/acoustics_sci/topology.ts b/src/acoustics_sci/topology.ts
new file mode 100644
index 000000000..117490f73
--- /dev/null
+++ b/src/acoustics_sci/topology.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci topology module — tsb analytics library. */
+export interface AcousticsSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciTopologyResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciTopology(data: number[], opts: AcousticsSciTopologyOptions = {}): AcousticsSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciTopology };
diff --git a/src/acoustics_sci/tracking.ts b/src/acoustics_sci/tracking.ts
new file mode 100644
index 000000000..3ddbbe01b
--- /dev/null
+++ b/src/acoustics_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci tracking module — tsb analytics library. */
+export interface AcousticsSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciTrackingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciTracking(data: number[], opts: AcousticsSciTrackingOptions = {}): AcousticsSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciTracking };
diff --git a/src/acoustics_sci/transform.ts b/src/acoustics_sci/transform.ts
new file mode 100644
index 000000000..0129eb98a
--- /dev/null
+++ b/src/acoustics_sci/transform.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci transform module — tsb analytics library. */
+export interface AcousticsSciTransformOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciTransformResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciTransform(data: number[], opts: AcousticsSciTransformOptions = {}): AcousticsSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciTransform };
diff --git a/src/acoustics_sci/uncertainty.ts b/src/acoustics_sci/uncertainty.ts
new file mode 100644
index 000000000..b9bde06de
--- /dev/null
+++ b/src/acoustics_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci uncertainty module — tsb analytics library. */
+export interface AcousticsSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciUncertainty(data: number[], opts: AcousticsSciUncertaintyOptions = {}): AcousticsSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciUncertainty };
diff --git a/src/acoustics_sci/validation.ts b/src/acoustics_sci/validation.ts
new file mode 100644
index 000000000..20e2eb66a
--- /dev/null
+++ b/src/acoustics_sci/validation.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci validation module — tsb analytics library. */
+export interface AcousticsSciValidationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciValidationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciValidation(data: number[], opts: AcousticsSciValidationOptions = {}): AcousticsSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciValidation };
diff --git a/src/acoustics_sci/verification.ts b/src/acoustics_sci/verification.ts
new file mode 100644
index 000000000..41a6b6cd9
--- /dev/null
+++ b/src/acoustics_sci/verification.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci verification module — tsb analytics library. */
+export interface AcousticsSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciVerificationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciVerification(data: number[], opts: AcousticsSciVerificationOptions = {}): AcousticsSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciVerification };
diff --git a/src/acoustics_sci/visualization.ts b/src/acoustics_sci/visualization.ts
new file mode 100644
index 000000000..3a425996c
--- /dev/null
+++ b/src/acoustics_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci visualization module — tsb analytics library. */
+export interface AcousticsSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciVisualization(data: number[], opts: AcousticsSciVisualizationOptions = {}): AcousticsSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciVisualization };
diff --git a/src/acoustics_sci/voting.ts b/src/acoustics_sci/voting.ts
new file mode 100644
index 000000000..7da68fc04
--- /dev/null
+++ b/src/acoustics_sci/voting.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci voting module — tsb analytics library. */
+export interface AcousticsSciVotingOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciVotingResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciVoting(data: number[], opts: AcousticsSciVotingOptions = {}): AcousticsSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciVoting };
diff --git a/src/acoustics_sci/wavelet.ts b/src/acoustics_sci/wavelet.ts
new file mode 100644
index 000000000..1ae67815c
--- /dev/null
+++ b/src/acoustics_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** acoustics_sci wavelet module — tsb analytics library. */
+export interface AcousticsSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface AcousticsSciWaveletResult { values: number[]; converged: boolean; }
+export function computeAcousticsSciWavelet(data: number[], opts: AcousticsSciWaveletOptions = {}): AcousticsSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAcousticsSciWavelet };
diff --git a/src/actuarial/advanced.ts b/src/actuarial/advanced.ts
new file mode 100644
index 000000000..c284b2656
--- /dev/null
+++ b/src/actuarial/advanced.ts
@@ -0,0 +1,15 @@
+/** Actuarial Advanced module — tsb analytics library. */
+export interface Actuarial advancedOptions { tol?: number; maxIter?: number; }
+export interface Actuarial advancedResult { values: number[]; converged: boolean; }
+export function computeActuarial advanced(data: number[], opts: Actuarial advancedOptions = {}): Actuarial advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial advanced };
diff --git a/src/actuarial/aggregate.ts b/src/actuarial/aggregate.ts
new file mode 100644
index 000000000..b9f49cca3
--- /dev/null
+++ b/src/actuarial/aggregate.ts
@@ -0,0 +1,22 @@
+/** Aggregate module — tsb analytics library. */
+
+/** Options for Aggregate. */
+export interface AggregateOptions { tol?: number; maxIter?: number; }
+
+/** Result from Aggregate. */
+export interface AggregateResult { values: number[]; converged: boolean; }
+
+/** Compute Aggregate. */
+export function computeAggregate(data: number[], opts: AggregateOptions = {}): AggregateResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAggregate };
diff --git a/src/actuarial/aje.ts b/src/actuarial/aje.ts
new file mode 100644
index 000000000..515b3624c
--- /dev/null
+++ b/src/actuarial/aje.ts
@@ -0,0 +1,22 @@
+/** Aje module — tsb analytics library. */
+
+/** Options for Aje. */
+export interface AjeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Aje. */
+export interface AjeResult { values: number[]; converged: boolean; }
+
+/** Compute Aje. */
+export function computeAje(data: number[], opts: AjeOptions = {}): AjeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAje };
diff --git a/src/actuarial/base2.ts b/src/actuarial/base2.ts
new file mode 100644
index 000000000..7872508fb
--- /dev/null
+++ b/src/actuarial/base2.ts
@@ -0,0 +1,15 @@
+/** Actuarial Base2 module — tsb analytics library. */
+export interface Actuarial base2Options { tol?: number; maxIter?: number; }
+export interface Actuarial base2Result { values: number[]; converged: boolean; }
+export function computeActuarial base2(data: number[], opts: Actuarial base2Options = {}): Actuarial base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial base2 };
diff --git a/src/actuarial/batch.ts b/src/actuarial/batch.ts
new file mode 100644
index 000000000..d19e6f94d
--- /dev/null
+++ b/src/actuarial/batch.ts
@@ -0,0 +1,15 @@
+/** Actuarial Batch module — tsb analytics library. */
+export interface Actuarial batchOptions { tol?: number; maxIter?: number; }
+export interface Actuarial batchResult { values: number[]; converged: boolean; }
+export function computeActuarial batch(data: number[], opts: Actuarial batchOptions = {}): Actuarial batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial batch };
diff --git a/src/actuarial/bayesian_grad.ts b/src/actuarial/bayesian_grad.ts
new file mode 100644
index 000000000..a232c73ce
--- /dev/null
+++ b/src/actuarial/bayesian_grad.ts
@@ -0,0 +1,22 @@
+/** Bayesian Grad module — tsb analytics library. */
+
+/** Options for Bayesian Grad. */
+export interface BayesianGradOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bayesian Grad. */
+export interface BayesianGradResult { values: number[]; converged: boolean; }
+
+/** Compute Bayesian Grad. */
+export function computeBayesianGrad(data: number[], opts: BayesianGradOptions = {}): BayesianGradResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBayesianGrad };
diff --git a/src/actuarial/beta.ts b/src/actuarial/beta.ts
new file mode 100644
index 000000000..9ffb49c3d
--- /dev/null
+++ b/src/actuarial/beta.ts
@@ -0,0 +1,15 @@
+/** Actuarial Beta module — tsb analytics library. */
+export interface Actuarial betaOptions { tol?: number; maxIter?: number; }
+export interface Actuarial betaResult { values: number[]; converged: boolean; }
+export function computeActuarial beta(data: number[], opts: Actuarial betaOptions = {}): Actuarial betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial beta };
diff --git a/src/actuarial/bornhuetter_ferguson.ts b/src/actuarial/bornhuetter_ferguson.ts
new file mode 100644
index 000000000..f7e3e4845
--- /dev/null
+++ b/src/actuarial/bornhuetter_ferguson.ts
@@ -0,0 +1,22 @@
+/** Bornhuetter Ferguson module — tsb analytics library. */
+
+/** Options for Bornhuetter Ferguson. */
+export interface BornhuetterFergusonOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bornhuetter Ferguson. */
+export interface BornhuetterFergusonResult { values: number[]; converged: boolean; }
+
+/** Compute Bornhuetter Ferguson. */
+export function computeBornhuetterFerguson(data: number[], opts: BornhuetterFergusonOptions = {}): BornhuetterFergusonResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBornhuetterFerguson };
diff --git a/src/actuarial/buhlmann.ts b/src/actuarial/buhlmann.ts
new file mode 100644
index 000000000..f90b63c86
--- /dev/null
+++ b/src/actuarial/buhlmann.ts
@@ -0,0 +1,22 @@
+/** Buhlmann module — tsb analytics library. */
+
+/** Options for Buhlmann. */
+export interface BuhlmannOptions { tol?: number; maxIter?: number; }
+
+/** Result from Buhlmann. */
+export interface BuhlmannResult { values: number[]; converged: boolean; }
+
+/** Compute Buhlmann. */
+export function computeBuhlmann(data: number[], opts: BuhlmannOptions = {}): BuhlmannResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBuhlmann };
diff --git a/src/actuarial/cairns_blake_dowd.ts b/src/actuarial/cairns_blake_dowd.ts
new file mode 100644
index 000000000..e0e526cf5
--- /dev/null
+++ b/src/actuarial/cairns_blake_dowd.ts
@@ -0,0 +1,22 @@
+/** Cairns Blake Dowd module — tsb analytics library. */
+
+/** Options for Cairns Blake Dowd. */
+export interface CairnsBlakeDowdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cairns Blake Dowd. */
+export interface CairnsBlakeDowdResult { values: number[]; converged: boolean; }
+
+/** Compute Cairns Blake Dowd. */
+export function computeCairnsBlakeDowd(data: number[], opts: CairnsBlakeDowdOptions = {}): CairnsBlakeDowdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCairnsBlakeDowd };
diff --git a/src/actuarial/cbd.ts b/src/actuarial/cbd.ts
new file mode 100644
index 000000000..114b8a025
--- /dev/null
+++ b/src/actuarial/cbd.ts
@@ -0,0 +1,22 @@
+/** Cbd module — tsb analytics library. */
+
+/** Options for Cbd. */
+export interface CbdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cbd. */
+export interface CbdResult { values: number[]; converged: boolean; }
+
+/** Compute Cbd. */
+export function computeCbd(data: number[], opts: CbdOptions = {}): CbdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCbd };
diff --git a/src/actuarial/chainladder.ts b/src/actuarial/chainladder.ts
new file mode 100644
index 000000000..88f6a5203
--- /dev/null
+++ b/src/actuarial/chainladder.ts
@@ -0,0 +1,22 @@
+/** Chainladder module — tsb analytics library. */
+
+/** Options for Chainladder. */
+export interface ChainladderOptions { tol?: number; maxIter?: number; }
+
+/** Result from Chainladder. */
+export interface ChainladderResult { values: number[]; converged: boolean; }
+
+/** Compute Chainladder. */
+export function computeChainladder(data: number[], opts: ChainladderOptions = {}): ChainladderResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeChainladder };
diff --git a/src/actuarial/cohort_table.ts b/src/actuarial/cohort_table.ts
new file mode 100644
index 000000000..bf4ae70d4
--- /dev/null
+++ b/src/actuarial/cohort_table.ts
@@ -0,0 +1,22 @@
+/** Cohort Table module — tsb analytics library. */
+
+/** Options for Cohort Table. */
+export interface CohortTableOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cohort Table. */
+export interface CohortTableResult { values: number[]; converged: boolean; }
+
+/** Compute Cohort Table. */
+export function computeCohortTable(data: number[], opts: CohortTableOptions = {}): CohortTableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCohortTable };
diff --git a/src/actuarial/cpu.ts b/src/actuarial/cpu.ts
new file mode 100644
index 000000000..cd6967564
--- /dev/null
+++ b/src/actuarial/cpu.ts
@@ -0,0 +1,15 @@
+/** Actuarial Cpu module — tsb analytics library. */
+export interface Actuarial cpuOptions { tol?: number; maxIter?: number; }
+export interface Actuarial cpuResult { values: number[]; converged: boolean; }
+export function computeActuarial cpu(data: number[], opts: Actuarial cpuOptions = {}): Actuarial cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial cpu };
diff --git a/src/actuarial/credibility.ts b/src/actuarial/credibility.ts
new file mode 100644
index 000000000..c727a72dc
--- /dev/null
+++ b/src/actuarial/credibility.ts
@@ -0,0 +1,22 @@
+/** Credibility module — tsb analytics library. */
+
+/** Options for Credibility. */
+export interface CredibilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Credibility. */
+export interface CredibilityResult { values: number[]; converged: boolean; }
+
+/** Compute Credibility. */
+export function computeCredibility(data: number[], opts: CredibilityOptions = {}): CredibilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCredibility };
diff --git a/src/actuarial/dense.ts b/src/actuarial/dense.ts
new file mode 100644
index 000000000..f06ca531f
--- /dev/null
+++ b/src/actuarial/dense.ts
@@ -0,0 +1,15 @@
+/** Actuarial Dense module — tsb analytics library. */
+export interface Actuarial denseOptions { tol?: number; maxIter?: number; }
+export interface Actuarial denseResult { values: number[]; converged: boolean; }
+export function computeActuarial dense(data: number[], opts: Actuarial denseOptions = {}): Actuarial denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial dense };
diff --git a/src/actuarial/distributed.ts b/src/actuarial/distributed.ts
new file mode 100644
index 000000000..57eadbea7
--- /dev/null
+++ b/src/actuarial/distributed.ts
@@ -0,0 +1,15 @@
+/** Actuarial Distributed module — tsb analytics library. */
+export interface Actuarial distributedOptions { tol?: number; maxIter?: number; }
+export interface Actuarial distributedResult { values: number[]; converged: boolean; }
+export function computeActuarial distributed(data: number[], opts: Actuarial distributedOptions = {}): Actuarial distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial distributed };
diff --git a/src/actuarial/experimental.ts b/src/actuarial/experimental.ts
new file mode 100644
index 000000000..e795ea2f9
--- /dev/null
+++ b/src/actuarial/experimental.ts
@@ -0,0 +1,15 @@
+/** Actuarial Experimental module — tsb analytics library. */
+export interface Actuarial experimentalOptions { tol?: number; maxIter?: number; }
+export interface Actuarial experimentalResult { values: number[]; converged: boolean; }
+export function computeActuarial experimental(data: number[], opts: Actuarial experimentalOptions = {}): Actuarial experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial experimental };
diff --git a/src/actuarial/fast.ts b/src/actuarial/fast.ts
new file mode 100644
index 000000000..821e83ff4
--- /dev/null
+++ b/src/actuarial/fast.ts
@@ -0,0 +1,15 @@
+/** Actuarial Fast module — tsb analytics library. */
+export interface Actuarial fastOptions { tol?: number; maxIter?: number; }
+export interface Actuarial fastResult { values: number[]; converged: boolean; }
+export function computeActuarial fast(data: number[], opts: Actuarial fastOptions = {}): Actuarial fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial fast };
diff --git a/src/actuarial/force_of_mortality.ts b/src/actuarial/force_of_mortality.ts
new file mode 100644
index 000000000..f49c6bb04
--- /dev/null
+++ b/src/actuarial/force_of_mortality.ts
@@ -0,0 +1,22 @@
+/** Force Of Mortality module — tsb analytics library. */
+
+/** Options for Force Of Mortality. */
+export interface ForceOfMortalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Force Of Mortality. */
+export interface ForceOfMortalityResult { values: number[]; converged: boolean; }
+
+/** Compute Force Of Mortality. */
+export function computeForceOfMortality(data: number[], opts: ForceOfMortalityOptions = {}): ForceOfMortalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeForceOfMortality };
diff --git a/src/actuarial/future.ts b/src/actuarial/future.ts
new file mode 100644
index 000000000..bf4b3ee68
--- /dev/null
+++ b/src/actuarial/future.ts
@@ -0,0 +1,15 @@
+/** Actuarial Future module — tsb analytics library. */
+export interface Actuarial futureOptions { tol?: number; maxIter?: number; }
+export interface Actuarial futureResult { values: number[]; converged: boolean; }
+export function computeActuarial future(data: number[], opts: Actuarial futureOptions = {}): Actuarial futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial future };
diff --git a/src/actuarial/gpu.ts b/src/actuarial/gpu.ts
new file mode 100644
index 000000000..becf86895
--- /dev/null
+++ b/src/actuarial/gpu.ts
@@ -0,0 +1,15 @@
+/** Actuarial Gpu module — tsb analytics library. */
+export interface Actuarial gpuOptions { tol?: number; maxIter?: number; }
+export interface Actuarial gpuResult { values: number[]; converged: boolean; }
+export function computeActuarial gpu(data: number[], opts: Actuarial gpuOptions = {}): Actuarial gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial gpu };
diff --git a/src/actuarial/graduation.ts b/src/actuarial/graduation.ts
new file mode 100644
index 000000000..cfd7c5003
--- /dev/null
+++ b/src/actuarial/graduation.ts
@@ -0,0 +1,22 @@
+/** Graduation module — tsb analytics library. */
+
+/** Options for Graduation. */
+export interface GraduationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Graduation. */
+export interface GraduationResult { values: number[]; converged: boolean; }
+
+/** Compute Graduation. */
+export function computeGraduation(data: number[], opts: GraduationOptions = {}): GraduationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGraduation };
diff --git a/src/actuarial/hazard.ts b/src/actuarial/hazard.ts
new file mode 100644
index 000000000..21e9e1166
--- /dev/null
+++ b/src/actuarial/hazard.ts
@@ -0,0 +1,22 @@
+/** Hazard module — tsb analytics library. */
+
+/** Options for Hazard. */
+export interface HazardOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hazard. */
+export interface HazardResult { values: number[]; converged: boolean; }
+
+/** Compute Hazard. */
+export function computeHazard(data: number[], opts: HazardOptions = {}): HazardResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHazard };
diff --git a/src/actuarial/improvement.ts b/src/actuarial/improvement.ts
new file mode 100644
index 000000000..e0083f677
--- /dev/null
+++ b/src/actuarial/improvement.ts
@@ -0,0 +1,22 @@
+/** Improvement module — tsb analytics library. */
+
+/** Options for Improvement. */
+export interface ImprovementOptions { tol?: number; maxIter?: number; }
+
+/** Result from Improvement. */
+export interface ImprovementResult { values: number[]; converged: boolean; }
+
+/** Compute Improvement. */
+export function computeImprovement(data: number[], opts: ImprovementOptions = {}): ImprovementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeImprovement };
diff --git a/src/actuarial/large.ts b/src/actuarial/large.ts
new file mode 100644
index 000000000..ac948b63d
--- /dev/null
+++ b/src/actuarial/large.ts
@@ -0,0 +1,15 @@
+/** Actuarial Large module — tsb analytics library. */
+export interface Actuarial largeOptions { tol?: number; maxIter?: number; }
+export interface Actuarial largeResult { values: number[]; converged: boolean; }
+export function computeActuarial large(data: number[], opts: Actuarial largeOptions = {}): Actuarial largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial large };
diff --git a/src/actuarial/lee_carter.ts b/src/actuarial/lee_carter.ts
new file mode 100644
index 000000000..c567c9d92
--- /dev/null
+++ b/src/actuarial/lee_carter.ts
@@ -0,0 +1,22 @@
+/** Lee Carter module — tsb analytics library. */
+
+/** Options for Lee Carter. */
+export interface LeeCarterOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lee Carter. */
+export interface LeeCarterResult { values: number[]; converged: boolean; }
+
+/** Compute Lee Carter. */
+export function computeLeeCarter(data: number[], opts: LeeCarterOptions = {}): LeeCarterResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLeeCarter };
diff --git a/src/actuarial/legacy.ts b/src/actuarial/legacy.ts
new file mode 100644
index 000000000..7c7e77063
--- /dev/null
+++ b/src/actuarial/legacy.ts
@@ -0,0 +1,15 @@
+/** Actuarial Legacy module — tsb analytics library. */
+export interface Actuarial legacyOptions { tol?: number; maxIter?: number; }
+export interface Actuarial legacyResult { values: number[]; converged: boolean; }
+export function computeActuarial legacy(data: number[], opts: Actuarial legacyOptions = {}): Actuarial legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial legacy };
diff --git a/src/actuarial/life_table.ts b/src/actuarial/life_table.ts
new file mode 100644
index 000000000..3ddc099e5
--- /dev/null
+++ b/src/actuarial/life_table.ts
@@ -0,0 +1,22 @@
+/** Life Table module — tsb analytics library. */
+
+/** Options for Life Table. */
+export interface LifeTableOptions { tol?: number; maxIter?: number; }
+
+/** Result from Life Table. */
+export interface LifeTableResult { values: number[]; converged: boolean; }
+
+/** Compute Life Table. */
+export function computeLifeTable(data: number[], opts: LifeTableOptions = {}): LifeTableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLifeTable };
diff --git a/src/actuarial/lite.ts b/src/actuarial/lite.ts
new file mode 100644
index 000000000..9815d49ef
--- /dev/null
+++ b/src/actuarial/lite.ts
@@ -0,0 +1,15 @@
+/** Actuarial Lite module — tsb analytics library. */
+export interface Actuarial liteOptions { tol?: number; maxIter?: number; }
+export interface Actuarial liteResult { values: number[]; converged: boolean; }
+export function computeActuarial lite(data: number[], opts: Actuarial liteOptions = {}): Actuarial liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial lite };
diff --git a/src/actuarial/longevity_swap.ts b/src/actuarial/longevity_swap.ts
new file mode 100644
index 000000000..d622d3694
--- /dev/null
+++ b/src/actuarial/longevity_swap.ts
@@ -0,0 +1,22 @@
+/** Longevity Swap module — tsb analytics library. */
+
+/** Options for Longevity Swap. */
+export interface LongevitySwapOptions { tol?: number; maxIter?: number; }
+
+/** Result from Longevity Swap. */
+export interface LongevitySwapResult { values: number[]; converged: boolean; }
+
+/** Compute Longevity Swap. */
+export function computeLongevitySwap(data: number[], opts: LongevitySwapOptions = {}): LongevitySwapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLongevitySwap };
diff --git a/src/actuarial/mini.ts b/src/actuarial/mini.ts
new file mode 100644
index 000000000..14e473be1
--- /dev/null
+++ b/src/actuarial/mini.ts
@@ -0,0 +1,15 @@
+/** Actuarial Mini module — tsb analytics library. */
+export interface Actuarial miniOptions { tol?: number; maxIter?: number; }
+export interface Actuarial miniResult { values: number[]; converged: boolean; }
+export function computeActuarial mini(data: number[], opts: Actuarial miniOptions = {}): Actuarial miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial mini };
diff --git a/src/actuarial/mortality_table.ts b/src/actuarial/mortality_table.ts
new file mode 100644
index 000000000..97476d340
--- /dev/null
+++ b/src/actuarial/mortality_table.ts
@@ -0,0 +1,22 @@
+/** Mortality Table module — tsb analytics library. */
+
+/** Options for Mortality Table. */
+export interface MortalityTableOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mortality Table. */
+export interface MortalityTableResult { values: number[]; converged: boolean; }
+
+/** Compute Mortality Table. */
+export function computeMortalityTable(data: number[], opts: MortalityTableOptions = {}): MortalityTableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMortalityTable };
diff --git a/src/actuarial/next.ts b/src/actuarial/next.ts
new file mode 100644
index 000000000..c1d046a9e
--- /dev/null
+++ b/src/actuarial/next.ts
@@ -0,0 +1,15 @@
+/** Actuarial Next module — tsb analytics library. */
+export interface Actuarial nextOptions { tol?: number; maxIter?: number; }
+export interface Actuarial nextResult { values: number[]; converged: boolean; }
+export function computeActuarial next(data: number[], opts: Actuarial nextOptions = {}): Actuarial nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial next };
diff --git a/src/actuarial/online.ts b/src/actuarial/online.ts
new file mode 100644
index 000000000..5d3a08c04
--- /dev/null
+++ b/src/actuarial/online.ts
@@ -0,0 +1,15 @@
+/** Actuarial Online module — tsb analytics library. */
+export interface Actuarial onlineOptions { tol?: number; maxIter?: number; }
+export interface Actuarial onlineResult { values: number[]; converged: boolean; }
+export function computeActuarial online(data: number[], opts: Actuarial onlineOptions = {}): Actuarial onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial online };
diff --git a/src/actuarial/parallel.ts b/src/actuarial/parallel.ts
new file mode 100644
index 000000000..9ae595a7f
--- /dev/null
+++ b/src/actuarial/parallel.ts
@@ -0,0 +1,15 @@
+/** Actuarial Parallel module — tsb analytics library. */
+export interface Actuarial parallelOptions { tol?: number; maxIter?: number; }
+export interface Actuarial parallelResult { values: number[]; converged: boolean; }
+export function computeActuarial parallel(data: number[], opts: Actuarial parallelOptions = {}): Actuarial parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial parallel };
diff --git a/src/actuarial/plus.ts b/src/actuarial/plus.ts
new file mode 100644
index 000000000..ace502786
--- /dev/null
+++ b/src/actuarial/plus.ts
@@ -0,0 +1,15 @@
+/** Actuarial Plus module — tsb analytics library. */
+export interface Actuarial plusOptions { tol?: number; maxIter?: number; }
+export interface Actuarial plusResult { values: number[]; converged: boolean; }
+export function computeActuarial plus(data: number[], opts: Actuarial plusOptions = {}): Actuarial plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial plus };
diff --git a/src/actuarial/population.ts b/src/actuarial/population.ts
new file mode 100644
index 000000000..f79901dc3
--- /dev/null
+++ b/src/actuarial/population.ts
@@ -0,0 +1,22 @@
+/** Population module — tsb analytics library. */
+
+/** Options for Population. */
+export interface PopulationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Population. */
+export interface PopulationResult { values: number[]; converged: boolean; }
+
+/** Compute Population. */
+export function computePopulation(data: number[], opts: PopulationOptions = {}): PopulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePopulation };
diff --git a/src/actuarial/pro.ts b/src/actuarial/pro.ts
new file mode 100644
index 000000000..9a6ad41ea
--- /dev/null
+++ b/src/actuarial/pro.ts
@@ -0,0 +1,15 @@
+/** Actuarial Pro module — tsb analytics library. */
+export interface Actuarial proOptions { tol?: number; maxIter?: number; }
+export interface Actuarial proResult { values: number[]; converged: boolean; }
+export function computeActuarial pro(data: number[], opts: Actuarial proOptions = {}): Actuarial proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial pro };
diff --git a/src/actuarial/projection.ts b/src/actuarial/projection.ts
new file mode 100644
index 000000000..178eb2971
--- /dev/null
+++ b/src/actuarial/projection.ts
@@ -0,0 +1,22 @@
+/** Projection module — tsb analytics library. */
+
+/** Options for Projection. */
+export interface ProjectionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Projection. */
+export interface ProjectionResult { values: number[]; converged: boolean; }
+
+/** Compute Projection. */
+export function computeProjection(data: number[], opts: ProjectionOptions = {}): ProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProjection };
diff --git a/src/actuarial/q_forward.ts b/src/actuarial/q_forward.ts
new file mode 100644
index 000000000..7c42b5e7e
--- /dev/null
+++ b/src/actuarial/q_forward.ts
@@ -0,0 +1,22 @@
+/** Q Forward module — tsb analytics library. */
+
+/** Options for Q Forward. */
+export interface QForwardOptions { tol?: number; maxIter?: number; }
+
+/** Result from Q Forward. */
+export interface QForwardResult { values: number[]; converged: boolean; }
+
+/** Compute Q Forward. */
+export function computeQForward(data: number[], opts: QForwardOptions = {}): QForwardResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQForward };
diff --git a/src/actuarial/robust.ts b/src/actuarial/robust.ts
new file mode 100644
index 000000000..df502d996
--- /dev/null
+++ b/src/actuarial/robust.ts
@@ -0,0 +1,15 @@
+/** Actuarial Robust module — tsb analytics library. */
+export interface Actuarial robustOptions { tol?: number; maxIter?: number; }
+export interface Actuarial robustResult { values: number[]; converged: boolean; }
+export function computeActuarial robust(data: number[], opts: Actuarial robustOptions = {}): Actuarial robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial robust };
diff --git a/src/actuarial/s_forward.ts b/src/actuarial/s_forward.ts
new file mode 100644
index 000000000..3f9f00492
--- /dev/null
+++ b/src/actuarial/s_forward.ts
@@ -0,0 +1,22 @@
+/** S Forward module — tsb analytics library. */
+
+/** Options for S Forward. */
+export interface SForwardOptions { tol?: number; maxIter?: number; }
+
+/** Result from S Forward. */
+export interface SForwardResult { values: number[]; converged: boolean; }
+
+/** Compute S Forward. */
+export function computeSForward(data: number[], opts: SForwardOptions = {}): SForwardResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSForward };
diff --git a/src/actuarial/select.ts b/src/actuarial/select.ts
new file mode 100644
index 000000000..3ddd88860
--- /dev/null
+++ b/src/actuarial/select.ts
@@ -0,0 +1,22 @@
+/** Select module — tsb analytics library. */
+
+/** Options for Select. */
+export interface SelectOptions { tol?: number; maxIter?: number; }
+
+/** Result from Select. */
+export interface SelectResult { values: number[]; converged: boolean; }
+
+/** Compute Select. */
+export function computeSelect(data: number[], opts: SelectOptions = {}): SelectResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSelect };
diff --git a/src/actuarial/small.ts b/src/actuarial/small.ts
new file mode 100644
index 000000000..10cd1f1ce
--- /dev/null
+++ b/src/actuarial/small.ts
@@ -0,0 +1,15 @@
+/** Actuarial Small module — tsb analytics library. */
+export interface Actuarial smallOptions { tol?: number; maxIter?: number; }
+export interface Actuarial smallResult { values: number[]; converged: boolean; }
+export function computeActuarial small(data: number[], opts: Actuarial smallOptions = {}): Actuarial smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial small };
diff --git a/src/actuarial/sparse.ts b/src/actuarial/sparse.ts
new file mode 100644
index 000000000..1e3f4ab0c
--- /dev/null
+++ b/src/actuarial/sparse.ts
@@ -0,0 +1,15 @@
+/** Actuarial Sparse module — tsb analytics library. */
+export interface Actuarial sparseOptions { tol?: number; maxIter?: number; }
+export interface Actuarial sparseResult { values: number[]; converged: boolean; }
+export function computeActuarial sparse(data: number[], opts: Actuarial sparseOptions = {}): Actuarial sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial sparse };
diff --git a/src/actuarial/spline_grad.ts b/src/actuarial/spline_grad.ts
new file mode 100644
index 000000000..6380980f7
--- /dev/null
+++ b/src/actuarial/spline_grad.ts
@@ -0,0 +1,22 @@
+/** Spline Grad module — tsb analytics library. */
+
+/** Options for Spline Grad. */
+export interface SplineGradOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spline Grad. */
+export interface SplineGradResult { values: number[]; converged: boolean; }
+
+/** Compute Spline Grad. */
+export function computeSplineGrad(data: number[], opts: SplineGradOptions = {}): SplineGradResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSplineGrad };
diff --git a/src/actuarial/stable.ts b/src/actuarial/stable.ts
new file mode 100644
index 000000000..3bdc2ef72
--- /dev/null
+++ b/src/actuarial/stable.ts
@@ -0,0 +1,15 @@
+/** Actuarial Stable module — tsb analytics library. */
+export interface Actuarial stableOptions { tol?: number; maxIter?: number; }
+export interface Actuarial stableResult { values: number[]; converged: boolean; }
+export function computeActuarial stable(data: number[], opts: Actuarial stableOptions = {}): Actuarial stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial stable };
diff --git a/src/actuarial/stochastic_mortality.ts b/src/actuarial/stochastic_mortality.ts
new file mode 100644
index 000000000..b3e79ded1
--- /dev/null
+++ b/src/actuarial/stochastic_mortality.ts
@@ -0,0 +1,22 @@
+/** Stochastic Mortality module — tsb analytics library. */
+
+/** Options for Stochastic Mortality. */
+export interface StochasticMortalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stochastic Mortality. */
+export interface StochasticMortalityResult { values: number[]; converged: boolean; }
+
+/** Compute Stochastic Mortality. */
+export function computeStochasticMortality(data: number[], opts: StochasticMortalityOptions = {}): StochasticMortalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStochasticMortality };
diff --git a/src/actuarial/straub.ts b/src/actuarial/straub.ts
new file mode 100644
index 000000000..33c616e17
--- /dev/null
+++ b/src/actuarial/straub.ts
@@ -0,0 +1,22 @@
+/** Straub module — tsb analytics library. */
+
+/** Options for Straub. */
+export interface StraubOptions { tol?: number; maxIter?: number; }
+
+/** Result from Straub. */
+export interface StraubResult { values: number[]; converged: boolean; }
+
+/** Compute Straub. */
+export function computeStraub(data: number[], opts: StraubOptions = {}): StraubResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStraub };
diff --git a/src/actuarial/streaming.ts b/src/actuarial/streaming.ts
new file mode 100644
index 000000000..1a96ee947
--- /dev/null
+++ b/src/actuarial/streaming.ts
@@ -0,0 +1,15 @@
+/** Actuarial Streaming module — tsb analytics library. */
+export interface Actuarial streamingOptions { tol?: number; maxIter?: number; }
+export interface Actuarial streamingResult { values: number[]; converged: boolean; }
+export function computeActuarial streaming(data: number[], opts: Actuarial streamingOptions = {}): Actuarial streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial streaming };
diff --git a/src/actuarial/survival.ts b/src/actuarial/survival.ts
new file mode 100644
index 000000000..a3b2ee029
--- /dev/null
+++ b/src/actuarial/survival.ts
@@ -0,0 +1,22 @@
+/** Survival module — tsb analytics library. */
+
+/** Options for Survival. */
+export interface SurvivalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Survival. */
+export interface SurvivalResult { values: number[]; converged: boolean; }
+
+/** Compute Survival. */
+export function computeSurvival(data: number[], opts: SurvivalOptions = {}): SurvivalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSurvival };
diff --git a/src/actuarial/ultimate.ts b/src/actuarial/ultimate.ts
new file mode 100644
index 000000000..60e46b346
--- /dev/null
+++ b/src/actuarial/ultimate.ts
@@ -0,0 +1,22 @@
+/** Ultimate module — tsb analytics library. */
+
+/** Options for Ultimate. */
+export interface UltimateOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ultimate. */
+export interface UltimateResult { values: number[]; converged: boolean; }
+
+/** Compute Ultimate. */
+export function computeUltimate(data: number[], opts: UltimateOptions = {}): UltimateResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeUltimate };
diff --git a/src/actuarial/v2.ts b/src/actuarial/v2.ts
new file mode 100644
index 000000000..e10a29740
--- /dev/null
+++ b/src/actuarial/v2.ts
@@ -0,0 +1,15 @@
+/** Actuarial V2 module — tsb analytics library. */
+export interface Actuarial v2Options { tol?: number; maxIter?: number; }
+export interface Actuarial v2Result { values: number[]; converged: boolean; }
+export function computeActuarial v2(data: number[], opts: Actuarial v2Options = {}): Actuarial v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial v2 };
diff --git a/src/actuarial/v3.ts b/src/actuarial/v3.ts
new file mode 100644
index 000000000..99db1c833
--- /dev/null
+++ b/src/actuarial/v3.ts
@@ -0,0 +1,15 @@
+/** Actuarial V3 module — tsb analytics library. */
+export interface Actuarial v3Options { tol?: number; maxIter?: number; }
+export interface Actuarial v3Result { values: number[]; converged: boolean; }
+export function computeActuarial v3(data: number[], opts: Actuarial v3Options = {}): Actuarial v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial v3 };
diff --git a/src/actuarial/wasm.ts b/src/actuarial/wasm.ts
new file mode 100644
index 000000000..e4511c13f
--- /dev/null
+++ b/src/actuarial/wasm.ts
@@ -0,0 +1,15 @@
+/** Actuarial Wasm module — tsb analytics library. */
+export interface Actuarial wasmOptions { tol?: number; maxIter?: number; }
+export interface Actuarial wasmResult { values: number[]; converged: boolean; }
+export function computeActuarial wasm(data: number[], opts: Actuarial wasmOptions = {}): Actuarial wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial wasm };
diff --git a/src/actuarial/whittaker.ts b/src/actuarial/whittaker.ts
new file mode 100644
index 000000000..1163a3bf1
--- /dev/null
+++ b/src/actuarial/whittaker.ts
@@ -0,0 +1,22 @@
+/** Whittaker module — tsb analytics library. */
+
+/** Options for Whittaker. */
+export interface WhittakerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Whittaker. */
+export interface WhittakerResult { values: number[]; converged: boolean; }
+
+/** Compute Whittaker. */
+export function computeWhittaker(data: number[], opts: WhittakerOptions = {}): WhittakerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWhittaker };
diff --git a/src/actuarial/xlarge.ts b/src/actuarial/xlarge.ts
new file mode 100644
index 000000000..9d5e5e248
--- /dev/null
+++ b/src/actuarial/xlarge.ts
@@ -0,0 +1,15 @@
+/** Actuarial Xlarge module — tsb analytics library. */
+export interface Actuarial xlargeOptions { tol?: number; maxIter?: number; }
+export interface Actuarial xlargeResult { values: number[]; converged: boolean; }
+export function computeActuarial xlarge(data: number[], opts: Actuarial xlargeOptions = {}): Actuarial xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeActuarial xlarge };
diff --git a/src/adhesion_sci/adaptation.ts b/src/adhesion_sci/adaptation.ts
new file mode 100644
index 000000000..028f99cbc
--- /dev/null
+++ b/src/adhesion_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci adaptation module — tsb analytics library. */
+export interface AdhesionSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciAdaptation(data: number[], opts: AdhesionSciAdaptationOptions = {}): AdhesionSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciAdaptation };
diff --git a/src/adhesion_sci/aggregation.ts b/src/adhesion_sci/aggregation.ts
new file mode 100644
index 000000000..41799b0fc
--- /dev/null
+++ b/src/adhesion_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci aggregation module — tsb analytics library. */
+export interface AdhesionSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciAggregationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciAggregation(data: number[], opts: AdhesionSciAggregationOptions = {}): AdhesionSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciAggregation };
diff --git a/src/adhesion_sci/algebra.ts b/src/adhesion_sci/algebra.ts
new file mode 100644
index 000000000..7f12f886e
--- /dev/null
+++ b/src/adhesion_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci algebra module — tsb analytics library. */
+export interface AdhesionSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciAlgebra(data: number[], opts: AdhesionSciAlgebraOptions = {}): AdhesionSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciAlgebra };
diff --git a/src/adhesion_sci/alignment.ts b/src/adhesion_sci/alignment.ts
new file mode 100644
index 000000000..405bcc935
--- /dev/null
+++ b/src/adhesion_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci alignment module — tsb analytics library. */
+export interface AdhesionSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciAlignment(data: number[], opts: AdhesionSciAlignmentOptions = {}): AdhesionSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciAlignment };
diff --git a/src/adhesion_sci/analysis.ts b/src/adhesion_sci/analysis.ts
new file mode 100644
index 000000000..decc72166
--- /dev/null
+++ b/src/adhesion_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci analysis module — tsb analytics library. */
+export interface AdhesionSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciAnalysis(data: number[], opts: AdhesionSciAnalysisOptions = {}): AdhesionSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciAnalysis };
diff --git a/src/adhesion_sci/augmentation.ts b/src/adhesion_sci/augmentation.ts
new file mode 100644
index 000000000..a9da7e15c
--- /dev/null
+++ b/src/adhesion_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci augmentation module — tsb analytics library. */
+export interface AdhesionSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciAugmentation(data: number[], opts: AdhesionSciAugmentationOptions = {}): AdhesionSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciAugmentation };
diff --git a/src/adhesion_sci/bagging.ts b/src/adhesion_sci/bagging.ts
new file mode 100644
index 000000000..96e6eed2c
--- /dev/null
+++ b/src/adhesion_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci bagging module — tsb analytics library. */
+export interface AdhesionSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciBaggingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciBagging(data: number[], opts: AdhesionSciBaggingOptions = {}): AdhesionSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciBagging };
diff --git a/src/adhesion_sci/basis.ts b/src/adhesion_sci/basis.ts
new file mode 100644
index 000000000..56b322842
--- /dev/null
+++ b/src/adhesion_sci/basis.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci basis module — tsb analytics library. */
+export interface AdhesionSciBasisOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciBasisResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciBasis(data: number[], opts: AdhesionSciBasisOptions = {}): AdhesionSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciBasis };
diff --git a/src/adhesion_sci/benchmarking.ts b/src/adhesion_sci/benchmarking.ts
new file mode 100644
index 000000000..ec6bf64d5
--- /dev/null
+++ b/src/adhesion_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci benchmarking module — tsb analytics library. */
+export interface AdhesionSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciBenchmarking(data: number[], opts: AdhesionSciBenchmarkingOptions = {}): AdhesionSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciBenchmarking };
diff --git a/src/adhesion_sci/blending.ts b/src/adhesion_sci/blending.ts
new file mode 100644
index 000000000..25e875645
--- /dev/null
+++ b/src/adhesion_sci/blending.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci blending module — tsb analytics library. */
+export interface AdhesionSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciBlendingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciBlending(data: number[], opts: AdhesionSciBlendingOptions = {}): AdhesionSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciBlending };
diff --git a/src/adhesion_sci/boosting.ts b/src/adhesion_sci/boosting.ts
new file mode 100644
index 000000000..cddd20b2a
--- /dev/null
+++ b/src/adhesion_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci boosting module — tsb analytics library. */
+export interface AdhesionSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciBoostingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciBoosting(data: number[], opts: AdhesionSciBoostingOptions = {}): AdhesionSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciBoosting };
diff --git a/src/adhesion_sci/bootstrap.ts b/src/adhesion_sci/bootstrap.ts
new file mode 100644
index 000000000..4ba1e0a6b
--- /dev/null
+++ b/src/adhesion_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci bootstrap module — tsb analytics library. */
+export interface AdhesionSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciBootstrap(data: number[], opts: AdhesionSciBootstrapOptions = {}): AdhesionSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciBootstrap };
diff --git a/src/adhesion_sci/calculus.ts b/src/adhesion_sci/calculus.ts
new file mode 100644
index 000000000..51e037d72
--- /dev/null
+++ b/src/adhesion_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci calculus module — tsb analytics library. */
+export interface AdhesionSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciCalculusResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciCalculus(data: number[], opts: AdhesionSciCalculusOptions = {}): AdhesionSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciCalculus };
diff --git a/src/adhesion_sci/calibration.ts b/src/adhesion_sci/calibration.ts
new file mode 100644
index 000000000..dba336d85
--- /dev/null
+++ b/src/adhesion_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci calibration module — tsb analytics library. */
+export interface AdhesionSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciCalibration(data: number[], opts: AdhesionSciCalibrationOptions = {}): AdhesionSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciCalibration };
diff --git a/src/adhesion_sci/characterization.ts b/src/adhesion_sci/characterization.ts
new file mode 100644
index 000000000..185d5d57a
--- /dev/null
+++ b/src/adhesion_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci characterization module — tsb analytics library. */
+export interface AdhesionSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciCharacterization(data: number[], opts: AdhesionSciCharacterizationOptions = {}): AdhesionSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciCharacterization };
diff --git a/src/adhesion_sci/classification.ts b/src/adhesion_sci/classification.ts
new file mode 100644
index 000000000..4fffb3c9d
--- /dev/null
+++ b/src/adhesion_sci/classification.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci classification module — tsb analytics library. */
+export interface AdhesionSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciClassificationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciClassification(data: number[], opts: AdhesionSciClassificationOptions = {}): AdhesionSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciClassification };
diff --git a/src/adhesion_sci/clustering.ts b/src/adhesion_sci/clustering.ts
new file mode 100644
index 000000000..3becc127e
--- /dev/null
+++ b/src/adhesion_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci clustering module — tsb analytics library. */
+export interface AdhesionSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciClusteringResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciClustering(data: number[], opts: AdhesionSciClusteringOptions = {}): AdhesionSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciClustering };
diff --git a/src/adhesion_sci/compression.ts b/src/adhesion_sci/compression.ts
new file mode 100644
index 000000000..555e24c0d
--- /dev/null
+++ b/src/adhesion_sci/compression.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci compression module — tsb analytics library. */
+export interface AdhesionSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciCompressionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciCompression(data: number[], opts: AdhesionSciCompressionOptions = {}): AdhesionSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciCompression };
diff --git a/src/adhesion_sci/continuous.ts b/src/adhesion_sci/continuous.ts
new file mode 100644
index 000000000..7aa0431f3
--- /dev/null
+++ b/src/adhesion_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci continuous module — tsb analytics library. */
+export interface AdhesionSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciContinuousResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciContinuous(data: number[], opts: AdhesionSciContinuousOptions = {}): AdhesionSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciContinuous };
diff --git a/src/adhesion_sci/control.ts b/src/adhesion_sci/control.ts
new file mode 100644
index 000000000..ecba744c7
--- /dev/null
+++ b/src/adhesion_sci/control.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci control module — tsb analytics library. */
+export interface AdhesionSciControlOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciControlResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciControl(data: number[], opts: AdhesionSciControlOptions = {}): AdhesionSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciControl };
diff --git a/src/adhesion_sci/convergence.ts b/src/adhesion_sci/convergence.ts
new file mode 100644
index 000000000..a3fc3c834
--- /dev/null
+++ b/src/adhesion_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci convergence module — tsb analytics library. */
+export interface AdhesionSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciConvergence(data: number[], opts: AdhesionSciConvergenceOptions = {}): AdhesionSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciConvergence };
diff --git a/src/adhesion_sci/convex.ts b/src/adhesion_sci/convex.ts
new file mode 100644
index 000000000..2a62be365
--- /dev/null
+++ b/src/adhesion_sci/convex.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci convex module — tsb analytics library. */
+export interface AdhesionSciConvexOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciConvexResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciConvex(data: number[], opts: AdhesionSciConvexOptions = {}): AdhesionSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciConvex };
diff --git a/src/adhesion_sci/correlation.ts b/src/adhesion_sci/correlation.ts
new file mode 100644
index 000000000..4743c8644
--- /dev/null
+++ b/src/adhesion_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci correlation module — tsb analytics library. */
+export interface AdhesionSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciCorrelation(data: number[], opts: AdhesionSciCorrelationOptions = {}): AdhesionSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciCorrelation };
diff --git a/src/adhesion_sci/covariance.ts b/src/adhesion_sci/covariance.ts
new file mode 100644
index 000000000..97687e07f
--- /dev/null
+++ b/src/adhesion_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci covariance module — tsb analytics library. */
+export interface AdhesionSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciCovariance(data: number[], opts: AdhesionSciCovarianceOptions = {}): AdhesionSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciCovariance };
diff --git a/src/adhesion_sci/cross_validation.ts b/src/adhesion_sci/cross_validation.ts
new file mode 100644
index 000000000..05ffe3cc0
--- /dev/null
+++ b/src/adhesion_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci cross_validation module — tsb analytics library. */
+export interface AdhesionSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciCrossValidation(data: number[], opts: AdhesionSciCrossValidationOptions = {}): AdhesionSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciCrossValidation };
diff --git a/src/adhesion_sci/decoding.ts b/src/adhesion_sci/decoding.ts
new file mode 100644
index 000000000..e61102ee8
--- /dev/null
+++ b/src/adhesion_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci decoding module — tsb analytics library. */
+export interface AdhesionSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDecodingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDecoding(data: number[], opts: AdhesionSciDecodingOptions = {}): AdhesionSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDecoding };
diff --git a/src/adhesion_sci/decomposition.ts b/src/adhesion_sci/decomposition.ts
new file mode 100644
index 000000000..9c6fb63f4
--- /dev/null
+++ b/src/adhesion_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci decomposition module — tsb analytics library. */
+export interface AdhesionSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDecomposition(data: number[], opts: AdhesionSciDecompositionOptions = {}): AdhesionSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDecomposition };
diff --git a/src/adhesion_sci/detection.ts b/src/adhesion_sci/detection.ts
new file mode 100644
index 000000000..085519ea5
--- /dev/null
+++ b/src/adhesion_sci/detection.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci detection module — tsb analytics library. */
+export interface AdhesionSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDetectionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDetection(data: number[], opts: AdhesionSciDetectionOptions = {}): AdhesionSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDetection };
diff --git a/src/adhesion_sci/deterministic.ts b/src/adhesion_sci/deterministic.ts
new file mode 100644
index 000000000..601d30797
--- /dev/null
+++ b/src/adhesion_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci deterministic module — tsb analytics library. */
+export interface AdhesionSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDeterministic(data: number[], opts: AdhesionSciDeterministicOptions = {}): AdhesionSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDeterministic };
diff --git a/src/adhesion_sci/diagnostics.ts b/src/adhesion_sci/diagnostics.ts
new file mode 100644
index 000000000..242d1791b
--- /dev/null
+++ b/src/adhesion_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci diagnostics module — tsb analytics library. */
+export interface AdhesionSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDiagnostics(data: number[], opts: AdhesionSciDiagnosticsOptions = {}): AdhesionSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDiagnostics };
diff --git a/src/adhesion_sci/differential.ts b/src/adhesion_sci/differential.ts
new file mode 100644
index 000000000..c708a4355
--- /dev/null
+++ b/src/adhesion_sci/differential.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci differential module — tsb analytics library. */
+export interface AdhesionSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDifferential(data: number[], opts: AdhesionSciDifferentialOptions = {}): AdhesionSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDifferential };
diff --git a/src/adhesion_sci/discrete.ts b/src/adhesion_sci/discrete.ts
new file mode 100644
index 000000000..e8cbc3104
--- /dev/null
+++ b/src/adhesion_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci discrete module — tsb analytics library. */
+export interface AdhesionSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDiscrete(data: number[], opts: AdhesionSciDiscreteOptions = {}): AdhesionSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDiscrete };
diff --git a/src/adhesion_sci/distribution.ts b/src/adhesion_sci/distribution.ts
new file mode 100644
index 000000000..5c70c8725
--- /dev/null
+++ b/src/adhesion_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci distribution module — tsb analytics library. */
+export interface AdhesionSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDistributionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDistribution(data: number[], opts: AdhesionSciDistributionOptions = {}): AdhesionSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDistribution };
diff --git a/src/adhesion_sci/dynamic.ts b/src/adhesion_sci/dynamic.ts
new file mode 100644
index 000000000..24dd4ecd6
--- /dev/null
+++ b/src/adhesion_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci dynamic module — tsb analytics library. */
+export interface AdhesionSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciDynamicResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciDynamic(data: number[], opts: AdhesionSciDynamicOptions = {}): AdhesionSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciDynamic };
diff --git a/src/adhesion_sci/embedding.ts b/src/adhesion_sci/embedding.ts
new file mode 100644
index 000000000..c25800c74
--- /dev/null
+++ b/src/adhesion_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci embedding module — tsb analytics library. */
+export interface AdhesionSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciEmbedding(data: number[], opts: AdhesionSciEmbeddingOptions = {}): AdhesionSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciEmbedding };
diff --git a/src/adhesion_sci/encoding.ts b/src/adhesion_sci/encoding.ts
new file mode 100644
index 000000000..276f47635
--- /dev/null
+++ b/src/adhesion_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci encoding module — tsb analytics library. */
+export interface AdhesionSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciEncodingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciEncoding(data: number[], opts: AdhesionSciEncodingOptions = {}): AdhesionSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciEncoding };
diff --git a/src/adhesion_sci/ensemble.ts b/src/adhesion_sci/ensemble.ts
new file mode 100644
index 000000000..467ed909e
--- /dev/null
+++ b/src/adhesion_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci ensemble module — tsb analytics library. */
+export interface AdhesionSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciEnsemble(data: number[], opts: AdhesionSciEnsembleOptions = {}): AdhesionSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciEnsemble };
diff --git a/src/adhesion_sci/estimation.ts b/src/adhesion_sci/estimation.ts
new file mode 100644
index 000000000..cbf6d3609
--- /dev/null
+++ b/src/adhesion_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci estimation module — tsb analytics library. */
+export interface AdhesionSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciEstimationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciEstimation(data: number[], opts: AdhesionSciEstimationOptions = {}): AdhesionSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciEstimation };
diff --git a/src/adhesion_sci/evaluation.ts b/src/adhesion_sci/evaluation.ts
new file mode 100644
index 000000000..c9ee3e269
--- /dev/null
+++ b/src/adhesion_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci evaluation module — tsb analytics library. */
+export interface AdhesionSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciEvaluation(data: number[], opts: AdhesionSciEvaluationOptions = {}): AdhesionSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciEvaluation };
diff --git a/src/adhesion_sci/extrapolation.ts b/src/adhesion_sci/extrapolation.ts
new file mode 100644
index 000000000..454cbe9f0
--- /dev/null
+++ b/src/adhesion_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci extrapolation module — tsb analytics library. */
+export interface AdhesionSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciExtrapolation(data: number[], opts: AdhesionSciExtrapolationOptions = {}): AdhesionSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciExtrapolation };
diff --git a/src/adhesion_sci/features.ts b/src/adhesion_sci/features.ts
new file mode 100644
index 000000000..bcf891ffd
--- /dev/null
+++ b/src/adhesion_sci/features.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci features module — tsb analytics library. */
+export interface AdhesionSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciFeatures(data: number[], opts: AdhesionSciFeaturesOptions = {}): AdhesionSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciFeatures };
diff --git a/src/adhesion_sci/feedback.ts b/src/adhesion_sci/feedback.ts
new file mode 100644
index 000000000..0ca9d9b22
--- /dev/null
+++ b/src/adhesion_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci feedback module — tsb analytics library. */
+export interface AdhesionSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciFeedback(data: number[], opts: AdhesionSciFeedbackOptions = {}): AdhesionSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciFeedback };
diff --git a/src/adhesion_sci/filtering.ts b/src/adhesion_sci/filtering.ts
new file mode 100644
index 000000000..7615cd26c
--- /dev/null
+++ b/src/adhesion_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci filtering module — tsb analytics library. */
+export interface AdhesionSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciFilteringResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciFiltering(data: number[], opts: AdhesionSciFilteringOptions = {}): AdhesionSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciFiltering };
diff --git a/src/adhesion_sci/fourier.ts b/src/adhesion_sci/fourier.ts
new file mode 100644
index 000000000..05ba0f930
--- /dev/null
+++ b/src/adhesion_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci fourier module — tsb analytics library. */
+export interface AdhesionSciFourierOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciFourierResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciFourier(data: number[], opts: AdhesionSciFourierOptions = {}): AdhesionSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciFourier };
diff --git a/src/adhesion_sci/fusion.ts b/src/adhesion_sci/fusion.ts
new file mode 100644
index 000000000..cadb6176c
--- /dev/null
+++ b/src/adhesion_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci fusion module — tsb analytics library. */
+export interface AdhesionSciFusionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciFusionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciFusion(data: number[], opts: AdhesionSciFusionOptions = {}): AdhesionSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciFusion };
diff --git a/src/adhesion_sci/generation.ts b/src/adhesion_sci/generation.ts
new file mode 100644
index 000000000..990653b45
--- /dev/null
+++ b/src/adhesion_sci/generation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci generation module — tsb analytics library. */
+export interface AdhesionSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciGenerationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciGeneration(data: number[], opts: AdhesionSciGenerationOptions = {}): AdhesionSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciGeneration };
diff --git a/src/adhesion_sci/geometry.ts b/src/adhesion_sci/geometry.ts
new file mode 100644
index 000000000..b870cd633
--- /dev/null
+++ b/src/adhesion_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci geometry module — tsb analytics library. */
+export interface AdhesionSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciGeometryResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciGeometry(data: number[], opts: AdhesionSciGeometryOptions = {}): AdhesionSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciGeometry };
diff --git a/src/adhesion_sci/gradient.ts b/src/adhesion_sci/gradient.ts
new file mode 100644
index 000000000..4bf8ab50f
--- /dev/null
+++ b/src/adhesion_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci gradient module — tsb analytics library. */
+export interface AdhesionSciGradientOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciGradientResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciGradient(data: number[], opts: AdhesionSciGradientOptions = {}): AdhesionSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciGradient };
diff --git a/src/adhesion_sci/hessian.ts b/src/adhesion_sci/hessian.ts
new file mode 100644
index 000000000..7bace9cb9
--- /dev/null
+++ b/src/adhesion_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci hessian module — tsb analytics library. */
+export interface AdhesionSciHessianOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciHessianResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciHessian(data: number[], opts: AdhesionSciHessianOptions = {}): AdhesionSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciHessian };
diff --git a/src/adhesion_sci/hypothesis.ts b/src/adhesion_sci/hypothesis.ts
new file mode 100644
index 000000000..cce0746da
--- /dev/null
+++ b/src/adhesion_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci hypothesis module — tsb analytics library. */
+export interface AdhesionSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciHypothesis(data: number[], opts: AdhesionSciHypothesisOptions = {}): AdhesionSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciHypothesis };
diff --git a/src/adhesion_sci/inference.ts b/src/adhesion_sci/inference.ts
new file mode 100644
index 000000000..8249ac45f
--- /dev/null
+++ b/src/adhesion_sci/inference.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci inference module — tsb analytics library. */
+export interface AdhesionSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciInferenceResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciInference(data: number[], opts: AdhesionSciInferenceOptions = {}): AdhesionSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciInference };
diff --git a/src/adhesion_sci/inference2.ts b/src/adhesion_sci/inference2.ts
new file mode 100644
index 000000000..3e11f632a
--- /dev/null
+++ b/src/adhesion_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci inference2 module — tsb analytics library. */
+export interface AdhesionSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciInferenceResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciInference(data: number[], opts: AdhesionSciInferenceOptions = {}): AdhesionSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciInference };
diff --git a/src/adhesion_sci/integral.ts b/src/adhesion_sci/integral.ts
new file mode 100644
index 000000000..a844809a7
--- /dev/null
+++ b/src/adhesion_sci/integral.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci integral module — tsb analytics library. */
+export interface AdhesionSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciIntegralResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciIntegral(data: number[], opts: AdhesionSciIntegralOptions = {}): AdhesionSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciIntegral };
diff --git a/src/adhesion_sci/integration.ts b/src/adhesion_sci/integration.ts
new file mode 100644
index 000000000..7ef75e864
--- /dev/null
+++ b/src/adhesion_sci/integration.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci integration module — tsb analytics library. */
+export interface AdhesionSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciIntegration(data: number[], opts: AdhesionSciIntegrationOptions = {}): AdhesionSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciIntegration };
diff --git a/src/adhesion_sci/interpolation.ts b/src/adhesion_sci/interpolation.ts
new file mode 100644
index 000000000..4df7cf732
--- /dev/null
+++ b/src/adhesion_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci interpolation module — tsb analytics library. */
+export interface AdhesionSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciInterpolation(data: number[], opts: AdhesionSciInterpolationOptions = {}): AdhesionSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciInterpolation };
diff --git a/src/adhesion_sci/jacobian.ts b/src/adhesion_sci/jacobian.ts
new file mode 100644
index 000000000..128d0d2c1
--- /dev/null
+++ b/src/adhesion_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci jacobian module — tsb analytics library. */
+export interface AdhesionSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciJacobianResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciJacobian(data: number[], opts: AdhesionSciJacobianOptions = {}): AdhesionSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciJacobian };
diff --git a/src/adhesion_sci/kernel.ts b/src/adhesion_sci/kernel.ts
new file mode 100644
index 000000000..89f925fe8
--- /dev/null
+++ b/src/adhesion_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci kernel module — tsb analytics library. */
+export interface AdhesionSciKernelOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciKernelResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciKernel(data: number[], opts: AdhesionSciKernelOptions = {}): AdhesionSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciKernel };
diff --git a/src/adhesion_sci/laplacian.ts b/src/adhesion_sci/laplacian.ts
new file mode 100644
index 000000000..e466b8cbc
--- /dev/null
+++ b/src/adhesion_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci laplacian module — tsb analytics library. */
+export interface AdhesionSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciLaplacian(data: number[], opts: AdhesionSciLaplacianOptions = {}): AdhesionSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciLaplacian };
diff --git a/src/adhesion_sci/learning.ts b/src/adhesion_sci/learning.ts
new file mode 100644
index 000000000..68f395529
--- /dev/null
+++ b/src/adhesion_sci/learning.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci learning module — tsb analytics library. */
+export interface AdhesionSciLearningOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciLearningResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciLearning(data: number[], opts: AdhesionSciLearningOptions = {}): AdhesionSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciLearning };
diff --git a/src/adhesion_sci/linear.ts b/src/adhesion_sci/linear.ts
new file mode 100644
index 000000000..be18e3c8a
--- /dev/null
+++ b/src/adhesion_sci/linear.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci linear module — tsb analytics library. */
+export interface AdhesionSciLinearOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciLinearResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciLinear(data: number[], opts: AdhesionSciLinearOptions = {}): AdhesionSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciLinear };
diff --git a/src/adhesion_sci/manifold.ts b/src/adhesion_sci/manifold.ts
new file mode 100644
index 000000000..7968c9cbb
--- /dev/null
+++ b/src/adhesion_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci manifold module — tsb analytics library. */
+export interface AdhesionSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciManifoldResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciManifold(data: number[], opts: AdhesionSciManifoldOptions = {}): AdhesionSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciManifold };
diff --git a/src/adhesion_sci/matching.ts b/src/adhesion_sci/matching.ts
new file mode 100644
index 000000000..26bdc4cc0
--- /dev/null
+++ b/src/adhesion_sci/matching.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci matching module — tsb analytics library. */
+export interface AdhesionSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciMatchingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciMatching(data: number[], opts: AdhesionSciMatchingOptions = {}): AdhesionSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciMatching };
diff --git a/src/adhesion_sci/measurement.ts b/src/adhesion_sci/measurement.ts
new file mode 100644
index 000000000..e6755a686
--- /dev/null
+++ b/src/adhesion_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci measurement module — tsb analytics library. */
+export interface AdhesionSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciMeasurement(data: number[], opts: AdhesionSciMeasurementOptions = {}): AdhesionSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciMeasurement };
diff --git a/src/adhesion_sci/metrics.ts b/src/adhesion_sci/metrics.ts
new file mode 100644
index 000000000..7f54b83af
--- /dev/null
+++ b/src/adhesion_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci metrics module — tsb analytics library. */
+export interface AdhesionSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciMetricsResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciMetrics(data: number[], opts: AdhesionSciMetricsOptions = {}): AdhesionSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciMetrics };
diff --git a/src/adhesion_sci/modeling.ts b/src/adhesion_sci/modeling.ts
new file mode 100644
index 000000000..911eb32e8
--- /dev/null
+++ b/src/adhesion_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci modeling module — tsb analytics library. */
+export interface AdhesionSciModelingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciModelingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciModeling(data: number[], opts: AdhesionSciModelingOptions = {}): AdhesionSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciModeling };
diff --git a/src/adhesion_sci/monitoring.ts b/src/adhesion_sci/monitoring.ts
new file mode 100644
index 000000000..2ced4f8b0
--- /dev/null
+++ b/src/adhesion_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci monitoring module — tsb analytics library. */
+export interface AdhesionSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciMonitoring(data: number[], opts: AdhesionSciMonitoringOptions = {}): AdhesionSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciMonitoring };
diff --git a/src/adhesion_sci/nonlinear.ts b/src/adhesion_sci/nonlinear.ts
new file mode 100644
index 000000000..ee9ab5c0c
--- /dev/null
+++ b/src/adhesion_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci nonlinear module — tsb analytics library. */
+export interface AdhesionSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciNonlinear(data: number[], opts: AdhesionSciNonlinearOptions = {}): AdhesionSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciNonlinear };
diff --git a/src/adhesion_sci/normalization.ts b/src/adhesion_sci/normalization.ts
new file mode 100644
index 000000000..cd265d6f6
--- /dev/null
+++ b/src/adhesion_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci normalization module — tsb analytics library. */
+export interface AdhesionSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciNormalization(data: number[], opts: AdhesionSciNormalizationOptions = {}): AdhesionSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciNormalization };
diff --git a/src/adhesion_sci/optimization.ts b/src/adhesion_sci/optimization.ts
new file mode 100644
index 000000000..73efebf6b
--- /dev/null
+++ b/src/adhesion_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci optimization module — tsb analytics library. */
+export interface AdhesionSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciOptimization(data: number[], opts: AdhesionSciOptimizationOptions = {}): AdhesionSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciOptimization };
diff --git a/src/adhesion_sci/patterns.ts b/src/adhesion_sci/patterns.ts
new file mode 100644
index 000000000..b2e507725
--- /dev/null
+++ b/src/adhesion_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci patterns module — tsb analytics library. */
+export interface AdhesionSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciPatternsResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciPatterns(data: number[], opts: AdhesionSciPatternsOptions = {}): AdhesionSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciPatterns };
diff --git a/src/adhesion_sci/permutation.ts b/src/adhesion_sci/permutation.ts
new file mode 100644
index 000000000..c49fdddff
--- /dev/null
+++ b/src/adhesion_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci permutation module — tsb analytics library. */
+export interface AdhesionSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciPermutationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciPermutation(data: number[], opts: AdhesionSciPermutationOptions = {}): AdhesionSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciPermutation };
diff --git a/src/adhesion_sci/prediction.ts b/src/adhesion_sci/prediction.ts
new file mode 100644
index 000000000..2d4cb794b
--- /dev/null
+++ b/src/adhesion_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci prediction module — tsb analytics library. */
+export interface AdhesionSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciPredictionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciPrediction(data: number[], opts: AdhesionSciPredictionOptions = {}): AdhesionSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciPrediction };
diff --git a/src/adhesion_sci/processing.ts b/src/adhesion_sci/processing.ts
new file mode 100644
index 000000000..c08906e25
--- /dev/null
+++ b/src/adhesion_sci/processing.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci processing module — tsb analytics library. */
+export interface AdhesionSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciProcessingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciProcessing(data: number[], opts: AdhesionSciProcessingOptions = {}): AdhesionSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciProcessing };
diff --git a/src/adhesion_sci/profiling.ts b/src/adhesion_sci/profiling.ts
new file mode 100644
index 000000000..47eea5be8
--- /dev/null
+++ b/src/adhesion_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci profiling module — tsb analytics library. */
+export interface AdhesionSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciProfilingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciProfiling(data: number[], opts: AdhesionSciProfilingOptions = {}): AdhesionSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciProfiling };
diff --git a/src/adhesion_sci/projection.ts b/src/adhesion_sci/projection.ts
new file mode 100644
index 000000000..8523ee8ab
--- /dev/null
+++ b/src/adhesion_sci/projection.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci projection module — tsb analytics library. */
+export interface AdhesionSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciProjectionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciProjection(data: number[], opts: AdhesionSciProjectionOptions = {}): AdhesionSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciProjection };
diff --git a/src/adhesion_sci/ranking.ts b/src/adhesion_sci/ranking.ts
new file mode 100644
index 000000000..e17637690
--- /dev/null
+++ b/src/adhesion_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci ranking module — tsb analytics library. */
+export interface AdhesionSciRankingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciRankingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciRanking(data: number[], opts: AdhesionSciRankingOptions = {}): AdhesionSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciRanking };
diff --git a/src/adhesion_sci/reconstruction.ts b/src/adhesion_sci/reconstruction.ts
new file mode 100644
index 000000000..d27c71fd7
--- /dev/null
+++ b/src/adhesion_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci reconstruction module — tsb analytics library. */
+export interface AdhesionSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciReconstruction(data: number[], opts: AdhesionSciReconstructionOptions = {}): AdhesionSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciReconstruction };
diff --git a/src/adhesion_sci/registration.ts b/src/adhesion_sci/registration.ts
new file mode 100644
index 000000000..9dc68bfaa
--- /dev/null
+++ b/src/adhesion_sci/registration.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci registration module — tsb analytics library. */
+export interface AdhesionSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciRegistration(data: number[], opts: AdhesionSciRegistrationOptions = {}): AdhesionSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciRegistration };
diff --git a/src/adhesion_sci/regression.ts b/src/adhesion_sci/regression.ts
new file mode 100644
index 000000000..208b61d39
--- /dev/null
+++ b/src/adhesion_sci/regression.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci regression module — tsb analytics library. */
+export interface AdhesionSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciRegressionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciRegression(data: number[], opts: AdhesionSciRegressionOptions = {}): AdhesionSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciRegression };
diff --git a/src/adhesion_sci/regularization.ts b/src/adhesion_sci/regularization.ts
new file mode 100644
index 000000000..26d6f2357
--- /dev/null
+++ b/src/adhesion_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci regularization module — tsb analytics library. */
+export interface AdhesionSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciRegularization(data: number[], opts: AdhesionSciRegularizationOptions = {}): AdhesionSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciRegularization };
diff --git a/src/adhesion_sci/robustness.ts b/src/adhesion_sci/robustness.ts
new file mode 100644
index 000000000..58b9ae434
--- /dev/null
+++ b/src/adhesion_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci robustness module — tsb analytics library. */
+export interface AdhesionSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciRobustness(data: number[], opts: AdhesionSciRobustnessOptions = {}): AdhesionSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciRobustness };
diff --git a/src/adhesion_sci/sampling.ts b/src/adhesion_sci/sampling.ts
new file mode 100644
index 000000000..15de59d85
--- /dev/null
+++ b/src/adhesion_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci sampling module — tsb analytics library. */
+export interface AdhesionSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciSamplingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciSampling(data: number[], opts: AdhesionSciSamplingOptions = {}): AdhesionSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciSampling };
diff --git a/src/adhesion_sci/sampling2.ts b/src/adhesion_sci/sampling2.ts
new file mode 100644
index 000000000..a4e2c3bde
--- /dev/null
+++ b/src/adhesion_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci sampling2 module — tsb analytics library. */
+export interface AdhesionSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciSamplingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciSampling(data: number[], opts: AdhesionSciSamplingOptions = {}): AdhesionSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciSampling };
diff --git a/src/adhesion_sci/scaling.ts b/src/adhesion_sci/scaling.ts
new file mode 100644
index 000000000..4f6ae7d09
--- /dev/null
+++ b/src/adhesion_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci scaling module — tsb analytics library. */
+export interface AdhesionSciScalingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciScalingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciScaling(data: number[], opts: AdhesionSciScalingOptions = {}): AdhesionSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciScaling };
diff --git a/src/adhesion_sci/scoring.ts b/src/adhesion_sci/scoring.ts
new file mode 100644
index 000000000..08c4f02c7
--- /dev/null
+++ b/src/adhesion_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci scoring module — tsb analytics library. */
+export interface AdhesionSciScoringOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciScoringResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciScoring(data: number[], opts: AdhesionSciScoringOptions = {}): AdhesionSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciScoring };
diff --git a/src/adhesion_sci/segmentation.ts b/src/adhesion_sci/segmentation.ts
new file mode 100644
index 000000000..4b7dd5fc3
--- /dev/null
+++ b/src/adhesion_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci segmentation module — tsb analytics library. */
+export interface AdhesionSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciSegmentation(data: number[], opts: AdhesionSciSegmentationOptions = {}): AdhesionSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciSegmentation };
diff --git a/src/adhesion_sci/selection.ts b/src/adhesion_sci/selection.ts
new file mode 100644
index 000000000..60fc202e8
--- /dev/null
+++ b/src/adhesion_sci/selection.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci selection module — tsb analytics library. */
+export interface AdhesionSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciSelectionResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciSelection(data: number[], opts: AdhesionSciSelectionOptions = {}): AdhesionSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciSelection };
diff --git a/src/adhesion_sci/sensitivity.ts b/src/adhesion_sci/sensitivity.ts
new file mode 100644
index 000000000..fd14782ee
--- /dev/null
+++ b/src/adhesion_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci sensitivity module — tsb analytics library. */
+export interface AdhesionSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciSensitivity(data: number[], opts: AdhesionSciSensitivityOptions = {}): AdhesionSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciSensitivity };
diff --git a/src/adhesion_sci/simulation.ts b/src/adhesion_sci/simulation.ts
new file mode 100644
index 000000000..ceda788ae
--- /dev/null
+++ b/src/adhesion_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci simulation module — tsb analytics library. */
+export interface AdhesionSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciSimulationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciSimulation(data: number[], opts: AdhesionSciSimulationOptions = {}): AdhesionSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciSimulation };
diff --git a/src/adhesion_sci/smoothing.ts b/src/adhesion_sci/smoothing.ts
new file mode 100644
index 000000000..985af4db1
--- /dev/null
+++ b/src/adhesion_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci smoothing module — tsb analytics library. */
+export interface AdhesionSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciSmoothing(data: number[], opts: AdhesionSciSmoothingOptions = {}): AdhesionSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciSmoothing };
diff --git a/src/adhesion_sci/stability.ts b/src/adhesion_sci/stability.ts
new file mode 100644
index 000000000..75f669c8a
--- /dev/null
+++ b/src/adhesion_sci/stability.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci stability module — tsb analytics library. */
+export interface AdhesionSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciStabilityResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciStability(data: number[], opts: AdhesionSciStabilityOptions = {}): AdhesionSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciStability };
diff --git a/src/adhesion_sci/stacking.ts b/src/adhesion_sci/stacking.ts
new file mode 100644
index 000000000..657adc2f2
--- /dev/null
+++ b/src/adhesion_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci stacking module — tsb analytics library. */
+export interface AdhesionSciStackingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciStackingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciStacking(data: number[], opts: AdhesionSciStackingOptions = {}): AdhesionSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciStacking };
diff --git a/src/adhesion_sci/standardization.ts b/src/adhesion_sci/standardization.ts
new file mode 100644
index 000000000..d50fd812c
--- /dev/null
+++ b/src/adhesion_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci standardization module — tsb analytics library. */
+export interface AdhesionSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciStandardization(data: number[], opts: AdhesionSciStandardizationOptions = {}): AdhesionSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciStandardization };
diff --git a/src/adhesion_sci/static.ts b/src/adhesion_sci/static.ts
new file mode 100644
index 000000000..ab9c73162
--- /dev/null
+++ b/src/adhesion_sci/static.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci static module — tsb analytics library. */
+export interface AdhesionSciStaticOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciStaticResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciStatic(data: number[], opts: AdhesionSciStaticOptions = {}): AdhesionSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciStatic };
diff --git a/src/adhesion_sci/stochastic.ts b/src/adhesion_sci/stochastic.ts
new file mode 100644
index 000000000..e88f8c722
--- /dev/null
+++ b/src/adhesion_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci stochastic module — tsb analytics library. */
+export interface AdhesionSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciStochasticResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciStochastic(data: number[], opts: AdhesionSciStochasticOptions = {}): AdhesionSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciStochastic };
diff --git a/src/adhesion_sci/synthesis.ts b/src/adhesion_sci/synthesis.ts
new file mode 100644
index 000000000..5e763c0eb
--- /dev/null
+++ b/src/adhesion_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci synthesis module — tsb analytics library. */
+export interface AdhesionSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciSynthesis(data: number[], opts: AdhesionSciSynthesisOptions = {}): AdhesionSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciSynthesis };
diff --git a/src/adhesion_sci/topology.ts b/src/adhesion_sci/topology.ts
new file mode 100644
index 000000000..7d18814b5
--- /dev/null
+++ b/src/adhesion_sci/topology.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci topology module — tsb analytics library. */
+export interface AdhesionSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciTopologyResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciTopology(data: number[], opts: AdhesionSciTopologyOptions = {}): AdhesionSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciTopology };
diff --git a/src/adhesion_sci/tracking.ts b/src/adhesion_sci/tracking.ts
new file mode 100644
index 000000000..fb9f246b2
--- /dev/null
+++ b/src/adhesion_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci tracking module — tsb analytics library. */
+export interface AdhesionSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciTrackingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciTracking(data: number[], opts: AdhesionSciTrackingOptions = {}): AdhesionSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciTracking };
diff --git a/src/adhesion_sci/transform.ts b/src/adhesion_sci/transform.ts
new file mode 100644
index 000000000..a36c192ca
--- /dev/null
+++ b/src/adhesion_sci/transform.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci transform module — tsb analytics library. */
+export interface AdhesionSciTransformOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciTransformResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciTransform(data: number[], opts: AdhesionSciTransformOptions = {}): AdhesionSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciTransform };
diff --git a/src/adhesion_sci/uncertainty.ts b/src/adhesion_sci/uncertainty.ts
new file mode 100644
index 000000000..db6a352eb
--- /dev/null
+++ b/src/adhesion_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci uncertainty module — tsb analytics library. */
+export interface AdhesionSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciUncertainty(data: number[], opts: AdhesionSciUncertaintyOptions = {}): AdhesionSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciUncertainty };
diff --git a/src/adhesion_sci/validation.ts b/src/adhesion_sci/validation.ts
new file mode 100644
index 000000000..a2b5aa976
--- /dev/null
+++ b/src/adhesion_sci/validation.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci validation module — tsb analytics library. */
+export interface AdhesionSciValidationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciValidationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciValidation(data: number[], opts: AdhesionSciValidationOptions = {}): AdhesionSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciValidation };
diff --git a/src/adhesion_sci/verification.ts b/src/adhesion_sci/verification.ts
new file mode 100644
index 000000000..1f2b280a1
--- /dev/null
+++ b/src/adhesion_sci/verification.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci verification module — tsb analytics library. */
+export interface AdhesionSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciVerificationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciVerification(data: number[], opts: AdhesionSciVerificationOptions = {}): AdhesionSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciVerification };
diff --git a/src/adhesion_sci/visualization.ts b/src/adhesion_sci/visualization.ts
new file mode 100644
index 000000000..4c700cf4f
--- /dev/null
+++ b/src/adhesion_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci visualization module — tsb analytics library. */
+export interface AdhesionSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciVisualization(data: number[], opts: AdhesionSciVisualizationOptions = {}): AdhesionSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciVisualization };
diff --git a/src/adhesion_sci/voting.ts b/src/adhesion_sci/voting.ts
new file mode 100644
index 000000000..e89e5a0ce
--- /dev/null
+++ b/src/adhesion_sci/voting.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci voting module — tsb analytics library. */
+export interface AdhesionSciVotingOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciVotingResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciVoting(data: number[], opts: AdhesionSciVotingOptions = {}): AdhesionSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciVoting };
diff --git a/src/adhesion_sci/wavelet.ts b/src/adhesion_sci/wavelet.ts
new file mode 100644
index 000000000..01f4466d6
--- /dev/null
+++ b/src/adhesion_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** adhesion_sci wavelet module — tsb analytics library. */
+export interface AdhesionSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface AdhesionSciWaveletResult { values: number[]; converged: boolean; }
+export function computeAdhesionSciWavelet(data: number[], opts: AdhesionSciWaveletOptions = {}): AdhesionSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAdhesionSciWavelet };
diff --git a/src/agricultural_sci/adaptation.ts b/src/agricultural_sci/adaptation.ts
new file mode 100644
index 000000000..a3cd77dea
--- /dev/null
+++ b/src/agricultural_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci adaptation module — tsb analytics library. */
+export interface AgriculturalSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciAdaptation(data: number[], opts: AgriculturalSciAdaptationOptions = {}): AgriculturalSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciAdaptation };
diff --git a/src/agricultural_sci/aggregation.ts b/src/agricultural_sci/aggregation.ts
new file mode 100644
index 000000000..2483b3060
--- /dev/null
+++ b/src/agricultural_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci aggregation module — tsb analytics library. */
+export interface AgriculturalSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciAggregationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciAggregation(data: number[], opts: AgriculturalSciAggregationOptions = {}): AgriculturalSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciAggregation };
diff --git a/src/agricultural_sci/algebra.ts b/src/agricultural_sci/algebra.ts
new file mode 100644
index 000000000..04b3e4b13
--- /dev/null
+++ b/src/agricultural_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci algebra module — tsb analytics library. */
+export interface AgriculturalSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciAlgebra(data: number[], opts: AgriculturalSciAlgebraOptions = {}): AgriculturalSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciAlgebra };
diff --git a/src/agricultural_sci/alignment.ts b/src/agricultural_sci/alignment.ts
new file mode 100644
index 000000000..d0e76caa6
--- /dev/null
+++ b/src/agricultural_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci alignment module — tsb analytics library. */
+export interface AgriculturalSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciAlignment(data: number[], opts: AgriculturalSciAlignmentOptions = {}): AgriculturalSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciAlignment };
diff --git a/src/agricultural_sci/analysis.ts b/src/agricultural_sci/analysis.ts
new file mode 100644
index 000000000..7c7a8c02a
--- /dev/null
+++ b/src/agricultural_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci analysis module — tsb analytics library. */
+export interface AgriculturalSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciAnalysis(data: number[], opts: AgriculturalSciAnalysisOptions = {}): AgriculturalSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciAnalysis };
diff --git a/src/agricultural_sci/augmentation.ts b/src/agricultural_sci/augmentation.ts
new file mode 100644
index 000000000..ffe86ebdd
--- /dev/null
+++ b/src/agricultural_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci augmentation module — tsb analytics library. */
+export interface AgriculturalSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciAugmentation(data: number[], opts: AgriculturalSciAugmentationOptions = {}): AgriculturalSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciAugmentation };
diff --git a/src/agricultural_sci/bagging.ts b/src/agricultural_sci/bagging.ts
new file mode 100644
index 000000000..a6295ba82
--- /dev/null
+++ b/src/agricultural_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci bagging module — tsb analytics library. */
+export interface AgriculturalSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciBaggingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciBagging(data: number[], opts: AgriculturalSciBaggingOptions = {}): AgriculturalSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciBagging };
diff --git a/src/agricultural_sci/basis.ts b/src/agricultural_sci/basis.ts
new file mode 100644
index 000000000..cd6148a14
--- /dev/null
+++ b/src/agricultural_sci/basis.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci basis module — tsb analytics library. */
+export interface AgriculturalSciBasisOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciBasisResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciBasis(data: number[], opts: AgriculturalSciBasisOptions = {}): AgriculturalSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciBasis };
diff --git a/src/agricultural_sci/benchmarking.ts b/src/agricultural_sci/benchmarking.ts
new file mode 100644
index 000000000..54a3ebf22
--- /dev/null
+++ b/src/agricultural_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci benchmarking module — tsb analytics library. */
+export interface AgriculturalSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciBenchmarking(data: number[], opts: AgriculturalSciBenchmarkingOptions = {}): AgriculturalSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciBenchmarking };
diff --git a/src/agricultural_sci/blending.ts b/src/agricultural_sci/blending.ts
new file mode 100644
index 000000000..59866a169
--- /dev/null
+++ b/src/agricultural_sci/blending.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci blending module — tsb analytics library. */
+export interface AgriculturalSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciBlendingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciBlending(data: number[], opts: AgriculturalSciBlendingOptions = {}): AgriculturalSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciBlending };
diff --git a/src/agricultural_sci/boosting.ts b/src/agricultural_sci/boosting.ts
new file mode 100644
index 000000000..624ca229a
--- /dev/null
+++ b/src/agricultural_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci boosting module — tsb analytics library. */
+export interface AgriculturalSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciBoostingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciBoosting(data: number[], opts: AgriculturalSciBoostingOptions = {}): AgriculturalSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciBoosting };
diff --git a/src/agricultural_sci/bootstrap.ts b/src/agricultural_sci/bootstrap.ts
new file mode 100644
index 000000000..4995a25da
--- /dev/null
+++ b/src/agricultural_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci bootstrap module — tsb analytics library. */
+export interface AgriculturalSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciBootstrap(data: number[], opts: AgriculturalSciBootstrapOptions = {}): AgriculturalSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciBootstrap };
diff --git a/src/agricultural_sci/calculus.ts b/src/agricultural_sci/calculus.ts
new file mode 100644
index 000000000..d3d47941e
--- /dev/null
+++ b/src/agricultural_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci calculus module — tsb analytics library. */
+export interface AgriculturalSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciCalculusResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciCalculus(data: number[], opts: AgriculturalSciCalculusOptions = {}): AgriculturalSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciCalculus };
diff --git a/src/agricultural_sci/calibration.ts b/src/agricultural_sci/calibration.ts
new file mode 100644
index 000000000..db98ead09
--- /dev/null
+++ b/src/agricultural_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci calibration module — tsb analytics library. */
+export interface AgriculturalSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciCalibration(data: number[], opts: AgriculturalSciCalibrationOptions = {}): AgriculturalSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciCalibration };
diff --git a/src/agricultural_sci/characterization.ts b/src/agricultural_sci/characterization.ts
new file mode 100644
index 000000000..78c6f9e1a
--- /dev/null
+++ b/src/agricultural_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci characterization module — tsb analytics library. */
+export interface AgriculturalSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciCharacterization(data: number[], opts: AgriculturalSciCharacterizationOptions = {}): AgriculturalSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciCharacterization };
diff --git a/src/agricultural_sci/classification.ts b/src/agricultural_sci/classification.ts
new file mode 100644
index 000000000..658dc8d26
--- /dev/null
+++ b/src/agricultural_sci/classification.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci classification module — tsb analytics library. */
+export interface AgriculturalSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciClassificationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciClassification(data: number[], opts: AgriculturalSciClassificationOptions = {}): AgriculturalSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciClassification };
diff --git a/src/agricultural_sci/clustering.ts b/src/agricultural_sci/clustering.ts
new file mode 100644
index 000000000..b55564a4e
--- /dev/null
+++ b/src/agricultural_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci clustering module — tsb analytics library. */
+export interface AgriculturalSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciClusteringResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciClustering(data: number[], opts: AgriculturalSciClusteringOptions = {}): AgriculturalSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciClustering };
diff --git a/src/agricultural_sci/compression.ts b/src/agricultural_sci/compression.ts
new file mode 100644
index 000000000..bf61799c7
--- /dev/null
+++ b/src/agricultural_sci/compression.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci compression module — tsb analytics library. */
+export interface AgriculturalSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciCompressionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciCompression(data: number[], opts: AgriculturalSciCompressionOptions = {}): AgriculturalSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciCompression };
diff --git a/src/agricultural_sci/continuous.ts b/src/agricultural_sci/continuous.ts
new file mode 100644
index 000000000..8590fd0fe
--- /dev/null
+++ b/src/agricultural_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci continuous module — tsb analytics library. */
+export interface AgriculturalSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciContinuousResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciContinuous(data: number[], opts: AgriculturalSciContinuousOptions = {}): AgriculturalSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciContinuous };
diff --git a/src/agricultural_sci/control.ts b/src/agricultural_sci/control.ts
new file mode 100644
index 000000000..e8b154258
--- /dev/null
+++ b/src/agricultural_sci/control.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci control module — tsb analytics library. */
+export interface AgriculturalSciControlOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciControlResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciControl(data: number[], opts: AgriculturalSciControlOptions = {}): AgriculturalSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciControl };
diff --git a/src/agricultural_sci/convergence.ts b/src/agricultural_sci/convergence.ts
new file mode 100644
index 000000000..e404d61d6
--- /dev/null
+++ b/src/agricultural_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci convergence module — tsb analytics library. */
+export interface AgriculturalSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciConvergence(data: number[], opts: AgriculturalSciConvergenceOptions = {}): AgriculturalSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciConvergence };
diff --git a/src/agricultural_sci/convex.ts b/src/agricultural_sci/convex.ts
new file mode 100644
index 000000000..fc89d9f65
--- /dev/null
+++ b/src/agricultural_sci/convex.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci convex module — tsb analytics library. */
+export interface AgriculturalSciConvexOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciConvexResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciConvex(data: number[], opts: AgriculturalSciConvexOptions = {}): AgriculturalSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciConvex };
diff --git a/src/agricultural_sci/correlation.ts b/src/agricultural_sci/correlation.ts
new file mode 100644
index 000000000..c2d84b57a
--- /dev/null
+++ b/src/agricultural_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci correlation module — tsb analytics library. */
+export interface AgriculturalSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciCorrelation(data: number[], opts: AgriculturalSciCorrelationOptions = {}): AgriculturalSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciCorrelation };
diff --git a/src/agricultural_sci/covariance.ts b/src/agricultural_sci/covariance.ts
new file mode 100644
index 000000000..438d238c7
--- /dev/null
+++ b/src/agricultural_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci covariance module — tsb analytics library. */
+export interface AgriculturalSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciCovariance(data: number[], opts: AgriculturalSciCovarianceOptions = {}): AgriculturalSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciCovariance };
diff --git a/src/agricultural_sci/cross_validation.ts b/src/agricultural_sci/cross_validation.ts
new file mode 100644
index 000000000..c565d5462
--- /dev/null
+++ b/src/agricultural_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci cross_validation module — tsb analytics library. */
+export interface AgriculturalSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciCrossValidation(data: number[], opts: AgriculturalSciCrossValidationOptions = {}): AgriculturalSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciCrossValidation };
diff --git a/src/agricultural_sci/decoding.ts b/src/agricultural_sci/decoding.ts
new file mode 100644
index 000000000..e0bf27a24
--- /dev/null
+++ b/src/agricultural_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci decoding module — tsb analytics library. */
+export interface AgriculturalSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDecodingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDecoding(data: number[], opts: AgriculturalSciDecodingOptions = {}): AgriculturalSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDecoding };
diff --git a/src/agricultural_sci/decomposition.ts b/src/agricultural_sci/decomposition.ts
new file mode 100644
index 000000000..1876e5777
--- /dev/null
+++ b/src/agricultural_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci decomposition module — tsb analytics library. */
+export interface AgriculturalSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDecomposition(data: number[], opts: AgriculturalSciDecompositionOptions = {}): AgriculturalSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDecomposition };
diff --git a/src/agricultural_sci/detection.ts b/src/agricultural_sci/detection.ts
new file mode 100644
index 000000000..262404c7c
--- /dev/null
+++ b/src/agricultural_sci/detection.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci detection module — tsb analytics library. */
+export interface AgriculturalSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDetectionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDetection(data: number[], opts: AgriculturalSciDetectionOptions = {}): AgriculturalSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDetection };
diff --git a/src/agricultural_sci/deterministic.ts b/src/agricultural_sci/deterministic.ts
new file mode 100644
index 000000000..35fe57934
--- /dev/null
+++ b/src/agricultural_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci deterministic module — tsb analytics library. */
+export interface AgriculturalSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDeterministic(data: number[], opts: AgriculturalSciDeterministicOptions = {}): AgriculturalSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDeterministic };
diff --git a/src/agricultural_sci/diagnostics.ts b/src/agricultural_sci/diagnostics.ts
new file mode 100644
index 000000000..4fb6de502
--- /dev/null
+++ b/src/agricultural_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci diagnostics module — tsb analytics library. */
+export interface AgriculturalSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDiagnostics(data: number[], opts: AgriculturalSciDiagnosticsOptions = {}): AgriculturalSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDiagnostics };
diff --git a/src/agricultural_sci/differential.ts b/src/agricultural_sci/differential.ts
new file mode 100644
index 000000000..1eccb659a
--- /dev/null
+++ b/src/agricultural_sci/differential.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci differential module — tsb analytics library. */
+export interface AgriculturalSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDifferential(data: number[], opts: AgriculturalSciDifferentialOptions = {}): AgriculturalSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDifferential };
diff --git a/src/agricultural_sci/discrete.ts b/src/agricultural_sci/discrete.ts
new file mode 100644
index 000000000..6084e2227
--- /dev/null
+++ b/src/agricultural_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci discrete module — tsb analytics library. */
+export interface AgriculturalSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDiscrete(data: number[], opts: AgriculturalSciDiscreteOptions = {}): AgriculturalSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDiscrete };
diff --git a/src/agricultural_sci/distribution.ts b/src/agricultural_sci/distribution.ts
new file mode 100644
index 000000000..cff6e6f1c
--- /dev/null
+++ b/src/agricultural_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci distribution module — tsb analytics library. */
+export interface AgriculturalSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDistributionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDistribution(data: number[], opts: AgriculturalSciDistributionOptions = {}): AgriculturalSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDistribution };
diff --git a/src/agricultural_sci/dynamic.ts b/src/agricultural_sci/dynamic.ts
new file mode 100644
index 000000000..a4d33f6dc
--- /dev/null
+++ b/src/agricultural_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci dynamic module — tsb analytics library. */
+export interface AgriculturalSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciDynamicResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciDynamic(data: number[], opts: AgriculturalSciDynamicOptions = {}): AgriculturalSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciDynamic };
diff --git a/src/agricultural_sci/embedding.ts b/src/agricultural_sci/embedding.ts
new file mode 100644
index 000000000..69dbb15e4
--- /dev/null
+++ b/src/agricultural_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci embedding module — tsb analytics library. */
+export interface AgriculturalSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciEmbedding(data: number[], opts: AgriculturalSciEmbeddingOptions = {}): AgriculturalSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciEmbedding };
diff --git a/src/agricultural_sci/encoding.ts b/src/agricultural_sci/encoding.ts
new file mode 100644
index 000000000..7739133f5
--- /dev/null
+++ b/src/agricultural_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci encoding module — tsb analytics library. */
+export interface AgriculturalSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciEncodingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciEncoding(data: number[], opts: AgriculturalSciEncodingOptions = {}): AgriculturalSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciEncoding };
diff --git a/src/agricultural_sci/ensemble.ts b/src/agricultural_sci/ensemble.ts
new file mode 100644
index 000000000..f2af58f8e
--- /dev/null
+++ b/src/agricultural_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci ensemble module — tsb analytics library. */
+export interface AgriculturalSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciEnsemble(data: number[], opts: AgriculturalSciEnsembleOptions = {}): AgriculturalSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciEnsemble };
diff --git a/src/agricultural_sci/estimation.ts b/src/agricultural_sci/estimation.ts
new file mode 100644
index 000000000..71b16bfed
--- /dev/null
+++ b/src/agricultural_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci estimation module — tsb analytics library. */
+export interface AgriculturalSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciEstimationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciEstimation(data: number[], opts: AgriculturalSciEstimationOptions = {}): AgriculturalSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciEstimation };
diff --git a/src/agricultural_sci/evaluation.ts b/src/agricultural_sci/evaluation.ts
new file mode 100644
index 000000000..41a210c8e
--- /dev/null
+++ b/src/agricultural_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci evaluation module — tsb analytics library. */
+export interface AgriculturalSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciEvaluation(data: number[], opts: AgriculturalSciEvaluationOptions = {}): AgriculturalSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciEvaluation };
diff --git a/src/agricultural_sci/extrapolation.ts b/src/agricultural_sci/extrapolation.ts
new file mode 100644
index 000000000..8d578a73a
--- /dev/null
+++ b/src/agricultural_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci extrapolation module — tsb analytics library. */
+export interface AgriculturalSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciExtrapolation(data: number[], opts: AgriculturalSciExtrapolationOptions = {}): AgriculturalSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciExtrapolation };
diff --git a/src/agricultural_sci/features.ts b/src/agricultural_sci/features.ts
new file mode 100644
index 000000000..75253f145
--- /dev/null
+++ b/src/agricultural_sci/features.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci features module — tsb analytics library. */
+export interface AgriculturalSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciFeatures(data: number[], opts: AgriculturalSciFeaturesOptions = {}): AgriculturalSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciFeatures };
diff --git a/src/agricultural_sci/feedback.ts b/src/agricultural_sci/feedback.ts
new file mode 100644
index 000000000..7ce35f30b
--- /dev/null
+++ b/src/agricultural_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci feedback module — tsb analytics library. */
+export interface AgriculturalSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciFeedback(data: number[], opts: AgriculturalSciFeedbackOptions = {}): AgriculturalSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciFeedback };
diff --git a/src/agricultural_sci/filtering.ts b/src/agricultural_sci/filtering.ts
new file mode 100644
index 000000000..09d9f341a
--- /dev/null
+++ b/src/agricultural_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci filtering module — tsb analytics library. */
+export interface AgriculturalSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciFilteringResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciFiltering(data: number[], opts: AgriculturalSciFilteringOptions = {}): AgriculturalSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciFiltering };
diff --git a/src/agricultural_sci/fourier.ts b/src/agricultural_sci/fourier.ts
new file mode 100644
index 000000000..d0136a0f0
--- /dev/null
+++ b/src/agricultural_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci fourier module — tsb analytics library. */
+export interface AgriculturalSciFourierOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciFourierResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciFourier(data: number[], opts: AgriculturalSciFourierOptions = {}): AgriculturalSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciFourier };
diff --git a/src/agricultural_sci/fusion.ts b/src/agricultural_sci/fusion.ts
new file mode 100644
index 000000000..0c0419b33
--- /dev/null
+++ b/src/agricultural_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci fusion module — tsb analytics library. */
+export interface AgriculturalSciFusionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciFusionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciFusion(data: number[], opts: AgriculturalSciFusionOptions = {}): AgriculturalSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciFusion };
diff --git a/src/agricultural_sci/generation.ts b/src/agricultural_sci/generation.ts
new file mode 100644
index 000000000..bb2fac031
--- /dev/null
+++ b/src/agricultural_sci/generation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci generation module — tsb analytics library. */
+export interface AgriculturalSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciGenerationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciGeneration(data: number[], opts: AgriculturalSciGenerationOptions = {}): AgriculturalSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciGeneration };
diff --git a/src/agricultural_sci/geometry.ts b/src/agricultural_sci/geometry.ts
new file mode 100644
index 000000000..871914f23
--- /dev/null
+++ b/src/agricultural_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci geometry module — tsb analytics library. */
+export interface AgriculturalSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciGeometryResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciGeometry(data: number[], opts: AgriculturalSciGeometryOptions = {}): AgriculturalSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciGeometry };
diff --git a/src/agricultural_sci/gradient.ts b/src/agricultural_sci/gradient.ts
new file mode 100644
index 000000000..b8a0982cf
--- /dev/null
+++ b/src/agricultural_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci gradient module — tsb analytics library. */
+export interface AgriculturalSciGradientOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciGradientResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciGradient(data: number[], opts: AgriculturalSciGradientOptions = {}): AgriculturalSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciGradient };
diff --git a/src/agricultural_sci/hessian.ts b/src/agricultural_sci/hessian.ts
new file mode 100644
index 000000000..b2e828545
--- /dev/null
+++ b/src/agricultural_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci hessian module — tsb analytics library. */
+export interface AgriculturalSciHessianOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciHessianResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciHessian(data: number[], opts: AgriculturalSciHessianOptions = {}): AgriculturalSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciHessian };
diff --git a/src/agricultural_sci/hypothesis.ts b/src/agricultural_sci/hypothesis.ts
new file mode 100644
index 000000000..2aece3861
--- /dev/null
+++ b/src/agricultural_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci hypothesis module — tsb analytics library. */
+export interface AgriculturalSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciHypothesis(data: number[], opts: AgriculturalSciHypothesisOptions = {}): AgriculturalSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciHypothesis };
diff --git a/src/agricultural_sci/inference.ts b/src/agricultural_sci/inference.ts
new file mode 100644
index 000000000..5761c9137
--- /dev/null
+++ b/src/agricultural_sci/inference.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci inference module — tsb analytics library. */
+export interface AgriculturalSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciInferenceResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciInference(data: number[], opts: AgriculturalSciInferenceOptions = {}): AgriculturalSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciInference };
diff --git a/src/agricultural_sci/inference2.ts b/src/agricultural_sci/inference2.ts
new file mode 100644
index 000000000..384d1a6c6
--- /dev/null
+++ b/src/agricultural_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci inference2 module — tsb analytics library. */
+export interface AgriculturalSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciInferenceResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciInference(data: number[], opts: AgriculturalSciInferenceOptions = {}): AgriculturalSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciInference };
diff --git a/src/agricultural_sci/integral.ts b/src/agricultural_sci/integral.ts
new file mode 100644
index 000000000..862acf43d
--- /dev/null
+++ b/src/agricultural_sci/integral.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci integral module — tsb analytics library. */
+export interface AgriculturalSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciIntegralResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciIntegral(data: number[], opts: AgriculturalSciIntegralOptions = {}): AgriculturalSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciIntegral };
diff --git a/src/agricultural_sci/integration.ts b/src/agricultural_sci/integration.ts
new file mode 100644
index 000000000..5e6cd3488
--- /dev/null
+++ b/src/agricultural_sci/integration.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci integration module — tsb analytics library. */
+export interface AgriculturalSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciIntegration(data: number[], opts: AgriculturalSciIntegrationOptions = {}): AgriculturalSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciIntegration };
diff --git a/src/agricultural_sci/interpolation.ts b/src/agricultural_sci/interpolation.ts
new file mode 100644
index 000000000..4402fe54d
--- /dev/null
+++ b/src/agricultural_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci interpolation module — tsb analytics library. */
+export interface AgriculturalSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciInterpolation(data: number[], opts: AgriculturalSciInterpolationOptions = {}): AgriculturalSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciInterpolation };
diff --git a/src/agricultural_sci/jacobian.ts b/src/agricultural_sci/jacobian.ts
new file mode 100644
index 000000000..511f665d7
--- /dev/null
+++ b/src/agricultural_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci jacobian module — tsb analytics library. */
+export interface AgriculturalSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciJacobianResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciJacobian(data: number[], opts: AgriculturalSciJacobianOptions = {}): AgriculturalSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciJacobian };
diff --git a/src/agricultural_sci/kernel.ts b/src/agricultural_sci/kernel.ts
new file mode 100644
index 000000000..fab3575fb
--- /dev/null
+++ b/src/agricultural_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci kernel module — tsb analytics library. */
+export interface AgriculturalSciKernelOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciKernelResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciKernel(data: number[], opts: AgriculturalSciKernelOptions = {}): AgriculturalSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciKernel };
diff --git a/src/agricultural_sci/laplacian.ts b/src/agricultural_sci/laplacian.ts
new file mode 100644
index 000000000..6fdd11d24
--- /dev/null
+++ b/src/agricultural_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci laplacian module — tsb analytics library. */
+export interface AgriculturalSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciLaplacian(data: number[], opts: AgriculturalSciLaplacianOptions = {}): AgriculturalSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciLaplacian };
diff --git a/src/agricultural_sci/learning.ts b/src/agricultural_sci/learning.ts
new file mode 100644
index 000000000..4a5b21cca
--- /dev/null
+++ b/src/agricultural_sci/learning.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci learning module — tsb analytics library. */
+export interface AgriculturalSciLearningOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciLearningResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciLearning(data: number[], opts: AgriculturalSciLearningOptions = {}): AgriculturalSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciLearning };
diff --git a/src/agricultural_sci/linear.ts b/src/agricultural_sci/linear.ts
new file mode 100644
index 000000000..b9f041f47
--- /dev/null
+++ b/src/agricultural_sci/linear.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci linear module — tsb analytics library. */
+export interface AgriculturalSciLinearOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciLinearResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciLinear(data: number[], opts: AgriculturalSciLinearOptions = {}): AgriculturalSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciLinear };
diff --git a/src/agricultural_sci/manifold.ts b/src/agricultural_sci/manifold.ts
new file mode 100644
index 000000000..48a1c0880
--- /dev/null
+++ b/src/agricultural_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci manifold module — tsb analytics library. */
+export interface AgriculturalSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciManifoldResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciManifold(data: number[], opts: AgriculturalSciManifoldOptions = {}): AgriculturalSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciManifold };
diff --git a/src/agricultural_sci/matching.ts b/src/agricultural_sci/matching.ts
new file mode 100644
index 000000000..4ef05362f
--- /dev/null
+++ b/src/agricultural_sci/matching.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci matching module — tsb analytics library. */
+export interface AgriculturalSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciMatchingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciMatching(data: number[], opts: AgriculturalSciMatchingOptions = {}): AgriculturalSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciMatching };
diff --git a/src/agricultural_sci/measurement.ts b/src/agricultural_sci/measurement.ts
new file mode 100644
index 000000000..08f62f69d
--- /dev/null
+++ b/src/agricultural_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci measurement module — tsb analytics library. */
+export interface AgriculturalSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciMeasurement(data: number[], opts: AgriculturalSciMeasurementOptions = {}): AgriculturalSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciMeasurement };
diff --git a/src/agricultural_sci/metrics.ts b/src/agricultural_sci/metrics.ts
new file mode 100644
index 000000000..d6d5e9aa7
--- /dev/null
+++ b/src/agricultural_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci metrics module — tsb analytics library. */
+export interface AgriculturalSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciMetricsResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciMetrics(data: number[], opts: AgriculturalSciMetricsOptions = {}): AgriculturalSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciMetrics };
diff --git a/src/agricultural_sci/modeling.ts b/src/agricultural_sci/modeling.ts
new file mode 100644
index 000000000..5b1a0776c
--- /dev/null
+++ b/src/agricultural_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci modeling module — tsb analytics library. */
+export interface AgriculturalSciModelingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciModelingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciModeling(data: number[], opts: AgriculturalSciModelingOptions = {}): AgriculturalSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciModeling };
diff --git a/src/agricultural_sci/monitoring.ts b/src/agricultural_sci/monitoring.ts
new file mode 100644
index 000000000..a7574e812
--- /dev/null
+++ b/src/agricultural_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci monitoring module — tsb analytics library. */
+export interface AgriculturalSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciMonitoring(data: number[], opts: AgriculturalSciMonitoringOptions = {}): AgriculturalSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciMonitoring };
diff --git a/src/agricultural_sci/nonlinear.ts b/src/agricultural_sci/nonlinear.ts
new file mode 100644
index 000000000..c8a7349cc
--- /dev/null
+++ b/src/agricultural_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci nonlinear module — tsb analytics library. */
+export interface AgriculturalSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciNonlinear(data: number[], opts: AgriculturalSciNonlinearOptions = {}): AgriculturalSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciNonlinear };
diff --git a/src/agricultural_sci/normalization.ts b/src/agricultural_sci/normalization.ts
new file mode 100644
index 000000000..04c8a602d
--- /dev/null
+++ b/src/agricultural_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci normalization module — tsb analytics library. */
+export interface AgriculturalSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciNormalization(data: number[], opts: AgriculturalSciNormalizationOptions = {}): AgriculturalSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciNormalization };
diff --git a/src/agricultural_sci/optimization.ts b/src/agricultural_sci/optimization.ts
new file mode 100644
index 000000000..28e0a8537
--- /dev/null
+++ b/src/agricultural_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci optimization module — tsb analytics library. */
+export interface AgriculturalSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciOptimization(data: number[], opts: AgriculturalSciOptimizationOptions = {}): AgriculturalSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciOptimization };
diff --git a/src/agricultural_sci/patterns.ts b/src/agricultural_sci/patterns.ts
new file mode 100644
index 000000000..4beacb0f2
--- /dev/null
+++ b/src/agricultural_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci patterns module — tsb analytics library. */
+export interface AgriculturalSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciPatternsResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciPatterns(data: number[], opts: AgriculturalSciPatternsOptions = {}): AgriculturalSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciPatterns };
diff --git a/src/agricultural_sci/permutation.ts b/src/agricultural_sci/permutation.ts
new file mode 100644
index 000000000..2257f9046
--- /dev/null
+++ b/src/agricultural_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci permutation module — tsb analytics library. */
+export interface AgriculturalSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciPermutationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciPermutation(data: number[], opts: AgriculturalSciPermutationOptions = {}): AgriculturalSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciPermutation };
diff --git a/src/agricultural_sci/prediction.ts b/src/agricultural_sci/prediction.ts
new file mode 100644
index 000000000..70c0372ba
--- /dev/null
+++ b/src/agricultural_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci prediction module — tsb analytics library. */
+export interface AgriculturalSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciPredictionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciPrediction(data: number[], opts: AgriculturalSciPredictionOptions = {}): AgriculturalSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciPrediction };
diff --git a/src/agricultural_sci/processing.ts b/src/agricultural_sci/processing.ts
new file mode 100644
index 000000000..fd1336e07
--- /dev/null
+++ b/src/agricultural_sci/processing.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci processing module — tsb analytics library. */
+export interface AgriculturalSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciProcessingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciProcessing(data: number[], opts: AgriculturalSciProcessingOptions = {}): AgriculturalSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciProcessing };
diff --git a/src/agricultural_sci/profiling.ts b/src/agricultural_sci/profiling.ts
new file mode 100644
index 000000000..3dcc3a873
--- /dev/null
+++ b/src/agricultural_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci profiling module — tsb analytics library. */
+export interface AgriculturalSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciProfilingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciProfiling(data: number[], opts: AgriculturalSciProfilingOptions = {}): AgriculturalSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciProfiling };
diff --git a/src/agricultural_sci/projection.ts b/src/agricultural_sci/projection.ts
new file mode 100644
index 000000000..7eea5add0
--- /dev/null
+++ b/src/agricultural_sci/projection.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci projection module — tsb analytics library. */
+export interface AgriculturalSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciProjectionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciProjection(data: number[], opts: AgriculturalSciProjectionOptions = {}): AgriculturalSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciProjection };
diff --git a/src/agricultural_sci/ranking.ts b/src/agricultural_sci/ranking.ts
new file mode 100644
index 000000000..02c02c789
--- /dev/null
+++ b/src/agricultural_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci ranking module — tsb analytics library. */
+export interface AgriculturalSciRankingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciRankingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciRanking(data: number[], opts: AgriculturalSciRankingOptions = {}): AgriculturalSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciRanking };
diff --git a/src/agricultural_sci/reconstruction.ts b/src/agricultural_sci/reconstruction.ts
new file mode 100644
index 000000000..8054c579b
--- /dev/null
+++ b/src/agricultural_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci reconstruction module — tsb analytics library. */
+export interface AgriculturalSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciReconstruction(data: number[], opts: AgriculturalSciReconstructionOptions = {}): AgriculturalSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciReconstruction };
diff --git a/src/agricultural_sci/registration.ts b/src/agricultural_sci/registration.ts
new file mode 100644
index 000000000..3a7c9600d
--- /dev/null
+++ b/src/agricultural_sci/registration.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci registration module — tsb analytics library. */
+export interface AgriculturalSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciRegistration(data: number[], opts: AgriculturalSciRegistrationOptions = {}): AgriculturalSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciRegistration };
diff --git a/src/agricultural_sci/regression.ts b/src/agricultural_sci/regression.ts
new file mode 100644
index 000000000..abbd45821
--- /dev/null
+++ b/src/agricultural_sci/regression.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci regression module — tsb analytics library. */
+export interface AgriculturalSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciRegressionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciRegression(data: number[], opts: AgriculturalSciRegressionOptions = {}): AgriculturalSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciRegression };
diff --git a/src/agricultural_sci/regularization.ts b/src/agricultural_sci/regularization.ts
new file mode 100644
index 000000000..db93009ca
--- /dev/null
+++ b/src/agricultural_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci regularization module — tsb analytics library. */
+export interface AgriculturalSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciRegularization(data: number[], opts: AgriculturalSciRegularizationOptions = {}): AgriculturalSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciRegularization };
diff --git a/src/agricultural_sci/robustness.ts b/src/agricultural_sci/robustness.ts
new file mode 100644
index 000000000..19d5cf43b
--- /dev/null
+++ b/src/agricultural_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci robustness module — tsb analytics library. */
+export interface AgriculturalSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciRobustness(data: number[], opts: AgriculturalSciRobustnessOptions = {}): AgriculturalSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciRobustness };
diff --git a/src/agricultural_sci/sampling.ts b/src/agricultural_sci/sampling.ts
new file mode 100644
index 000000000..e75d8ca83
--- /dev/null
+++ b/src/agricultural_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci sampling module — tsb analytics library. */
+export interface AgriculturalSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciSamplingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciSampling(data: number[], opts: AgriculturalSciSamplingOptions = {}): AgriculturalSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciSampling };
diff --git a/src/agricultural_sci/sampling2.ts b/src/agricultural_sci/sampling2.ts
new file mode 100644
index 000000000..657f4497e
--- /dev/null
+++ b/src/agricultural_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci sampling2 module — tsb analytics library. */
+export interface AgriculturalSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciSamplingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciSampling(data: number[], opts: AgriculturalSciSamplingOptions = {}): AgriculturalSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciSampling };
diff --git a/src/agricultural_sci/scaling.ts b/src/agricultural_sci/scaling.ts
new file mode 100644
index 000000000..3ab21c879
--- /dev/null
+++ b/src/agricultural_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci scaling module — tsb analytics library. */
+export interface AgriculturalSciScalingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciScalingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciScaling(data: number[], opts: AgriculturalSciScalingOptions = {}): AgriculturalSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciScaling };
diff --git a/src/agricultural_sci/scoring.ts b/src/agricultural_sci/scoring.ts
new file mode 100644
index 000000000..3e717d3fa
--- /dev/null
+++ b/src/agricultural_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci scoring module — tsb analytics library. */
+export interface AgriculturalSciScoringOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciScoringResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciScoring(data: number[], opts: AgriculturalSciScoringOptions = {}): AgriculturalSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciScoring };
diff --git a/src/agricultural_sci/segmentation.ts b/src/agricultural_sci/segmentation.ts
new file mode 100644
index 000000000..dcbd9b2e7
--- /dev/null
+++ b/src/agricultural_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci segmentation module — tsb analytics library. */
+export interface AgriculturalSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciSegmentation(data: number[], opts: AgriculturalSciSegmentationOptions = {}): AgriculturalSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciSegmentation };
diff --git a/src/agricultural_sci/selection.ts b/src/agricultural_sci/selection.ts
new file mode 100644
index 000000000..8f8e5698f
--- /dev/null
+++ b/src/agricultural_sci/selection.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci selection module — tsb analytics library. */
+export interface AgriculturalSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciSelectionResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciSelection(data: number[], opts: AgriculturalSciSelectionOptions = {}): AgriculturalSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciSelection };
diff --git a/src/agricultural_sci/sensitivity.ts b/src/agricultural_sci/sensitivity.ts
new file mode 100644
index 000000000..baa1f50d5
--- /dev/null
+++ b/src/agricultural_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci sensitivity module — tsb analytics library. */
+export interface AgriculturalSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciSensitivity(data: number[], opts: AgriculturalSciSensitivityOptions = {}): AgriculturalSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciSensitivity };
diff --git a/src/agricultural_sci/simulation.ts b/src/agricultural_sci/simulation.ts
new file mode 100644
index 000000000..f45ee06bb
--- /dev/null
+++ b/src/agricultural_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci simulation module — tsb analytics library. */
+export interface AgriculturalSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciSimulationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciSimulation(data: number[], opts: AgriculturalSciSimulationOptions = {}): AgriculturalSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciSimulation };
diff --git a/src/agricultural_sci/smoothing.ts b/src/agricultural_sci/smoothing.ts
new file mode 100644
index 000000000..232213c48
--- /dev/null
+++ b/src/agricultural_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci smoothing module — tsb analytics library. */
+export interface AgriculturalSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciSmoothing(data: number[], opts: AgriculturalSciSmoothingOptions = {}): AgriculturalSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciSmoothing };
diff --git a/src/agricultural_sci/stability.ts b/src/agricultural_sci/stability.ts
new file mode 100644
index 000000000..7dc5ee8e9
--- /dev/null
+++ b/src/agricultural_sci/stability.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci stability module — tsb analytics library. */
+export interface AgriculturalSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciStabilityResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciStability(data: number[], opts: AgriculturalSciStabilityOptions = {}): AgriculturalSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciStability };
diff --git a/src/agricultural_sci/stacking.ts b/src/agricultural_sci/stacking.ts
new file mode 100644
index 000000000..b2afb1521
--- /dev/null
+++ b/src/agricultural_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci stacking module — tsb analytics library. */
+export interface AgriculturalSciStackingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciStackingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciStacking(data: number[], opts: AgriculturalSciStackingOptions = {}): AgriculturalSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciStacking };
diff --git a/src/agricultural_sci/standardization.ts b/src/agricultural_sci/standardization.ts
new file mode 100644
index 000000000..93e819c79
--- /dev/null
+++ b/src/agricultural_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci standardization module — tsb analytics library. */
+export interface AgriculturalSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciStandardization(data: number[], opts: AgriculturalSciStandardizationOptions = {}): AgriculturalSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciStandardization };
diff --git a/src/agricultural_sci/static.ts b/src/agricultural_sci/static.ts
new file mode 100644
index 000000000..32a51d9f8
--- /dev/null
+++ b/src/agricultural_sci/static.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci static module — tsb analytics library. */
+export interface AgriculturalSciStaticOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciStaticResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciStatic(data: number[], opts: AgriculturalSciStaticOptions = {}): AgriculturalSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciStatic };
diff --git a/src/agricultural_sci/stochastic.ts b/src/agricultural_sci/stochastic.ts
new file mode 100644
index 000000000..24c851366
--- /dev/null
+++ b/src/agricultural_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci stochastic module — tsb analytics library. */
+export interface AgriculturalSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciStochasticResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciStochastic(data: number[], opts: AgriculturalSciStochasticOptions = {}): AgriculturalSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciStochastic };
diff --git a/src/agricultural_sci/synthesis.ts b/src/agricultural_sci/synthesis.ts
new file mode 100644
index 000000000..c713016c1
--- /dev/null
+++ b/src/agricultural_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci synthesis module — tsb analytics library. */
+export interface AgriculturalSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciSynthesis(data: number[], opts: AgriculturalSciSynthesisOptions = {}): AgriculturalSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciSynthesis };
diff --git a/src/agricultural_sci/topology.ts b/src/agricultural_sci/topology.ts
new file mode 100644
index 000000000..1827852c4
--- /dev/null
+++ b/src/agricultural_sci/topology.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci topology module — tsb analytics library. */
+export interface AgriculturalSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciTopologyResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciTopology(data: number[], opts: AgriculturalSciTopologyOptions = {}): AgriculturalSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciTopology };
diff --git a/src/agricultural_sci/tracking.ts b/src/agricultural_sci/tracking.ts
new file mode 100644
index 000000000..dba19e3db
--- /dev/null
+++ b/src/agricultural_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci tracking module — tsb analytics library. */
+export interface AgriculturalSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciTrackingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciTracking(data: number[], opts: AgriculturalSciTrackingOptions = {}): AgriculturalSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciTracking };
diff --git a/src/agricultural_sci/transform.ts b/src/agricultural_sci/transform.ts
new file mode 100644
index 000000000..0b59c0ecb
--- /dev/null
+++ b/src/agricultural_sci/transform.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci transform module — tsb analytics library. */
+export interface AgriculturalSciTransformOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciTransformResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciTransform(data: number[], opts: AgriculturalSciTransformOptions = {}): AgriculturalSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciTransform };
diff --git a/src/agricultural_sci/uncertainty.ts b/src/agricultural_sci/uncertainty.ts
new file mode 100644
index 000000000..45db32806
--- /dev/null
+++ b/src/agricultural_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci uncertainty module — tsb analytics library. */
+export interface AgriculturalSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciUncertainty(data: number[], opts: AgriculturalSciUncertaintyOptions = {}): AgriculturalSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciUncertainty };
diff --git a/src/agricultural_sci/validation.ts b/src/agricultural_sci/validation.ts
new file mode 100644
index 000000000..83da38b0b
--- /dev/null
+++ b/src/agricultural_sci/validation.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci validation module — tsb analytics library. */
+export interface AgriculturalSciValidationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciValidationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciValidation(data: number[], opts: AgriculturalSciValidationOptions = {}): AgriculturalSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciValidation };
diff --git a/src/agricultural_sci/verification.ts b/src/agricultural_sci/verification.ts
new file mode 100644
index 000000000..f3beceaa1
--- /dev/null
+++ b/src/agricultural_sci/verification.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci verification module — tsb analytics library. */
+export interface AgriculturalSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciVerificationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciVerification(data: number[], opts: AgriculturalSciVerificationOptions = {}): AgriculturalSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciVerification };
diff --git a/src/agricultural_sci/visualization.ts b/src/agricultural_sci/visualization.ts
new file mode 100644
index 000000000..50f63d4fe
--- /dev/null
+++ b/src/agricultural_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci visualization module — tsb analytics library. */
+export interface AgriculturalSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciVisualization(data: number[], opts: AgriculturalSciVisualizationOptions = {}): AgriculturalSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciVisualization };
diff --git a/src/agricultural_sci/voting.ts b/src/agricultural_sci/voting.ts
new file mode 100644
index 000000000..0b1ed6b13
--- /dev/null
+++ b/src/agricultural_sci/voting.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci voting module — tsb analytics library. */
+export interface AgriculturalSciVotingOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciVotingResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciVoting(data: number[], opts: AgriculturalSciVotingOptions = {}): AgriculturalSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciVoting };
diff --git a/src/agricultural_sci/wavelet.ts b/src/agricultural_sci/wavelet.ts
new file mode 100644
index 000000000..058a169d8
--- /dev/null
+++ b/src/agricultural_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** agricultural_sci wavelet module — tsb analytics library. */
+export interface AgriculturalSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface AgriculturalSciWaveletResult { values: number[]; converged: boolean; }
+export function computeAgriculturalSciWavelet(data: number[], opts: AgriculturalSciWaveletOptions = {}): AgriculturalSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAgriculturalSciWavelet };
diff --git a/src/analytics/ab_testing.ts b/src/analytics/ab_testing.ts
new file mode 100644
index 000000000..f998cfe8a
--- /dev/null
+++ b/src/analytics/ab_testing.ts
@@ -0,0 +1,22 @@
+/** Ab Testing module — tsb analytics library. */
+
+/** Options for Ab Testing. */
+export interface AbTestingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ab Testing. */
+export interface AbTestingResult { values: number[]; converged: boolean; }
+
+/** Compute Ab Testing. */
+export function computeAbTesting(data: number[], opts: AbTestingOptions = {}): AbTestingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAbTesting };
diff --git a/src/analytics/acquisition.ts b/src/analytics/acquisition.ts
new file mode 100644
index 000000000..8b921d071
--- /dev/null
+++ b/src/analytics/acquisition.ts
@@ -0,0 +1,22 @@
+/** Acquisition module — tsb analytics library. */
+
+/** Options for Acquisition. */
+export interface AcquisitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Acquisition. */
+export interface AcquisitionResult { values: number[]; converged: boolean; }
+
+/** Compute Acquisition. */
+export function computeAcquisition(data: number[], opts: AcquisitionOptions = {}): AcquisitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAcquisition };
diff --git a/src/analytics/activation.ts b/src/analytics/activation.ts
new file mode 100644
index 000000000..d34b74792
--- /dev/null
+++ b/src/analytics/activation.ts
@@ -0,0 +1,22 @@
+/** Activation module — tsb analytics library. */
+
+/** Options for Activation. */
+export interface ActivationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Activation. */
+export interface ActivationResult { values: number[]; converged: boolean; }
+
+/** Compute Activation. */
+export function computeActivation(data: number[], opts: ActivationOptions = {}): ActivationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeActivation };
diff --git a/src/analytics/advanced.ts b/src/analytics/advanced.ts
new file mode 100644
index 000000000..5659cd89d
--- /dev/null
+++ b/src/analytics/advanced.ts
@@ -0,0 +1,15 @@
+/** Analytics Advanced module — tsb analytics library. */
+export interface Analytics advancedOptions { tol?: number; maxIter?: number; }
+export interface Analytics advancedResult { values: number[]; converged: boolean; }
+export function computeAnalytics advanced(data: number[], opts: Analytics advancedOptions = {}): Analytics advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics advanced };
diff --git a/src/analytics/anomaly.ts b/src/analytics/anomaly.ts
new file mode 100644
index 000000000..a1e730a58
--- /dev/null
+++ b/src/analytics/anomaly.ts
@@ -0,0 +1,22 @@
+/** Anomaly module — tsb analytics library. */
+
+/** Options for Anomaly. */
+export interface AnomalyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Anomaly. */
+export interface AnomalyResult { values: number[]; converged: boolean; }
+
+/** Compute Anomaly. */
+export function computeAnomaly(data: number[], opts: AnomalyOptions = {}): AnomalyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAnomaly };
diff --git a/src/analytics/attribution.ts b/src/analytics/attribution.ts
new file mode 100644
index 000000000..6a397df16
--- /dev/null
+++ b/src/analytics/attribution.ts
@@ -0,0 +1,22 @@
+/** Attribution module — tsb analytics library. */
+
+/** Options for Attribution. */
+export interface AttributionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Attribution. */
+export interface AttributionResult { values: number[]; converged: boolean; }
+
+/** Compute Attribution. */
+export function computeAttribution(data: number[], opts: AttributionOptions = {}): AttributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAttribution };
diff --git a/src/analytics/base2.ts b/src/analytics/base2.ts
new file mode 100644
index 000000000..aee69feef
--- /dev/null
+++ b/src/analytics/base2.ts
@@ -0,0 +1,15 @@
+/** Analytics Base2 module — tsb analytics library. */
+export interface Analytics base2Options { tol?: number; maxIter?: number; }
+export interface Analytics base2Result { values: number[]; converged: boolean; }
+export function computeAnalytics base2(data: number[], opts: Analytics base2Options = {}): Analytics base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics base2 };
diff --git a/src/analytics/batch.ts b/src/analytics/batch.ts
new file mode 100644
index 000000000..6c798d0a0
--- /dev/null
+++ b/src/analytics/batch.ts
@@ -0,0 +1,15 @@
+/** Analytics Batch module — tsb analytics library. */
+export interface Analytics batchOptions { tol?: number; maxIter?: number; }
+export interface Analytics batchResult { values: number[]; converged: boolean; }
+export function computeAnalytics batch(data: number[], opts: Analytics batchOptions = {}): Analytics batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics batch };
diff --git a/src/analytics/beta.ts b/src/analytics/beta.ts
new file mode 100644
index 000000000..635224c92
--- /dev/null
+++ b/src/analytics/beta.ts
@@ -0,0 +1,15 @@
+/** Analytics Beta module — tsb analytics library. */
+export interface Analytics betaOptions { tol?: number; maxIter?: number; }
+export interface Analytics betaResult { values: number[]; converged: boolean; }
+export function computeAnalytics beta(data: number[], opts: Analytics betaOptions = {}): Analytics betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics beta };
diff --git a/src/analytics/canary.ts b/src/analytics/canary.ts
new file mode 100644
index 000000000..38627a668
--- /dev/null
+++ b/src/analytics/canary.ts
@@ -0,0 +1,22 @@
+/** Canary module — tsb analytics library. */
+
+/** Options for Canary. */
+export interface CanaryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Canary. */
+export interface CanaryResult { values: number[]; converged: boolean; }
+
+/** Compute Canary. */
+export function computeCanary(data: number[], opts: CanaryOptions = {}): CanaryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCanary };
diff --git a/src/analytics/churn.ts b/src/analytics/churn.ts
new file mode 100644
index 000000000..1a20fb09c
--- /dev/null
+++ b/src/analytics/churn.ts
@@ -0,0 +1,22 @@
+/** Churn module — tsb analytics library. */
+
+/** Options for Churn. */
+export interface ChurnOptions { tol?: number; maxIter?: number; }
+
+/** Result from Churn. */
+export interface ChurnResult { values: number[]; converged: boolean; }
+
+/** Compute Churn. */
+export function computeChurn(data: number[], opts: ChurnOptions = {}): ChurnResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeChurn };
diff --git a/src/analytics/clustering.ts b/src/analytics/clustering.ts
new file mode 100644
index 000000000..76db9a775
--- /dev/null
+++ b/src/analytics/clustering.ts
@@ -0,0 +1,22 @@
+/** Clustering module — tsb analytics library. */
+
+/** Options for Clustering. */
+export interface ClusteringOptions { tol?: number; maxIter?: number; }
+
+/** Result from Clustering. */
+export interface ClusteringResult { values: number[]; converged: boolean; }
+
+/** Compute Clustering. */
+export function computeClustering(data: number[], opts: ClusteringOptions = {}): ClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClustering };
diff --git a/src/analytics/cohort.ts b/src/analytics/cohort.ts
new file mode 100644
index 000000000..ffdec21d5
--- /dev/null
+++ b/src/analytics/cohort.ts
@@ -0,0 +1,22 @@
+/** Cohort module — tsb analytics library. */
+
+/** Options for Cohort. */
+export interface CohortOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cohort. */
+export interface CohortResult { values: number[]; converged: boolean; }
+
+/** Compute Cohort. */
+export function computeCohort(data: number[], opts: CohortOptions = {}): CohortResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCohort };
diff --git a/src/analytics/conversion.ts b/src/analytics/conversion.ts
new file mode 100644
index 000000000..19a565775
--- /dev/null
+++ b/src/analytics/conversion.ts
@@ -0,0 +1,22 @@
+/** Conversion module — tsb analytics library. */
+
+/** Options for Conversion. */
+export interface ConversionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Conversion. */
+export interface ConversionResult { values: number[]; converged: boolean; }
+
+/** Compute Conversion. */
+export function computeConversion(data: number[], opts: ConversionOptions = {}): ConversionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConversion };
diff --git a/src/analytics/cpu.ts b/src/analytics/cpu.ts
new file mode 100644
index 000000000..bdd0a4bc4
--- /dev/null
+++ b/src/analytics/cpu.ts
@@ -0,0 +1,15 @@
+/** Analytics Cpu module — tsb analytics library. */
+export interface Analytics cpuOptions { tol?: number; maxIter?: number; }
+export interface Analytics cpuResult { values: number[]; converged: boolean; }
+export function computeAnalytics cpu(data: number[], opts: Analytics cpuOptions = {}): Analytics cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics cpu };
diff --git a/src/analytics/dense.ts b/src/analytics/dense.ts
new file mode 100644
index 000000000..a185c66a6
--- /dev/null
+++ b/src/analytics/dense.ts
@@ -0,0 +1,15 @@
+/** Analytics Dense module — tsb analytics library. */
+export interface Analytics denseOptions { tol?: number; maxIter?: number; }
+export interface Analytics denseResult { values: number[]; converged: boolean; }
+export function computeAnalytics dense(data: number[], opts: Analytics denseOptions = {}): Analytics denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics dense };
diff --git a/src/analytics/descriptive.ts b/src/analytics/descriptive.ts
new file mode 100644
index 000000000..9988dbe78
--- /dev/null
+++ b/src/analytics/descriptive.ts
@@ -0,0 +1,22 @@
+/** Descriptive module — tsb analytics library. */
+
+/** Options for Descriptive. */
+export interface DescriptiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Descriptive. */
+export interface DescriptiveResult { values: number[]; converged: boolean; }
+
+/** Compute Descriptive. */
+export function computeDescriptive(data: number[], opts: DescriptiveOptions = {}): DescriptiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDescriptive };
diff --git a/src/analytics/diagnostic.ts b/src/analytics/diagnostic.ts
new file mode 100644
index 000000000..b92ee112e
--- /dev/null
+++ b/src/analytics/diagnostic.ts
@@ -0,0 +1,22 @@
+/** Diagnostic module — tsb analytics library. */
+
+/** Options for Diagnostic. */
+export interface DiagnosticOptions { tol?: number; maxIter?: number; }
+
+/** Result from Diagnostic. */
+export interface DiagnosticResult { values: number[]; converged: boolean; }
+
+/** Compute Diagnostic. */
+export function computeDiagnostic(data: number[], opts: DiagnosticOptions = {}): DiagnosticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDiagnostic };
diff --git a/src/analytics/distributed.ts b/src/analytics/distributed.ts
new file mode 100644
index 000000000..33203c442
--- /dev/null
+++ b/src/analytics/distributed.ts
@@ -0,0 +1,15 @@
+/** Analytics Distributed module — tsb analytics library. */
+export interface Analytics distributedOptions { tol?: number; maxIter?: number; }
+export interface Analytics distributedResult { values: number[]; converged: boolean; }
+export function computeAnalytics distributed(data: number[], opts: Analytics distributedOptions = {}): Analytics distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics distributed };
diff --git a/src/analytics/engagement.ts b/src/analytics/engagement.ts
new file mode 100644
index 000000000..6b0f93abd
--- /dev/null
+++ b/src/analytics/engagement.ts
@@ -0,0 +1,22 @@
+/** Engagement module — tsb analytics library. */
+
+/** Options for Engagement. */
+export interface EngagementOptions { tol?: number; maxIter?: number; }
+
+/** Result from Engagement. */
+export interface EngagementResult { values: number[]; converged: boolean; }
+
+/** Compute Engagement. */
+export function computeEngagement(data: number[], opts: EngagementOptions = {}): EngagementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEngagement };
diff --git a/src/analytics/experiment.ts b/src/analytics/experiment.ts
new file mode 100644
index 000000000..a243a35b8
--- /dev/null
+++ b/src/analytics/experiment.ts
@@ -0,0 +1,22 @@
+/** Experiment module — tsb analytics library. */
+
+/** Options for Experiment. */
+export interface ExperimentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Experiment. */
+export interface ExperimentResult { values: number[]; converged: boolean; }
+
+/** Compute Experiment. */
+export function computeExperiment(data: number[], opts: ExperimentOptions = {}): ExperimentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExperiment };
diff --git a/src/analytics/experimental.ts b/src/analytics/experimental.ts
new file mode 100644
index 000000000..b4c1fb604
--- /dev/null
+++ b/src/analytics/experimental.ts
@@ -0,0 +1,15 @@
+/** Analytics Experimental module — tsb analytics library. */
+export interface Analytics experimentalOptions { tol?: number; maxIter?: number; }
+export interface Analytics experimentalResult { values: number[]; converged: boolean; }
+export function computeAnalytics experimental(data: number[], opts: Analytics experimentalOptions = {}): Analytics experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics experimental };
diff --git a/src/analytics/fast.ts b/src/analytics/fast.ts
new file mode 100644
index 000000000..2e1f39d31
--- /dev/null
+++ b/src/analytics/fast.ts
@@ -0,0 +1,15 @@
+/** Analytics Fast module — tsb analytics library. */
+export interface Analytics fastOptions { tol?: number; maxIter?: number; }
+export interface Analytics fastResult { values: number[]; converged: boolean; }
+export function computeAnalytics fast(data: number[], opts: Analytics fastOptions = {}): Analytics fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics fast };
diff --git a/src/analytics/feature_flag.ts b/src/analytics/feature_flag.ts
new file mode 100644
index 000000000..b112e9656
--- /dev/null
+++ b/src/analytics/feature_flag.ts
@@ -0,0 +1,22 @@
+/** Feature Flag module — tsb analytics library. */
+
+/** Options for Feature Flag. */
+export interface FeatureFlagOptions { tol?: number; maxIter?: number; }
+
+/** Result from Feature Flag. */
+export interface FeatureFlagResult { values: number[]; converged: boolean; }
+
+/** Compute Feature Flag. */
+export function computeFeatureFlag(data: number[], opts: FeatureFlagOptions = {}): FeatureFlagResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFeatureFlag };
diff --git a/src/analytics/funnel.ts b/src/analytics/funnel.ts
new file mode 100644
index 000000000..449bb4e8d
--- /dev/null
+++ b/src/analytics/funnel.ts
@@ -0,0 +1,22 @@
+/** Funnel module — tsb analytics library. */
+
+/** Options for Funnel. */
+export interface FunnelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Funnel. */
+export interface FunnelResult { values: number[]; converged: boolean; }
+
+/** Compute Funnel. */
+export function computeFunnel(data: number[], opts: FunnelOptions = {}): FunnelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFunnel };
diff --git a/src/analytics/future.ts b/src/analytics/future.ts
new file mode 100644
index 000000000..031dcaef6
--- /dev/null
+++ b/src/analytics/future.ts
@@ -0,0 +1,15 @@
+/** Analytics Future module — tsb analytics library. */
+export interface Analytics futureOptions { tol?: number; maxIter?: number; }
+export interface Analytics futureResult { values: number[]; converged: boolean; }
+export function computeAnalytics future(data: number[], opts: Analytics futureOptions = {}): Analytics futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics future };
diff --git a/src/analytics/gpu.ts b/src/analytics/gpu.ts
new file mode 100644
index 000000000..3442cad11
--- /dev/null
+++ b/src/analytics/gpu.ts
@@ -0,0 +1,15 @@
+/** Analytics Gpu module — tsb analytics library. */
+export interface Analytics gpuOptions { tol?: number; maxIter?: number; }
+export interface Analytics gpuResult { values: number[]; converged: boolean; }
+export function computeAnalytics gpu(data: number[], opts: Analytics gpuOptions = {}): Analytics gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics gpu };
diff --git a/src/analytics/growth.ts b/src/analytics/growth.ts
new file mode 100644
index 000000000..95e007fc9
--- /dev/null
+++ b/src/analytics/growth.ts
@@ -0,0 +1,22 @@
+/** Growth module — tsb analytics library. */
+
+/** Options for Growth. */
+export interface GrowthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Growth. */
+export interface GrowthResult { values: number[]; converged: boolean; }
+
+/** Compute Growth. */
+export function computeGrowth(data: number[], opts: GrowthOptions = {}): GrowthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGrowth };
diff --git a/src/analytics/inferential.ts b/src/analytics/inferential.ts
new file mode 100644
index 000000000..d327f8c79
--- /dev/null
+++ b/src/analytics/inferential.ts
@@ -0,0 +1,22 @@
+/** Inferential module — tsb analytics library. */
+
+/** Options for Inferential. */
+export interface InferentialOptions { tol?: number; maxIter?: number; }
+
+/** Result from Inferential. */
+export interface InferentialResult { values: number[]; converged: boolean; }
+
+/** Compute Inferential. */
+export function computeInferential(data: number[], opts: InferentialOptions = {}): InferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInferential };
diff --git a/src/analytics/large.ts b/src/analytics/large.ts
new file mode 100644
index 000000000..1214ffd80
--- /dev/null
+++ b/src/analytics/large.ts
@@ -0,0 +1,15 @@
+/** Analytics Large module — tsb analytics library. */
+export interface Analytics largeOptions { tol?: number; maxIter?: number; }
+export interface Analytics largeResult { values: number[]; converged: boolean; }
+export function computeAnalytics large(data: number[], opts: Analytics largeOptions = {}): Analytics largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics large };
diff --git a/src/analytics/legacy.ts b/src/analytics/legacy.ts
new file mode 100644
index 000000000..ecb1c3139
--- /dev/null
+++ b/src/analytics/legacy.ts
@@ -0,0 +1,15 @@
+/** Analytics Legacy module — tsb analytics library. */
+export interface Analytics legacyOptions { tol?: number; maxIter?: number; }
+export interface Analytics legacyResult { values: number[]; converged: boolean; }
+export function computeAnalytics legacy(data: number[], opts: Analytics legacyOptions = {}): Analytics legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics legacy };
diff --git a/src/analytics/lifetime.ts b/src/analytics/lifetime.ts
new file mode 100644
index 000000000..1374dcb9b
--- /dev/null
+++ b/src/analytics/lifetime.ts
@@ -0,0 +1,22 @@
+/** Lifetime module — tsb analytics library. */
+
+/** Options for Lifetime. */
+export interface LifetimeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lifetime. */
+export interface LifetimeResult { values: number[]; converged: boolean; }
+
+/** Compute Lifetime. */
+export function computeLifetime(data: number[], opts: LifetimeOptions = {}): LifetimeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLifetime };
diff --git a/src/analytics/lite.ts b/src/analytics/lite.ts
new file mode 100644
index 000000000..3de1863dd
--- /dev/null
+++ b/src/analytics/lite.ts
@@ -0,0 +1,15 @@
+/** Analytics Lite module — tsb analytics library. */
+export interface Analytics liteOptions { tol?: number; maxIter?: number; }
+export interface Analytics liteResult { values: number[]; converged: boolean; }
+export function computeAnalytics lite(data: number[], opts: Analytics liteOptions = {}): Analytics liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics lite };
diff --git a/src/analytics/mini.ts b/src/analytics/mini.ts
new file mode 100644
index 000000000..529edd539
--- /dev/null
+++ b/src/analytics/mini.ts
@@ -0,0 +1,15 @@
+/** Analytics Mini module — tsb analytics library. */
+export interface Analytics miniOptions { tol?: number; maxIter?: number; }
+export interface Analytics miniResult { values: number[]; converged: boolean; }
+export function computeAnalytics mini(data: number[], opts: Analytics miniOptions = {}): Analytics miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics mini };
diff --git a/src/analytics/monetization.ts b/src/analytics/monetization.ts
new file mode 100644
index 000000000..c1ec763a3
--- /dev/null
+++ b/src/analytics/monetization.ts
@@ -0,0 +1,22 @@
+/** Monetization module — tsb analytics library. */
+
+/** Options for Monetization. */
+export interface MonetizationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Monetization. */
+export interface MonetizationResult { values: number[]; converged: boolean; }
+
+/** Compute Monetization. */
+export function computeMonetization(data: number[], opts: MonetizationOptions = {}): MonetizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMonetization };
diff --git a/src/analytics/multivariate.ts b/src/analytics/multivariate.ts
new file mode 100644
index 000000000..b94eee077
--- /dev/null
+++ b/src/analytics/multivariate.ts
@@ -0,0 +1,22 @@
+/** Multivariate module — tsb analytics library. */
+
+/** Options for Multivariate. */
+export interface MultivariateOptions { tol?: number; maxIter?: number; }
+
+/** Result from Multivariate. */
+export interface MultivariateResult { values: number[]; converged: boolean; }
+
+/** Compute Multivariate. */
+export function computeMultivariate(data: number[], opts: MultivariateOptions = {}): MultivariateResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMultivariate };
diff --git a/src/analytics/next.ts b/src/analytics/next.ts
new file mode 100644
index 000000000..0cf2d92f8
--- /dev/null
+++ b/src/analytics/next.ts
@@ -0,0 +1,15 @@
+/** Analytics Next module — tsb analytics library. */
+export interface Analytics nextOptions { tol?: number; maxIter?: number; }
+export interface Analytics nextResult { values: number[]; converged: boolean; }
+export function computeAnalytics next(data: number[], opts: Analytics nextOptions = {}): Analytics nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics next };
diff --git a/src/analytics/online.ts b/src/analytics/online.ts
new file mode 100644
index 000000000..9ae674eee
--- /dev/null
+++ b/src/analytics/online.ts
@@ -0,0 +1,15 @@
+/** Analytics Online module — tsb analytics library. */
+export interface Analytics onlineOptions { tol?: number; maxIter?: number; }
+export interface Analytics onlineResult { values: number[]; converged: boolean; }
+export function computeAnalytics online(data: number[], opts: Analytics onlineOptions = {}): Analytics onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics online };
diff --git a/src/analytics/parallel.ts b/src/analytics/parallel.ts
new file mode 100644
index 000000000..3bb5d78ba
--- /dev/null
+++ b/src/analytics/parallel.ts
@@ -0,0 +1,15 @@
+/** Analytics Parallel module — tsb analytics library. */
+export interface Analytics parallelOptions { tol?: number; maxIter?: number; }
+export interface Analytics parallelResult { values: number[]; converged: boolean; }
+export function computeAnalytics parallel(data: number[], opts: Analytics parallelOptions = {}): Analytics parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics parallel };
diff --git a/src/analytics/plus.ts b/src/analytics/plus.ts
new file mode 100644
index 000000000..8be08fd9c
--- /dev/null
+++ b/src/analytics/plus.ts
@@ -0,0 +1,15 @@
+/** Analytics Plus module — tsb analytics library. */
+export interface Analytics plusOptions { tol?: number; maxIter?: number; }
+export interface Analytics plusResult { values: number[]; converged: boolean; }
+export function computeAnalytics plus(data: number[], opts: Analytics plusOptions = {}): Analytics plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics plus };
diff --git a/src/analytics/predictive.ts b/src/analytics/predictive.ts
new file mode 100644
index 000000000..4ecd4ccd7
--- /dev/null
+++ b/src/analytics/predictive.ts
@@ -0,0 +1,22 @@
+/** Predictive module — tsb analytics library. */
+
+/** Options for Predictive. */
+export interface PredictiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Predictive. */
+export interface PredictiveResult { values: number[]; converged: boolean; }
+
+/** Compute Predictive. */
+export function computePredictive(data: number[], opts: PredictiveOptions = {}): PredictiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePredictive };
diff --git a/src/analytics/prescriptive.ts b/src/analytics/prescriptive.ts
new file mode 100644
index 000000000..f1f398dce
--- /dev/null
+++ b/src/analytics/prescriptive.ts
@@ -0,0 +1,22 @@
+/** Prescriptive module — tsb analytics library. */
+
+/** Options for Prescriptive. */
+export interface PrescriptiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Prescriptive. */
+export interface PrescriptiveResult { values: number[]; converged: boolean; }
+
+/** Compute Prescriptive. */
+export function computePrescriptive(data: number[], opts: PrescriptiveOptions = {}): PrescriptiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrescriptive };
diff --git a/src/analytics/pro.ts b/src/analytics/pro.ts
new file mode 100644
index 000000000..c8221be5b
--- /dev/null
+++ b/src/analytics/pro.ts
@@ -0,0 +1,15 @@
+/** Analytics Pro module — tsb analytics library. */
+export interface Analytics proOptions { tol?: number; maxIter?: number; }
+export interface Analytics proResult { values: number[]; converged: boolean; }
+export function computeAnalytics pro(data: number[], opts: Analytics proOptions = {}): Analytics proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics pro };
diff --git a/src/analytics/referral.ts b/src/analytics/referral.ts
new file mode 100644
index 000000000..e9d8b622f
--- /dev/null
+++ b/src/analytics/referral.ts
@@ -0,0 +1,22 @@
+/** Referral module — tsb analytics library. */
+
+/** Options for Referral. */
+export interface ReferralOptions { tol?: number; maxIter?: number; }
+
+/** Result from Referral. */
+export interface ReferralResult { values: number[]; converged: boolean; }
+
+/** Compute Referral. */
+export function computeReferral(data: number[], opts: ReferralOptions = {}): ReferralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReferral };
diff --git a/src/analytics/retention.ts b/src/analytics/retention.ts
new file mode 100644
index 000000000..f0956cb16
--- /dev/null
+++ b/src/analytics/retention.ts
@@ -0,0 +1,22 @@
+/** Retention module — tsb analytics library. */
+
+/** Options for Retention. */
+export interface RetentionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Retention. */
+export interface RetentionResult { values: number[]; converged: boolean; }
+
+/** Compute Retention. */
+export function computeRetention(data: number[], opts: RetentionOptions = {}): RetentionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRetention };
diff --git a/src/analytics/robust.ts b/src/analytics/robust.ts
new file mode 100644
index 000000000..feca18aa1
--- /dev/null
+++ b/src/analytics/robust.ts
@@ -0,0 +1,15 @@
+/** Analytics Robust module — tsb analytics library. */
+export interface Analytics robustOptions { tol?: number; maxIter?: number; }
+export interface Analytics robustResult { values: number[]; converged: boolean; }
+export function computeAnalytics robust(data: number[], opts: Analytics robustOptions = {}): Analytics robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics robust };
diff --git a/src/analytics/rollout.ts b/src/analytics/rollout.ts
new file mode 100644
index 000000000..c405f514a
--- /dev/null
+++ b/src/analytics/rollout.ts
@@ -0,0 +1,22 @@
+/** Rollout module — tsb analytics library. */
+
+/** Options for Rollout. */
+export interface RolloutOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rollout. */
+export interface RolloutResult { values: number[]; converged: boolean; }
+
+/** Compute Rollout. */
+export function computeRollout(data: number[], opts: RolloutOptions = {}): RolloutResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRollout };
diff --git a/src/analytics/seasonality.ts b/src/analytics/seasonality.ts
new file mode 100644
index 000000000..5eaefbded
--- /dev/null
+++ b/src/analytics/seasonality.ts
@@ -0,0 +1,22 @@
+/** Seasonality module — tsb analytics library. */
+
+/** Options for Seasonality. */
+export interface SeasonalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Seasonality. */
+export interface SeasonalityResult { values: number[]; converged: boolean; }
+
+/** Compute Seasonality. */
+export function computeSeasonality(data: number[], opts: SeasonalityOptions = {}): SeasonalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeasonality };
diff --git a/src/analytics/segmentation.ts b/src/analytics/segmentation.ts
new file mode 100644
index 000000000..c74e19ce2
--- /dev/null
+++ b/src/analytics/segmentation.ts
@@ -0,0 +1,22 @@
+/** Segmentation module — tsb analytics library. */
+
+/** Options for Segmentation. */
+export interface SegmentationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Segmentation. */
+export interface SegmentationResult { values: number[]; converged: boolean; }
+
+/** Compute Segmentation. */
+export function computeSegmentation(data: number[], opts: SegmentationOptions = {}): SegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSegmentation };
diff --git a/src/analytics/small.ts b/src/analytics/small.ts
new file mode 100644
index 000000000..e22c64e74
--- /dev/null
+++ b/src/analytics/small.ts
@@ -0,0 +1,15 @@
+/** Analytics Small module — tsb analytics library. */
+export interface Analytics smallOptions { tol?: number; maxIter?: number; }
+export interface Analytics smallResult { values: number[]; converged: boolean; }
+export function computeAnalytics small(data: number[], opts: Analytics smallOptions = {}): Analytics smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics small };
diff --git a/src/analytics/sparse.ts b/src/analytics/sparse.ts
new file mode 100644
index 000000000..e7ae41768
--- /dev/null
+++ b/src/analytics/sparse.ts
@@ -0,0 +1,15 @@
+/** Analytics Sparse module — tsb analytics library. */
+export interface Analytics sparseOptions { tol?: number; maxIter?: number; }
+export interface Analytics sparseResult { values: number[]; converged: boolean; }
+export function computeAnalytics sparse(data: number[], opts: Analytics sparseOptions = {}): Analytics sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics sparse };
diff --git a/src/analytics/stable.ts b/src/analytics/stable.ts
new file mode 100644
index 000000000..53807cf9e
--- /dev/null
+++ b/src/analytics/stable.ts
@@ -0,0 +1,15 @@
+/** Analytics Stable module — tsb analytics library. */
+export interface Analytics stableOptions { tol?: number; maxIter?: number; }
+export interface Analytics stableResult { values: number[]; converged: boolean; }
+export function computeAnalytics stable(data: number[], opts: Analytics stableOptions = {}): Analytics stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics stable };
diff --git a/src/analytics/streaming.ts b/src/analytics/streaming.ts
new file mode 100644
index 000000000..c967778fd
--- /dev/null
+++ b/src/analytics/streaming.ts
@@ -0,0 +1,15 @@
+/** Analytics Streaming module — tsb analytics library. */
+export interface Analytics streamingOptions { tol?: number; maxIter?: number; }
+export interface Analytics streamingResult { values: number[]; converged: boolean; }
+export function computeAnalytics streaming(data: number[], opts: Analytics streamingOptions = {}): Analytics streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics streaming };
diff --git a/src/analytics/trend.ts b/src/analytics/trend.ts
new file mode 100644
index 000000000..801716a31
--- /dev/null
+++ b/src/analytics/trend.ts
@@ -0,0 +1,22 @@
+/** Trend module — tsb analytics library. */
+
+/** Options for Trend. */
+export interface TrendOptions { tol?: number; maxIter?: number; }
+
+/** Result from Trend. */
+export interface TrendResult { values: number[]; converged: boolean; }
+
+/** Compute Trend. */
+export function computeTrend(data: number[], opts: TrendOptions = {}): TrendResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTrend };
diff --git a/src/analytics/v2.ts b/src/analytics/v2.ts
new file mode 100644
index 000000000..f5ca5c0ad
--- /dev/null
+++ b/src/analytics/v2.ts
@@ -0,0 +1,15 @@
+/** Analytics V2 module — tsb analytics library. */
+export interface Analytics v2Options { tol?: number; maxIter?: number; }
+export interface Analytics v2Result { values: number[]; converged: boolean; }
+export function computeAnalytics v2(data: number[], opts: Analytics v2Options = {}): Analytics v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics v2 };
diff --git a/src/analytics/v3.ts b/src/analytics/v3.ts
new file mode 100644
index 000000000..daa16e321
--- /dev/null
+++ b/src/analytics/v3.ts
@@ -0,0 +1,15 @@
+/** Analytics V3 module — tsb analytics library. */
+export interface Analytics v3Options { tol?: number; maxIter?: number; }
+export interface Analytics v3Result { values: number[]; converged: boolean; }
+export function computeAnalytics v3(data: number[], opts: Analytics v3Options = {}): Analytics v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics v3 };
diff --git a/src/analytics/virality.ts b/src/analytics/virality.ts
new file mode 100644
index 000000000..676622c1a
--- /dev/null
+++ b/src/analytics/virality.ts
@@ -0,0 +1,22 @@
+/** Virality module — tsb analytics library. */
+
+/** Options for Virality. */
+export interface ViralityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Virality. */
+export interface ViralityResult { values: number[]; converged: boolean; }
+
+/** Compute Virality. */
+export function computeVirality(data: number[], opts: ViralityOptions = {}): ViralityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVirality };
diff --git a/src/analytics/wasm.ts b/src/analytics/wasm.ts
new file mode 100644
index 000000000..bebfdc585
--- /dev/null
+++ b/src/analytics/wasm.ts
@@ -0,0 +1,15 @@
+/** Analytics Wasm module — tsb analytics library. */
+export interface Analytics wasmOptions { tol?: number; maxIter?: number; }
+export interface Analytics wasmResult { values: number[]; converged: boolean; }
+export function computeAnalytics wasm(data: number[], opts: Analytics wasmOptions = {}): Analytics wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics wasm };
diff --git a/src/analytics/xlarge.ts b/src/analytics/xlarge.ts
new file mode 100644
index 000000000..dcd5bd528
--- /dev/null
+++ b/src/analytics/xlarge.ts
@@ -0,0 +1,15 @@
+/** Analytics Xlarge module — tsb analytics library. */
+export interface Analytics xlargeOptions { tol?: number; maxIter?: number; }
+export interface Analytics xlargeResult { values: number[]; converged: boolean; }
+export function computeAnalytics xlarge(data: number[], opts: Analytics xlargeOptions = {}): Analytics xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnalytics xlarge };
diff --git a/src/anthropology/advanced.ts b/src/anthropology/advanced.ts
new file mode 100644
index 000000000..3130d27e4
--- /dev/null
+++ b/src/anthropology/advanced.ts
@@ -0,0 +1,15 @@
+/** Anthropology Advanced module — tsb analytics library. */
+export interface Anthropology advancedOptions { tol?: number; maxIter?: number; }
+export interface Anthropology advancedResult { values: number[]; converged: boolean; }
+export function computeAnthropology advanced(data: number[], opts: Anthropology advancedOptions = {}): Anthropology advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology advanced };
diff --git a/src/anthropology/ancient_dna.ts b/src/anthropology/ancient_dna.ts
new file mode 100644
index 000000000..285bbdcbc
--- /dev/null
+++ b/src/anthropology/ancient_dna.ts
@@ -0,0 +1,22 @@
+/** Ancient Dna module — tsb analytics library. */
+
+/** Options for Ancient Dna. */
+export interface AncientDnaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ancient Dna. */
+export interface AncientDnaResult { values: number[]; converged: boolean; }
+
+/** Compute Ancient Dna. */
+export function computeAncientDna(data: number[], opts: AncientDnaOptions = {}): AncientDnaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAncientDna };
diff --git a/src/anthropology/archaeobotany.ts b/src/anthropology/archaeobotany.ts
new file mode 100644
index 000000000..7ba20a611
--- /dev/null
+++ b/src/anthropology/archaeobotany.ts
@@ -0,0 +1,22 @@
+/** Archaeobotany module — tsb analytics library. */
+
+/** Options for Archaeobotany. */
+export interface ArchaeobotanyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Archaeobotany. */
+export interface ArchaeobotanyResult { values: number[]; converged: boolean; }
+
+/** Compute Archaeobotany. */
+export function computeArchaeobotany(data: number[], opts: ArchaeobotanyOptions = {}): ArchaeobotanyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeArchaeobotany };
diff --git a/src/anthropology/archaeological.ts b/src/anthropology/archaeological.ts
new file mode 100644
index 000000000..5a679f298
--- /dev/null
+++ b/src/anthropology/archaeological.ts
@@ -0,0 +1,22 @@
+/** Archaeological module — tsb analytics library. */
+
+/** Options for Archaeological. */
+export interface ArchaeologicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Archaeological. */
+export interface ArchaeologicalResult { values: number[]; converged: boolean; }
+
+/** Compute Archaeological. */
+export function computeArchaeological(data: number[], opts: ArchaeologicalOptions = {}): ArchaeologicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeArchaeological };
diff --git a/src/anthropology/argon_argon.ts b/src/anthropology/argon_argon.ts
new file mode 100644
index 000000000..0f839a06d
--- /dev/null
+++ b/src/anthropology/argon_argon.ts
@@ -0,0 +1,22 @@
+/** Argon Argon module — tsb analytics library. */
+
+/** Options for Argon Argon. */
+export interface ArgonArgonOptions { tol?: number; maxIter?: number; }
+
+/** Result from Argon Argon. */
+export interface ArgonArgonResult { values: number[]; converged: boolean; }
+
+/** Compute Argon Argon. */
+export function computeArgonArgon(data: number[], opts: ArgonArgonOptions = {}): ArgonArgonResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeArgonArgon };
diff --git a/src/anthropology/base2.ts b/src/anthropology/base2.ts
new file mode 100644
index 000000000..3dabfcb9b
--- /dev/null
+++ b/src/anthropology/base2.ts
@@ -0,0 +1,15 @@
+/** Anthropology Base2 module — tsb analytics library. */
+export interface Anthropology base2Options { tol?: number; maxIter?: number; }
+export interface Anthropology base2Result { values: number[]; converged: boolean; }
+export function computeAnthropology base2(data: number[], opts: Anthropology base2Options = {}): Anthropology base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology base2 };
diff --git a/src/anthropology/batch.ts b/src/anthropology/batch.ts
new file mode 100644
index 000000000..5a7054966
--- /dev/null
+++ b/src/anthropology/batch.ts
@@ -0,0 +1,15 @@
+/** Anthropology Batch module — tsb analytics library. */
+export interface Anthropology batchOptions { tol?: number; maxIter?: number; }
+export interface Anthropology batchResult { values: number[]; converged: boolean; }
+export function computeAnthropology batch(data: number[], opts: Anthropology batchOptions = {}): Anthropology batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology batch };
diff --git a/src/anthropology/beta.ts b/src/anthropology/beta.ts
new file mode 100644
index 000000000..1565445f9
--- /dev/null
+++ b/src/anthropology/beta.ts
@@ -0,0 +1,15 @@
+/** Anthropology Beta module — tsb analytics library. */
+export interface Anthropology betaOptions { tol?: number; maxIter?: number; }
+export interface Anthropology betaResult { values: number[]; converged: boolean; }
+export function computeAnthropology beta(data: number[], opts: Anthropology betaOptions = {}): Anthropology betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology beta };
diff --git a/src/anthropology/biological.ts b/src/anthropology/biological.ts
new file mode 100644
index 000000000..d3df352ad
--- /dev/null
+++ b/src/anthropology/biological.ts
@@ -0,0 +1,22 @@
+/** Biological module — tsb analytics library. */
+
+/** Options for Biological. */
+export interface BiologicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Biological. */
+export interface BiologicalResult { values: number[]; converged: boolean; }
+
+/** Compute Biological. */
+export function computeBiological(data: number[], opts: BiologicalOptions = {}): BiologicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBiological };
diff --git a/src/anthropology/cosmogenic_anth.ts b/src/anthropology/cosmogenic_anth.ts
new file mode 100644
index 000000000..077b119ed
--- /dev/null
+++ b/src/anthropology/cosmogenic_anth.ts
@@ -0,0 +1,22 @@
+/** Cosmogenic Anth module — tsb analytics library. */
+
+/** Options for Cosmogenic Anth. */
+export interface CosmogenicAnthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cosmogenic Anth. */
+export interface CosmogenicAnthResult { values: number[]; converged: boolean; }
+
+/** Compute Cosmogenic Anth. */
+export function computeCosmogenicAnth(data: number[], opts: CosmogenicAnthOptions = {}): CosmogenicAnthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCosmogenicAnth };
diff --git a/src/anthropology/cpu.ts b/src/anthropology/cpu.ts
new file mode 100644
index 000000000..3fa37827a
--- /dev/null
+++ b/src/anthropology/cpu.ts
@@ -0,0 +1,15 @@
+/** Anthropology Cpu module — tsb analytics library. */
+export interface Anthropology cpuOptions { tol?: number; maxIter?: number; }
+export interface Anthropology cpuResult { values: number[]; converged: boolean; }
+export function computeAnthropology cpu(data: number[], opts: Anthropology cpuOptions = {}): Anthropology cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology cpu };
diff --git a/src/anthropology/cultural.ts b/src/anthropology/cultural.ts
new file mode 100644
index 000000000..2e2c0c638
--- /dev/null
+++ b/src/anthropology/cultural.ts
@@ -0,0 +1,22 @@
+/** Cultural module — tsb analytics library. */
+
+/** Options for Cultural. */
+export interface CulturalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cultural. */
+export interface CulturalResult { values: number[]; converged: boolean; }
+
+/** Compute Cultural. */
+export function computeCultural(data: number[], opts: CulturalOptions = {}): CulturalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCultural };
diff --git a/src/anthropology/dendrochronology.ts b/src/anthropology/dendrochronology.ts
new file mode 100644
index 000000000..2fc187f89
--- /dev/null
+++ b/src/anthropology/dendrochronology.ts
@@ -0,0 +1,22 @@
+/** Dendrochronology module — tsb analytics library. */
+
+/** Options for Dendrochronology. */
+export interface DendrochronologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dendrochronology. */
+export interface DendrochronologyResult { values: number[]; converged: boolean; }
+
+/** Compute Dendrochronology. */
+export function computeDendrochronology(data: number[], opts: DendrochronologyOptions = {}): DendrochronologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDendrochronology };
diff --git a/src/anthropology/dense.ts b/src/anthropology/dense.ts
new file mode 100644
index 000000000..b62e52ae6
--- /dev/null
+++ b/src/anthropology/dense.ts
@@ -0,0 +1,15 @@
+/** Anthropology Dense module — tsb analytics library. */
+export interface Anthropology denseOptions { tol?: number; maxIter?: number; }
+export interface Anthropology denseResult { values: number[]; converged: boolean; }
+export function computeAnthropology dense(data: number[], opts: Anthropology denseOptions = {}): Anthropology denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology dense };
diff --git a/src/anthropology/distributed.ts b/src/anthropology/distributed.ts
new file mode 100644
index 000000000..a7323b6c9
--- /dev/null
+++ b/src/anthropology/distributed.ts
@@ -0,0 +1,15 @@
+/** Anthropology Distributed module — tsb analytics library. */
+export interface Anthropology distributedOptions { tol?: number; maxIter?: number; }
+export interface Anthropology distributedResult { values: number[]; converged: boolean; }
+export function computeAnthropology distributed(data: number[], opts: Anthropology distributedOptions = {}): Anthropology distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology distributed };
diff --git a/src/anthropology/electron_spin.ts b/src/anthropology/electron_spin.ts
new file mode 100644
index 000000000..0546ca27d
--- /dev/null
+++ b/src/anthropology/electron_spin.ts
@@ -0,0 +1,22 @@
+/** Electron Spin module — tsb analytics library. */
+
+/** Options for Electron Spin. */
+export interface ElectronSpinOptions { tol?: number; maxIter?: number; }
+
+/** Result from Electron Spin. */
+export interface ElectronSpinResult { values: number[]; converged: boolean; }
+
+/** Compute Electron Spin. */
+export function computeElectronSpin(data: number[], opts: ElectronSpinOptions = {}): ElectronSpinResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeElectronSpin };
diff --git a/src/anthropology/experimental.ts b/src/anthropology/experimental.ts
new file mode 100644
index 000000000..03c3f2596
--- /dev/null
+++ b/src/anthropology/experimental.ts
@@ -0,0 +1,15 @@
+/** Anthropology Experimental module — tsb analytics library. */
+export interface Anthropology experimentalOptions { tol?: number; maxIter?: number; }
+export interface Anthropology experimentalResult { values: number[]; converged: boolean; }
+export function computeAnthropology experimental(data: number[], opts: Anthropology experimentalOptions = {}): Anthropology experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology experimental };
diff --git a/src/anthropology/fast.ts b/src/anthropology/fast.ts
new file mode 100644
index 000000000..dbf51f916
--- /dev/null
+++ b/src/anthropology/fast.ts
@@ -0,0 +1,15 @@
+/** Anthropology Fast module — tsb analytics library. */
+export interface Anthropology fastOptions { tol?: number; maxIter?: number; }
+export interface Anthropology fastResult { values: number[]; converged: boolean; }
+export function computeAnthropology fast(data: number[], opts: Anthropology fastOptions = {}): Anthropology fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology fast };
diff --git a/src/anthropology/fission_track.ts b/src/anthropology/fission_track.ts
new file mode 100644
index 000000000..449597244
--- /dev/null
+++ b/src/anthropology/fission_track.ts
@@ -0,0 +1,22 @@
+/** Fission Track module — tsb analytics library. */
+
+/** Options for Fission Track. */
+export interface FissionTrackOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fission Track. */
+export interface FissionTrackResult { values: number[]; converged: boolean; }
+
+/** Compute Fission Track. */
+export function computeFissionTrack(data: number[], opts: FissionTrackOptions = {}): FissionTrackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFissionTrack };
diff --git a/src/anthropology/future.ts b/src/anthropology/future.ts
new file mode 100644
index 000000000..ceb741784
--- /dev/null
+++ b/src/anthropology/future.ts
@@ -0,0 +1,15 @@
+/** Anthropology Future module — tsb analytics library. */
+export interface Anthropology futureOptions { tol?: number; maxIter?: number; }
+export interface Anthropology futureResult { values: number[]; converged: boolean; }
+export function computeAnthropology future(data: number[], opts: Anthropology futureOptions = {}): Anthropology futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology future };
diff --git a/src/anthropology/geoarchaeology.ts b/src/anthropology/geoarchaeology.ts
new file mode 100644
index 000000000..f2945d472
--- /dev/null
+++ b/src/anthropology/geoarchaeology.ts
@@ -0,0 +1,22 @@
+/** Geoarchaeology module — tsb analytics library. */
+
+/** Options for Geoarchaeology. */
+export interface GeoarchaeologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Geoarchaeology. */
+export interface GeoarchaeologyResult { values: number[]; converged: boolean; }
+
+/** Compute Geoarchaeology. */
+export function computeGeoarchaeology(data: number[], opts: GeoarchaeologyOptions = {}): GeoarchaeologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeoarchaeology };
diff --git a/src/anthropology/gis_anth.ts b/src/anthropology/gis_anth.ts
new file mode 100644
index 000000000..6dd9ac72a
--- /dev/null
+++ b/src/anthropology/gis_anth.ts
@@ -0,0 +1,22 @@
+/** Gis Anth module — tsb analytics library. */
+
+/** Options for Gis Anth. */
+export interface GisAnthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gis Anth. */
+export interface GisAnthResult { values: number[]; converged: boolean; }
+
+/** Compute Gis Anth. */
+export function computeGisAnth(data: number[], opts: GisAnthOptions = {}): GisAnthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGisAnth };
diff --git a/src/anthropology/gpu.ts b/src/anthropology/gpu.ts
new file mode 100644
index 000000000..f141d11f0
--- /dev/null
+++ b/src/anthropology/gpu.ts
@@ -0,0 +1,15 @@
+/** Anthropology Gpu module — tsb analytics library. */
+export interface Anthropology gpuOptions { tol?: number; maxIter?: number; }
+export interface Anthropology gpuResult { values: number[]; converged: boolean; }
+export function computeAnthropology gpu(data: number[], opts: Anthropology gpuOptions = {}): Anthropology gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology gpu };
diff --git a/src/anthropology/human_evolution.ts b/src/anthropology/human_evolution.ts
new file mode 100644
index 000000000..531f74ad4
--- /dev/null
+++ b/src/anthropology/human_evolution.ts
@@ -0,0 +1,22 @@
+/** Human Evolution module — tsb analytics library. */
+
+/** Options for Human Evolution. */
+export interface HumanEvolutionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Human Evolution. */
+export interface HumanEvolutionResult { values: number[]; converged: boolean; }
+
+/** Compute Human Evolution. */
+export function computeHumanEvolution(data: number[], opts: HumanEvolutionOptions = {}): HumanEvolutionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHumanEvolution };
diff --git a/src/anthropology/landscape_anth.ts b/src/anthropology/landscape_anth.ts
new file mode 100644
index 000000000..33687d515
--- /dev/null
+++ b/src/anthropology/landscape_anth.ts
@@ -0,0 +1,22 @@
+/** Landscape Anth module — tsb analytics library. */
+
+/** Options for Landscape Anth. */
+export interface LandscapeAnthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Landscape Anth. */
+export interface LandscapeAnthResult { values: number[]; converged: boolean; }
+
+/** Compute Landscape Anth. */
+export function computeLandscapeAnth(data: number[], opts: LandscapeAnthOptions = {}): LandscapeAnthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLandscapeAnth };
diff --git a/src/anthropology/large.ts b/src/anthropology/large.ts
new file mode 100644
index 000000000..9e7b893eb
--- /dev/null
+++ b/src/anthropology/large.ts
@@ -0,0 +1,15 @@
+/** Anthropology Large module — tsb analytics library. */
+export interface Anthropology largeOptions { tol?: number; maxIter?: number; }
+export interface Anthropology largeResult { values: number[]; converged: boolean; }
+export function computeAnthropology large(data: number[], opts: Anthropology largeOptions = {}): Anthropology largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology large };
diff --git a/src/anthropology/legacy.ts b/src/anthropology/legacy.ts
new file mode 100644
index 000000000..53e406c21
--- /dev/null
+++ b/src/anthropology/legacy.ts
@@ -0,0 +1,15 @@
+/** Anthropology Legacy module — tsb analytics library. */
+export interface Anthropology legacyOptions { tol?: number; maxIter?: number; }
+export interface Anthropology legacyResult { values: number[]; converged: boolean; }
+export function computeAnthropology legacy(data: number[], opts: Anthropology legacyOptions = {}): Anthropology legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology legacy };
diff --git a/src/anthropology/linguistic_anth.ts b/src/anthropology/linguistic_anth.ts
new file mode 100644
index 000000000..da26c6912
--- /dev/null
+++ b/src/anthropology/linguistic_anth.ts
@@ -0,0 +1,22 @@
+/** Linguistic Anth module — tsb analytics library. */
+
+/** Options for Linguistic Anth. */
+export interface LinguisticAnthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Linguistic Anth. */
+export interface LinguisticAnthResult { values: number[]; converged: boolean; }
+
+/** Compute Linguistic Anth. */
+export function computeLinguisticAnth(data: number[], opts: LinguisticAnthOptions = {}): LinguisticAnthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLinguisticAnth };
diff --git a/src/anthropology/lite.ts b/src/anthropology/lite.ts
new file mode 100644
index 000000000..bb59a047c
--- /dev/null
+++ b/src/anthropology/lite.ts
@@ -0,0 +1,15 @@
+/** Anthropology Lite module — tsb analytics library. */
+export interface Anthropology liteOptions { tol?: number; maxIter?: number; }
+export interface Anthropology liteResult { values: number[]; converged: boolean; }
+export function computeAnthropology lite(data: number[], opts: Anthropology liteOptions = {}): Anthropology liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology lite };
diff --git a/src/anthropology/luminescence.ts b/src/anthropology/luminescence.ts
new file mode 100644
index 000000000..095858484
--- /dev/null
+++ b/src/anthropology/luminescence.ts
@@ -0,0 +1,22 @@
+/** Luminescence module — tsb analytics library. */
+
+/** Options for Luminescence. */
+export interface LuminescenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Luminescence. */
+export interface LuminescenceResult { values: number[]; converged: boolean; }
+
+/** Compute Luminescence. */
+export function computeLuminescence(data: number[], opts: LuminescenceOptions = {}): LuminescenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLuminescence };
diff --git a/src/anthropology/mini.ts b/src/anthropology/mini.ts
new file mode 100644
index 000000000..939776abb
--- /dev/null
+++ b/src/anthropology/mini.ts
@@ -0,0 +1,15 @@
+/** Anthropology Mini module — tsb analytics library. */
+export interface Anthropology miniOptions { tol?: number; maxIter?: number; }
+export interface Anthropology miniResult { values: number[]; converged: boolean; }
+export function computeAnthropology mini(data: number[], opts: Anthropology miniOptions = {}): Anthropology miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology mini };
diff --git a/src/anthropology/modern_human_origins.ts b/src/anthropology/modern_human_origins.ts
new file mode 100644
index 000000000..ec590bac5
--- /dev/null
+++ b/src/anthropology/modern_human_origins.ts
@@ -0,0 +1,22 @@
+/** Modern Human Origins module — tsb analytics library. */
+
+/** Options for Modern Human Origins. */
+export interface ModernHumanOriginsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Modern Human Origins. */
+export interface ModernHumanOriginsResult { values: number[]; converged: boolean; }
+
+/** Compute Modern Human Origins. */
+export function computeModernHumanOrigins(data: number[], opts: ModernHumanOriginsOptions = {}): ModernHumanOriginsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeModernHumanOrigins };
diff --git a/src/anthropology/molecular.ts b/src/anthropology/molecular.ts
new file mode 100644
index 000000000..114ab3253
--- /dev/null
+++ b/src/anthropology/molecular.ts
@@ -0,0 +1,22 @@
+/** Molecular module — tsb analytics library. */
+
+/** Options for Molecular. */
+export interface MolecularOptions { tol?: number; maxIter?: number; }
+
+/** Result from Molecular. */
+export interface MolecularResult { values: number[]; converged: boolean; }
+
+/** Compute Molecular. */
+export function computeMolecular(data: number[], opts: MolecularOptions = {}): MolecularResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMolecular };
diff --git a/src/anthropology/morphometry.ts b/src/anthropology/morphometry.ts
new file mode 100644
index 000000000..860eb6fc7
--- /dev/null
+++ b/src/anthropology/morphometry.ts
@@ -0,0 +1,22 @@
+/** Morphometry module — tsb analytics library. */
+
+/** Options for Morphometry. */
+export interface MorphometryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Morphometry. */
+export interface MorphometryResult { values: number[]; converged: boolean; }
+
+/** Compute Morphometry. */
+export function computeMorphometry(data: number[], opts: MorphometryOptions = {}): MorphometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMorphometry };
diff --git a/src/anthropology/next.ts b/src/anthropology/next.ts
new file mode 100644
index 000000000..154ad3343
--- /dev/null
+++ b/src/anthropology/next.ts
@@ -0,0 +1,15 @@
+/** Anthropology Next module — tsb analytics library. */
+export interface Anthropology nextOptions { tol?: number; maxIter?: number; }
+export interface Anthropology nextResult { values: number[]; converged: boolean; }
+export function computeAnthropology next(data: number[], opts: Anthropology nextOptions = {}): Anthropology nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology next };
diff --git a/src/anthropology/online.ts b/src/anthropology/online.ts
new file mode 100644
index 000000000..8dcd7cc29
--- /dev/null
+++ b/src/anthropology/online.ts
@@ -0,0 +1,15 @@
+/** Anthropology Online module — tsb analytics library. */
+export interface Anthropology onlineOptions { tol?: number; maxIter?: number; }
+export interface Anthropology onlineResult { values: number[]; converged: boolean; }
+export function computeAnthropology online(data: number[], opts: Anthropology onlineOptions = {}): Anthropology onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology online };
diff --git a/src/anthropology/paleoanthropology.ts b/src/anthropology/paleoanthropology.ts
new file mode 100644
index 000000000..3376d8e32
--- /dev/null
+++ b/src/anthropology/paleoanthropology.ts
@@ -0,0 +1,22 @@
+/** Paleoanthropology module — tsb analytics library. */
+
+/** Options for Paleoanthropology. */
+export interface PaleoanthropologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Paleoanthropology. */
+export interface PaleoanthropologyResult { values: number[]; converged: boolean; }
+
+/** Compute Paleoanthropology. */
+export function computePaleoanthropology(data: number[], opts: PaleoanthropologyOptions = {}): PaleoanthropologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePaleoanthropology };
diff --git a/src/anthropology/parallel.ts b/src/anthropology/parallel.ts
new file mode 100644
index 000000000..6c447a595
--- /dev/null
+++ b/src/anthropology/parallel.ts
@@ -0,0 +1,15 @@
+/** Anthropology Parallel module — tsb analytics library. */
+export interface Anthropology parallelOptions { tol?: number; maxIter?: number; }
+export interface Anthropology parallelResult { values: number[]; converged: boolean; }
+export function computeAnthropology parallel(data: number[], opts: Anthropology parallelOptions = {}): Anthropology parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology parallel };
diff --git a/src/anthropology/physical.ts b/src/anthropology/physical.ts
new file mode 100644
index 000000000..211999352
--- /dev/null
+++ b/src/anthropology/physical.ts
@@ -0,0 +1,22 @@
+/** Physical module — tsb analytics library. */
+
+/** Options for Physical. */
+export interface PhysicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Physical. */
+export interface PhysicalResult { values: number[]; converged: boolean; }
+
+/** Compute Physical. */
+export function computePhysical(data: number[], opts: PhysicalOptions = {}): PhysicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhysical };
diff --git a/src/anthropology/plus.ts b/src/anthropology/plus.ts
new file mode 100644
index 000000000..b285f4155
--- /dev/null
+++ b/src/anthropology/plus.ts
@@ -0,0 +1,15 @@
+/** Anthropology Plus module — tsb analytics library. */
+export interface Anthropology plusOptions { tol?: number; maxIter?: number; }
+export interface Anthropology plusResult { values: number[]; converged: boolean; }
+export function computeAnthropology plus(data: number[], opts: Anthropology plusOptions = {}): Anthropology plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology plus };
diff --git a/src/anthropology/population_genetics_anth.ts b/src/anthropology/population_genetics_anth.ts
new file mode 100644
index 000000000..28b2cf5f9
--- /dev/null
+++ b/src/anthropology/population_genetics_anth.ts
@@ -0,0 +1,22 @@
+/** Population Genetics Anth module — tsb analytics library. */
+
+/** Options for Population Genetics Anth. */
+export interface PopulationGeneticsAnthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Population Genetics Anth. */
+export interface PopulationGeneticsAnthResult { values: number[]; converged: boolean; }
+
+/** Compute Population Genetics Anth. */
+export function computePopulationGeneticsAnth(data: number[], opts: PopulationGeneticsAnthOptions = {}): PopulationGeneticsAnthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePopulationGeneticsAnth };
diff --git a/src/anthropology/potassium_argon.ts b/src/anthropology/potassium_argon.ts
new file mode 100644
index 000000000..da13b0b72
--- /dev/null
+++ b/src/anthropology/potassium_argon.ts
@@ -0,0 +1,22 @@
+/** Potassium Argon module — tsb analytics library. */
+
+/** Options for Potassium Argon. */
+export interface PotassiumArgonOptions { tol?: number; maxIter?: number; }
+
+/** Result from Potassium Argon. */
+export interface PotassiumArgonResult { values: number[]; converged: boolean; }
+
+/** Compute Potassium Argon. */
+export function computePotassiumArgon(data: number[], opts: PotassiumArgonOptions = {}): PotassiumArgonResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePotassiumArgon };
diff --git a/src/anthropology/primatology.ts b/src/anthropology/primatology.ts
new file mode 100644
index 000000000..c29325fe9
--- /dev/null
+++ b/src/anthropology/primatology.ts
@@ -0,0 +1,22 @@
+/** Primatology module — tsb analytics library. */
+
+/** Options for Primatology. */
+export interface PrimatologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Primatology. */
+export interface PrimatologyResult { values: number[]; converged: boolean; }
+
+/** Compute Primatology. */
+export function computePrimatology(data: number[], opts: PrimatologyOptions = {}): PrimatologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrimatology };
diff --git a/src/anthropology/pro.ts b/src/anthropology/pro.ts
new file mode 100644
index 000000000..3f279bd15
--- /dev/null
+++ b/src/anthropology/pro.ts
@@ -0,0 +1,15 @@
+/** Anthropology Pro module — tsb analytics library. */
+export interface Anthropology proOptions { tol?: number; maxIter?: number; }
+export interface Anthropology proResult { values: number[]; converged: boolean; }
+export function computeAnthropology pro(data: number[], opts: Anthropology proOptions = {}): Anthropology proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology pro };
diff --git a/src/anthropology/radiocarbon.ts b/src/anthropology/radiocarbon.ts
new file mode 100644
index 000000000..559dfb1c2
--- /dev/null
+++ b/src/anthropology/radiocarbon.ts
@@ -0,0 +1,22 @@
+/** Radiocarbon module — tsb analytics library. */
+
+/** Options for Radiocarbon. */
+export interface RadiocarbonOptions { tol?: number; maxIter?: number; }
+
+/** Result from Radiocarbon. */
+export interface RadiocarbonResult { values: number[]; converged: boolean; }
+
+/** Compute Radiocarbon. */
+export function computeRadiocarbon(data: number[], opts: RadiocarbonOptions = {}): RadiocarbonResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRadiocarbon };
diff --git a/src/anthropology/remote_sensing_anth.ts b/src/anthropology/remote_sensing_anth.ts
new file mode 100644
index 000000000..3140b8349
--- /dev/null
+++ b/src/anthropology/remote_sensing_anth.ts
@@ -0,0 +1,22 @@
+/** Remote Sensing Anth module — tsb analytics library. */
+
+/** Options for Remote Sensing Anth. */
+export interface RemoteSensingAnthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Remote Sensing Anth. */
+export interface RemoteSensingAnthResult { values: number[]; converged: boolean; }
+
+/** Compute Remote Sensing Anth. */
+export function computeRemoteSensingAnth(data: number[], opts: RemoteSensingAnthOptions = {}): RemoteSensingAnthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRemoteSensingAnth };
diff --git a/src/anthropology/robust.ts b/src/anthropology/robust.ts
new file mode 100644
index 000000000..37faec9fb
--- /dev/null
+++ b/src/anthropology/robust.ts
@@ -0,0 +1,15 @@
+/** Anthropology Robust module — tsb analytics library. */
+export interface Anthropology robustOptions { tol?: number; maxIter?: number; }
+export interface Anthropology robustResult { values: number[]; converged: boolean; }
+export function computeAnthropology robust(data: number[], opts: Anthropology robustOptions = {}): Anthropology robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology robust };
diff --git a/src/anthropology/small.ts b/src/anthropology/small.ts
new file mode 100644
index 000000000..75e092f73
--- /dev/null
+++ b/src/anthropology/small.ts
@@ -0,0 +1,15 @@
+/** Anthropology Small module — tsb analytics library. */
+export interface Anthropology smallOptions { tol?: number; maxIter?: number; }
+export interface Anthropology smallResult { values: number[]; converged: boolean; }
+export function computeAnthropology small(data: number[], opts: Anthropology smallOptions = {}): Anthropology smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology small };
diff --git a/src/anthropology/sparse.ts b/src/anthropology/sparse.ts
new file mode 100644
index 000000000..8c4fbd6b3
--- /dev/null
+++ b/src/anthropology/sparse.ts
@@ -0,0 +1,15 @@
+/** Anthropology Sparse module — tsb analytics library. */
+export interface Anthropology sparseOptions { tol?: number; maxIter?: number; }
+export interface Anthropology sparseResult { values: number[]; converged: boolean; }
+export function computeAnthropology sparse(data: number[], opts: Anthropology sparseOptions = {}): Anthropology sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology sparse };
diff --git a/src/anthropology/stable.ts b/src/anthropology/stable.ts
new file mode 100644
index 000000000..513a4dd99
--- /dev/null
+++ b/src/anthropology/stable.ts
@@ -0,0 +1,15 @@
+/** Anthropology Stable module — tsb analytics library. */
+export interface Anthropology stableOptions { tol?: number; maxIter?: number; }
+export interface Anthropology stableResult { values: number[]; converged: boolean; }
+export function computeAnthropology stable(data: number[], opts: Anthropology stableOptions = {}): Anthropology stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology stable };
diff --git a/src/anthropology/stable_isotope_anth.ts b/src/anthropology/stable_isotope_anth.ts
new file mode 100644
index 000000000..e0e6db7a3
--- /dev/null
+++ b/src/anthropology/stable_isotope_anth.ts
@@ -0,0 +1,22 @@
+/** Stable Isotope Anth module — tsb analytics library. */
+
+/** Options for Stable Isotope Anth. */
+export interface StableIsotopeAnthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stable Isotope Anth. */
+export interface StableIsotopeAnthResult { values: number[]; converged: boolean; }
+
+/** Compute Stable Isotope Anth. */
+export function computeStableIsotopeAnth(data: number[], opts: StableIsotopeAnthOptions = {}): StableIsotopeAnthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStableIsotopeAnth };
diff --git a/src/anthropology/streaming.ts b/src/anthropology/streaming.ts
new file mode 100644
index 000000000..80229f72f
--- /dev/null
+++ b/src/anthropology/streaming.ts
@@ -0,0 +1,15 @@
+/** Anthropology Streaming module — tsb analytics library. */
+export interface Anthropology streamingOptions { tol?: number; maxIter?: number; }
+export interface Anthropology streamingResult { values: number[]; converged: boolean; }
+export function computeAnthropology streaming(data: number[], opts: Anthropology streamingOptions = {}): Anthropology streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology streaming };
diff --git a/src/anthropology/uranium_series.ts b/src/anthropology/uranium_series.ts
new file mode 100644
index 000000000..b7d6d7945
--- /dev/null
+++ b/src/anthropology/uranium_series.ts
@@ -0,0 +1,22 @@
+/** Uranium Series module — tsb analytics library. */
+
+/** Options for Uranium Series. */
+export interface UraniumSeriesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Uranium Series. */
+export interface UraniumSeriesResult { values: number[]; converged: boolean; }
+
+/** Compute Uranium Series. */
+export function computeUraniumSeries(data: number[], opts: UraniumSeriesOptions = {}): UraniumSeriesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeUraniumSeries };
diff --git a/src/anthropology/v2.ts b/src/anthropology/v2.ts
new file mode 100644
index 000000000..b2e2d9ffb
--- /dev/null
+++ b/src/anthropology/v2.ts
@@ -0,0 +1,15 @@
+/** Anthropology V2 module — tsb analytics library. */
+export interface Anthropology v2Options { tol?: number; maxIter?: number; }
+export interface Anthropology v2Result { values: number[]; converged: boolean; }
+export function computeAnthropology v2(data: number[], opts: Anthropology v2Options = {}): Anthropology v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology v2 };
diff --git a/src/anthropology/v3.ts b/src/anthropology/v3.ts
new file mode 100644
index 000000000..48c26b8fe
--- /dev/null
+++ b/src/anthropology/v3.ts
@@ -0,0 +1,15 @@
+/** Anthropology V3 module — tsb analytics library. */
+export interface Anthropology v3Options { tol?: number; maxIter?: number; }
+export interface Anthropology v3Result { values: number[]; converged: boolean; }
+export function computeAnthropology v3(data: number[], opts: Anthropology v3Options = {}): Anthropology v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology v3 };
diff --git a/src/anthropology/wasm.ts b/src/anthropology/wasm.ts
new file mode 100644
index 000000000..edf0be058
--- /dev/null
+++ b/src/anthropology/wasm.ts
@@ -0,0 +1,15 @@
+/** Anthropology Wasm module — tsb analytics library. */
+export interface Anthropology wasmOptions { tol?: number; maxIter?: number; }
+export interface Anthropology wasmResult { values: number[]; converged: boolean; }
+export function computeAnthropology wasm(data: number[], opts: Anthropology wasmOptions = {}): Anthropology wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology wasm };
diff --git a/src/anthropology/xlarge.ts b/src/anthropology/xlarge.ts
new file mode 100644
index 000000000..456da32f5
--- /dev/null
+++ b/src/anthropology/xlarge.ts
@@ -0,0 +1,15 @@
+/** Anthropology Xlarge module — tsb analytics library. */
+export interface Anthropology xlargeOptions { tol?: number; maxIter?: number; }
+export interface Anthropology xlargeResult { values: number[]; converged: boolean; }
+export function computeAnthropology xlarge(data: number[], opts: Anthropology xlargeOptions = {}): Anthropology xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAnthropology xlarge };
diff --git a/src/anthropology/zooarchaeology.ts b/src/anthropology/zooarchaeology.ts
new file mode 100644
index 000000000..4dbcbf701
--- /dev/null
+++ b/src/anthropology/zooarchaeology.ts
@@ -0,0 +1,22 @@
+/** Zooarchaeology module — tsb analytics library. */
+
+/** Options for Zooarchaeology. */
+export interface ZooarchaeologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Zooarchaeology. */
+export interface ZooarchaeologyResult { values: number[]; converged: boolean; }
+
+/** Compute Zooarchaeology. */
+export function computeZooarchaeology(data: number[], opts: ZooarchaeologyOptions = {}): ZooarchaeologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeZooarchaeology };
diff --git a/src/aquaculture_sci/adaptation.ts b/src/aquaculture_sci/adaptation.ts
new file mode 100644
index 000000000..75012c6c0
--- /dev/null
+++ b/src/aquaculture_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci adaptation module — tsb analytics library. */
+export interface AquacultureSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciAdaptation(data: number[], opts: AquacultureSciAdaptationOptions = {}): AquacultureSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciAdaptation };
diff --git a/src/aquaculture_sci/aggregation.ts b/src/aquaculture_sci/aggregation.ts
new file mode 100644
index 000000000..e97cd5576
--- /dev/null
+++ b/src/aquaculture_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci aggregation module — tsb analytics library. */
+export interface AquacultureSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciAggregationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciAggregation(data: number[], opts: AquacultureSciAggregationOptions = {}): AquacultureSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciAggregation };
diff --git a/src/aquaculture_sci/algebra.ts b/src/aquaculture_sci/algebra.ts
new file mode 100644
index 000000000..54ac55092
--- /dev/null
+++ b/src/aquaculture_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci algebra module — tsb analytics library. */
+export interface AquacultureSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciAlgebra(data: number[], opts: AquacultureSciAlgebraOptions = {}): AquacultureSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciAlgebra };
diff --git a/src/aquaculture_sci/alignment.ts b/src/aquaculture_sci/alignment.ts
new file mode 100644
index 000000000..efa2db909
--- /dev/null
+++ b/src/aquaculture_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci alignment module — tsb analytics library. */
+export interface AquacultureSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciAlignment(data: number[], opts: AquacultureSciAlignmentOptions = {}): AquacultureSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciAlignment };
diff --git a/src/aquaculture_sci/analysis.ts b/src/aquaculture_sci/analysis.ts
new file mode 100644
index 000000000..b985f1aaa
--- /dev/null
+++ b/src/aquaculture_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci analysis module — tsb analytics library. */
+export interface AquacultureSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciAnalysis(data: number[], opts: AquacultureSciAnalysisOptions = {}): AquacultureSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciAnalysis };
diff --git a/src/aquaculture_sci/augmentation.ts b/src/aquaculture_sci/augmentation.ts
new file mode 100644
index 000000000..12fbafc39
--- /dev/null
+++ b/src/aquaculture_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci augmentation module — tsb analytics library. */
+export interface AquacultureSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciAugmentation(data: number[], opts: AquacultureSciAugmentationOptions = {}): AquacultureSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciAugmentation };
diff --git a/src/aquaculture_sci/bagging.ts b/src/aquaculture_sci/bagging.ts
new file mode 100644
index 000000000..efad16fb0
--- /dev/null
+++ b/src/aquaculture_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci bagging module — tsb analytics library. */
+export interface AquacultureSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciBaggingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciBagging(data: number[], opts: AquacultureSciBaggingOptions = {}): AquacultureSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciBagging };
diff --git a/src/aquaculture_sci/basis.ts b/src/aquaculture_sci/basis.ts
new file mode 100644
index 000000000..2fb55ceea
--- /dev/null
+++ b/src/aquaculture_sci/basis.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci basis module — tsb analytics library. */
+export interface AquacultureSciBasisOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciBasisResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciBasis(data: number[], opts: AquacultureSciBasisOptions = {}): AquacultureSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciBasis };
diff --git a/src/aquaculture_sci/benchmarking.ts b/src/aquaculture_sci/benchmarking.ts
new file mode 100644
index 000000000..054baac08
--- /dev/null
+++ b/src/aquaculture_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci benchmarking module — tsb analytics library. */
+export interface AquacultureSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciBenchmarking(data: number[], opts: AquacultureSciBenchmarkingOptions = {}): AquacultureSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciBenchmarking };
diff --git a/src/aquaculture_sci/blending.ts b/src/aquaculture_sci/blending.ts
new file mode 100644
index 000000000..14ff27286
--- /dev/null
+++ b/src/aquaculture_sci/blending.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci blending module — tsb analytics library. */
+export interface AquacultureSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciBlendingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciBlending(data: number[], opts: AquacultureSciBlendingOptions = {}): AquacultureSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciBlending };
diff --git a/src/aquaculture_sci/boosting.ts b/src/aquaculture_sci/boosting.ts
new file mode 100644
index 000000000..597b4f6c7
--- /dev/null
+++ b/src/aquaculture_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci boosting module — tsb analytics library. */
+export interface AquacultureSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciBoostingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciBoosting(data: number[], opts: AquacultureSciBoostingOptions = {}): AquacultureSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciBoosting };
diff --git a/src/aquaculture_sci/bootstrap.ts b/src/aquaculture_sci/bootstrap.ts
new file mode 100644
index 000000000..9e7fb3d5c
--- /dev/null
+++ b/src/aquaculture_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci bootstrap module — tsb analytics library. */
+export interface AquacultureSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciBootstrap(data: number[], opts: AquacultureSciBootstrapOptions = {}): AquacultureSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciBootstrap };
diff --git a/src/aquaculture_sci/calculus.ts b/src/aquaculture_sci/calculus.ts
new file mode 100644
index 000000000..9374effcb
--- /dev/null
+++ b/src/aquaculture_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci calculus module — tsb analytics library. */
+export interface AquacultureSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciCalculusResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciCalculus(data: number[], opts: AquacultureSciCalculusOptions = {}): AquacultureSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciCalculus };
diff --git a/src/aquaculture_sci/calibration.ts b/src/aquaculture_sci/calibration.ts
new file mode 100644
index 000000000..24f411327
--- /dev/null
+++ b/src/aquaculture_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci calibration module — tsb analytics library. */
+export interface AquacultureSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciCalibration(data: number[], opts: AquacultureSciCalibrationOptions = {}): AquacultureSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciCalibration };
diff --git a/src/aquaculture_sci/characterization.ts b/src/aquaculture_sci/characterization.ts
new file mode 100644
index 000000000..92536f86f
--- /dev/null
+++ b/src/aquaculture_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci characterization module — tsb analytics library. */
+export interface AquacultureSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciCharacterization(data: number[], opts: AquacultureSciCharacterizationOptions = {}): AquacultureSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciCharacterization };
diff --git a/src/aquaculture_sci/classification.ts b/src/aquaculture_sci/classification.ts
new file mode 100644
index 000000000..0d3768791
--- /dev/null
+++ b/src/aquaculture_sci/classification.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci classification module — tsb analytics library. */
+export interface AquacultureSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciClassificationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciClassification(data: number[], opts: AquacultureSciClassificationOptions = {}): AquacultureSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciClassification };
diff --git a/src/aquaculture_sci/clustering.ts b/src/aquaculture_sci/clustering.ts
new file mode 100644
index 000000000..9f2f958b0
--- /dev/null
+++ b/src/aquaculture_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci clustering module — tsb analytics library. */
+export interface AquacultureSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciClusteringResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciClustering(data: number[], opts: AquacultureSciClusteringOptions = {}): AquacultureSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciClustering };
diff --git a/src/aquaculture_sci/compression.ts b/src/aquaculture_sci/compression.ts
new file mode 100644
index 000000000..5d26743ad
--- /dev/null
+++ b/src/aquaculture_sci/compression.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci compression module — tsb analytics library. */
+export interface AquacultureSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciCompressionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciCompression(data: number[], opts: AquacultureSciCompressionOptions = {}): AquacultureSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciCompression };
diff --git a/src/aquaculture_sci/continuous.ts b/src/aquaculture_sci/continuous.ts
new file mode 100644
index 000000000..56cffb746
--- /dev/null
+++ b/src/aquaculture_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci continuous module — tsb analytics library. */
+export interface AquacultureSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciContinuousResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciContinuous(data: number[], opts: AquacultureSciContinuousOptions = {}): AquacultureSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciContinuous };
diff --git a/src/aquaculture_sci/control.ts b/src/aquaculture_sci/control.ts
new file mode 100644
index 000000000..c53bd821f
--- /dev/null
+++ b/src/aquaculture_sci/control.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci control module — tsb analytics library. */
+export interface AquacultureSciControlOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciControlResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciControl(data: number[], opts: AquacultureSciControlOptions = {}): AquacultureSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciControl };
diff --git a/src/aquaculture_sci/convergence.ts b/src/aquaculture_sci/convergence.ts
new file mode 100644
index 000000000..e991783ca
--- /dev/null
+++ b/src/aquaculture_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci convergence module — tsb analytics library. */
+export interface AquacultureSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciConvergence(data: number[], opts: AquacultureSciConvergenceOptions = {}): AquacultureSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciConvergence };
diff --git a/src/aquaculture_sci/convex.ts b/src/aquaculture_sci/convex.ts
new file mode 100644
index 000000000..cd1121ad6
--- /dev/null
+++ b/src/aquaculture_sci/convex.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci convex module — tsb analytics library. */
+export interface AquacultureSciConvexOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciConvexResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciConvex(data: number[], opts: AquacultureSciConvexOptions = {}): AquacultureSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciConvex };
diff --git a/src/aquaculture_sci/correlation.ts b/src/aquaculture_sci/correlation.ts
new file mode 100644
index 000000000..8634ed4b3
--- /dev/null
+++ b/src/aquaculture_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci correlation module — tsb analytics library. */
+export interface AquacultureSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciCorrelation(data: number[], opts: AquacultureSciCorrelationOptions = {}): AquacultureSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciCorrelation };
diff --git a/src/aquaculture_sci/covariance.ts b/src/aquaculture_sci/covariance.ts
new file mode 100644
index 000000000..b04321d6c
--- /dev/null
+++ b/src/aquaculture_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci covariance module — tsb analytics library. */
+export interface AquacultureSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciCovariance(data: number[], opts: AquacultureSciCovarianceOptions = {}): AquacultureSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciCovariance };
diff --git a/src/aquaculture_sci/cross_validation.ts b/src/aquaculture_sci/cross_validation.ts
new file mode 100644
index 000000000..d5d382070
--- /dev/null
+++ b/src/aquaculture_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci cross_validation module — tsb analytics library. */
+export interface AquacultureSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciCrossValidation(data: number[], opts: AquacultureSciCrossValidationOptions = {}): AquacultureSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciCrossValidation };
diff --git a/src/aquaculture_sci/decoding.ts b/src/aquaculture_sci/decoding.ts
new file mode 100644
index 000000000..52882bc8f
--- /dev/null
+++ b/src/aquaculture_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci decoding module — tsb analytics library. */
+export interface AquacultureSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDecodingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDecoding(data: number[], opts: AquacultureSciDecodingOptions = {}): AquacultureSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDecoding };
diff --git a/src/aquaculture_sci/decomposition.ts b/src/aquaculture_sci/decomposition.ts
new file mode 100644
index 000000000..001e427d6
--- /dev/null
+++ b/src/aquaculture_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci decomposition module — tsb analytics library. */
+export interface AquacultureSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDecomposition(data: number[], opts: AquacultureSciDecompositionOptions = {}): AquacultureSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDecomposition };
diff --git a/src/aquaculture_sci/detection.ts b/src/aquaculture_sci/detection.ts
new file mode 100644
index 000000000..c0c2a2298
--- /dev/null
+++ b/src/aquaculture_sci/detection.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci detection module — tsb analytics library. */
+export interface AquacultureSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDetectionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDetection(data: number[], opts: AquacultureSciDetectionOptions = {}): AquacultureSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDetection };
diff --git a/src/aquaculture_sci/deterministic.ts b/src/aquaculture_sci/deterministic.ts
new file mode 100644
index 000000000..360dc0680
--- /dev/null
+++ b/src/aquaculture_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci deterministic module — tsb analytics library. */
+export interface AquacultureSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDeterministic(data: number[], opts: AquacultureSciDeterministicOptions = {}): AquacultureSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDeterministic };
diff --git a/src/aquaculture_sci/diagnostics.ts b/src/aquaculture_sci/diagnostics.ts
new file mode 100644
index 000000000..225aa88f6
--- /dev/null
+++ b/src/aquaculture_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci diagnostics module — tsb analytics library. */
+export interface AquacultureSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDiagnostics(data: number[], opts: AquacultureSciDiagnosticsOptions = {}): AquacultureSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDiagnostics };
diff --git a/src/aquaculture_sci/differential.ts b/src/aquaculture_sci/differential.ts
new file mode 100644
index 000000000..804d79163
--- /dev/null
+++ b/src/aquaculture_sci/differential.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci differential module — tsb analytics library. */
+export interface AquacultureSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDifferential(data: number[], opts: AquacultureSciDifferentialOptions = {}): AquacultureSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDifferential };
diff --git a/src/aquaculture_sci/discrete.ts b/src/aquaculture_sci/discrete.ts
new file mode 100644
index 000000000..0568490d8
--- /dev/null
+++ b/src/aquaculture_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci discrete module — tsb analytics library. */
+export interface AquacultureSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDiscrete(data: number[], opts: AquacultureSciDiscreteOptions = {}): AquacultureSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDiscrete };
diff --git a/src/aquaculture_sci/distribution.ts b/src/aquaculture_sci/distribution.ts
new file mode 100644
index 000000000..cd63e6561
--- /dev/null
+++ b/src/aquaculture_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci distribution module — tsb analytics library. */
+export interface AquacultureSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDistributionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDistribution(data: number[], opts: AquacultureSciDistributionOptions = {}): AquacultureSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDistribution };
diff --git a/src/aquaculture_sci/dynamic.ts b/src/aquaculture_sci/dynamic.ts
new file mode 100644
index 000000000..9b946972b
--- /dev/null
+++ b/src/aquaculture_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci dynamic module — tsb analytics library. */
+export interface AquacultureSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciDynamicResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciDynamic(data: number[], opts: AquacultureSciDynamicOptions = {}): AquacultureSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciDynamic };
diff --git a/src/aquaculture_sci/embedding.ts b/src/aquaculture_sci/embedding.ts
new file mode 100644
index 000000000..dc30893b0
--- /dev/null
+++ b/src/aquaculture_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci embedding module — tsb analytics library. */
+export interface AquacultureSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciEmbedding(data: number[], opts: AquacultureSciEmbeddingOptions = {}): AquacultureSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciEmbedding };
diff --git a/src/aquaculture_sci/encoding.ts b/src/aquaculture_sci/encoding.ts
new file mode 100644
index 000000000..332125a8f
--- /dev/null
+++ b/src/aquaculture_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci encoding module — tsb analytics library. */
+export interface AquacultureSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciEncodingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciEncoding(data: number[], opts: AquacultureSciEncodingOptions = {}): AquacultureSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciEncoding };
diff --git a/src/aquaculture_sci/ensemble.ts b/src/aquaculture_sci/ensemble.ts
new file mode 100644
index 000000000..54cd37022
--- /dev/null
+++ b/src/aquaculture_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci ensemble module — tsb analytics library. */
+export interface AquacultureSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciEnsemble(data: number[], opts: AquacultureSciEnsembleOptions = {}): AquacultureSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciEnsemble };
diff --git a/src/aquaculture_sci/estimation.ts b/src/aquaculture_sci/estimation.ts
new file mode 100644
index 000000000..d7653ac8c
--- /dev/null
+++ b/src/aquaculture_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci estimation module — tsb analytics library. */
+export interface AquacultureSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciEstimationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciEstimation(data: number[], opts: AquacultureSciEstimationOptions = {}): AquacultureSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciEstimation };
diff --git a/src/aquaculture_sci/evaluation.ts b/src/aquaculture_sci/evaluation.ts
new file mode 100644
index 000000000..79c01a025
--- /dev/null
+++ b/src/aquaculture_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci evaluation module — tsb analytics library. */
+export interface AquacultureSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciEvaluation(data: number[], opts: AquacultureSciEvaluationOptions = {}): AquacultureSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciEvaluation };
diff --git a/src/aquaculture_sci/extrapolation.ts b/src/aquaculture_sci/extrapolation.ts
new file mode 100644
index 000000000..fdfecb7b8
--- /dev/null
+++ b/src/aquaculture_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci extrapolation module — tsb analytics library. */
+export interface AquacultureSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciExtrapolation(data: number[], opts: AquacultureSciExtrapolationOptions = {}): AquacultureSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciExtrapolation };
diff --git a/src/aquaculture_sci/features.ts b/src/aquaculture_sci/features.ts
new file mode 100644
index 000000000..99ce65de3
--- /dev/null
+++ b/src/aquaculture_sci/features.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci features module — tsb analytics library. */
+export interface AquacultureSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciFeatures(data: number[], opts: AquacultureSciFeaturesOptions = {}): AquacultureSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciFeatures };
diff --git a/src/aquaculture_sci/feedback.ts b/src/aquaculture_sci/feedback.ts
new file mode 100644
index 000000000..58bbb4476
--- /dev/null
+++ b/src/aquaculture_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci feedback module — tsb analytics library. */
+export interface AquacultureSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciFeedback(data: number[], opts: AquacultureSciFeedbackOptions = {}): AquacultureSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciFeedback };
diff --git a/src/aquaculture_sci/filtering.ts b/src/aquaculture_sci/filtering.ts
new file mode 100644
index 000000000..e0f5555fb
--- /dev/null
+++ b/src/aquaculture_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci filtering module — tsb analytics library. */
+export interface AquacultureSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciFilteringResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciFiltering(data: number[], opts: AquacultureSciFilteringOptions = {}): AquacultureSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciFiltering };
diff --git a/src/aquaculture_sci/fourier.ts b/src/aquaculture_sci/fourier.ts
new file mode 100644
index 000000000..53437a81d
--- /dev/null
+++ b/src/aquaculture_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci fourier module — tsb analytics library. */
+export interface AquacultureSciFourierOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciFourierResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciFourier(data: number[], opts: AquacultureSciFourierOptions = {}): AquacultureSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciFourier };
diff --git a/src/aquaculture_sci/fusion.ts b/src/aquaculture_sci/fusion.ts
new file mode 100644
index 000000000..1a55dde50
--- /dev/null
+++ b/src/aquaculture_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci fusion module — tsb analytics library. */
+export interface AquacultureSciFusionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciFusionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciFusion(data: number[], opts: AquacultureSciFusionOptions = {}): AquacultureSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciFusion };
diff --git a/src/aquaculture_sci/generation.ts b/src/aquaculture_sci/generation.ts
new file mode 100644
index 000000000..7075cbc4e
--- /dev/null
+++ b/src/aquaculture_sci/generation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci generation module — tsb analytics library. */
+export interface AquacultureSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciGenerationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciGeneration(data: number[], opts: AquacultureSciGenerationOptions = {}): AquacultureSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciGeneration };
diff --git a/src/aquaculture_sci/geometry.ts b/src/aquaculture_sci/geometry.ts
new file mode 100644
index 000000000..2d3b27443
--- /dev/null
+++ b/src/aquaculture_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci geometry module — tsb analytics library. */
+export interface AquacultureSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciGeometryResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciGeometry(data: number[], opts: AquacultureSciGeometryOptions = {}): AquacultureSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciGeometry };
diff --git a/src/aquaculture_sci/gradient.ts b/src/aquaculture_sci/gradient.ts
new file mode 100644
index 000000000..604562e8d
--- /dev/null
+++ b/src/aquaculture_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci gradient module — tsb analytics library. */
+export interface AquacultureSciGradientOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciGradientResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciGradient(data: number[], opts: AquacultureSciGradientOptions = {}): AquacultureSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciGradient };
diff --git a/src/aquaculture_sci/hessian.ts b/src/aquaculture_sci/hessian.ts
new file mode 100644
index 000000000..e4a4062db
--- /dev/null
+++ b/src/aquaculture_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci hessian module — tsb analytics library. */
+export interface AquacultureSciHessianOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciHessianResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciHessian(data: number[], opts: AquacultureSciHessianOptions = {}): AquacultureSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciHessian };
diff --git a/src/aquaculture_sci/hypothesis.ts b/src/aquaculture_sci/hypothesis.ts
new file mode 100644
index 000000000..591075133
--- /dev/null
+++ b/src/aquaculture_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci hypothesis module — tsb analytics library. */
+export interface AquacultureSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciHypothesis(data: number[], opts: AquacultureSciHypothesisOptions = {}): AquacultureSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciHypothesis };
diff --git a/src/aquaculture_sci/inference.ts b/src/aquaculture_sci/inference.ts
new file mode 100644
index 000000000..eae4d2f3e
--- /dev/null
+++ b/src/aquaculture_sci/inference.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci inference module — tsb analytics library. */
+export interface AquacultureSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciInferenceResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciInference(data: number[], opts: AquacultureSciInferenceOptions = {}): AquacultureSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciInference };
diff --git a/src/aquaculture_sci/inference2.ts b/src/aquaculture_sci/inference2.ts
new file mode 100644
index 000000000..040f5f6ed
--- /dev/null
+++ b/src/aquaculture_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci inference2 module — tsb analytics library. */
+export interface AquacultureSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciInferenceResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciInference(data: number[], opts: AquacultureSciInferenceOptions = {}): AquacultureSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciInference };
diff --git a/src/aquaculture_sci/integral.ts b/src/aquaculture_sci/integral.ts
new file mode 100644
index 000000000..8202ca8ba
--- /dev/null
+++ b/src/aquaculture_sci/integral.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci integral module — tsb analytics library. */
+export interface AquacultureSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciIntegralResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciIntegral(data: number[], opts: AquacultureSciIntegralOptions = {}): AquacultureSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciIntegral };
diff --git a/src/aquaculture_sci/integration.ts b/src/aquaculture_sci/integration.ts
new file mode 100644
index 000000000..8bef8de67
--- /dev/null
+++ b/src/aquaculture_sci/integration.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci integration module — tsb analytics library. */
+export interface AquacultureSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciIntegration(data: number[], opts: AquacultureSciIntegrationOptions = {}): AquacultureSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciIntegration };
diff --git a/src/aquaculture_sci/interpolation.ts b/src/aquaculture_sci/interpolation.ts
new file mode 100644
index 000000000..438a9f13e
--- /dev/null
+++ b/src/aquaculture_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci interpolation module — tsb analytics library. */
+export interface AquacultureSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciInterpolation(data: number[], opts: AquacultureSciInterpolationOptions = {}): AquacultureSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciInterpolation };
diff --git a/src/aquaculture_sci/jacobian.ts b/src/aquaculture_sci/jacobian.ts
new file mode 100644
index 000000000..33974b82c
--- /dev/null
+++ b/src/aquaculture_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci jacobian module — tsb analytics library. */
+export interface AquacultureSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciJacobianResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciJacobian(data: number[], opts: AquacultureSciJacobianOptions = {}): AquacultureSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciJacobian };
diff --git a/src/aquaculture_sci/kernel.ts b/src/aquaculture_sci/kernel.ts
new file mode 100644
index 000000000..a6c6725ca
--- /dev/null
+++ b/src/aquaculture_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci kernel module — tsb analytics library. */
+export interface AquacultureSciKernelOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciKernelResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciKernel(data: number[], opts: AquacultureSciKernelOptions = {}): AquacultureSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciKernel };
diff --git a/src/aquaculture_sci/laplacian.ts b/src/aquaculture_sci/laplacian.ts
new file mode 100644
index 000000000..6574ac6b5
--- /dev/null
+++ b/src/aquaculture_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci laplacian module — tsb analytics library. */
+export interface AquacultureSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciLaplacian(data: number[], opts: AquacultureSciLaplacianOptions = {}): AquacultureSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciLaplacian };
diff --git a/src/aquaculture_sci/learning.ts b/src/aquaculture_sci/learning.ts
new file mode 100644
index 000000000..12d6f49f9
--- /dev/null
+++ b/src/aquaculture_sci/learning.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci learning module — tsb analytics library. */
+export interface AquacultureSciLearningOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciLearningResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciLearning(data: number[], opts: AquacultureSciLearningOptions = {}): AquacultureSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciLearning };
diff --git a/src/aquaculture_sci/linear.ts b/src/aquaculture_sci/linear.ts
new file mode 100644
index 000000000..fe0a4ee5f
--- /dev/null
+++ b/src/aquaculture_sci/linear.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci linear module — tsb analytics library. */
+export interface AquacultureSciLinearOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciLinearResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciLinear(data: number[], opts: AquacultureSciLinearOptions = {}): AquacultureSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciLinear };
diff --git a/src/aquaculture_sci/manifold.ts b/src/aquaculture_sci/manifold.ts
new file mode 100644
index 000000000..4d4944a3b
--- /dev/null
+++ b/src/aquaculture_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci manifold module — tsb analytics library. */
+export interface AquacultureSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciManifoldResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciManifold(data: number[], opts: AquacultureSciManifoldOptions = {}): AquacultureSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciManifold };
diff --git a/src/aquaculture_sci/matching.ts b/src/aquaculture_sci/matching.ts
new file mode 100644
index 000000000..120eb6904
--- /dev/null
+++ b/src/aquaculture_sci/matching.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci matching module — tsb analytics library. */
+export interface AquacultureSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciMatchingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciMatching(data: number[], opts: AquacultureSciMatchingOptions = {}): AquacultureSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciMatching };
diff --git a/src/aquaculture_sci/measurement.ts b/src/aquaculture_sci/measurement.ts
new file mode 100644
index 000000000..f5126e1ec
--- /dev/null
+++ b/src/aquaculture_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci measurement module — tsb analytics library. */
+export interface AquacultureSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciMeasurement(data: number[], opts: AquacultureSciMeasurementOptions = {}): AquacultureSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciMeasurement };
diff --git a/src/aquaculture_sci/metrics.ts b/src/aquaculture_sci/metrics.ts
new file mode 100644
index 000000000..da631863d
--- /dev/null
+++ b/src/aquaculture_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci metrics module — tsb analytics library. */
+export interface AquacultureSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciMetricsResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciMetrics(data: number[], opts: AquacultureSciMetricsOptions = {}): AquacultureSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciMetrics };
diff --git a/src/aquaculture_sci/modeling.ts b/src/aquaculture_sci/modeling.ts
new file mode 100644
index 000000000..1f05a0d3b
--- /dev/null
+++ b/src/aquaculture_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci modeling module — tsb analytics library. */
+export interface AquacultureSciModelingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciModelingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciModeling(data: number[], opts: AquacultureSciModelingOptions = {}): AquacultureSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciModeling };
diff --git a/src/aquaculture_sci/monitoring.ts b/src/aquaculture_sci/monitoring.ts
new file mode 100644
index 000000000..29aa71f1e
--- /dev/null
+++ b/src/aquaculture_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci monitoring module — tsb analytics library. */
+export interface AquacultureSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciMonitoring(data: number[], opts: AquacultureSciMonitoringOptions = {}): AquacultureSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciMonitoring };
diff --git a/src/aquaculture_sci/nonlinear.ts b/src/aquaculture_sci/nonlinear.ts
new file mode 100644
index 000000000..d65b3ce22
--- /dev/null
+++ b/src/aquaculture_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci nonlinear module — tsb analytics library. */
+export interface AquacultureSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciNonlinear(data: number[], opts: AquacultureSciNonlinearOptions = {}): AquacultureSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciNonlinear };
diff --git a/src/aquaculture_sci/normalization.ts b/src/aquaculture_sci/normalization.ts
new file mode 100644
index 000000000..6eaa7b3db
--- /dev/null
+++ b/src/aquaculture_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci normalization module — tsb analytics library. */
+export interface AquacultureSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciNormalization(data: number[], opts: AquacultureSciNormalizationOptions = {}): AquacultureSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciNormalization };
diff --git a/src/aquaculture_sci/optimization.ts b/src/aquaculture_sci/optimization.ts
new file mode 100644
index 000000000..eabd083a9
--- /dev/null
+++ b/src/aquaculture_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci optimization module — tsb analytics library. */
+export interface AquacultureSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciOptimization(data: number[], opts: AquacultureSciOptimizationOptions = {}): AquacultureSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciOptimization };
diff --git a/src/aquaculture_sci/patterns.ts b/src/aquaculture_sci/patterns.ts
new file mode 100644
index 000000000..3d09821ce
--- /dev/null
+++ b/src/aquaculture_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci patterns module — tsb analytics library. */
+export interface AquacultureSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciPatternsResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciPatterns(data: number[], opts: AquacultureSciPatternsOptions = {}): AquacultureSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciPatterns };
diff --git a/src/aquaculture_sci/permutation.ts b/src/aquaculture_sci/permutation.ts
new file mode 100644
index 000000000..c906f3af4
--- /dev/null
+++ b/src/aquaculture_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci permutation module — tsb analytics library. */
+export interface AquacultureSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciPermutationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciPermutation(data: number[], opts: AquacultureSciPermutationOptions = {}): AquacultureSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciPermutation };
diff --git a/src/aquaculture_sci/prediction.ts b/src/aquaculture_sci/prediction.ts
new file mode 100644
index 000000000..72d38f54d
--- /dev/null
+++ b/src/aquaculture_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci prediction module — tsb analytics library. */
+export interface AquacultureSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciPredictionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciPrediction(data: number[], opts: AquacultureSciPredictionOptions = {}): AquacultureSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciPrediction };
diff --git a/src/aquaculture_sci/processing.ts b/src/aquaculture_sci/processing.ts
new file mode 100644
index 000000000..31866befc
--- /dev/null
+++ b/src/aquaculture_sci/processing.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci processing module — tsb analytics library. */
+export interface AquacultureSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciProcessingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciProcessing(data: number[], opts: AquacultureSciProcessingOptions = {}): AquacultureSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciProcessing };
diff --git a/src/aquaculture_sci/profiling.ts b/src/aquaculture_sci/profiling.ts
new file mode 100644
index 000000000..fd4575e1c
--- /dev/null
+++ b/src/aquaculture_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci profiling module — tsb analytics library. */
+export interface AquacultureSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciProfilingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciProfiling(data: number[], opts: AquacultureSciProfilingOptions = {}): AquacultureSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciProfiling };
diff --git a/src/aquaculture_sci/projection.ts b/src/aquaculture_sci/projection.ts
new file mode 100644
index 000000000..44ab11434
--- /dev/null
+++ b/src/aquaculture_sci/projection.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci projection module — tsb analytics library. */
+export interface AquacultureSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciProjectionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciProjection(data: number[], opts: AquacultureSciProjectionOptions = {}): AquacultureSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciProjection };
diff --git a/src/aquaculture_sci/ranking.ts b/src/aquaculture_sci/ranking.ts
new file mode 100644
index 000000000..5a8dd2d30
--- /dev/null
+++ b/src/aquaculture_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci ranking module — tsb analytics library. */
+export interface AquacultureSciRankingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciRankingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciRanking(data: number[], opts: AquacultureSciRankingOptions = {}): AquacultureSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciRanking };
diff --git a/src/aquaculture_sci/reconstruction.ts b/src/aquaculture_sci/reconstruction.ts
new file mode 100644
index 000000000..8e129a1cd
--- /dev/null
+++ b/src/aquaculture_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci reconstruction module — tsb analytics library. */
+export interface AquacultureSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciReconstruction(data: number[], opts: AquacultureSciReconstructionOptions = {}): AquacultureSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciReconstruction };
diff --git a/src/aquaculture_sci/registration.ts b/src/aquaculture_sci/registration.ts
new file mode 100644
index 000000000..5250ab6d2
--- /dev/null
+++ b/src/aquaculture_sci/registration.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci registration module — tsb analytics library. */
+export interface AquacultureSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciRegistration(data: number[], opts: AquacultureSciRegistrationOptions = {}): AquacultureSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciRegistration };
diff --git a/src/aquaculture_sci/regression.ts b/src/aquaculture_sci/regression.ts
new file mode 100644
index 000000000..015918a04
--- /dev/null
+++ b/src/aquaculture_sci/regression.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci regression module — tsb analytics library. */
+export interface AquacultureSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciRegressionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciRegression(data: number[], opts: AquacultureSciRegressionOptions = {}): AquacultureSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciRegression };
diff --git a/src/aquaculture_sci/regularization.ts b/src/aquaculture_sci/regularization.ts
new file mode 100644
index 000000000..f0f8f9b75
--- /dev/null
+++ b/src/aquaculture_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci regularization module — tsb analytics library. */
+export interface AquacultureSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciRegularization(data: number[], opts: AquacultureSciRegularizationOptions = {}): AquacultureSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciRegularization };
diff --git a/src/aquaculture_sci/robustness.ts b/src/aquaculture_sci/robustness.ts
new file mode 100644
index 000000000..177b6acf4
--- /dev/null
+++ b/src/aquaculture_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci robustness module — tsb analytics library. */
+export interface AquacultureSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciRobustness(data: number[], opts: AquacultureSciRobustnessOptions = {}): AquacultureSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciRobustness };
diff --git a/src/aquaculture_sci/sampling.ts b/src/aquaculture_sci/sampling.ts
new file mode 100644
index 000000000..15609b96a
--- /dev/null
+++ b/src/aquaculture_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci sampling module — tsb analytics library. */
+export interface AquacultureSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciSamplingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciSampling(data: number[], opts: AquacultureSciSamplingOptions = {}): AquacultureSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciSampling };
diff --git a/src/aquaculture_sci/sampling2.ts b/src/aquaculture_sci/sampling2.ts
new file mode 100644
index 000000000..08900aa73
--- /dev/null
+++ b/src/aquaculture_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci sampling2 module — tsb analytics library. */
+export interface AquacultureSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciSamplingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciSampling(data: number[], opts: AquacultureSciSamplingOptions = {}): AquacultureSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciSampling };
diff --git a/src/aquaculture_sci/scaling.ts b/src/aquaculture_sci/scaling.ts
new file mode 100644
index 000000000..84d59a57c
--- /dev/null
+++ b/src/aquaculture_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci scaling module — tsb analytics library. */
+export interface AquacultureSciScalingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciScalingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciScaling(data: number[], opts: AquacultureSciScalingOptions = {}): AquacultureSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciScaling };
diff --git a/src/aquaculture_sci/scoring.ts b/src/aquaculture_sci/scoring.ts
new file mode 100644
index 000000000..eb18d4107
--- /dev/null
+++ b/src/aquaculture_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci scoring module — tsb analytics library. */
+export interface AquacultureSciScoringOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciScoringResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciScoring(data: number[], opts: AquacultureSciScoringOptions = {}): AquacultureSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciScoring };
diff --git a/src/aquaculture_sci/segmentation.ts b/src/aquaculture_sci/segmentation.ts
new file mode 100644
index 000000000..1fa72391f
--- /dev/null
+++ b/src/aquaculture_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci segmentation module — tsb analytics library. */
+export interface AquacultureSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciSegmentation(data: number[], opts: AquacultureSciSegmentationOptions = {}): AquacultureSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciSegmentation };
diff --git a/src/aquaculture_sci/selection.ts b/src/aquaculture_sci/selection.ts
new file mode 100644
index 000000000..b9461ad62
--- /dev/null
+++ b/src/aquaculture_sci/selection.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci selection module — tsb analytics library. */
+export interface AquacultureSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciSelectionResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciSelection(data: number[], opts: AquacultureSciSelectionOptions = {}): AquacultureSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciSelection };
diff --git a/src/aquaculture_sci/sensitivity.ts b/src/aquaculture_sci/sensitivity.ts
new file mode 100644
index 000000000..95fec66dd
--- /dev/null
+++ b/src/aquaculture_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci sensitivity module — tsb analytics library. */
+export interface AquacultureSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciSensitivity(data: number[], opts: AquacultureSciSensitivityOptions = {}): AquacultureSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciSensitivity };
diff --git a/src/aquaculture_sci/simulation.ts b/src/aquaculture_sci/simulation.ts
new file mode 100644
index 000000000..8e27a4f9d
--- /dev/null
+++ b/src/aquaculture_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci simulation module — tsb analytics library. */
+export interface AquacultureSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciSimulationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciSimulation(data: number[], opts: AquacultureSciSimulationOptions = {}): AquacultureSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciSimulation };
diff --git a/src/aquaculture_sci/smoothing.ts b/src/aquaculture_sci/smoothing.ts
new file mode 100644
index 000000000..772b42001
--- /dev/null
+++ b/src/aquaculture_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci smoothing module — tsb analytics library. */
+export interface AquacultureSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciSmoothing(data: number[], opts: AquacultureSciSmoothingOptions = {}): AquacultureSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciSmoothing };
diff --git a/src/aquaculture_sci/stability.ts b/src/aquaculture_sci/stability.ts
new file mode 100644
index 000000000..77c93dd1d
--- /dev/null
+++ b/src/aquaculture_sci/stability.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci stability module — tsb analytics library. */
+export interface AquacultureSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciStabilityResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciStability(data: number[], opts: AquacultureSciStabilityOptions = {}): AquacultureSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciStability };
diff --git a/src/aquaculture_sci/stacking.ts b/src/aquaculture_sci/stacking.ts
new file mode 100644
index 000000000..f93d4d530
--- /dev/null
+++ b/src/aquaculture_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci stacking module — tsb analytics library. */
+export interface AquacultureSciStackingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciStackingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciStacking(data: number[], opts: AquacultureSciStackingOptions = {}): AquacultureSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciStacking };
diff --git a/src/aquaculture_sci/standardization.ts b/src/aquaculture_sci/standardization.ts
new file mode 100644
index 000000000..ccfdfcfed
--- /dev/null
+++ b/src/aquaculture_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci standardization module — tsb analytics library. */
+export interface AquacultureSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciStandardization(data: number[], opts: AquacultureSciStandardizationOptions = {}): AquacultureSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciStandardization };
diff --git a/src/aquaculture_sci/static.ts b/src/aquaculture_sci/static.ts
new file mode 100644
index 000000000..2c33986da
--- /dev/null
+++ b/src/aquaculture_sci/static.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci static module — tsb analytics library. */
+export interface AquacultureSciStaticOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciStaticResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciStatic(data: number[], opts: AquacultureSciStaticOptions = {}): AquacultureSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciStatic };
diff --git a/src/aquaculture_sci/stochastic.ts b/src/aquaculture_sci/stochastic.ts
new file mode 100644
index 000000000..a2d356786
--- /dev/null
+++ b/src/aquaculture_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci stochastic module — tsb analytics library. */
+export interface AquacultureSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciStochasticResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciStochastic(data: number[], opts: AquacultureSciStochasticOptions = {}): AquacultureSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciStochastic };
diff --git a/src/aquaculture_sci/synthesis.ts b/src/aquaculture_sci/synthesis.ts
new file mode 100644
index 000000000..2269eb4d1
--- /dev/null
+++ b/src/aquaculture_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci synthesis module — tsb analytics library. */
+export interface AquacultureSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciSynthesis(data: number[], opts: AquacultureSciSynthesisOptions = {}): AquacultureSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciSynthesis };
diff --git a/src/aquaculture_sci/topology.ts b/src/aquaculture_sci/topology.ts
new file mode 100644
index 000000000..fc836c5f9
--- /dev/null
+++ b/src/aquaculture_sci/topology.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci topology module — tsb analytics library. */
+export interface AquacultureSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciTopologyResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciTopology(data: number[], opts: AquacultureSciTopologyOptions = {}): AquacultureSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciTopology };
diff --git a/src/aquaculture_sci/tracking.ts b/src/aquaculture_sci/tracking.ts
new file mode 100644
index 000000000..00bb00045
--- /dev/null
+++ b/src/aquaculture_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci tracking module — tsb analytics library. */
+export interface AquacultureSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciTrackingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciTracking(data: number[], opts: AquacultureSciTrackingOptions = {}): AquacultureSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciTracking };
diff --git a/src/aquaculture_sci/transform.ts b/src/aquaculture_sci/transform.ts
new file mode 100644
index 000000000..4fa3cbd16
--- /dev/null
+++ b/src/aquaculture_sci/transform.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci transform module — tsb analytics library. */
+export interface AquacultureSciTransformOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciTransformResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciTransform(data: number[], opts: AquacultureSciTransformOptions = {}): AquacultureSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciTransform };
diff --git a/src/aquaculture_sci/uncertainty.ts b/src/aquaculture_sci/uncertainty.ts
new file mode 100644
index 000000000..dd278623d
--- /dev/null
+++ b/src/aquaculture_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci uncertainty module — tsb analytics library. */
+export interface AquacultureSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciUncertainty(data: number[], opts: AquacultureSciUncertaintyOptions = {}): AquacultureSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciUncertainty };
diff --git a/src/aquaculture_sci/validation.ts b/src/aquaculture_sci/validation.ts
new file mode 100644
index 000000000..a41365e93
--- /dev/null
+++ b/src/aquaculture_sci/validation.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci validation module — tsb analytics library. */
+export interface AquacultureSciValidationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciValidationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciValidation(data: number[], opts: AquacultureSciValidationOptions = {}): AquacultureSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciValidation };
diff --git a/src/aquaculture_sci/verification.ts b/src/aquaculture_sci/verification.ts
new file mode 100644
index 000000000..55cb4aab3
--- /dev/null
+++ b/src/aquaculture_sci/verification.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci verification module — tsb analytics library. */
+export interface AquacultureSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciVerificationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciVerification(data: number[], opts: AquacultureSciVerificationOptions = {}): AquacultureSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciVerification };
diff --git a/src/aquaculture_sci/visualization.ts b/src/aquaculture_sci/visualization.ts
new file mode 100644
index 000000000..39e9293d7
--- /dev/null
+++ b/src/aquaculture_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci visualization module — tsb analytics library. */
+export interface AquacultureSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciVisualization(data: number[], opts: AquacultureSciVisualizationOptions = {}): AquacultureSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciVisualization };
diff --git a/src/aquaculture_sci/voting.ts b/src/aquaculture_sci/voting.ts
new file mode 100644
index 000000000..6878faef9
--- /dev/null
+++ b/src/aquaculture_sci/voting.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci voting module — tsb analytics library. */
+export interface AquacultureSciVotingOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciVotingResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciVoting(data: number[], opts: AquacultureSciVotingOptions = {}): AquacultureSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciVoting };
diff --git a/src/aquaculture_sci/wavelet.ts b/src/aquaculture_sci/wavelet.ts
new file mode 100644
index 000000000..ee33845a1
--- /dev/null
+++ b/src/aquaculture_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** aquaculture_sci wavelet module — tsb analytics library. */
+export interface AquacultureSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface AquacultureSciWaveletResult { values: number[]; converged: boolean; }
+export function computeAquacultureSciWavelet(data: number[], opts: AquacultureSciWaveletOptions = {}): AquacultureSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAquacultureSciWavelet };
diff --git a/src/astrochemistry/adaptation.ts b/src/astrochemistry/adaptation.ts
new file mode 100644
index 000000000..7f8f90131
--- /dev/null
+++ b/src/astrochemistry/adaptation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry adaptation module — tsb analytics library. */
+export interface AstrochemistryAdaptationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryAdaptationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryAdaptation(data: number[], opts: AstrochemistryAdaptationOptions = {}): AstrochemistryAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryAdaptation };
diff --git a/src/astrochemistry/aggregation.ts b/src/astrochemistry/aggregation.ts
new file mode 100644
index 000000000..ce009d457
--- /dev/null
+++ b/src/astrochemistry/aggregation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry aggregation module — tsb analytics library. */
+export interface AstrochemistryAggregationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryAggregationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryAggregation(data: number[], opts: AstrochemistryAggregationOptions = {}): AstrochemistryAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryAggregation };
diff --git a/src/astrochemistry/algebra.ts b/src/astrochemistry/algebra.ts
new file mode 100644
index 000000000..689ce6c14
--- /dev/null
+++ b/src/astrochemistry/algebra.ts
@@ -0,0 +1,14 @@
+/** astrochemistry algebra module — tsb analytics library. */
+export interface AstrochemistryAlgebraOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryAlgebraResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryAlgebra(data: number[], opts: AstrochemistryAlgebraOptions = {}): AstrochemistryAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryAlgebra };
diff --git a/src/astrochemistry/alignment.ts b/src/astrochemistry/alignment.ts
new file mode 100644
index 000000000..edf6ca6fc
--- /dev/null
+++ b/src/astrochemistry/alignment.ts
@@ -0,0 +1,14 @@
+/** astrochemistry alignment module — tsb analytics library. */
+export interface AstrochemistryAlignmentOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryAlignmentResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryAlignment(data: number[], opts: AstrochemistryAlignmentOptions = {}): AstrochemistryAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryAlignment };
diff --git a/src/astrochemistry/analysis.ts b/src/astrochemistry/analysis.ts
new file mode 100644
index 000000000..9a3511e75
--- /dev/null
+++ b/src/astrochemistry/analysis.ts
@@ -0,0 +1,14 @@
+/** astrochemistry analysis module — tsb analytics library. */
+export interface AstrochemistryAnalysisOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryAnalysisResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryAnalysis(data: number[], opts: AstrochemistryAnalysisOptions = {}): AstrochemistryAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryAnalysis };
diff --git a/src/astrochemistry/augmentation.ts b/src/astrochemistry/augmentation.ts
new file mode 100644
index 000000000..8e99fe0e9
--- /dev/null
+++ b/src/astrochemistry/augmentation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry augmentation module — tsb analytics library. */
+export interface AstrochemistryAugmentationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryAugmentationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryAugmentation(data: number[], opts: AstrochemistryAugmentationOptions = {}): AstrochemistryAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryAugmentation };
diff --git a/src/astrochemistry/bagging.ts b/src/astrochemistry/bagging.ts
new file mode 100644
index 000000000..e98fd4ff4
--- /dev/null
+++ b/src/astrochemistry/bagging.ts
@@ -0,0 +1,14 @@
+/** astrochemistry bagging module — tsb analytics library. */
+export interface AstrochemistryBaggingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryBaggingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryBagging(data: number[], opts: AstrochemistryBaggingOptions = {}): AstrochemistryBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryBagging };
diff --git a/src/astrochemistry/basis.ts b/src/astrochemistry/basis.ts
new file mode 100644
index 000000000..0caeff9e0
--- /dev/null
+++ b/src/astrochemistry/basis.ts
@@ -0,0 +1,14 @@
+/** astrochemistry basis module — tsb analytics library. */
+export interface AstrochemistryBasisOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryBasisResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryBasis(data: number[], opts: AstrochemistryBasisOptions = {}): AstrochemistryBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryBasis };
diff --git a/src/astrochemistry/benchmarking.ts b/src/astrochemistry/benchmarking.ts
new file mode 100644
index 000000000..0a2021d50
--- /dev/null
+++ b/src/astrochemistry/benchmarking.ts
@@ -0,0 +1,14 @@
+/** astrochemistry benchmarking module — tsb analytics library. */
+export interface AstrochemistryBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryBenchmarking(data: number[], opts: AstrochemistryBenchmarkingOptions = {}): AstrochemistryBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryBenchmarking };
diff --git a/src/astrochemistry/blending.ts b/src/astrochemistry/blending.ts
new file mode 100644
index 000000000..d6d0fd525
--- /dev/null
+++ b/src/astrochemistry/blending.ts
@@ -0,0 +1,14 @@
+/** astrochemistry blending module — tsb analytics library. */
+export interface AstrochemistryBlendingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryBlendingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryBlending(data: number[], opts: AstrochemistryBlendingOptions = {}): AstrochemistryBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryBlending };
diff --git a/src/astrochemistry/boosting.ts b/src/astrochemistry/boosting.ts
new file mode 100644
index 000000000..f32b14042
--- /dev/null
+++ b/src/astrochemistry/boosting.ts
@@ -0,0 +1,14 @@
+/** astrochemistry boosting module — tsb analytics library. */
+export interface AstrochemistryBoostingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryBoostingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryBoosting(data: number[], opts: AstrochemistryBoostingOptions = {}): AstrochemistryBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryBoosting };
diff --git a/src/astrochemistry/bootstrap.ts b/src/astrochemistry/bootstrap.ts
new file mode 100644
index 000000000..83a859251
--- /dev/null
+++ b/src/astrochemistry/bootstrap.ts
@@ -0,0 +1,14 @@
+/** astrochemistry bootstrap module — tsb analytics library. */
+export interface AstrochemistryBootstrapOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryBootstrapResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryBootstrap(data: number[], opts: AstrochemistryBootstrapOptions = {}): AstrochemistryBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryBootstrap };
diff --git a/src/astrochemistry/calculus.ts b/src/astrochemistry/calculus.ts
new file mode 100644
index 000000000..cb8e7203c
--- /dev/null
+++ b/src/astrochemistry/calculus.ts
@@ -0,0 +1,14 @@
+/** astrochemistry calculus module — tsb analytics library. */
+export interface AstrochemistryCalculusOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryCalculusResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryCalculus(data: number[], opts: AstrochemistryCalculusOptions = {}): AstrochemistryCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryCalculus };
diff --git a/src/astrochemistry/calibration.ts b/src/astrochemistry/calibration.ts
new file mode 100644
index 000000000..c249cecc7
--- /dev/null
+++ b/src/astrochemistry/calibration.ts
@@ -0,0 +1,14 @@
+/** astrochemistry calibration module — tsb analytics library. */
+export interface AstrochemistryCalibrationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryCalibrationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryCalibration(data: number[], opts: AstrochemistryCalibrationOptions = {}): AstrochemistryCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryCalibration };
diff --git a/src/astrochemistry/characterization.ts b/src/astrochemistry/characterization.ts
new file mode 100644
index 000000000..486b75f01
--- /dev/null
+++ b/src/astrochemistry/characterization.ts
@@ -0,0 +1,14 @@
+/** astrochemistry characterization module — tsb analytics library. */
+export interface AstrochemistryCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryCharacterizationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryCharacterization(data: number[], opts: AstrochemistryCharacterizationOptions = {}): AstrochemistryCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryCharacterization };
diff --git a/src/astrochemistry/classification.ts b/src/astrochemistry/classification.ts
new file mode 100644
index 000000000..f7ee6abb7
--- /dev/null
+++ b/src/astrochemistry/classification.ts
@@ -0,0 +1,14 @@
+/** astrochemistry classification module — tsb analytics library. */
+export interface AstrochemistryClassificationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryClassificationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryClassification(data: number[], opts: AstrochemistryClassificationOptions = {}): AstrochemistryClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryClassification };
diff --git a/src/astrochemistry/clustering.ts b/src/astrochemistry/clustering.ts
new file mode 100644
index 000000000..c60c86b4c
--- /dev/null
+++ b/src/astrochemistry/clustering.ts
@@ -0,0 +1,14 @@
+/** astrochemistry clustering module — tsb analytics library. */
+export interface AstrochemistryClusteringOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryClusteringResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryClustering(data: number[], opts: AstrochemistryClusteringOptions = {}): AstrochemistryClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryClustering };
diff --git a/src/astrochemistry/compression.ts b/src/astrochemistry/compression.ts
new file mode 100644
index 000000000..05473fc6d
--- /dev/null
+++ b/src/astrochemistry/compression.ts
@@ -0,0 +1,14 @@
+/** astrochemistry compression module — tsb analytics library. */
+export interface AstrochemistryCompressionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryCompressionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryCompression(data: number[], opts: AstrochemistryCompressionOptions = {}): AstrochemistryCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryCompression };
diff --git a/src/astrochemistry/continuous.ts b/src/astrochemistry/continuous.ts
new file mode 100644
index 000000000..22c030da6
--- /dev/null
+++ b/src/astrochemistry/continuous.ts
@@ -0,0 +1,14 @@
+/** astrochemistry continuous module — tsb analytics library. */
+export interface AstrochemistryContinuousOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryContinuousResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryContinuous(data: number[], opts: AstrochemistryContinuousOptions = {}): AstrochemistryContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryContinuous };
diff --git a/src/astrochemistry/control.ts b/src/astrochemistry/control.ts
new file mode 100644
index 000000000..302a0ad57
--- /dev/null
+++ b/src/astrochemistry/control.ts
@@ -0,0 +1,14 @@
+/** astrochemistry control module — tsb analytics library. */
+export interface AstrochemistryControlOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryControlResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryControl(data: number[], opts: AstrochemistryControlOptions = {}): AstrochemistryControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryControl };
diff --git a/src/astrochemistry/convergence.ts b/src/astrochemistry/convergence.ts
new file mode 100644
index 000000000..922b18750
--- /dev/null
+++ b/src/astrochemistry/convergence.ts
@@ -0,0 +1,14 @@
+/** astrochemistry convergence module — tsb analytics library. */
+export interface AstrochemistryConvergenceOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryConvergenceResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryConvergence(data: number[], opts: AstrochemistryConvergenceOptions = {}): AstrochemistryConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryConvergence };
diff --git a/src/astrochemistry/convex.ts b/src/astrochemistry/convex.ts
new file mode 100644
index 000000000..b639b14a1
--- /dev/null
+++ b/src/astrochemistry/convex.ts
@@ -0,0 +1,14 @@
+/** astrochemistry convex module — tsb analytics library. */
+export interface AstrochemistryConvexOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryConvexResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryConvex(data: number[], opts: AstrochemistryConvexOptions = {}): AstrochemistryConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryConvex };
diff --git a/src/astrochemistry/correlation.ts b/src/astrochemistry/correlation.ts
new file mode 100644
index 000000000..fdc039ad4
--- /dev/null
+++ b/src/astrochemistry/correlation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry correlation module — tsb analytics library. */
+export interface AstrochemistryCorrelationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryCorrelationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryCorrelation(data: number[], opts: AstrochemistryCorrelationOptions = {}): AstrochemistryCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryCorrelation };
diff --git a/src/astrochemistry/covariance.ts b/src/astrochemistry/covariance.ts
new file mode 100644
index 000000000..c05e68852
--- /dev/null
+++ b/src/astrochemistry/covariance.ts
@@ -0,0 +1,14 @@
+/** astrochemistry covariance module — tsb analytics library. */
+export interface AstrochemistryCovarianceOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryCovarianceResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryCovariance(data: number[], opts: AstrochemistryCovarianceOptions = {}): AstrochemistryCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryCovariance };
diff --git a/src/astrochemistry/cross_validation.ts b/src/astrochemistry/cross_validation.ts
new file mode 100644
index 000000000..48660d5c3
--- /dev/null
+++ b/src/astrochemistry/cross_validation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry cross_validation module — tsb analytics library. */
+export interface AstrochemistryCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryCrossValidationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryCrossValidation(data: number[], opts: AstrochemistryCrossValidationOptions = {}): AstrochemistryCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryCrossValidation };
diff --git a/src/astrochemistry/decoding.ts b/src/astrochemistry/decoding.ts
new file mode 100644
index 000000000..c8c8d62d6
--- /dev/null
+++ b/src/astrochemistry/decoding.ts
@@ -0,0 +1,14 @@
+/** astrochemistry decoding module — tsb analytics library. */
+export interface AstrochemistryDecodingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDecodingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDecoding(data: number[], opts: AstrochemistryDecodingOptions = {}): AstrochemistryDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDecoding };
diff --git a/src/astrochemistry/decomposition.ts b/src/astrochemistry/decomposition.ts
new file mode 100644
index 000000000..788e51680
--- /dev/null
+++ b/src/astrochemistry/decomposition.ts
@@ -0,0 +1,14 @@
+/** astrochemistry decomposition module — tsb analytics library. */
+export interface AstrochemistryDecompositionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDecompositionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDecomposition(data: number[], opts: AstrochemistryDecompositionOptions = {}): AstrochemistryDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDecomposition };
diff --git a/src/astrochemistry/detection.ts b/src/astrochemistry/detection.ts
new file mode 100644
index 000000000..c0bbba1e4
--- /dev/null
+++ b/src/astrochemistry/detection.ts
@@ -0,0 +1,14 @@
+/** astrochemistry detection module — tsb analytics library. */
+export interface AstrochemistryDetectionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDetectionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDetection(data: number[], opts: AstrochemistryDetectionOptions = {}): AstrochemistryDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDetection };
diff --git a/src/astrochemistry/deterministic.ts b/src/astrochemistry/deterministic.ts
new file mode 100644
index 000000000..973c691f8
--- /dev/null
+++ b/src/astrochemistry/deterministic.ts
@@ -0,0 +1,14 @@
+/** astrochemistry deterministic module — tsb analytics library. */
+export interface AstrochemistryDeterministicOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDeterministicResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDeterministic(data: number[], opts: AstrochemistryDeterministicOptions = {}): AstrochemistryDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDeterministic };
diff --git a/src/astrochemistry/diagnostics.ts b/src/astrochemistry/diagnostics.ts
new file mode 100644
index 000000000..f96436283
--- /dev/null
+++ b/src/astrochemistry/diagnostics.ts
@@ -0,0 +1,14 @@
+/** astrochemistry diagnostics module — tsb analytics library. */
+export interface AstrochemistryDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDiagnostics(data: number[], opts: AstrochemistryDiagnosticsOptions = {}): AstrochemistryDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDiagnostics };
diff --git a/src/astrochemistry/differential.ts b/src/astrochemistry/differential.ts
new file mode 100644
index 000000000..931ac657e
--- /dev/null
+++ b/src/astrochemistry/differential.ts
@@ -0,0 +1,14 @@
+/** astrochemistry differential module — tsb analytics library. */
+export interface AstrochemistryDifferentialOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDifferentialResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDifferential(data: number[], opts: AstrochemistryDifferentialOptions = {}): AstrochemistryDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDifferential };
diff --git a/src/astrochemistry/discrete.ts b/src/astrochemistry/discrete.ts
new file mode 100644
index 000000000..452ae077f
--- /dev/null
+++ b/src/astrochemistry/discrete.ts
@@ -0,0 +1,14 @@
+/** astrochemistry discrete module — tsb analytics library. */
+export interface AstrochemistryDiscreteOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDiscreteResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDiscrete(data: number[], opts: AstrochemistryDiscreteOptions = {}): AstrochemistryDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDiscrete };
diff --git a/src/astrochemistry/distribution.ts b/src/astrochemistry/distribution.ts
new file mode 100644
index 000000000..afd513be9
--- /dev/null
+++ b/src/astrochemistry/distribution.ts
@@ -0,0 +1,14 @@
+/** astrochemistry distribution module — tsb analytics library. */
+export interface AstrochemistryDistributionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDistributionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDistribution(data: number[], opts: AstrochemistryDistributionOptions = {}): AstrochemistryDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDistribution };
diff --git a/src/astrochemistry/dynamic.ts b/src/astrochemistry/dynamic.ts
new file mode 100644
index 000000000..e95d11e12
--- /dev/null
+++ b/src/astrochemistry/dynamic.ts
@@ -0,0 +1,14 @@
+/** astrochemistry dynamic module — tsb analytics library. */
+export interface AstrochemistryDynamicOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryDynamicResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryDynamic(data: number[], opts: AstrochemistryDynamicOptions = {}): AstrochemistryDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryDynamic };
diff --git a/src/astrochemistry/embedding.ts b/src/astrochemistry/embedding.ts
new file mode 100644
index 000000000..b8506f2f7
--- /dev/null
+++ b/src/astrochemistry/embedding.ts
@@ -0,0 +1,14 @@
+/** astrochemistry embedding module — tsb analytics library. */
+export interface AstrochemistryEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryEmbeddingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryEmbedding(data: number[], opts: AstrochemistryEmbeddingOptions = {}): AstrochemistryEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryEmbedding };
diff --git a/src/astrochemistry/encoding.ts b/src/astrochemistry/encoding.ts
new file mode 100644
index 000000000..1b6cc8074
--- /dev/null
+++ b/src/astrochemistry/encoding.ts
@@ -0,0 +1,14 @@
+/** astrochemistry encoding module — tsb analytics library. */
+export interface AstrochemistryEncodingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryEncodingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryEncoding(data: number[], opts: AstrochemistryEncodingOptions = {}): AstrochemistryEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryEncoding };
diff --git a/src/astrochemistry/ensemble.ts b/src/astrochemistry/ensemble.ts
new file mode 100644
index 000000000..35169be21
--- /dev/null
+++ b/src/astrochemistry/ensemble.ts
@@ -0,0 +1,14 @@
+/** astrochemistry ensemble module — tsb analytics library. */
+export interface AstrochemistryEnsembleOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryEnsembleResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryEnsemble(data: number[], opts: AstrochemistryEnsembleOptions = {}): AstrochemistryEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryEnsemble };
diff --git a/src/astrochemistry/estimation.ts b/src/astrochemistry/estimation.ts
new file mode 100644
index 000000000..582a810b0
--- /dev/null
+++ b/src/astrochemistry/estimation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry estimation module — tsb analytics library. */
+export interface AstrochemistryEstimationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryEstimationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryEstimation(data: number[], opts: AstrochemistryEstimationOptions = {}): AstrochemistryEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryEstimation };
diff --git a/src/astrochemistry/evaluation.ts b/src/astrochemistry/evaluation.ts
new file mode 100644
index 000000000..e17d711dd
--- /dev/null
+++ b/src/astrochemistry/evaluation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry evaluation module — tsb analytics library. */
+export interface AstrochemistryEvaluationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryEvaluationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryEvaluation(data: number[], opts: AstrochemistryEvaluationOptions = {}): AstrochemistryEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryEvaluation };
diff --git a/src/astrochemistry/extrapolation.ts b/src/astrochemistry/extrapolation.ts
new file mode 100644
index 000000000..bc2279bb3
--- /dev/null
+++ b/src/astrochemistry/extrapolation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry extrapolation module — tsb analytics library. */
+export interface AstrochemistryExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryExtrapolationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryExtrapolation(data: number[], opts: AstrochemistryExtrapolationOptions = {}): AstrochemistryExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryExtrapolation };
diff --git a/src/astrochemistry/features.ts b/src/astrochemistry/features.ts
new file mode 100644
index 000000000..04e20c055
--- /dev/null
+++ b/src/astrochemistry/features.ts
@@ -0,0 +1,14 @@
+/** astrochemistry features module — tsb analytics library. */
+export interface AstrochemistryFeaturesOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryFeaturesResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryFeatures(data: number[], opts: AstrochemistryFeaturesOptions = {}): AstrochemistryFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryFeatures };
diff --git a/src/astrochemistry/feedback.ts b/src/astrochemistry/feedback.ts
new file mode 100644
index 000000000..ff21fac69
--- /dev/null
+++ b/src/astrochemistry/feedback.ts
@@ -0,0 +1,14 @@
+/** astrochemistry feedback module — tsb analytics library. */
+export interface AstrochemistryFeedbackOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryFeedbackResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryFeedback(data: number[], opts: AstrochemistryFeedbackOptions = {}): AstrochemistryFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryFeedback };
diff --git a/src/astrochemistry/filtering.ts b/src/astrochemistry/filtering.ts
new file mode 100644
index 000000000..7fb5f9053
--- /dev/null
+++ b/src/astrochemistry/filtering.ts
@@ -0,0 +1,14 @@
+/** astrochemistry filtering module — tsb analytics library. */
+export interface AstrochemistryFilteringOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryFilteringResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryFiltering(data: number[], opts: AstrochemistryFilteringOptions = {}): AstrochemistryFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryFiltering };
diff --git a/src/astrochemistry/fourier.ts b/src/astrochemistry/fourier.ts
new file mode 100644
index 000000000..ed77ac0de
--- /dev/null
+++ b/src/astrochemistry/fourier.ts
@@ -0,0 +1,14 @@
+/** astrochemistry fourier module — tsb analytics library. */
+export interface AstrochemistryFourierOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryFourierResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryFourier(data: number[], opts: AstrochemistryFourierOptions = {}): AstrochemistryFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryFourier };
diff --git a/src/astrochemistry/fusion.ts b/src/astrochemistry/fusion.ts
new file mode 100644
index 000000000..a057e25d9
--- /dev/null
+++ b/src/astrochemistry/fusion.ts
@@ -0,0 +1,14 @@
+/** astrochemistry fusion module — tsb analytics library. */
+export interface AstrochemistryFusionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryFusionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryFusion(data: number[], opts: AstrochemistryFusionOptions = {}): AstrochemistryFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryFusion };
diff --git a/src/astrochemistry/generation.ts b/src/astrochemistry/generation.ts
new file mode 100644
index 000000000..d921d29c1
--- /dev/null
+++ b/src/astrochemistry/generation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry generation module — tsb analytics library. */
+export interface AstrochemistryGenerationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryGenerationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryGeneration(data: number[], opts: AstrochemistryGenerationOptions = {}): AstrochemistryGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryGeneration };
diff --git a/src/astrochemistry/geometry.ts b/src/astrochemistry/geometry.ts
new file mode 100644
index 000000000..d9303a082
--- /dev/null
+++ b/src/astrochemistry/geometry.ts
@@ -0,0 +1,14 @@
+/** astrochemistry geometry module — tsb analytics library. */
+export interface AstrochemistryGeometryOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryGeometryResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryGeometry(data: number[], opts: AstrochemistryGeometryOptions = {}): AstrochemistryGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryGeometry };
diff --git a/src/astrochemistry/gradient.ts b/src/astrochemistry/gradient.ts
new file mode 100644
index 000000000..d0cbff476
--- /dev/null
+++ b/src/astrochemistry/gradient.ts
@@ -0,0 +1,14 @@
+/** astrochemistry gradient module — tsb analytics library. */
+export interface AstrochemistryGradientOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryGradientResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryGradient(data: number[], opts: AstrochemistryGradientOptions = {}): AstrochemistryGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryGradient };
diff --git a/src/astrochemistry/hessian.ts b/src/astrochemistry/hessian.ts
new file mode 100644
index 000000000..b17e8911d
--- /dev/null
+++ b/src/astrochemistry/hessian.ts
@@ -0,0 +1,14 @@
+/** astrochemistry hessian module — tsb analytics library. */
+export interface AstrochemistryHessianOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryHessianResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryHessian(data: number[], opts: AstrochemistryHessianOptions = {}): AstrochemistryHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryHessian };
diff --git a/src/astrochemistry/hypothesis.ts b/src/astrochemistry/hypothesis.ts
new file mode 100644
index 000000000..e06daf9ee
--- /dev/null
+++ b/src/astrochemistry/hypothesis.ts
@@ -0,0 +1,14 @@
+/** astrochemistry hypothesis module — tsb analytics library. */
+export interface AstrochemistryHypothesisOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryHypothesisResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryHypothesis(data: number[], opts: AstrochemistryHypothesisOptions = {}): AstrochemistryHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryHypothesis };
diff --git a/src/astrochemistry/inference.ts b/src/astrochemistry/inference.ts
new file mode 100644
index 000000000..1497834ba
--- /dev/null
+++ b/src/astrochemistry/inference.ts
@@ -0,0 +1,14 @@
+/** astrochemistry inference module — tsb analytics library. */
+export interface AstrochemistryInferenceOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryInferenceResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryInference(data: number[], opts: AstrochemistryInferenceOptions = {}): AstrochemistryInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryInference };
diff --git a/src/astrochemistry/inference2.ts b/src/astrochemistry/inference2.ts
new file mode 100644
index 000000000..672dfbf47
--- /dev/null
+++ b/src/astrochemistry/inference2.ts
@@ -0,0 +1,14 @@
+/** astrochemistry inference2 module — tsb analytics library. */
+export interface AstrochemistryInferenceOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryInferenceResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryInference(data: number[], opts: AstrochemistryInferenceOptions = {}): AstrochemistryInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryInference };
diff --git a/src/astrochemistry/integral.ts b/src/astrochemistry/integral.ts
new file mode 100644
index 000000000..b9cea4191
--- /dev/null
+++ b/src/astrochemistry/integral.ts
@@ -0,0 +1,14 @@
+/** astrochemistry integral module — tsb analytics library. */
+export interface AstrochemistryIntegralOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryIntegralResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryIntegral(data: number[], opts: AstrochemistryIntegralOptions = {}): AstrochemistryIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryIntegral };
diff --git a/src/astrochemistry/integration.ts b/src/astrochemistry/integration.ts
new file mode 100644
index 000000000..641cbe8b2
--- /dev/null
+++ b/src/astrochemistry/integration.ts
@@ -0,0 +1,14 @@
+/** astrochemistry integration module — tsb analytics library. */
+export interface AstrochemistryIntegrationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryIntegrationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryIntegration(data: number[], opts: AstrochemistryIntegrationOptions = {}): AstrochemistryIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryIntegration };
diff --git a/src/astrochemistry/interpolation.ts b/src/astrochemistry/interpolation.ts
new file mode 100644
index 000000000..989d0edb4
--- /dev/null
+++ b/src/astrochemistry/interpolation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry interpolation module — tsb analytics library. */
+export interface AstrochemistryInterpolationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryInterpolationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryInterpolation(data: number[], opts: AstrochemistryInterpolationOptions = {}): AstrochemistryInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryInterpolation };
diff --git a/src/astrochemistry/jacobian.ts b/src/astrochemistry/jacobian.ts
new file mode 100644
index 000000000..87eb9b7c4
--- /dev/null
+++ b/src/astrochemistry/jacobian.ts
@@ -0,0 +1,14 @@
+/** astrochemistry jacobian module — tsb analytics library. */
+export interface AstrochemistryJacobianOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryJacobianResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryJacobian(data: number[], opts: AstrochemistryJacobianOptions = {}): AstrochemistryJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryJacobian };
diff --git a/src/astrochemistry/kernel.ts b/src/astrochemistry/kernel.ts
new file mode 100644
index 000000000..6f4750be4
--- /dev/null
+++ b/src/astrochemistry/kernel.ts
@@ -0,0 +1,14 @@
+/** astrochemistry kernel module — tsb analytics library. */
+export interface AstrochemistryKernelOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryKernelResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryKernel(data: number[], opts: AstrochemistryKernelOptions = {}): AstrochemistryKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryKernel };
diff --git a/src/astrochemistry/laplacian.ts b/src/astrochemistry/laplacian.ts
new file mode 100644
index 000000000..351b49534
--- /dev/null
+++ b/src/astrochemistry/laplacian.ts
@@ -0,0 +1,14 @@
+/** astrochemistry laplacian module — tsb analytics library. */
+export interface AstrochemistryLaplacianOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryLaplacianResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryLaplacian(data: number[], opts: AstrochemistryLaplacianOptions = {}): AstrochemistryLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryLaplacian };
diff --git a/src/astrochemistry/learning.ts b/src/astrochemistry/learning.ts
new file mode 100644
index 000000000..56d8dde88
--- /dev/null
+++ b/src/astrochemistry/learning.ts
@@ -0,0 +1,14 @@
+/** astrochemistry learning module — tsb analytics library. */
+export interface AstrochemistryLearningOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryLearningResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryLearning(data: number[], opts: AstrochemistryLearningOptions = {}): AstrochemistryLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryLearning };
diff --git a/src/astrochemistry/linear.ts b/src/astrochemistry/linear.ts
new file mode 100644
index 000000000..0a3b496bb
--- /dev/null
+++ b/src/astrochemistry/linear.ts
@@ -0,0 +1,14 @@
+/** astrochemistry linear module — tsb analytics library. */
+export interface AstrochemistryLinearOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryLinearResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryLinear(data: number[], opts: AstrochemistryLinearOptions = {}): AstrochemistryLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryLinear };
diff --git a/src/astrochemistry/manifold.ts b/src/astrochemistry/manifold.ts
new file mode 100644
index 000000000..0196e669e
--- /dev/null
+++ b/src/astrochemistry/manifold.ts
@@ -0,0 +1,14 @@
+/** astrochemistry manifold module — tsb analytics library. */
+export interface AstrochemistryManifoldOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryManifoldResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryManifold(data: number[], opts: AstrochemistryManifoldOptions = {}): AstrochemistryManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryManifold };
diff --git a/src/astrochemistry/matching.ts b/src/astrochemistry/matching.ts
new file mode 100644
index 000000000..31efad2a5
--- /dev/null
+++ b/src/astrochemistry/matching.ts
@@ -0,0 +1,14 @@
+/** astrochemistry matching module — tsb analytics library. */
+export interface AstrochemistryMatchingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryMatchingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryMatching(data: number[], opts: AstrochemistryMatchingOptions = {}): AstrochemistryMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryMatching };
diff --git a/src/astrochemistry/measurement.ts b/src/astrochemistry/measurement.ts
new file mode 100644
index 000000000..9b8ef6d9d
--- /dev/null
+++ b/src/astrochemistry/measurement.ts
@@ -0,0 +1,14 @@
+/** astrochemistry measurement module — tsb analytics library. */
+export interface AstrochemistryMeasurementOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryMeasurementResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryMeasurement(data: number[], opts: AstrochemistryMeasurementOptions = {}): AstrochemistryMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryMeasurement };
diff --git a/src/astrochemistry/metrics.ts b/src/astrochemistry/metrics.ts
new file mode 100644
index 000000000..e3121dbe2
--- /dev/null
+++ b/src/astrochemistry/metrics.ts
@@ -0,0 +1,14 @@
+/** astrochemistry metrics module — tsb analytics library. */
+export interface AstrochemistryMetricsOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryMetricsResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryMetrics(data: number[], opts: AstrochemistryMetricsOptions = {}): AstrochemistryMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryMetrics };
diff --git a/src/astrochemistry/modeling.ts b/src/astrochemistry/modeling.ts
new file mode 100644
index 000000000..af6842d5c
--- /dev/null
+++ b/src/astrochemistry/modeling.ts
@@ -0,0 +1,14 @@
+/** astrochemistry modeling module — tsb analytics library. */
+export interface AstrochemistryModelingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryModelingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryModeling(data: number[], opts: AstrochemistryModelingOptions = {}): AstrochemistryModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryModeling };
diff --git a/src/astrochemistry/monitoring.ts b/src/astrochemistry/monitoring.ts
new file mode 100644
index 000000000..ae2d44222
--- /dev/null
+++ b/src/astrochemistry/monitoring.ts
@@ -0,0 +1,14 @@
+/** astrochemistry monitoring module — tsb analytics library. */
+export interface AstrochemistryMonitoringOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryMonitoringResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryMonitoring(data: number[], opts: AstrochemistryMonitoringOptions = {}): AstrochemistryMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryMonitoring };
diff --git a/src/astrochemistry/nonlinear.ts b/src/astrochemistry/nonlinear.ts
new file mode 100644
index 000000000..ef7593b38
--- /dev/null
+++ b/src/astrochemistry/nonlinear.ts
@@ -0,0 +1,14 @@
+/** astrochemistry nonlinear module — tsb analytics library. */
+export interface AstrochemistryNonlinearOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryNonlinearResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryNonlinear(data: number[], opts: AstrochemistryNonlinearOptions = {}): AstrochemistryNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryNonlinear };
diff --git a/src/astrochemistry/normalization.ts b/src/astrochemistry/normalization.ts
new file mode 100644
index 000000000..b8e8130ab
--- /dev/null
+++ b/src/astrochemistry/normalization.ts
@@ -0,0 +1,14 @@
+/** astrochemistry normalization module — tsb analytics library. */
+export interface AstrochemistryNormalizationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryNormalizationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryNormalization(data: number[], opts: AstrochemistryNormalizationOptions = {}): AstrochemistryNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryNormalization };
diff --git a/src/astrochemistry/optimization.ts b/src/astrochemistry/optimization.ts
new file mode 100644
index 000000000..9bbc6d6f4
--- /dev/null
+++ b/src/astrochemistry/optimization.ts
@@ -0,0 +1,14 @@
+/** astrochemistry optimization module — tsb analytics library. */
+export interface AstrochemistryOptimizationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryOptimizationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryOptimization(data: number[], opts: AstrochemistryOptimizationOptions = {}): AstrochemistryOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryOptimization };
diff --git a/src/astrochemistry/patterns.ts b/src/astrochemistry/patterns.ts
new file mode 100644
index 000000000..aafdf0716
--- /dev/null
+++ b/src/astrochemistry/patterns.ts
@@ -0,0 +1,14 @@
+/** astrochemistry patterns module — tsb analytics library. */
+export interface AstrochemistryPatternsOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryPatternsResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryPatterns(data: number[], opts: AstrochemistryPatternsOptions = {}): AstrochemistryPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryPatterns };
diff --git a/src/astrochemistry/permutation.ts b/src/astrochemistry/permutation.ts
new file mode 100644
index 000000000..53ab85d6c
--- /dev/null
+++ b/src/astrochemistry/permutation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry permutation module — tsb analytics library. */
+export interface AstrochemistryPermutationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryPermutationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryPermutation(data: number[], opts: AstrochemistryPermutationOptions = {}): AstrochemistryPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryPermutation };
diff --git a/src/astrochemistry/prediction.ts b/src/astrochemistry/prediction.ts
new file mode 100644
index 000000000..5a7993a2e
--- /dev/null
+++ b/src/astrochemistry/prediction.ts
@@ -0,0 +1,14 @@
+/** astrochemistry prediction module — tsb analytics library. */
+export interface AstrochemistryPredictionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryPredictionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryPrediction(data: number[], opts: AstrochemistryPredictionOptions = {}): AstrochemistryPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryPrediction };
diff --git a/src/astrochemistry/processing.ts b/src/astrochemistry/processing.ts
new file mode 100644
index 000000000..91313f975
--- /dev/null
+++ b/src/astrochemistry/processing.ts
@@ -0,0 +1,14 @@
+/** astrochemistry processing module — tsb analytics library. */
+export interface AstrochemistryProcessingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryProcessingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryProcessing(data: number[], opts: AstrochemistryProcessingOptions = {}): AstrochemistryProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryProcessing };
diff --git a/src/astrochemistry/profiling.ts b/src/astrochemistry/profiling.ts
new file mode 100644
index 000000000..f4e3735d1
--- /dev/null
+++ b/src/astrochemistry/profiling.ts
@@ -0,0 +1,14 @@
+/** astrochemistry profiling module — tsb analytics library. */
+export interface AstrochemistryProfilingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryProfilingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryProfiling(data: number[], opts: AstrochemistryProfilingOptions = {}): AstrochemistryProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryProfiling };
diff --git a/src/astrochemistry/projection.ts b/src/astrochemistry/projection.ts
new file mode 100644
index 000000000..e10f15020
--- /dev/null
+++ b/src/astrochemistry/projection.ts
@@ -0,0 +1,14 @@
+/** astrochemistry projection module — tsb analytics library. */
+export interface AstrochemistryProjectionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryProjectionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryProjection(data: number[], opts: AstrochemistryProjectionOptions = {}): AstrochemistryProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryProjection };
diff --git a/src/astrochemistry/ranking.ts b/src/astrochemistry/ranking.ts
new file mode 100644
index 000000000..6b5cb6c65
--- /dev/null
+++ b/src/astrochemistry/ranking.ts
@@ -0,0 +1,14 @@
+/** astrochemistry ranking module — tsb analytics library. */
+export interface AstrochemistryRankingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryRankingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryRanking(data: number[], opts: AstrochemistryRankingOptions = {}): AstrochemistryRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryRanking };
diff --git a/src/astrochemistry/reconstruction.ts b/src/astrochemistry/reconstruction.ts
new file mode 100644
index 000000000..c2e832ff9
--- /dev/null
+++ b/src/astrochemistry/reconstruction.ts
@@ -0,0 +1,14 @@
+/** astrochemistry reconstruction module — tsb analytics library. */
+export interface AstrochemistryReconstructionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryReconstructionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryReconstruction(data: number[], opts: AstrochemistryReconstructionOptions = {}): AstrochemistryReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryReconstruction };
diff --git a/src/astrochemistry/registration.ts b/src/astrochemistry/registration.ts
new file mode 100644
index 000000000..0213ecfd2
--- /dev/null
+++ b/src/astrochemistry/registration.ts
@@ -0,0 +1,14 @@
+/** astrochemistry registration module — tsb analytics library. */
+export interface AstrochemistryRegistrationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryRegistrationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryRegistration(data: number[], opts: AstrochemistryRegistrationOptions = {}): AstrochemistryRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryRegistration };
diff --git a/src/astrochemistry/regression.ts b/src/astrochemistry/regression.ts
new file mode 100644
index 000000000..0d5d984be
--- /dev/null
+++ b/src/astrochemistry/regression.ts
@@ -0,0 +1,14 @@
+/** astrochemistry regression module — tsb analytics library. */
+export interface AstrochemistryRegressionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryRegressionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryRegression(data: number[], opts: AstrochemistryRegressionOptions = {}): AstrochemistryRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryRegression };
diff --git a/src/astrochemistry/regularization.ts b/src/astrochemistry/regularization.ts
new file mode 100644
index 000000000..205c78b17
--- /dev/null
+++ b/src/astrochemistry/regularization.ts
@@ -0,0 +1,14 @@
+/** astrochemistry regularization module — tsb analytics library. */
+export interface AstrochemistryRegularizationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryRegularizationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryRegularization(data: number[], opts: AstrochemistryRegularizationOptions = {}): AstrochemistryRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryRegularization };
diff --git a/src/astrochemistry/robustness.ts b/src/astrochemistry/robustness.ts
new file mode 100644
index 000000000..4047c3989
--- /dev/null
+++ b/src/astrochemistry/robustness.ts
@@ -0,0 +1,14 @@
+/** astrochemistry robustness module — tsb analytics library. */
+export interface AstrochemistryRobustnessOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryRobustnessResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryRobustness(data: number[], opts: AstrochemistryRobustnessOptions = {}): AstrochemistryRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryRobustness };
diff --git a/src/astrochemistry/sampling.ts b/src/astrochemistry/sampling.ts
new file mode 100644
index 000000000..5335d5b71
--- /dev/null
+++ b/src/astrochemistry/sampling.ts
@@ -0,0 +1,14 @@
+/** astrochemistry sampling module — tsb analytics library. */
+export interface AstrochemistrySamplingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistrySamplingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistrySampling(data: number[], opts: AstrochemistrySamplingOptions = {}): AstrochemistrySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistrySampling };
diff --git a/src/astrochemistry/sampling2.ts b/src/astrochemistry/sampling2.ts
new file mode 100644
index 000000000..e09d4c40a
--- /dev/null
+++ b/src/astrochemistry/sampling2.ts
@@ -0,0 +1,14 @@
+/** astrochemistry sampling2 module — tsb analytics library. */
+export interface AstrochemistrySamplingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistrySamplingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistrySampling(data: number[], opts: AstrochemistrySamplingOptions = {}): AstrochemistrySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistrySampling };
diff --git a/src/astrochemistry/scaling.ts b/src/astrochemistry/scaling.ts
new file mode 100644
index 000000000..b827db92b
--- /dev/null
+++ b/src/astrochemistry/scaling.ts
@@ -0,0 +1,14 @@
+/** astrochemistry scaling module — tsb analytics library. */
+export interface AstrochemistryScalingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryScalingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryScaling(data: number[], opts: AstrochemistryScalingOptions = {}): AstrochemistryScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryScaling };
diff --git a/src/astrochemistry/scoring.ts b/src/astrochemistry/scoring.ts
new file mode 100644
index 000000000..209143687
--- /dev/null
+++ b/src/astrochemistry/scoring.ts
@@ -0,0 +1,14 @@
+/** astrochemistry scoring module — tsb analytics library. */
+export interface AstrochemistryScoringOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryScoringResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryScoring(data: number[], opts: AstrochemistryScoringOptions = {}): AstrochemistryScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryScoring };
diff --git a/src/astrochemistry/segmentation.ts b/src/astrochemistry/segmentation.ts
new file mode 100644
index 000000000..025360a92
--- /dev/null
+++ b/src/astrochemistry/segmentation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry segmentation module — tsb analytics library. */
+export interface AstrochemistrySegmentationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistrySegmentationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistrySegmentation(data: number[], opts: AstrochemistrySegmentationOptions = {}): AstrochemistrySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistrySegmentation };
diff --git a/src/astrochemistry/selection.ts b/src/astrochemistry/selection.ts
new file mode 100644
index 000000000..cbf51874b
--- /dev/null
+++ b/src/astrochemistry/selection.ts
@@ -0,0 +1,14 @@
+/** astrochemistry selection module — tsb analytics library. */
+export interface AstrochemistrySelectionOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistrySelectionResult { values: number[]; converged: boolean; }
+export function computeAstrochemistrySelection(data: number[], opts: AstrochemistrySelectionOptions = {}): AstrochemistrySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistrySelection };
diff --git a/src/astrochemistry/sensitivity.ts b/src/astrochemistry/sensitivity.ts
new file mode 100644
index 000000000..151c5e7fb
--- /dev/null
+++ b/src/astrochemistry/sensitivity.ts
@@ -0,0 +1,14 @@
+/** astrochemistry sensitivity module — tsb analytics library. */
+export interface AstrochemistrySensitivityOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistrySensitivityResult { values: number[]; converged: boolean; }
+export function computeAstrochemistrySensitivity(data: number[], opts: AstrochemistrySensitivityOptions = {}): AstrochemistrySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistrySensitivity };
diff --git a/src/astrochemistry/simulation.ts b/src/astrochemistry/simulation.ts
new file mode 100644
index 000000000..6aed34d5b
--- /dev/null
+++ b/src/astrochemistry/simulation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry simulation module — tsb analytics library. */
+export interface AstrochemistrySimulationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistrySimulationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistrySimulation(data: number[], opts: AstrochemistrySimulationOptions = {}): AstrochemistrySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistrySimulation };
diff --git a/src/astrochemistry/smoothing.ts b/src/astrochemistry/smoothing.ts
new file mode 100644
index 000000000..5612d9cc3
--- /dev/null
+++ b/src/astrochemistry/smoothing.ts
@@ -0,0 +1,14 @@
+/** astrochemistry smoothing module — tsb analytics library. */
+export interface AstrochemistrySmoothingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistrySmoothingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistrySmoothing(data: number[], opts: AstrochemistrySmoothingOptions = {}): AstrochemistrySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistrySmoothing };
diff --git a/src/astrochemistry/stability.ts b/src/astrochemistry/stability.ts
new file mode 100644
index 000000000..26a9e44ca
--- /dev/null
+++ b/src/astrochemistry/stability.ts
@@ -0,0 +1,14 @@
+/** astrochemistry stability module — tsb analytics library. */
+export interface AstrochemistryStabilityOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryStabilityResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryStability(data: number[], opts: AstrochemistryStabilityOptions = {}): AstrochemistryStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryStability };
diff --git a/src/astrochemistry/stacking.ts b/src/astrochemistry/stacking.ts
new file mode 100644
index 000000000..a5f78e6a3
--- /dev/null
+++ b/src/astrochemistry/stacking.ts
@@ -0,0 +1,14 @@
+/** astrochemistry stacking module — tsb analytics library. */
+export interface AstrochemistryStackingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryStackingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryStacking(data: number[], opts: AstrochemistryStackingOptions = {}): AstrochemistryStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryStacking };
diff --git a/src/astrochemistry/standardization.ts b/src/astrochemistry/standardization.ts
new file mode 100644
index 000000000..e84b280dc
--- /dev/null
+++ b/src/astrochemistry/standardization.ts
@@ -0,0 +1,14 @@
+/** astrochemistry standardization module — tsb analytics library. */
+export interface AstrochemistryStandardizationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryStandardizationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryStandardization(data: number[], opts: AstrochemistryStandardizationOptions = {}): AstrochemistryStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryStandardization };
diff --git a/src/astrochemistry/static.ts b/src/astrochemistry/static.ts
new file mode 100644
index 000000000..d59a6b520
--- /dev/null
+++ b/src/astrochemistry/static.ts
@@ -0,0 +1,14 @@
+/** astrochemistry static module — tsb analytics library. */
+export interface AstrochemistryStaticOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryStaticResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryStatic(data: number[], opts: AstrochemistryStaticOptions = {}): AstrochemistryStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryStatic };
diff --git a/src/astrochemistry/stochastic.ts b/src/astrochemistry/stochastic.ts
new file mode 100644
index 000000000..f9054bbfa
--- /dev/null
+++ b/src/astrochemistry/stochastic.ts
@@ -0,0 +1,14 @@
+/** astrochemistry stochastic module — tsb analytics library. */
+export interface AstrochemistryStochasticOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryStochasticResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryStochastic(data: number[], opts: AstrochemistryStochasticOptions = {}): AstrochemistryStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryStochastic };
diff --git a/src/astrochemistry/synthesis.ts b/src/astrochemistry/synthesis.ts
new file mode 100644
index 000000000..dc81c64a8
--- /dev/null
+++ b/src/astrochemistry/synthesis.ts
@@ -0,0 +1,14 @@
+/** astrochemistry synthesis module — tsb analytics library. */
+export interface AstrochemistrySynthesisOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistrySynthesisResult { values: number[]; converged: boolean; }
+export function computeAstrochemistrySynthesis(data: number[], opts: AstrochemistrySynthesisOptions = {}): AstrochemistrySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistrySynthesis };
diff --git a/src/astrochemistry/topology.ts b/src/astrochemistry/topology.ts
new file mode 100644
index 000000000..dc0951534
--- /dev/null
+++ b/src/astrochemistry/topology.ts
@@ -0,0 +1,14 @@
+/** astrochemistry topology module — tsb analytics library. */
+export interface AstrochemistryTopologyOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryTopologyResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryTopology(data: number[], opts: AstrochemistryTopologyOptions = {}): AstrochemistryTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryTopology };
diff --git a/src/astrochemistry/tracking.ts b/src/astrochemistry/tracking.ts
new file mode 100644
index 000000000..4187e6643
--- /dev/null
+++ b/src/astrochemistry/tracking.ts
@@ -0,0 +1,14 @@
+/** astrochemistry tracking module — tsb analytics library. */
+export interface AstrochemistryTrackingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryTrackingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryTracking(data: number[], opts: AstrochemistryTrackingOptions = {}): AstrochemistryTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryTracking };
diff --git a/src/astrochemistry/transform.ts b/src/astrochemistry/transform.ts
new file mode 100644
index 000000000..6ba241e67
--- /dev/null
+++ b/src/astrochemistry/transform.ts
@@ -0,0 +1,14 @@
+/** astrochemistry transform module — tsb analytics library. */
+export interface AstrochemistryTransformOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryTransformResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryTransform(data: number[], opts: AstrochemistryTransformOptions = {}): AstrochemistryTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryTransform };
diff --git a/src/astrochemistry/uncertainty.ts b/src/astrochemistry/uncertainty.ts
new file mode 100644
index 000000000..4e5dc0f17
--- /dev/null
+++ b/src/astrochemistry/uncertainty.ts
@@ -0,0 +1,14 @@
+/** astrochemistry uncertainty module — tsb analytics library. */
+export interface AstrochemistryUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryUncertaintyResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryUncertainty(data: number[], opts: AstrochemistryUncertaintyOptions = {}): AstrochemistryUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryUncertainty };
diff --git a/src/astrochemistry/validation.ts b/src/astrochemistry/validation.ts
new file mode 100644
index 000000000..fadc4f3cb
--- /dev/null
+++ b/src/astrochemistry/validation.ts
@@ -0,0 +1,14 @@
+/** astrochemistry validation module — tsb analytics library. */
+export interface AstrochemistryValidationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryValidationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryValidation(data: number[], opts: AstrochemistryValidationOptions = {}): AstrochemistryValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryValidation };
diff --git a/src/astrochemistry/verification.ts b/src/astrochemistry/verification.ts
new file mode 100644
index 000000000..1a743af9e
--- /dev/null
+++ b/src/astrochemistry/verification.ts
@@ -0,0 +1,14 @@
+/** astrochemistry verification module — tsb analytics library. */
+export interface AstrochemistryVerificationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryVerificationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryVerification(data: number[], opts: AstrochemistryVerificationOptions = {}): AstrochemistryVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryVerification };
diff --git a/src/astrochemistry/visualization.ts b/src/astrochemistry/visualization.ts
new file mode 100644
index 000000000..328cd84e9
--- /dev/null
+++ b/src/astrochemistry/visualization.ts
@@ -0,0 +1,14 @@
+/** astrochemistry visualization module — tsb analytics library. */
+export interface AstrochemistryVisualizationOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryVisualizationResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryVisualization(data: number[], opts: AstrochemistryVisualizationOptions = {}): AstrochemistryVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryVisualization };
diff --git a/src/astrochemistry/voting.ts b/src/astrochemistry/voting.ts
new file mode 100644
index 000000000..811ef5721
--- /dev/null
+++ b/src/astrochemistry/voting.ts
@@ -0,0 +1,14 @@
+/** astrochemistry voting module — tsb analytics library. */
+export interface AstrochemistryVotingOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryVotingResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryVoting(data: number[], opts: AstrochemistryVotingOptions = {}): AstrochemistryVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryVoting };
diff --git a/src/astrochemistry/wavelet.ts b/src/astrochemistry/wavelet.ts
new file mode 100644
index 000000000..dadc53f27
--- /dev/null
+++ b/src/astrochemistry/wavelet.ts
@@ -0,0 +1,14 @@
+/** astrochemistry wavelet module — tsb analytics library. */
+export interface AstrochemistryWaveletOptions { tol?: number; maxIter?: number; }
+export interface AstrochemistryWaveletResult { values: number[]; converged: boolean; }
+export function computeAstrochemistryWavelet(data: number[], opts: AstrochemistryWaveletOptions = {}): AstrochemistryWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstrochemistryWavelet };
diff --git a/src/astronomy/advanced.ts b/src/astronomy/advanced.ts
new file mode 100644
index 000000000..81574373d
--- /dev/null
+++ b/src/astronomy/advanced.ts
@@ -0,0 +1,15 @@
+/** Astronomy Advanced module — tsb analytics library. */
+export interface Astronomy advancedOptions { tol?: number; maxIter?: number; }
+export interface Astronomy advancedResult { values: number[]; converged: boolean; }
+export function computeAstronomy advanced(data: number[], opts: Astronomy advancedOptions = {}): Astronomy advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy advanced };
diff --git a/src/astronomy/astrometry.ts b/src/astronomy/astrometry.ts
new file mode 100644
index 000000000..217fa973e
--- /dev/null
+++ b/src/astronomy/astrometry.ts
@@ -0,0 +1,22 @@
+/** Astrometry module — tsb analytics library. */
+
+/** Options for Astrometry. */
+export interface AstrometryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Astrometry. */
+export interface AstrometryResult { values: number[]; converged: boolean; }
+
+/** Compute Astrometry. */
+export function computeAstrometry(data: number[], opts: AstrometryOptions = {}): AstrometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAstrometry };
diff --git a/src/astronomy/base2.ts b/src/astronomy/base2.ts
new file mode 100644
index 000000000..7bd2b6af0
--- /dev/null
+++ b/src/astronomy/base2.ts
@@ -0,0 +1,15 @@
+/** Astronomy Base2 module — tsb analytics library. */
+export interface Astronomy base2Options { tol?: number; maxIter?: number; }
+export interface Astronomy base2Result { values: number[]; converged: boolean; }
+export function computeAstronomy base2(data: number[], opts: Astronomy base2Options = {}): Astronomy base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy base2 };
diff --git a/src/astronomy/batch.ts b/src/astronomy/batch.ts
new file mode 100644
index 000000000..42c23a79f
--- /dev/null
+++ b/src/astronomy/batch.ts
@@ -0,0 +1,15 @@
+/** Astronomy Batch module — tsb analytics library. */
+export interface Astronomy batchOptions { tol?: number; maxIter?: number; }
+export interface Astronomy batchResult { values: number[]; converged: boolean; }
+export function computeAstronomy batch(data: number[], opts: Astronomy batchOptions = {}): Astronomy batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy batch };
diff --git a/src/astronomy/beta.ts b/src/astronomy/beta.ts
new file mode 100644
index 000000000..993b9d611
--- /dev/null
+++ b/src/astronomy/beta.ts
@@ -0,0 +1,15 @@
+/** Astronomy Beta module — tsb analytics library. */
+export interface Astronomy betaOptions { tol?: number; maxIter?: number; }
+export interface Astronomy betaResult { values: number[]; converged: boolean; }
+export function computeAstronomy beta(data: number[], opts: Astronomy betaOptions = {}): Astronomy betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy beta };
diff --git a/src/astronomy/binary.ts b/src/astronomy/binary.ts
new file mode 100644
index 000000000..81b53b0f8
--- /dev/null
+++ b/src/astronomy/binary.ts
@@ -0,0 +1,22 @@
+/** Binary module — tsb analytics library. */
+
+/** Options for Binary. */
+export interface BinaryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Binary. */
+export interface BinaryResult { values: number[]; converged: boolean; }
+
+/** Compute Binary. */
+export function computeBinary(data: number[], opts: BinaryOptions = {}): BinaryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBinary };
diff --git a/src/astronomy/blackhole.ts b/src/astronomy/blackhole.ts
new file mode 100644
index 000000000..a4c6aaf4d
--- /dev/null
+++ b/src/astronomy/blackhole.ts
@@ -0,0 +1,22 @@
+/** Blackhole module — tsb analytics library. */
+
+/** Options for Blackhole. */
+export interface BlackholeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Blackhole. */
+export interface BlackholeResult { values: number[]; converged: boolean; }
+
+/** Compute Blackhole. */
+export function computeBlackhole(data: number[], opts: BlackholeOptions = {}): BlackholeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBlackhole };
diff --git a/src/astronomy/catalog.ts b/src/astronomy/catalog.ts
new file mode 100644
index 000000000..659fe9ddd
--- /dev/null
+++ b/src/astronomy/catalog.ts
@@ -0,0 +1,22 @@
+/** Catalog module — tsb analytics library. */
+
+/** Options for Catalog. */
+export interface CatalogOptions { tol?: number; maxIter?: number; }
+
+/** Result from Catalog. */
+export interface CatalogResult { values: number[]; converged: boolean; }
+
+/** Compute Catalog. */
+export function computeCatalog(data: number[], opts: CatalogOptions = {}): CatalogResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCatalog };
diff --git a/src/astronomy/cluster.ts b/src/astronomy/cluster.ts
new file mode 100644
index 000000000..5d0a923bf
--- /dev/null
+++ b/src/astronomy/cluster.ts
@@ -0,0 +1,22 @@
+/** Cluster module — tsb analytics library. */
+
+/** Options for Cluster. */
+export interface ClusterOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cluster. */
+export interface ClusterResult { values: number[]; converged: boolean; }
+
+/** Compute Cluster. */
+export function computeCluster(data: number[], opts: ClusterOptions = {}): ClusterResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCluster };
diff --git a/src/astronomy/cmb.ts b/src/astronomy/cmb.ts
new file mode 100644
index 000000000..b7a1530ef
--- /dev/null
+++ b/src/astronomy/cmb.ts
@@ -0,0 +1,22 @@
+/** Cmb module — tsb analytics library. */
+
+/** Options for Cmb. */
+export interface CmbOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cmb. */
+export interface CmbResult { values: number[]; converged: boolean; }
+
+/** Compute Cmb. */
+export function computeCmb(data: number[], opts: CmbOptions = {}): CmbResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCmb };
diff --git a/src/astronomy/cosmological.ts b/src/astronomy/cosmological.ts
new file mode 100644
index 000000000..d8b6f25f0
--- /dev/null
+++ b/src/astronomy/cosmological.ts
@@ -0,0 +1,22 @@
+/** Cosmological module — tsb analytics library. */
+
+/** Options for Cosmological. */
+export interface CosmologicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cosmological. */
+export interface CosmologicalResult { values: number[]; converged: boolean; }
+
+/** Compute Cosmological. */
+export function computeCosmological(data: number[], opts: CosmologicalOptions = {}): CosmologicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCosmological };
diff --git a/src/astronomy/cpu.ts b/src/astronomy/cpu.ts
new file mode 100644
index 000000000..5a1d53a7a
--- /dev/null
+++ b/src/astronomy/cpu.ts
@@ -0,0 +1,15 @@
+/** Astronomy Cpu module — tsb analytics library. */
+export interface Astronomy cpuOptions { tol?: number; maxIter?: number; }
+export interface Astronomy cpuResult { values: number[]; converged: boolean; }
+export function computeAstronomy cpu(data: number[], opts: Astronomy cpuOptions = {}): Astronomy cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy cpu };
diff --git a/src/astronomy/crossmatch.ts b/src/astronomy/crossmatch.ts
new file mode 100644
index 000000000..094b5c006
--- /dev/null
+++ b/src/astronomy/crossmatch.ts
@@ -0,0 +1,22 @@
+/** Crossmatch module — tsb analytics library. */
+
+/** Options for Crossmatch. */
+export interface CrossmatchOptions { tol?: number; maxIter?: number; }
+
+/** Result from Crossmatch. */
+export interface CrossmatchResult { values: number[]; converged: boolean; }
+
+/** Compute Crossmatch. */
+export function computeCrossmatch(data: number[], opts: CrossmatchOptions = {}): CrossmatchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCrossmatch };
diff --git a/src/astronomy/dark_energy.ts b/src/astronomy/dark_energy.ts
new file mode 100644
index 000000000..b793018bc
--- /dev/null
+++ b/src/astronomy/dark_energy.ts
@@ -0,0 +1,22 @@
+/** Dark Energy module — tsb analytics library. */
+
+/** Options for Dark Energy. */
+export interface DarkEnergyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dark Energy. */
+export interface DarkEnergyResult { values: number[]; converged: boolean; }
+
+/** Compute Dark Energy. */
+export function computeDarkEnergy(data: number[], opts: DarkEnergyOptions = {}): DarkEnergyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDarkEnergy };
diff --git a/src/astronomy/dark_matter.ts b/src/astronomy/dark_matter.ts
new file mode 100644
index 000000000..315b1151f
--- /dev/null
+++ b/src/astronomy/dark_matter.ts
@@ -0,0 +1,22 @@
+/** Dark Matter module — tsb analytics library. */
+
+/** Options for Dark Matter. */
+export interface DarkMatterOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dark Matter. */
+export interface DarkMatterResult { values: number[]; converged: boolean; }
+
+/** Compute Dark Matter. */
+export function computeDarkMatter(data: number[], opts: DarkMatterOptions = {}): DarkMatterResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDarkMatter };
diff --git a/src/astronomy/deblending.ts b/src/astronomy/deblending.ts
new file mode 100644
index 000000000..7b7d41a00
--- /dev/null
+++ b/src/astronomy/deblending.ts
@@ -0,0 +1,22 @@
+/** Deblending module — tsb analytics library. */
+
+/** Options for Deblending. */
+export interface DeblendingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Deblending. */
+export interface DeblendingResult { values: number[]; converged: boolean; }
+
+/** Compute Deblending. */
+export function computeDeblending(data: number[], opts: DeblendingOptions = {}): DeblendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDeblending };
diff --git a/src/astronomy/dense.ts b/src/astronomy/dense.ts
new file mode 100644
index 000000000..6224bec03
--- /dev/null
+++ b/src/astronomy/dense.ts
@@ -0,0 +1,15 @@
+/** Astronomy Dense module — tsb analytics library. */
+export interface Astronomy denseOptions { tol?: number; maxIter?: number; }
+export interface Astronomy denseResult { values: number[]; converged: boolean; }
+export function computeAstronomy dense(data: number[], opts: Astronomy denseOptions = {}): Astronomy denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy dense };
diff --git a/src/astronomy/distributed.ts b/src/astronomy/distributed.ts
new file mode 100644
index 000000000..f0ed856a2
--- /dev/null
+++ b/src/astronomy/distributed.ts
@@ -0,0 +1,15 @@
+/** Astronomy Distributed module — tsb analytics library. */
+export interface Astronomy distributedOptions { tol?: number; maxIter?: number; }
+export interface Astronomy distributedResult { values: number[]; converged: boolean; }
+export function computeAstronomy distributed(data: number[], opts: Astronomy distributedOptions = {}): Astronomy distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy distributed };
diff --git a/src/astronomy/exoplanet.ts b/src/astronomy/exoplanet.ts
new file mode 100644
index 000000000..0e25c8cd1
--- /dev/null
+++ b/src/astronomy/exoplanet.ts
@@ -0,0 +1,22 @@
+/** Exoplanet module — tsb analytics library. */
+
+/** Options for Exoplanet. */
+export interface ExoplanetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Exoplanet. */
+export interface ExoplanetResult { values: number[]; converged: boolean; }
+
+/** Compute Exoplanet. */
+export function computeExoplanet(data: number[], opts: ExoplanetOptions = {}): ExoplanetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExoplanet };
diff --git a/src/astronomy/experimental.ts b/src/astronomy/experimental.ts
new file mode 100644
index 000000000..ad4b8d9f0
--- /dev/null
+++ b/src/astronomy/experimental.ts
@@ -0,0 +1,15 @@
+/** Astronomy Experimental module — tsb analytics library. */
+export interface Astronomy experimentalOptions { tol?: number; maxIter?: number; }
+export interface Astronomy experimentalResult { values: number[]; converged: boolean; }
+export function computeAstronomy experimental(data: number[], opts: Astronomy experimentalOptions = {}): Astronomy experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy experimental };
diff --git a/src/astronomy/fast.ts b/src/astronomy/fast.ts
new file mode 100644
index 000000000..f2e21ea61
--- /dev/null
+++ b/src/astronomy/fast.ts
@@ -0,0 +1,15 @@
+/** Astronomy Fast module — tsb analytics library. */
+export interface Astronomy fastOptions { tol?: number; maxIter?: number; }
+export interface Astronomy fastResult { values: number[]; converged: boolean; }
+export function computeAstronomy fast(data: number[], opts: Astronomy fastOptions = {}): Astronomy fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy fast };
diff --git a/src/astronomy/future.ts b/src/astronomy/future.ts
new file mode 100644
index 000000000..1ca1d2427
--- /dev/null
+++ b/src/astronomy/future.ts
@@ -0,0 +1,15 @@
+/** Astronomy Future module — tsb analytics library. */
+export interface Astronomy futureOptions { tol?: number; maxIter?: number; }
+export interface Astronomy futureResult { values: number[]; converged: boolean; }
+export function computeAstronomy future(data: number[], opts: Astronomy futureOptions = {}): Astronomy futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy future };
diff --git a/src/astronomy/galactic.ts b/src/astronomy/galactic.ts
new file mode 100644
index 000000000..76c944454
--- /dev/null
+++ b/src/astronomy/galactic.ts
@@ -0,0 +1,22 @@
+/** Galactic module — tsb analytics library. */
+
+/** Options for Galactic. */
+export interface GalacticOptions { tol?: number; maxIter?: number; }
+
+/** Result from Galactic. */
+export interface GalacticResult { values: number[]; converged: boolean; }
+
+/** Compute Galactic. */
+export function computeGalactic(data: number[], opts: GalacticOptions = {}): GalacticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGalactic };
diff --git a/src/astronomy/gpu.ts b/src/astronomy/gpu.ts
new file mode 100644
index 000000000..2982bfbe1
--- /dev/null
+++ b/src/astronomy/gpu.ts
@@ -0,0 +1,15 @@
+/** Astronomy Gpu module — tsb analytics library. */
+export interface Astronomy gpuOptions { tol?: number; maxIter?: number; }
+export interface Astronomy gpuResult { values: number[]; converged: boolean; }
+export function computeAstronomy gpu(data: number[], opts: Astronomy gpuOptions = {}): Astronomy gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy gpu };
diff --git a/src/astronomy/gravitational_wave.ts b/src/astronomy/gravitational_wave.ts
new file mode 100644
index 000000000..291267326
--- /dev/null
+++ b/src/astronomy/gravitational_wave.ts
@@ -0,0 +1,22 @@
+/** Gravitational Wave module — tsb analytics library. */
+
+/** Options for Gravitational Wave. */
+export interface GravitationalWaveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gravitational Wave. */
+export interface GravitationalWaveResult { values: number[]; converged: boolean; }
+
+/** Compute Gravitational Wave. */
+export function computeGravitationalWave(data: number[], opts: GravitationalWaveOptions = {}): GravitationalWaveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGravitationalWave };
diff --git a/src/astronomy/image_processing.ts b/src/astronomy/image_processing.ts
new file mode 100644
index 000000000..685eca7f4
--- /dev/null
+++ b/src/astronomy/image_processing.ts
@@ -0,0 +1,22 @@
+/** Image Processing module — tsb analytics library. */
+
+/** Options for Image Processing. */
+export interface ImageProcessingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Image Processing. */
+export interface ImageProcessingResult { values: number[]; converged: boolean; }
+
+/** Compute Image Processing. */
+export function computeImageProcessing(data: number[], opts: ImageProcessingOptions = {}): ImageProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeImageProcessing };
diff --git a/src/astronomy/interferometry.ts b/src/astronomy/interferometry.ts
new file mode 100644
index 000000000..34353467d
--- /dev/null
+++ b/src/astronomy/interferometry.ts
@@ -0,0 +1,22 @@
+/** Interferometry module — tsb analytics library. */
+
+/** Options for Interferometry. */
+export interface InterferometryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Interferometry. */
+export interface InterferometryResult { values: number[]; converged: boolean; }
+
+/** Compute Interferometry. */
+export function computeInterferometry(data: number[], opts: InterferometryOptions = {}): InterferometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInterferometry };
diff --git a/src/astronomy/large.ts b/src/astronomy/large.ts
new file mode 100644
index 000000000..ab36b0cd6
--- /dev/null
+++ b/src/astronomy/large.ts
@@ -0,0 +1,15 @@
+/** Astronomy Large module — tsb analytics library. */
+export interface Astronomy largeOptions { tol?: number; maxIter?: number; }
+export interface Astronomy largeResult { values: number[]; converged: boolean; }
+export function computeAstronomy large(data: number[], opts: Astronomy largeOptions = {}): Astronomy largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy large };
diff --git a/src/astronomy/legacy.ts b/src/astronomy/legacy.ts
new file mode 100644
index 000000000..6e062c75f
--- /dev/null
+++ b/src/astronomy/legacy.ts
@@ -0,0 +1,15 @@
+/** Astronomy Legacy module — tsb analytics library. */
+export interface Astronomy legacyOptions { tol?: number; maxIter?: number; }
+export interface Astronomy legacyResult { values: number[]; converged: boolean; }
+export function computeAstronomy legacy(data: number[], opts: Astronomy legacyOptions = {}): Astronomy legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy legacy };
diff --git a/src/astronomy/lite.ts b/src/astronomy/lite.ts
new file mode 100644
index 000000000..b53a31d1f
--- /dev/null
+++ b/src/astronomy/lite.ts
@@ -0,0 +1,15 @@
+/** Astronomy Lite module — tsb analytics library. */
+export interface Astronomy liteOptions { tol?: number; maxIter?: number; }
+export interface Astronomy liteResult { values: number[]; converged: boolean; }
+export function computeAstronomy lite(data: number[], opts: Astronomy liteOptions = {}): Astronomy liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy lite };
diff --git a/src/astronomy/mini.ts b/src/astronomy/mini.ts
new file mode 100644
index 000000000..8eb46b778
--- /dev/null
+++ b/src/astronomy/mini.ts
@@ -0,0 +1,15 @@
+/** Astronomy Mini module — tsb analytics library. */
+export interface Astronomy miniOptions { tol?: number; maxIter?: number; }
+export interface Astronomy miniResult { values: number[]; converged: boolean; }
+export function computeAstronomy mini(data: number[], opts: Astronomy miniOptions = {}): Astronomy miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy mini };
diff --git a/src/astronomy/nebula.ts b/src/astronomy/nebula.ts
new file mode 100644
index 000000000..5818b5a4c
--- /dev/null
+++ b/src/astronomy/nebula.ts
@@ -0,0 +1,22 @@
+/** Nebula module — tsb analytics library. */
+
+/** Options for Nebula. */
+export interface NebulaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nebula. */
+export interface NebulaResult { values: number[]; converged: boolean; }
+
+/** Compute Nebula. */
+export function computeNebula(data: number[], opts: NebulaOptions = {}): NebulaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNebula };
diff --git a/src/astronomy/neutron_star.ts b/src/astronomy/neutron_star.ts
new file mode 100644
index 000000000..88b21a862
--- /dev/null
+++ b/src/astronomy/neutron_star.ts
@@ -0,0 +1,22 @@
+/** Neutron Star module — tsb analytics library. */
+
+/** Options for Neutron Star. */
+export interface NeutronStarOptions { tol?: number; maxIter?: number; }
+
+/** Result from Neutron Star. */
+export interface NeutronStarResult { values: number[]; converged: boolean; }
+
+/** Compute Neutron Star. */
+export function computeNeutronStar(data: number[], opts: NeutronStarOptions = {}): NeutronStarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNeutronStar };
diff --git a/src/astronomy/next.ts b/src/astronomy/next.ts
new file mode 100644
index 000000000..e0ae58998
--- /dev/null
+++ b/src/astronomy/next.ts
@@ -0,0 +1,15 @@
+/** Astronomy Next module — tsb analytics library. */
+export interface Astronomy nextOptions { tol?: number; maxIter?: number; }
+export interface Astronomy nextResult { values: number[]; converged: boolean; }
+export function computeAstronomy next(data: number[], opts: Astronomy nextOptions = {}): Astronomy nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy next };
diff --git a/src/astronomy/online.ts b/src/astronomy/online.ts
new file mode 100644
index 000000000..affd3f596
--- /dev/null
+++ b/src/astronomy/online.ts
@@ -0,0 +1,15 @@
+/** Astronomy Online module — tsb analytics library. */
+export interface Astronomy onlineOptions { tol?: number; maxIter?: number; }
+export interface Astronomy onlineResult { values: number[]; converged: boolean; }
+export function computeAstronomy online(data: number[], opts: Astronomy onlineOptions = {}): Astronomy onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy online };
diff --git a/src/astronomy/parallel.ts b/src/astronomy/parallel.ts
new file mode 100644
index 000000000..063c31997
--- /dev/null
+++ b/src/astronomy/parallel.ts
@@ -0,0 +1,15 @@
+/** Astronomy Parallel module — tsb analytics library. */
+export interface Astronomy parallelOptions { tol?: number; maxIter?: number; }
+export interface Astronomy parallelResult { values: number[]; converged: boolean; }
+export function computeAstronomy parallel(data: number[], opts: Astronomy parallelOptions = {}): Astronomy parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy parallel };
diff --git a/src/astronomy/photometric_redshift.ts b/src/astronomy/photometric_redshift.ts
new file mode 100644
index 000000000..26f5244fc
--- /dev/null
+++ b/src/astronomy/photometric_redshift.ts
@@ -0,0 +1,22 @@
+/** Photometric Redshift module — tsb analytics library. */
+
+/** Options for Photometric Redshift. */
+export interface PhotometricRedshiftOptions { tol?: number; maxIter?: number; }
+
+/** Result from Photometric Redshift. */
+export interface PhotometricRedshiftResult { values: number[]; converged: boolean; }
+
+/** Compute Photometric Redshift. */
+export function computePhotometricRedshift(data: number[], opts: PhotometricRedshiftOptions = {}): PhotometricRedshiftResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhotometricRedshift };
diff --git a/src/astronomy/photometry.ts b/src/astronomy/photometry.ts
new file mode 100644
index 000000000..d541a94cd
--- /dev/null
+++ b/src/astronomy/photometry.ts
@@ -0,0 +1,22 @@
+/** Photometry module — tsb analytics library. */
+
+/** Options for Photometry. */
+export interface PhotometryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Photometry. */
+export interface PhotometryResult { values: number[]; converged: boolean; }
+
+/** Compute Photometry. */
+export function computePhotometry(data: number[], opts: PhotometryOptions = {}): PhotometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhotometry };
diff --git a/src/astronomy/planetary.ts b/src/astronomy/planetary.ts
new file mode 100644
index 000000000..15938f362
--- /dev/null
+++ b/src/astronomy/planetary.ts
@@ -0,0 +1,22 @@
+/** Planetary module — tsb analytics library. */
+
+/** Options for Planetary. */
+export interface PlanetaryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Planetary. */
+export interface PlanetaryResult { values: number[]; converged: boolean; }
+
+/** Compute Planetary. */
+export function computePlanetary(data: number[], opts: PlanetaryOptions = {}): PlanetaryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePlanetary };
diff --git a/src/astronomy/plus.ts b/src/astronomy/plus.ts
new file mode 100644
index 000000000..0053e78ea
--- /dev/null
+++ b/src/astronomy/plus.ts
@@ -0,0 +1,15 @@
+/** Astronomy Plus module — tsb analytics library. */
+export interface Astronomy plusOptions { tol?: number; maxIter?: number; }
+export interface Astronomy plusResult { values: number[]; converged: boolean; }
+export function computeAstronomy plus(data: number[], opts: Astronomy plusOptions = {}): Astronomy plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy plus };
diff --git a/src/astronomy/pro.ts b/src/astronomy/pro.ts
new file mode 100644
index 000000000..76573d8f2
--- /dev/null
+++ b/src/astronomy/pro.ts
@@ -0,0 +1,15 @@
+/** Astronomy Pro module — tsb analytics library. */
+export interface Astronomy proOptions { tol?: number; maxIter?: number; }
+export interface Astronomy proResult { values: number[]; converged: boolean; }
+export function computeAstronomy pro(data: number[], opts: Astronomy proOptions = {}): Astronomy proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy pro };
diff --git a/src/astronomy/robust.ts b/src/astronomy/robust.ts
new file mode 100644
index 000000000..8fa2d166b
--- /dev/null
+++ b/src/astronomy/robust.ts
@@ -0,0 +1,15 @@
+/** Astronomy Robust module — tsb analytics library. */
+export interface Astronomy robustOptions { tol?: number; maxIter?: number; }
+export interface Astronomy robustResult { values: number[]; converged: boolean; }
+export function computeAstronomy robust(data: number[], opts: Astronomy robustOptions = {}): Astronomy robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy robust };
diff --git a/src/astronomy/small.ts b/src/astronomy/small.ts
new file mode 100644
index 000000000..44c42613b
--- /dev/null
+++ b/src/astronomy/small.ts
@@ -0,0 +1,15 @@
+/** Astronomy Small module — tsb analytics library. */
+export interface Astronomy smallOptions { tol?: number; maxIter?: number; }
+export interface Astronomy smallResult { values: number[]; converged: boolean; }
+export function computeAstronomy small(data: number[], opts: Astronomy smallOptions = {}): Astronomy smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy small };
diff --git a/src/astronomy/solar.ts b/src/astronomy/solar.ts
new file mode 100644
index 000000000..59e46f03d
--- /dev/null
+++ b/src/astronomy/solar.ts
@@ -0,0 +1,22 @@
+/** Solar module — tsb analytics library. */
+
+/** Options for Solar. */
+export interface SolarOptions { tol?: number; maxIter?: number; }
+
+/** Result from Solar. */
+export interface SolarResult { values: number[]; converged: boolean; }
+
+/** Compute Solar. */
+export function computeSolar(data: number[], opts: SolarOptions = {}): SolarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSolar };
diff --git a/src/astronomy/source_extraction.ts b/src/astronomy/source_extraction.ts
new file mode 100644
index 000000000..e6db68f26
--- /dev/null
+++ b/src/astronomy/source_extraction.ts
@@ -0,0 +1,22 @@
+/** Source Extraction module — tsb analytics library. */
+
+/** Options for Source Extraction. */
+export interface SourceExtractionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Source Extraction. */
+export interface SourceExtractionResult { values: number[]; converged: boolean; }
+
+/** Compute Source Extraction. */
+export function computeSourceExtraction(data: number[], opts: SourceExtractionOptions = {}): SourceExtractionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSourceExtraction };
diff --git a/src/astronomy/sparse.ts b/src/astronomy/sparse.ts
new file mode 100644
index 000000000..842386e2f
--- /dev/null
+++ b/src/astronomy/sparse.ts
@@ -0,0 +1,15 @@
+/** Astronomy Sparse module — tsb analytics library. */
+export interface Astronomy sparseOptions { tol?: number; maxIter?: number; }
+export interface Astronomy sparseResult { values: number[]; converged: boolean; }
+export function computeAstronomy sparse(data: number[], opts: Astronomy sparseOptions = {}): Astronomy sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy sparse };
diff --git a/src/astronomy/spectroscopy.ts b/src/astronomy/spectroscopy.ts
new file mode 100644
index 000000000..e1af4c92e
--- /dev/null
+++ b/src/astronomy/spectroscopy.ts
@@ -0,0 +1,22 @@
+/** Spectroscopy module — tsb analytics library. */
+
+/** Options for Spectroscopy. */
+export interface SpectroscopyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spectroscopy. */
+export interface SpectroscopyResult { values: number[]; converged: boolean; }
+
+/** Compute Spectroscopy. */
+export function computeSpectroscopy(data: number[], opts: SpectroscopyOptions = {}): SpectroscopyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpectroscopy };
diff --git a/src/astronomy/stable.ts b/src/astronomy/stable.ts
new file mode 100644
index 000000000..111b7c16e
--- /dev/null
+++ b/src/astronomy/stable.ts
@@ -0,0 +1,15 @@
+/** Astronomy Stable module — tsb analytics library. */
+export interface Astronomy stableOptions { tol?: number; maxIter?: number; }
+export interface Astronomy stableResult { values: number[]; converged: boolean; }
+export function computeAstronomy stable(data: number[], opts: Astronomy stableOptions = {}): Astronomy stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy stable };
diff --git a/src/astronomy/stellar.ts b/src/astronomy/stellar.ts
new file mode 100644
index 000000000..82fceb885
--- /dev/null
+++ b/src/astronomy/stellar.ts
@@ -0,0 +1,22 @@
+/** Stellar module — tsb analytics library. */
+
+/** Options for Stellar. */
+export interface StellarOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stellar. */
+export interface StellarResult { values: number[]; converged: boolean; }
+
+/** Compute Stellar. */
+export function computeStellar(data: number[], opts: StellarOptions = {}): StellarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStellar };
diff --git a/src/astronomy/streaming.ts b/src/astronomy/streaming.ts
new file mode 100644
index 000000000..92d8d45de
--- /dev/null
+++ b/src/astronomy/streaming.ts
@@ -0,0 +1,15 @@
+/** Astronomy Streaming module — tsb analytics library. */
+export interface Astronomy streamingOptions { tol?: number; maxIter?: number; }
+export interface Astronomy streamingResult { values: number[]; converged: boolean; }
+export function computeAstronomy streaming(data: number[], opts: Astronomy streamingOptions = {}): Astronomy streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy streaming };
diff --git a/src/astronomy/supernova.ts b/src/astronomy/supernova.ts
new file mode 100644
index 000000000..d1a781d80
--- /dev/null
+++ b/src/astronomy/supernova.ts
@@ -0,0 +1,22 @@
+/** Supernova module — tsb analytics library. */
+
+/** Options for Supernova. */
+export interface SupernovaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Supernova. */
+export interface SupernovaResult { values: number[]; converged: boolean; }
+
+/** Compute Supernova. */
+export function computeSupernova(data: number[], opts: SupernovaOptions = {}): SupernovaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSupernova };
diff --git a/src/astronomy/survey_astro.ts b/src/astronomy/survey_astro.ts
new file mode 100644
index 000000000..58ea6309f
--- /dev/null
+++ b/src/astronomy/survey_astro.ts
@@ -0,0 +1,22 @@
+/** Survey Astro module — tsb analytics library. */
+
+/** Options for Survey Astro. */
+export interface SurveyAstroOptions { tol?: number; maxIter?: number; }
+
+/** Result from Survey Astro. */
+export interface SurveyAstroResult { values: number[]; converged: boolean; }
+
+/** Compute Survey Astro. */
+export function computeSurveyAstro(data: number[], opts: SurveyAstroOptions = {}): SurveyAstroResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSurveyAstro };
diff --git a/src/astronomy/transient.ts b/src/astronomy/transient.ts
new file mode 100644
index 000000000..681948001
--- /dev/null
+++ b/src/astronomy/transient.ts
@@ -0,0 +1,22 @@
+/** Transient module — tsb analytics library. */
+
+/** Options for Transient. */
+export interface TransientOptions { tol?: number; maxIter?: number; }
+
+/** Result from Transient. */
+export interface TransientResult { values: number[]; converged: boolean; }
+
+/** Compute Transient. */
+export function computeTransient(data: number[], opts: TransientOptions = {}): TransientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTransient };
diff --git a/src/astronomy/v2.ts b/src/astronomy/v2.ts
new file mode 100644
index 000000000..7ee9dbfd1
--- /dev/null
+++ b/src/astronomy/v2.ts
@@ -0,0 +1,15 @@
+/** Astronomy V2 module — tsb analytics library. */
+export interface Astronomy v2Options { tol?: number; maxIter?: number; }
+export interface Astronomy v2Result { values: number[]; converged: boolean; }
+export function computeAstronomy v2(data: number[], opts: Astronomy v2Options = {}): Astronomy v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy v2 };
diff --git a/src/astronomy/v3.ts b/src/astronomy/v3.ts
new file mode 100644
index 000000000..9edaf5b9d
--- /dev/null
+++ b/src/astronomy/v3.ts
@@ -0,0 +1,15 @@
+/** Astronomy V3 module — tsb analytics library. */
+export interface Astronomy v3Options { tol?: number; maxIter?: number; }
+export interface Astronomy v3Result { values: number[]; converged: boolean; }
+export function computeAstronomy v3(data: number[], opts: Astronomy v3Options = {}): Astronomy v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy v3 };
diff --git a/src/astronomy/variability.ts b/src/astronomy/variability.ts
new file mode 100644
index 000000000..3a97b30da
--- /dev/null
+++ b/src/astronomy/variability.ts
@@ -0,0 +1,22 @@
+/** Variability module — tsb analytics library. */
+
+/** Options for Variability. */
+export interface VariabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Variability. */
+export interface VariabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Variability. */
+export function computeVariability(data: number[], opts: VariabilityOptions = {}): VariabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVariability };
diff --git a/src/astronomy/wasm.ts b/src/astronomy/wasm.ts
new file mode 100644
index 000000000..977ef323c
--- /dev/null
+++ b/src/astronomy/wasm.ts
@@ -0,0 +1,15 @@
+/** Astronomy Wasm module — tsb analytics library. */
+export interface Astronomy wasmOptions { tol?: number; maxIter?: number; }
+export interface Astronomy wasmResult { values: number[]; converged: boolean; }
+export function computeAstronomy wasm(data: number[], opts: Astronomy wasmOptions = {}): Astronomy wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy wasm };
diff --git a/src/astronomy/white_dwarf.ts b/src/astronomy/white_dwarf.ts
new file mode 100644
index 000000000..150f1247b
--- /dev/null
+++ b/src/astronomy/white_dwarf.ts
@@ -0,0 +1,22 @@
+/** White Dwarf module — tsb analytics library. */
+
+/** Options for White Dwarf. */
+export interface WhiteDwarfOptions { tol?: number; maxIter?: number; }
+
+/** Result from White Dwarf. */
+export interface WhiteDwarfResult { values: number[]; converged: boolean; }
+
+/** Compute White Dwarf. */
+export function computeWhiteDwarf(data: number[], opts: WhiteDwarfOptions = {}): WhiteDwarfResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWhiteDwarf };
diff --git a/src/astronomy/xlarge.ts b/src/astronomy/xlarge.ts
new file mode 100644
index 000000000..2371bf567
--- /dev/null
+++ b/src/astronomy/xlarge.ts
@@ -0,0 +1,15 @@
+/** Astronomy Xlarge module — tsb analytics library. */
+export interface Astronomy xlargeOptions { tol?: number; maxIter?: number; }
+export interface Astronomy xlargeResult { values: number[]; converged: boolean; }
+export function computeAstronomy xlarge(data: number[], opts: Astronomy xlargeOptions = {}): Astronomy xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeAstronomy xlarge };
diff --git a/src/bacteriology/adaptation.ts b/src/bacteriology/adaptation.ts
new file mode 100644
index 000000000..03515b605
--- /dev/null
+++ b/src/bacteriology/adaptation.ts
@@ -0,0 +1,14 @@
+/** bacteriology adaptation module — tsb analytics library. */
+export interface BacteriologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyAdaptation(data: number[], opts: BacteriologyAdaptationOptions = {}): BacteriologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyAdaptation };
diff --git a/src/bacteriology/aggregation.ts b/src/bacteriology/aggregation.ts
new file mode 100644
index 000000000..10ab15209
--- /dev/null
+++ b/src/bacteriology/aggregation.ts
@@ -0,0 +1,14 @@
+/** bacteriology aggregation module — tsb analytics library. */
+export interface BacteriologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyAggregationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyAggregation(data: number[], opts: BacteriologyAggregationOptions = {}): BacteriologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyAggregation };
diff --git a/src/bacteriology/algebra.ts b/src/bacteriology/algebra.ts
new file mode 100644
index 000000000..4d88c0caf
--- /dev/null
+++ b/src/bacteriology/algebra.ts
@@ -0,0 +1,14 @@
+/** bacteriology algebra module — tsb analytics library. */
+export interface BacteriologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeBacteriologyAlgebra(data: number[], opts: BacteriologyAlgebraOptions = {}): BacteriologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyAlgebra };
diff --git a/src/bacteriology/alignment.ts b/src/bacteriology/alignment.ts
new file mode 100644
index 000000000..ec51a543e
--- /dev/null
+++ b/src/bacteriology/alignment.ts
@@ -0,0 +1,14 @@
+/** bacteriology alignment module — tsb analytics library. */
+export interface BacteriologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeBacteriologyAlignment(data: number[], opts: BacteriologyAlignmentOptions = {}): BacteriologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyAlignment };
diff --git a/src/bacteriology/analysis.ts b/src/bacteriology/analysis.ts
new file mode 100644
index 000000000..e7938041a
--- /dev/null
+++ b/src/bacteriology/analysis.ts
@@ -0,0 +1,14 @@
+/** bacteriology analysis module — tsb analytics library. */
+export interface BacteriologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeBacteriologyAnalysis(data: number[], opts: BacteriologyAnalysisOptions = {}): BacteriologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyAnalysis };
diff --git a/src/bacteriology/augmentation.ts b/src/bacteriology/augmentation.ts
new file mode 100644
index 000000000..22f9339df
--- /dev/null
+++ b/src/bacteriology/augmentation.ts
@@ -0,0 +1,14 @@
+/** bacteriology augmentation module — tsb analytics library. */
+export interface BacteriologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyAugmentation(data: number[], opts: BacteriologyAugmentationOptions = {}): BacteriologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyAugmentation };
diff --git a/src/bacteriology/bagging.ts b/src/bacteriology/bagging.ts
new file mode 100644
index 000000000..aedccf369
--- /dev/null
+++ b/src/bacteriology/bagging.ts
@@ -0,0 +1,14 @@
+/** bacteriology bagging module — tsb analytics library. */
+export interface BacteriologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyBaggingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyBagging(data: number[], opts: BacteriologyBaggingOptions = {}): BacteriologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyBagging };
diff --git a/src/bacteriology/basis.ts b/src/bacteriology/basis.ts
new file mode 100644
index 000000000..884abcb07
--- /dev/null
+++ b/src/bacteriology/basis.ts
@@ -0,0 +1,14 @@
+/** bacteriology basis module — tsb analytics library. */
+export interface BacteriologyBasisOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyBasisResult { values: number[]; converged: boolean; }
+export function computeBacteriologyBasis(data: number[], opts: BacteriologyBasisOptions = {}): BacteriologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyBasis };
diff --git a/src/bacteriology/benchmarking.ts b/src/bacteriology/benchmarking.ts
new file mode 100644
index 000000000..3390f42f5
--- /dev/null
+++ b/src/bacteriology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** bacteriology benchmarking module — tsb analytics library. */
+export interface BacteriologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyBenchmarking(data: number[], opts: BacteriologyBenchmarkingOptions = {}): BacteriologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyBenchmarking };
diff --git a/src/bacteriology/blending.ts b/src/bacteriology/blending.ts
new file mode 100644
index 000000000..d16e198cd
--- /dev/null
+++ b/src/bacteriology/blending.ts
@@ -0,0 +1,14 @@
+/** bacteriology blending module — tsb analytics library. */
+export interface BacteriologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyBlendingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyBlending(data: number[], opts: BacteriologyBlendingOptions = {}): BacteriologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyBlending };
diff --git a/src/bacteriology/boosting.ts b/src/bacteriology/boosting.ts
new file mode 100644
index 000000000..c7b8885d8
--- /dev/null
+++ b/src/bacteriology/boosting.ts
@@ -0,0 +1,14 @@
+/** bacteriology boosting module — tsb analytics library. */
+export interface BacteriologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyBoostingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyBoosting(data: number[], opts: BacteriologyBoostingOptions = {}): BacteriologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyBoosting };
diff --git a/src/bacteriology/bootstrap.ts b/src/bacteriology/bootstrap.ts
new file mode 100644
index 000000000..be3d96719
--- /dev/null
+++ b/src/bacteriology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** bacteriology bootstrap module — tsb analytics library. */
+export interface BacteriologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeBacteriologyBootstrap(data: number[], opts: BacteriologyBootstrapOptions = {}): BacteriologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyBootstrap };
diff --git a/src/bacteriology/calculus.ts b/src/bacteriology/calculus.ts
new file mode 100644
index 000000000..c78873a22
--- /dev/null
+++ b/src/bacteriology/calculus.ts
@@ -0,0 +1,14 @@
+/** bacteriology calculus module — tsb analytics library. */
+export interface BacteriologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyCalculusResult { values: number[]; converged: boolean; }
+export function computeBacteriologyCalculus(data: number[], opts: BacteriologyCalculusOptions = {}): BacteriologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyCalculus };
diff --git a/src/bacteriology/calibration.ts b/src/bacteriology/calibration.ts
new file mode 100644
index 000000000..bc9617463
--- /dev/null
+++ b/src/bacteriology/calibration.ts
@@ -0,0 +1,14 @@
+/** bacteriology calibration module — tsb analytics library. */
+export interface BacteriologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyCalibration(data: number[], opts: BacteriologyCalibrationOptions = {}): BacteriologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyCalibration };
diff --git a/src/bacteriology/characterization.ts b/src/bacteriology/characterization.ts
new file mode 100644
index 000000000..11889405d
--- /dev/null
+++ b/src/bacteriology/characterization.ts
@@ -0,0 +1,14 @@
+/** bacteriology characterization module — tsb analytics library. */
+export interface BacteriologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyCharacterization(data: number[], opts: BacteriologyCharacterizationOptions = {}): BacteriologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyCharacterization };
diff --git a/src/bacteriology/classification.ts b/src/bacteriology/classification.ts
new file mode 100644
index 000000000..a465dbebf
--- /dev/null
+++ b/src/bacteriology/classification.ts
@@ -0,0 +1,14 @@
+/** bacteriology classification module — tsb analytics library. */
+export interface BacteriologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyClassificationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyClassification(data: number[], opts: BacteriologyClassificationOptions = {}): BacteriologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyClassification };
diff --git a/src/bacteriology/clustering.ts b/src/bacteriology/clustering.ts
new file mode 100644
index 000000000..75f095a37
--- /dev/null
+++ b/src/bacteriology/clustering.ts
@@ -0,0 +1,14 @@
+/** bacteriology clustering module — tsb analytics library. */
+export interface BacteriologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyClusteringResult { values: number[]; converged: boolean; }
+export function computeBacteriologyClustering(data: number[], opts: BacteriologyClusteringOptions = {}): BacteriologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyClustering };
diff --git a/src/bacteriology/compression.ts b/src/bacteriology/compression.ts
new file mode 100644
index 000000000..40c7e6cf9
--- /dev/null
+++ b/src/bacteriology/compression.ts
@@ -0,0 +1,14 @@
+/** bacteriology compression module — tsb analytics library. */
+export interface BacteriologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyCompressionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyCompression(data: number[], opts: BacteriologyCompressionOptions = {}): BacteriologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyCompression };
diff --git a/src/bacteriology/continuous.ts b/src/bacteriology/continuous.ts
new file mode 100644
index 000000000..24e314e28
--- /dev/null
+++ b/src/bacteriology/continuous.ts
@@ -0,0 +1,14 @@
+/** bacteriology continuous module — tsb analytics library. */
+export interface BacteriologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyContinuousResult { values: number[]; converged: boolean; }
+export function computeBacteriologyContinuous(data: number[], opts: BacteriologyContinuousOptions = {}): BacteriologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyContinuous };
diff --git a/src/bacteriology/control.ts b/src/bacteriology/control.ts
new file mode 100644
index 000000000..22d37137d
--- /dev/null
+++ b/src/bacteriology/control.ts
@@ -0,0 +1,14 @@
+/** bacteriology control module — tsb analytics library. */
+export interface BacteriologyControlOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyControlResult { values: number[]; converged: boolean; }
+export function computeBacteriologyControl(data: number[], opts: BacteriologyControlOptions = {}): BacteriologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyControl };
diff --git a/src/bacteriology/convergence.ts b/src/bacteriology/convergence.ts
new file mode 100644
index 000000000..e29c36cf5
--- /dev/null
+++ b/src/bacteriology/convergence.ts
@@ -0,0 +1,14 @@
+/** bacteriology convergence module — tsb analytics library. */
+export interface BacteriologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeBacteriologyConvergence(data: number[], opts: BacteriologyConvergenceOptions = {}): BacteriologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyConvergence };
diff --git a/src/bacteriology/convex.ts b/src/bacteriology/convex.ts
new file mode 100644
index 000000000..488487d7b
--- /dev/null
+++ b/src/bacteriology/convex.ts
@@ -0,0 +1,14 @@
+/** bacteriology convex module — tsb analytics library. */
+export interface BacteriologyConvexOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyConvexResult { values: number[]; converged: boolean; }
+export function computeBacteriologyConvex(data: number[], opts: BacteriologyConvexOptions = {}): BacteriologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyConvex };
diff --git a/src/bacteriology/correlation.ts b/src/bacteriology/correlation.ts
new file mode 100644
index 000000000..01f57c2d4
--- /dev/null
+++ b/src/bacteriology/correlation.ts
@@ -0,0 +1,14 @@
+/** bacteriology correlation module — tsb analytics library. */
+export interface BacteriologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyCorrelation(data: number[], opts: BacteriologyCorrelationOptions = {}): BacteriologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyCorrelation };
diff --git a/src/bacteriology/covariance.ts b/src/bacteriology/covariance.ts
new file mode 100644
index 000000000..f111057da
--- /dev/null
+++ b/src/bacteriology/covariance.ts
@@ -0,0 +1,14 @@
+/** bacteriology covariance module — tsb analytics library. */
+export interface BacteriologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeBacteriologyCovariance(data: number[], opts: BacteriologyCovarianceOptions = {}): BacteriologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyCovariance };
diff --git a/src/bacteriology/cross_validation.ts b/src/bacteriology/cross_validation.ts
new file mode 100644
index 000000000..5cf594fa2
--- /dev/null
+++ b/src/bacteriology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** bacteriology cross_validation module — tsb analytics library. */
+export interface BacteriologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyCrossValidation(data: number[], opts: BacteriologyCrossValidationOptions = {}): BacteriologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyCrossValidation };
diff --git a/src/bacteriology/decoding.ts b/src/bacteriology/decoding.ts
new file mode 100644
index 000000000..e685a55d4
--- /dev/null
+++ b/src/bacteriology/decoding.ts
@@ -0,0 +1,14 @@
+/** bacteriology decoding module — tsb analytics library. */
+export interface BacteriologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDecodingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDecoding(data: number[], opts: BacteriologyDecodingOptions = {}): BacteriologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDecoding };
diff --git a/src/bacteriology/decomposition.ts b/src/bacteriology/decomposition.ts
new file mode 100644
index 000000000..5e73a3767
--- /dev/null
+++ b/src/bacteriology/decomposition.ts
@@ -0,0 +1,14 @@
+/** bacteriology decomposition module — tsb analytics library. */
+export interface BacteriologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDecomposition(data: number[], opts: BacteriologyDecompositionOptions = {}): BacteriologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDecomposition };
diff --git a/src/bacteriology/detection.ts b/src/bacteriology/detection.ts
new file mode 100644
index 000000000..02289071a
--- /dev/null
+++ b/src/bacteriology/detection.ts
@@ -0,0 +1,14 @@
+/** bacteriology detection module — tsb analytics library. */
+export interface BacteriologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDetectionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDetection(data: number[], opts: BacteriologyDetectionOptions = {}): BacteriologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDetection };
diff --git a/src/bacteriology/deterministic.ts b/src/bacteriology/deterministic.ts
new file mode 100644
index 000000000..6252cee34
--- /dev/null
+++ b/src/bacteriology/deterministic.ts
@@ -0,0 +1,14 @@
+/** bacteriology deterministic module — tsb analytics library. */
+export interface BacteriologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDeterministic(data: number[], opts: BacteriologyDeterministicOptions = {}): BacteriologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDeterministic };
diff --git a/src/bacteriology/diagnostics.ts b/src/bacteriology/diagnostics.ts
new file mode 100644
index 000000000..9bc987155
--- /dev/null
+++ b/src/bacteriology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** bacteriology diagnostics module — tsb analytics library. */
+export interface BacteriologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDiagnostics(data: number[], opts: BacteriologyDiagnosticsOptions = {}): BacteriologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDiagnostics };
diff --git a/src/bacteriology/differential.ts b/src/bacteriology/differential.ts
new file mode 100644
index 000000000..60616e571
--- /dev/null
+++ b/src/bacteriology/differential.ts
@@ -0,0 +1,14 @@
+/** bacteriology differential module — tsb analytics library. */
+export interface BacteriologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDifferential(data: number[], opts: BacteriologyDifferentialOptions = {}): BacteriologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDifferential };
diff --git a/src/bacteriology/discrete.ts b/src/bacteriology/discrete.ts
new file mode 100644
index 000000000..ccba817de
--- /dev/null
+++ b/src/bacteriology/discrete.ts
@@ -0,0 +1,14 @@
+/** bacteriology discrete module — tsb analytics library. */
+export interface BacteriologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDiscrete(data: number[], opts: BacteriologyDiscreteOptions = {}): BacteriologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDiscrete };
diff --git a/src/bacteriology/distribution.ts b/src/bacteriology/distribution.ts
new file mode 100644
index 000000000..82405eeee
--- /dev/null
+++ b/src/bacteriology/distribution.ts
@@ -0,0 +1,14 @@
+/** bacteriology distribution module — tsb analytics library. */
+export interface BacteriologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDistributionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDistribution(data: number[], opts: BacteriologyDistributionOptions = {}): BacteriologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDistribution };
diff --git a/src/bacteriology/dynamic.ts b/src/bacteriology/dynamic.ts
new file mode 100644
index 000000000..dadcb80e6
--- /dev/null
+++ b/src/bacteriology/dynamic.ts
@@ -0,0 +1,14 @@
+/** bacteriology dynamic module — tsb analytics library. */
+export interface BacteriologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyDynamicResult { values: number[]; converged: boolean; }
+export function computeBacteriologyDynamic(data: number[], opts: BacteriologyDynamicOptions = {}): BacteriologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyDynamic };
diff --git a/src/bacteriology/embedding.ts b/src/bacteriology/embedding.ts
new file mode 100644
index 000000000..d3a5a4d7a
--- /dev/null
+++ b/src/bacteriology/embedding.ts
@@ -0,0 +1,14 @@
+/** bacteriology embedding module — tsb analytics library. */
+export interface BacteriologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyEmbedding(data: number[], opts: BacteriologyEmbeddingOptions = {}): BacteriologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyEmbedding };
diff --git a/src/bacteriology/encoding.ts b/src/bacteriology/encoding.ts
new file mode 100644
index 000000000..bb99e11b8
--- /dev/null
+++ b/src/bacteriology/encoding.ts
@@ -0,0 +1,14 @@
+/** bacteriology encoding module — tsb analytics library. */
+export interface BacteriologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyEncodingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyEncoding(data: number[], opts: BacteriologyEncodingOptions = {}): BacteriologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyEncoding };
diff --git a/src/bacteriology/ensemble.ts b/src/bacteriology/ensemble.ts
new file mode 100644
index 000000000..05487f384
--- /dev/null
+++ b/src/bacteriology/ensemble.ts
@@ -0,0 +1,14 @@
+/** bacteriology ensemble module — tsb analytics library. */
+export interface BacteriologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeBacteriologyEnsemble(data: number[], opts: BacteriologyEnsembleOptions = {}): BacteriologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyEnsemble };
diff --git a/src/bacteriology/estimation.ts b/src/bacteriology/estimation.ts
new file mode 100644
index 000000000..234b0d2b4
--- /dev/null
+++ b/src/bacteriology/estimation.ts
@@ -0,0 +1,14 @@
+/** bacteriology estimation module — tsb analytics library. */
+export interface BacteriologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyEstimationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyEstimation(data: number[], opts: BacteriologyEstimationOptions = {}): BacteriologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyEstimation };
diff --git a/src/bacteriology/evaluation.ts b/src/bacteriology/evaluation.ts
new file mode 100644
index 000000000..bb2d5e718
--- /dev/null
+++ b/src/bacteriology/evaluation.ts
@@ -0,0 +1,14 @@
+/** bacteriology evaluation module — tsb analytics library. */
+export interface BacteriologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyEvaluation(data: number[], opts: BacteriologyEvaluationOptions = {}): BacteriologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyEvaluation };
diff --git a/src/bacteriology/extrapolation.ts b/src/bacteriology/extrapolation.ts
new file mode 100644
index 000000000..5a04b19d6
--- /dev/null
+++ b/src/bacteriology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** bacteriology extrapolation module — tsb analytics library. */
+export interface BacteriologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyExtrapolation(data: number[], opts: BacteriologyExtrapolationOptions = {}): BacteriologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyExtrapolation };
diff --git a/src/bacteriology/features.ts b/src/bacteriology/features.ts
new file mode 100644
index 000000000..603a43d48
--- /dev/null
+++ b/src/bacteriology/features.ts
@@ -0,0 +1,14 @@
+/** bacteriology features module — tsb analytics library. */
+export interface BacteriologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeBacteriologyFeatures(data: number[], opts: BacteriologyFeaturesOptions = {}): BacteriologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyFeatures };
diff --git a/src/bacteriology/feedback.ts b/src/bacteriology/feedback.ts
new file mode 100644
index 000000000..c34e34418
--- /dev/null
+++ b/src/bacteriology/feedback.ts
@@ -0,0 +1,14 @@
+/** bacteriology feedback module — tsb analytics library. */
+export interface BacteriologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeBacteriologyFeedback(data: number[], opts: BacteriologyFeedbackOptions = {}): BacteriologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyFeedback };
diff --git a/src/bacteriology/filtering.ts b/src/bacteriology/filtering.ts
new file mode 100644
index 000000000..f93fb21f6
--- /dev/null
+++ b/src/bacteriology/filtering.ts
@@ -0,0 +1,14 @@
+/** bacteriology filtering module — tsb analytics library. */
+export interface BacteriologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyFilteringResult { values: number[]; converged: boolean; }
+export function computeBacteriologyFiltering(data: number[], opts: BacteriologyFilteringOptions = {}): BacteriologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyFiltering };
diff --git a/src/bacteriology/fourier.ts b/src/bacteriology/fourier.ts
new file mode 100644
index 000000000..577d563ca
--- /dev/null
+++ b/src/bacteriology/fourier.ts
@@ -0,0 +1,14 @@
+/** bacteriology fourier module — tsb analytics library. */
+export interface BacteriologyFourierOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyFourierResult { values: number[]; converged: boolean; }
+export function computeBacteriologyFourier(data: number[], opts: BacteriologyFourierOptions = {}): BacteriologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyFourier };
diff --git a/src/bacteriology/fusion.ts b/src/bacteriology/fusion.ts
new file mode 100644
index 000000000..7eb16551d
--- /dev/null
+++ b/src/bacteriology/fusion.ts
@@ -0,0 +1,14 @@
+/** bacteriology fusion module — tsb analytics library. */
+export interface BacteriologyFusionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyFusionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyFusion(data: number[], opts: BacteriologyFusionOptions = {}): BacteriologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyFusion };
diff --git a/src/bacteriology/generation.ts b/src/bacteriology/generation.ts
new file mode 100644
index 000000000..f9db3834c
--- /dev/null
+++ b/src/bacteriology/generation.ts
@@ -0,0 +1,14 @@
+/** bacteriology generation module — tsb analytics library. */
+export interface BacteriologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyGenerationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyGeneration(data: number[], opts: BacteriologyGenerationOptions = {}): BacteriologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyGeneration };
diff --git a/src/bacteriology/geometry.ts b/src/bacteriology/geometry.ts
new file mode 100644
index 000000000..393aa9140
--- /dev/null
+++ b/src/bacteriology/geometry.ts
@@ -0,0 +1,14 @@
+/** bacteriology geometry module — tsb analytics library. */
+export interface BacteriologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyGeometryResult { values: number[]; converged: boolean; }
+export function computeBacteriologyGeometry(data: number[], opts: BacteriologyGeometryOptions = {}): BacteriologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyGeometry };
diff --git a/src/bacteriology/gradient.ts b/src/bacteriology/gradient.ts
new file mode 100644
index 000000000..9a7fef89e
--- /dev/null
+++ b/src/bacteriology/gradient.ts
@@ -0,0 +1,14 @@
+/** bacteriology gradient module — tsb analytics library. */
+export interface BacteriologyGradientOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyGradientResult { values: number[]; converged: boolean; }
+export function computeBacteriologyGradient(data: number[], opts: BacteriologyGradientOptions = {}): BacteriologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyGradient };
diff --git a/src/bacteriology/hessian.ts b/src/bacteriology/hessian.ts
new file mode 100644
index 000000000..76b287cb8
--- /dev/null
+++ b/src/bacteriology/hessian.ts
@@ -0,0 +1,14 @@
+/** bacteriology hessian module — tsb analytics library. */
+export interface BacteriologyHessianOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyHessianResult { values: number[]; converged: boolean; }
+export function computeBacteriologyHessian(data: number[], opts: BacteriologyHessianOptions = {}): BacteriologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyHessian };
diff --git a/src/bacteriology/hypothesis.ts b/src/bacteriology/hypothesis.ts
new file mode 100644
index 000000000..9afcb7f1d
--- /dev/null
+++ b/src/bacteriology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** bacteriology hypothesis module — tsb analytics library. */
+export interface BacteriologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeBacteriologyHypothesis(data: number[], opts: BacteriologyHypothesisOptions = {}): BacteriologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyHypothesis };
diff --git a/src/bacteriology/inference.ts b/src/bacteriology/inference.ts
new file mode 100644
index 000000000..85d874271
--- /dev/null
+++ b/src/bacteriology/inference.ts
@@ -0,0 +1,14 @@
+/** bacteriology inference module — tsb analytics library. */
+export interface BacteriologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyInferenceResult { values: number[]; converged: boolean; }
+export function computeBacteriologyInference(data: number[], opts: BacteriologyInferenceOptions = {}): BacteriologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyInference };
diff --git a/src/bacteriology/inference2.ts b/src/bacteriology/inference2.ts
new file mode 100644
index 000000000..3a285e0a9
--- /dev/null
+++ b/src/bacteriology/inference2.ts
@@ -0,0 +1,14 @@
+/** bacteriology inference2 module — tsb analytics library. */
+export interface BacteriologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyInferenceResult { values: number[]; converged: boolean; }
+export function computeBacteriologyInference(data: number[], opts: BacteriologyInferenceOptions = {}): BacteriologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyInference };
diff --git a/src/bacteriology/integral.ts b/src/bacteriology/integral.ts
new file mode 100644
index 000000000..7f26e7075
--- /dev/null
+++ b/src/bacteriology/integral.ts
@@ -0,0 +1,14 @@
+/** bacteriology integral module — tsb analytics library. */
+export interface BacteriologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyIntegralResult { values: number[]; converged: boolean; }
+export function computeBacteriologyIntegral(data: number[], opts: BacteriologyIntegralOptions = {}): BacteriologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyIntegral };
diff --git a/src/bacteriology/integration.ts b/src/bacteriology/integration.ts
new file mode 100644
index 000000000..267d92324
--- /dev/null
+++ b/src/bacteriology/integration.ts
@@ -0,0 +1,14 @@
+/** bacteriology integration module — tsb analytics library. */
+export interface BacteriologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyIntegration(data: number[], opts: BacteriologyIntegrationOptions = {}): BacteriologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyIntegration };
diff --git a/src/bacteriology/interpolation.ts b/src/bacteriology/interpolation.ts
new file mode 100644
index 000000000..4ecb13884
--- /dev/null
+++ b/src/bacteriology/interpolation.ts
@@ -0,0 +1,14 @@
+/** bacteriology interpolation module — tsb analytics library. */
+export interface BacteriologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyInterpolation(data: number[], opts: BacteriologyInterpolationOptions = {}): BacteriologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyInterpolation };
diff --git a/src/bacteriology/jacobian.ts b/src/bacteriology/jacobian.ts
new file mode 100644
index 000000000..9596332d0
--- /dev/null
+++ b/src/bacteriology/jacobian.ts
@@ -0,0 +1,14 @@
+/** bacteriology jacobian module — tsb analytics library. */
+export interface BacteriologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyJacobianResult { values: number[]; converged: boolean; }
+export function computeBacteriologyJacobian(data: number[], opts: BacteriologyJacobianOptions = {}): BacteriologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyJacobian };
diff --git a/src/bacteriology/kernel.ts b/src/bacteriology/kernel.ts
new file mode 100644
index 000000000..5f31d6885
--- /dev/null
+++ b/src/bacteriology/kernel.ts
@@ -0,0 +1,14 @@
+/** bacteriology kernel module — tsb analytics library. */
+export interface BacteriologyKernelOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyKernelResult { values: number[]; converged: boolean; }
+export function computeBacteriologyKernel(data: number[], opts: BacteriologyKernelOptions = {}): BacteriologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyKernel };
diff --git a/src/bacteriology/laplacian.ts b/src/bacteriology/laplacian.ts
new file mode 100644
index 000000000..83895374e
--- /dev/null
+++ b/src/bacteriology/laplacian.ts
@@ -0,0 +1,14 @@
+/** bacteriology laplacian module — tsb analytics library. */
+export interface BacteriologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeBacteriologyLaplacian(data: number[], opts: BacteriologyLaplacianOptions = {}): BacteriologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyLaplacian };
diff --git a/src/bacteriology/learning.ts b/src/bacteriology/learning.ts
new file mode 100644
index 000000000..b5c1414ad
--- /dev/null
+++ b/src/bacteriology/learning.ts
@@ -0,0 +1,14 @@
+/** bacteriology learning module — tsb analytics library. */
+export interface BacteriologyLearningOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyLearningResult { values: number[]; converged: boolean; }
+export function computeBacteriologyLearning(data: number[], opts: BacteriologyLearningOptions = {}): BacteriologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyLearning };
diff --git a/src/bacteriology/linear.ts b/src/bacteriology/linear.ts
new file mode 100644
index 000000000..3cf57113b
--- /dev/null
+++ b/src/bacteriology/linear.ts
@@ -0,0 +1,14 @@
+/** bacteriology linear module — tsb analytics library. */
+export interface BacteriologyLinearOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyLinearResult { values: number[]; converged: boolean; }
+export function computeBacteriologyLinear(data: number[], opts: BacteriologyLinearOptions = {}): BacteriologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyLinear };
diff --git a/src/bacteriology/manifold.ts b/src/bacteriology/manifold.ts
new file mode 100644
index 000000000..9c1aae8dc
--- /dev/null
+++ b/src/bacteriology/manifold.ts
@@ -0,0 +1,14 @@
+/** bacteriology manifold module — tsb analytics library. */
+export interface BacteriologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyManifoldResult { values: number[]; converged: boolean; }
+export function computeBacteriologyManifold(data: number[], opts: BacteriologyManifoldOptions = {}): BacteriologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyManifold };
diff --git a/src/bacteriology/matching.ts b/src/bacteriology/matching.ts
new file mode 100644
index 000000000..f30710643
--- /dev/null
+++ b/src/bacteriology/matching.ts
@@ -0,0 +1,14 @@
+/** bacteriology matching module — tsb analytics library. */
+export interface BacteriologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyMatchingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyMatching(data: number[], opts: BacteriologyMatchingOptions = {}): BacteriologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyMatching };
diff --git a/src/bacteriology/measurement.ts b/src/bacteriology/measurement.ts
new file mode 100644
index 000000000..f0c3b2e3a
--- /dev/null
+++ b/src/bacteriology/measurement.ts
@@ -0,0 +1,14 @@
+/** bacteriology measurement module — tsb analytics library. */
+export interface BacteriologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeBacteriologyMeasurement(data: number[], opts: BacteriologyMeasurementOptions = {}): BacteriologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyMeasurement };
diff --git a/src/bacteriology/metrics.ts b/src/bacteriology/metrics.ts
new file mode 100644
index 000000000..d36b23453
--- /dev/null
+++ b/src/bacteriology/metrics.ts
@@ -0,0 +1,14 @@
+/** bacteriology metrics module — tsb analytics library. */
+export interface BacteriologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyMetricsResult { values: number[]; converged: boolean; }
+export function computeBacteriologyMetrics(data: number[], opts: BacteriologyMetricsOptions = {}): BacteriologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyMetrics };
diff --git a/src/bacteriology/modeling.ts b/src/bacteriology/modeling.ts
new file mode 100644
index 000000000..13100db94
--- /dev/null
+++ b/src/bacteriology/modeling.ts
@@ -0,0 +1,14 @@
+/** bacteriology modeling module — tsb analytics library. */
+export interface BacteriologyModelingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyModelingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyModeling(data: number[], opts: BacteriologyModelingOptions = {}): BacteriologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyModeling };
diff --git a/src/bacteriology/monitoring.ts b/src/bacteriology/monitoring.ts
new file mode 100644
index 000000000..1b3e5a00c
--- /dev/null
+++ b/src/bacteriology/monitoring.ts
@@ -0,0 +1,14 @@
+/** bacteriology monitoring module — tsb analytics library. */
+export interface BacteriologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeBacteriologyMonitoring(data: number[], opts: BacteriologyMonitoringOptions = {}): BacteriologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyMonitoring };
diff --git a/src/bacteriology/nonlinear.ts b/src/bacteriology/nonlinear.ts
new file mode 100644
index 000000000..7b55372ea
--- /dev/null
+++ b/src/bacteriology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** bacteriology nonlinear module — tsb analytics library. */
+export interface BacteriologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeBacteriologyNonlinear(data: number[], opts: BacteriologyNonlinearOptions = {}): BacteriologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyNonlinear };
diff --git a/src/bacteriology/normalization.ts b/src/bacteriology/normalization.ts
new file mode 100644
index 000000000..d3a977162
--- /dev/null
+++ b/src/bacteriology/normalization.ts
@@ -0,0 +1,14 @@
+/** bacteriology normalization module — tsb analytics library. */
+export interface BacteriologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyNormalization(data: number[], opts: BacteriologyNormalizationOptions = {}): BacteriologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyNormalization };
diff --git a/src/bacteriology/optimization.ts b/src/bacteriology/optimization.ts
new file mode 100644
index 000000000..2bc96cfab
--- /dev/null
+++ b/src/bacteriology/optimization.ts
@@ -0,0 +1,14 @@
+/** bacteriology optimization module — tsb analytics library. */
+export interface BacteriologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyOptimization(data: number[], opts: BacteriologyOptimizationOptions = {}): BacteriologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyOptimization };
diff --git a/src/bacteriology/patterns.ts b/src/bacteriology/patterns.ts
new file mode 100644
index 000000000..0f6bd8bf9
--- /dev/null
+++ b/src/bacteriology/patterns.ts
@@ -0,0 +1,14 @@
+/** bacteriology patterns module — tsb analytics library. */
+export interface BacteriologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyPatternsResult { values: number[]; converged: boolean; }
+export function computeBacteriologyPatterns(data: number[], opts: BacteriologyPatternsOptions = {}): BacteriologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyPatterns };
diff --git a/src/bacteriology/permutation.ts b/src/bacteriology/permutation.ts
new file mode 100644
index 000000000..2fb36d536
--- /dev/null
+++ b/src/bacteriology/permutation.ts
@@ -0,0 +1,14 @@
+/** bacteriology permutation module — tsb analytics library. */
+export interface BacteriologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyPermutationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyPermutation(data: number[], opts: BacteriologyPermutationOptions = {}): BacteriologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyPermutation };
diff --git a/src/bacteriology/prediction.ts b/src/bacteriology/prediction.ts
new file mode 100644
index 000000000..87bda315e
--- /dev/null
+++ b/src/bacteriology/prediction.ts
@@ -0,0 +1,14 @@
+/** bacteriology prediction module — tsb analytics library. */
+export interface BacteriologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyPredictionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyPrediction(data: number[], opts: BacteriologyPredictionOptions = {}): BacteriologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyPrediction };
diff --git a/src/bacteriology/processing.ts b/src/bacteriology/processing.ts
new file mode 100644
index 000000000..8d9f30d65
--- /dev/null
+++ b/src/bacteriology/processing.ts
@@ -0,0 +1,14 @@
+/** bacteriology processing module — tsb analytics library. */
+export interface BacteriologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyProcessingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyProcessing(data: number[], opts: BacteriologyProcessingOptions = {}): BacteriologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyProcessing };
diff --git a/src/bacteriology/profiling.ts b/src/bacteriology/profiling.ts
new file mode 100644
index 000000000..905b84c5b
--- /dev/null
+++ b/src/bacteriology/profiling.ts
@@ -0,0 +1,14 @@
+/** bacteriology profiling module — tsb analytics library. */
+export interface BacteriologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyProfilingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyProfiling(data: number[], opts: BacteriologyProfilingOptions = {}): BacteriologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyProfiling };
diff --git a/src/bacteriology/projection.ts b/src/bacteriology/projection.ts
new file mode 100644
index 000000000..79d189aa2
--- /dev/null
+++ b/src/bacteriology/projection.ts
@@ -0,0 +1,14 @@
+/** bacteriology projection module — tsb analytics library. */
+export interface BacteriologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyProjectionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyProjection(data: number[], opts: BacteriologyProjectionOptions = {}): BacteriologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyProjection };
diff --git a/src/bacteriology/ranking.ts b/src/bacteriology/ranking.ts
new file mode 100644
index 000000000..1cd9a6ad3
--- /dev/null
+++ b/src/bacteriology/ranking.ts
@@ -0,0 +1,14 @@
+/** bacteriology ranking module — tsb analytics library. */
+export interface BacteriologyRankingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyRankingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyRanking(data: number[], opts: BacteriologyRankingOptions = {}): BacteriologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyRanking };
diff --git a/src/bacteriology/reconstruction.ts b/src/bacteriology/reconstruction.ts
new file mode 100644
index 000000000..142f7fe74
--- /dev/null
+++ b/src/bacteriology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** bacteriology reconstruction module — tsb analytics library. */
+export interface BacteriologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyReconstruction(data: number[], opts: BacteriologyReconstructionOptions = {}): BacteriologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyReconstruction };
diff --git a/src/bacteriology/registration.ts b/src/bacteriology/registration.ts
new file mode 100644
index 000000000..838652d31
--- /dev/null
+++ b/src/bacteriology/registration.ts
@@ -0,0 +1,14 @@
+/** bacteriology registration module — tsb analytics library. */
+export interface BacteriologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyRegistration(data: number[], opts: BacteriologyRegistrationOptions = {}): BacteriologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyRegistration };
diff --git a/src/bacteriology/regression.ts b/src/bacteriology/regression.ts
new file mode 100644
index 000000000..fd96febcc
--- /dev/null
+++ b/src/bacteriology/regression.ts
@@ -0,0 +1,14 @@
+/** bacteriology regression module — tsb analytics library. */
+export interface BacteriologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyRegressionResult { values: number[]; converged: boolean; }
+export function computeBacteriologyRegression(data: number[], opts: BacteriologyRegressionOptions = {}): BacteriologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyRegression };
diff --git a/src/bacteriology/regularization.ts b/src/bacteriology/regularization.ts
new file mode 100644
index 000000000..9331540db
--- /dev/null
+++ b/src/bacteriology/regularization.ts
@@ -0,0 +1,14 @@
+/** bacteriology regularization module — tsb analytics library. */
+export interface BacteriologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyRegularization(data: number[], opts: BacteriologyRegularizationOptions = {}): BacteriologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyRegularization };
diff --git a/src/bacteriology/robustness.ts b/src/bacteriology/robustness.ts
new file mode 100644
index 000000000..cf0e28fa6
--- /dev/null
+++ b/src/bacteriology/robustness.ts
@@ -0,0 +1,14 @@
+/** bacteriology robustness module — tsb analytics library. */
+export interface BacteriologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeBacteriologyRobustness(data: number[], opts: BacteriologyRobustnessOptions = {}): BacteriologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyRobustness };
diff --git a/src/bacteriology/sampling.ts b/src/bacteriology/sampling.ts
new file mode 100644
index 000000000..145181069
--- /dev/null
+++ b/src/bacteriology/sampling.ts
@@ -0,0 +1,14 @@
+/** bacteriology sampling module — tsb analytics library. */
+export interface BacteriologySamplingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologySamplingResult { values: number[]; converged: boolean; }
+export function computeBacteriologySampling(data: number[], opts: BacteriologySamplingOptions = {}): BacteriologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologySampling };
diff --git a/src/bacteriology/sampling2.ts b/src/bacteriology/sampling2.ts
new file mode 100644
index 000000000..96090b883
--- /dev/null
+++ b/src/bacteriology/sampling2.ts
@@ -0,0 +1,14 @@
+/** bacteriology sampling2 module — tsb analytics library. */
+export interface BacteriologySamplingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologySamplingResult { values: number[]; converged: boolean; }
+export function computeBacteriologySampling(data: number[], opts: BacteriologySamplingOptions = {}): BacteriologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologySampling };
diff --git a/src/bacteriology/scaling.ts b/src/bacteriology/scaling.ts
new file mode 100644
index 000000000..3c8a324e6
--- /dev/null
+++ b/src/bacteriology/scaling.ts
@@ -0,0 +1,14 @@
+/** bacteriology scaling module — tsb analytics library. */
+export interface BacteriologyScalingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyScalingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyScaling(data: number[], opts: BacteriologyScalingOptions = {}): BacteriologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyScaling };
diff --git a/src/bacteriology/scoring.ts b/src/bacteriology/scoring.ts
new file mode 100644
index 000000000..53c525520
--- /dev/null
+++ b/src/bacteriology/scoring.ts
@@ -0,0 +1,14 @@
+/** bacteriology scoring module — tsb analytics library. */
+export interface BacteriologyScoringOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyScoringResult { values: number[]; converged: boolean; }
+export function computeBacteriologyScoring(data: number[], opts: BacteriologyScoringOptions = {}): BacteriologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyScoring };
diff --git a/src/bacteriology/segmentation.ts b/src/bacteriology/segmentation.ts
new file mode 100644
index 000000000..9ff4dd8c2
--- /dev/null
+++ b/src/bacteriology/segmentation.ts
@@ -0,0 +1,14 @@
+/** bacteriology segmentation module — tsb analytics library. */
+export interface BacteriologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologySegmentationResult { values: number[]; converged: boolean; }
+export function computeBacteriologySegmentation(data: number[], opts: BacteriologySegmentationOptions = {}): BacteriologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologySegmentation };
diff --git a/src/bacteriology/selection.ts b/src/bacteriology/selection.ts
new file mode 100644
index 000000000..6abf73aeb
--- /dev/null
+++ b/src/bacteriology/selection.ts
@@ -0,0 +1,14 @@
+/** bacteriology selection module — tsb analytics library. */
+export interface BacteriologySelectionOptions { tol?: number; maxIter?: number; }
+export interface BacteriologySelectionResult { values: number[]; converged: boolean; }
+export function computeBacteriologySelection(data: number[], opts: BacteriologySelectionOptions = {}): BacteriologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologySelection };
diff --git a/src/bacteriology/sensitivity.ts b/src/bacteriology/sensitivity.ts
new file mode 100644
index 000000000..bb1e07188
--- /dev/null
+++ b/src/bacteriology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** bacteriology sensitivity module — tsb analytics library. */
+export interface BacteriologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface BacteriologySensitivityResult { values: number[]; converged: boolean; }
+export function computeBacteriologySensitivity(data: number[], opts: BacteriologySensitivityOptions = {}): BacteriologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologySensitivity };
diff --git a/src/bacteriology/simulation.ts b/src/bacteriology/simulation.ts
new file mode 100644
index 000000000..faa7174ec
--- /dev/null
+++ b/src/bacteriology/simulation.ts
@@ -0,0 +1,14 @@
+/** bacteriology simulation module — tsb analytics library. */
+export interface BacteriologySimulationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologySimulationResult { values: number[]; converged: boolean; }
+export function computeBacteriologySimulation(data: number[], opts: BacteriologySimulationOptions = {}): BacteriologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologySimulation };
diff --git a/src/bacteriology/smoothing.ts b/src/bacteriology/smoothing.ts
new file mode 100644
index 000000000..9f8241a05
--- /dev/null
+++ b/src/bacteriology/smoothing.ts
@@ -0,0 +1,14 @@
+/** bacteriology smoothing module — tsb analytics library. */
+export interface BacteriologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologySmoothingResult { values: number[]; converged: boolean; }
+export function computeBacteriologySmoothing(data: number[], opts: BacteriologySmoothingOptions = {}): BacteriologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologySmoothing };
diff --git a/src/bacteriology/stability.ts b/src/bacteriology/stability.ts
new file mode 100644
index 000000000..2f8928287
--- /dev/null
+++ b/src/bacteriology/stability.ts
@@ -0,0 +1,14 @@
+/** bacteriology stability module — tsb analytics library. */
+export interface BacteriologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyStabilityResult { values: number[]; converged: boolean; }
+export function computeBacteriologyStability(data: number[], opts: BacteriologyStabilityOptions = {}): BacteriologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyStability };
diff --git a/src/bacteriology/stacking.ts b/src/bacteriology/stacking.ts
new file mode 100644
index 000000000..f740b17e0
--- /dev/null
+++ b/src/bacteriology/stacking.ts
@@ -0,0 +1,14 @@
+/** bacteriology stacking module — tsb analytics library. */
+export interface BacteriologyStackingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyStackingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyStacking(data: number[], opts: BacteriologyStackingOptions = {}): BacteriologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyStacking };
diff --git a/src/bacteriology/standardization.ts b/src/bacteriology/standardization.ts
new file mode 100644
index 000000000..c902213af
--- /dev/null
+++ b/src/bacteriology/standardization.ts
@@ -0,0 +1,14 @@
+/** bacteriology standardization module — tsb analytics library. */
+export interface BacteriologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyStandardization(data: number[], opts: BacteriologyStandardizationOptions = {}): BacteriologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyStandardization };
diff --git a/src/bacteriology/static.ts b/src/bacteriology/static.ts
new file mode 100644
index 000000000..0fffbbcc6
--- /dev/null
+++ b/src/bacteriology/static.ts
@@ -0,0 +1,14 @@
+/** bacteriology static module — tsb analytics library. */
+export interface BacteriologyStaticOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyStaticResult { values: number[]; converged: boolean; }
+export function computeBacteriologyStatic(data: number[], opts: BacteriologyStaticOptions = {}): BacteriologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyStatic };
diff --git a/src/bacteriology/stochastic.ts b/src/bacteriology/stochastic.ts
new file mode 100644
index 000000000..441dfe596
--- /dev/null
+++ b/src/bacteriology/stochastic.ts
@@ -0,0 +1,14 @@
+/** bacteriology stochastic module — tsb analytics library. */
+export interface BacteriologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyStochasticResult { values: number[]; converged: boolean; }
+export function computeBacteriologyStochastic(data: number[], opts: BacteriologyStochasticOptions = {}): BacteriologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyStochastic };
diff --git a/src/bacteriology/synthesis.ts b/src/bacteriology/synthesis.ts
new file mode 100644
index 000000000..0caddb91e
--- /dev/null
+++ b/src/bacteriology/synthesis.ts
@@ -0,0 +1,14 @@
+/** bacteriology synthesis module — tsb analytics library. */
+export interface BacteriologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface BacteriologySynthesisResult { values: number[]; converged: boolean; }
+export function computeBacteriologySynthesis(data: number[], opts: BacteriologySynthesisOptions = {}): BacteriologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologySynthesis };
diff --git a/src/bacteriology/topology.ts b/src/bacteriology/topology.ts
new file mode 100644
index 000000000..5d4265275
--- /dev/null
+++ b/src/bacteriology/topology.ts
@@ -0,0 +1,14 @@
+/** bacteriology topology module — tsb analytics library. */
+export interface BacteriologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyTopologyResult { values: number[]; converged: boolean; }
+export function computeBacteriologyTopology(data: number[], opts: BacteriologyTopologyOptions = {}): BacteriologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyTopology };
diff --git a/src/bacteriology/tracking.ts b/src/bacteriology/tracking.ts
new file mode 100644
index 000000000..c68348fdd
--- /dev/null
+++ b/src/bacteriology/tracking.ts
@@ -0,0 +1,14 @@
+/** bacteriology tracking module — tsb analytics library. */
+export interface BacteriologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyTrackingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyTracking(data: number[], opts: BacteriologyTrackingOptions = {}): BacteriologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyTracking };
diff --git a/src/bacteriology/transform.ts b/src/bacteriology/transform.ts
new file mode 100644
index 000000000..cfc188175
--- /dev/null
+++ b/src/bacteriology/transform.ts
@@ -0,0 +1,14 @@
+/** bacteriology transform module — tsb analytics library. */
+export interface BacteriologyTransformOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyTransformResult { values: number[]; converged: boolean; }
+export function computeBacteriologyTransform(data: number[], opts: BacteriologyTransformOptions = {}): BacteriologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyTransform };
diff --git a/src/bacteriology/uncertainty.ts b/src/bacteriology/uncertainty.ts
new file mode 100644
index 000000000..c518aca39
--- /dev/null
+++ b/src/bacteriology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** bacteriology uncertainty module — tsb analytics library. */
+export interface BacteriologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeBacteriologyUncertainty(data: number[], opts: BacteriologyUncertaintyOptions = {}): BacteriologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyUncertainty };
diff --git a/src/bacteriology/validation.ts b/src/bacteriology/validation.ts
new file mode 100644
index 000000000..39ffc6b1e
--- /dev/null
+++ b/src/bacteriology/validation.ts
@@ -0,0 +1,14 @@
+/** bacteriology validation module — tsb analytics library. */
+export interface BacteriologyValidationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyValidationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyValidation(data: number[], opts: BacteriologyValidationOptions = {}): BacteriologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyValidation };
diff --git a/src/bacteriology/verification.ts b/src/bacteriology/verification.ts
new file mode 100644
index 000000000..7e081757e
--- /dev/null
+++ b/src/bacteriology/verification.ts
@@ -0,0 +1,14 @@
+/** bacteriology verification module — tsb analytics library. */
+export interface BacteriologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyVerificationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyVerification(data: number[], opts: BacteriologyVerificationOptions = {}): BacteriologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyVerification };
diff --git a/src/bacteriology/visualization.ts b/src/bacteriology/visualization.ts
new file mode 100644
index 000000000..1c953cf9d
--- /dev/null
+++ b/src/bacteriology/visualization.ts
@@ -0,0 +1,14 @@
+/** bacteriology visualization module — tsb analytics library. */
+export interface BacteriologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeBacteriologyVisualization(data: number[], opts: BacteriologyVisualizationOptions = {}): BacteriologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyVisualization };
diff --git a/src/bacteriology/voting.ts b/src/bacteriology/voting.ts
new file mode 100644
index 000000000..0e2f02f5f
--- /dev/null
+++ b/src/bacteriology/voting.ts
@@ -0,0 +1,14 @@
+/** bacteriology voting module — tsb analytics library. */
+export interface BacteriologyVotingOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyVotingResult { values: number[]; converged: boolean; }
+export function computeBacteriologyVoting(data: number[], opts: BacteriologyVotingOptions = {}): BacteriologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyVoting };
diff --git a/src/bacteriology/wavelet.ts b/src/bacteriology/wavelet.ts
new file mode 100644
index 000000000..006a1b872
--- /dev/null
+++ b/src/bacteriology/wavelet.ts
@@ -0,0 +1,14 @@
+/** bacteriology wavelet module — tsb analytics library. */
+export interface BacteriologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface BacteriologyWaveletResult { values: number[]; converged: boolean; }
+export function computeBacteriologyWavelet(data: number[], opts: BacteriologyWaveletOptions = {}): BacteriologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBacteriologyWavelet };
diff --git a/src/bayes/abc.ts b/src/bayes/abc.ts
new file mode 100644
index 000000000..b83932422
--- /dev/null
+++ b/src/bayes/abc.ts
@@ -0,0 +1,22 @@
+/** Abc module — tsb analytics library. */
+
+/** Options for Abc. */
+export interface AbcOptions { tol?: number; maxIter?: number; }
+
+/** Result from Abc. */
+export interface AbcResult { values: number[]; converged: boolean; }
+
+/** Compute Abc. */
+export function computeAbc(data: number[], opts: AbcOptions = {}): AbcResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAbc };
diff --git a/src/bayes/active_learning.ts b/src/bayes/active_learning.ts
new file mode 100644
index 000000000..9795fa769
--- /dev/null
+++ b/src/bayes/active_learning.ts
@@ -0,0 +1,22 @@
+/** Active Learning module — tsb analytics library. */
+
+/** Options for Active Learning. */
+export interface ActiveLearningOptions { tol?: number; maxIter?: number; }
+
+/** Result from Active Learning. */
+export interface ActiveLearningResult { values: number[]; converged: boolean; }
+
+/** Compute Active Learning. */
+export function computeActiveLearning(data: number[], opts: ActiveLearningOptions = {}): ActiveLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeActiveLearning };
diff --git a/src/bayes/advanced.ts b/src/bayes/advanced.ts
new file mode 100644
index 000000000..1be62ccfd
--- /dev/null
+++ b/src/bayes/advanced.ts
@@ -0,0 +1,15 @@
+/** Bayes Advanced module — tsb analytics library. */
+export interface Bayes advancedOptions { tol?: number; maxIter?: number; }
+export interface Bayes advancedResult { values: number[]; converged: boolean; }
+export function computeBayes advanced(data: number[], opts: Bayes advancedOptions = {}): Bayes advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes advanced };
diff --git a/src/bayes/base2.ts b/src/bayes/base2.ts
new file mode 100644
index 000000000..02a48c8c2
--- /dev/null
+++ b/src/bayes/base2.ts
@@ -0,0 +1,15 @@
+/** Bayes Base2 module — tsb analytics library. */
+export interface Bayes base2Options { tol?: number; maxIter?: number; }
+export interface Bayes base2Result { values: number[]; converged: boolean; }
+export function computeBayes base2(data: number[], opts: Bayes base2Options = {}): Bayes base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes base2 };
diff --git a/src/bayes/batch.ts b/src/bayes/batch.ts
new file mode 100644
index 000000000..c98aae934
--- /dev/null
+++ b/src/bayes/batch.ts
@@ -0,0 +1,15 @@
+/** Bayes Batch module — tsb analytics library. */
+export interface Bayes batchOptions { tol?: number; maxIter?: number; }
+export interface Bayes batchResult { values: number[]; converged: boolean; }
+export function computeBayes batch(data: number[], opts: Bayes batchOptions = {}): Bayes batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes batch };
diff --git a/src/bayes/bayesian_nn.ts b/src/bayes/bayesian_nn.ts
new file mode 100644
index 000000000..188d4a025
--- /dev/null
+++ b/src/bayes/bayesian_nn.ts
@@ -0,0 +1,22 @@
+/** Bayesian Nn module — tsb analytics library. */
+
+/** Options for Bayesian Nn. */
+export interface BayesianNnOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bayesian Nn. */
+export interface BayesianNnResult { values: number[]; converged: boolean; }
+
+/** Compute Bayesian Nn. */
+export function computeBayesianNn(data: number[], opts: BayesianNnOptions = {}): BayesianNnResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBayesianNn };
diff --git a/src/bayes/bayesian_opt.ts b/src/bayes/bayesian_opt.ts
new file mode 100644
index 000000000..014f07823
--- /dev/null
+++ b/src/bayes/bayesian_opt.ts
@@ -0,0 +1,22 @@
+/** Bayesian Opt module — tsb analytics library. */
+
+/** Options for Bayesian Opt. */
+export interface BayesianOptOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bayesian Opt. */
+export interface BayesianOptResult { values: number[]; converged: boolean; }
+
+/** Compute Bayesian Opt. */
+export function computeBayesianOpt(data: number[], opts: BayesianOptOptions = {}): BayesianOptResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBayesianOpt };
diff --git a/src/bayes/bayesian_rl.ts b/src/bayes/bayesian_rl.ts
new file mode 100644
index 000000000..59b13e205
--- /dev/null
+++ b/src/bayes/bayesian_rl.ts
@@ -0,0 +1,22 @@
+/** Bayesian Rl module — tsb analytics library. */
+
+/** Options for Bayesian Rl. */
+export interface BayesianRlOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bayesian Rl. */
+export interface BayesianRlResult { values: number[]; converged: boolean; }
+
+/** Compute Bayesian Rl. */
+export function computeBayesianRl(data: number[], opts: BayesianRlOptions = {}): BayesianRlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBayesianRl };
diff --git a/src/bayes/beta.ts b/src/bayes/beta.ts
new file mode 100644
index 000000000..ccb15a13a
--- /dev/null
+++ b/src/bayes/beta.ts
@@ -0,0 +1,15 @@
+/** Bayes Beta module — tsb analytics library. */
+export interface Bayes betaOptions { tol?: number; maxIter?: number; }
+export interface Bayes betaResult { values: number[]; converged: boolean; }
+export function computeBayes beta(data: number[], opts: Bayes betaOptions = {}): Bayes betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes beta };
diff --git a/src/bayes/cpu.ts b/src/bayes/cpu.ts
new file mode 100644
index 000000000..71edfe993
--- /dev/null
+++ b/src/bayes/cpu.ts
@@ -0,0 +1,15 @@
+/** Bayes Cpu module — tsb analytics library. */
+export interface Bayes cpuOptions { tol?: number; maxIter?: number; }
+export interface Bayes cpuResult { values: number[]; converged: boolean; }
+export function computeBayes cpu(data: number[], opts: Bayes cpuOptions = {}): Bayes cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes cpu };
diff --git a/src/bayes/dense.ts b/src/bayes/dense.ts
new file mode 100644
index 000000000..077acf928
--- /dev/null
+++ b/src/bayes/dense.ts
@@ -0,0 +1,15 @@
+/** Bayes Dense module — tsb analytics library. */
+export interface Bayes denseOptions { tol?: number; maxIter?: number; }
+export interface Bayes denseResult { values: number[]; converged: boolean; }
+export function computeBayes dense(data: number[], opts: Bayes denseOptions = {}): Bayes denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes dense };
diff --git a/src/bayes/diffusion_bayes.ts b/src/bayes/diffusion_bayes.ts
new file mode 100644
index 000000000..7226e4a23
--- /dev/null
+++ b/src/bayes/diffusion_bayes.ts
@@ -0,0 +1,22 @@
+/** Diffusion Bayes module — tsb analytics library. */
+
+/** Options for Diffusion Bayes. */
+export interface DiffusionBayesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Diffusion Bayes. */
+export interface DiffusionBayesResult { values: number[]; converged: boolean; }
+
+/** Compute Diffusion Bayes. */
+export function computeDiffusionBayes(data: number[], opts: DiffusionBayesOptions = {}): DiffusionBayesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDiffusionBayes };
diff --git a/src/bayes/distributed.ts b/src/bayes/distributed.ts
new file mode 100644
index 000000000..49778abc1
--- /dev/null
+++ b/src/bayes/distributed.ts
@@ -0,0 +1,15 @@
+/** Bayes Distributed module — tsb analytics library. */
+export interface Bayes distributedOptions { tol?: number; maxIter?: number; }
+export interface Bayes distributedResult { values: number[]; converged: boolean; }
+export function computeBayes distributed(data: number[], opts: Bayes distributedOptions = {}): Bayes distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes distributed };
diff --git a/src/bayes/elbo.ts b/src/bayes/elbo.ts
new file mode 100644
index 000000000..2b71cfd98
--- /dev/null
+++ b/src/bayes/elbo.ts
@@ -0,0 +1,22 @@
+/** Elbo module — tsb analytics library. */
+
+/** Options for Elbo. */
+export interface ElboOptions { tol?: number; maxIter?: number; }
+
+/** Result from Elbo. */
+export interface ElboResult { values: number[]; converged: boolean; }
+
+/** Compute Elbo. */
+export function computeElbo(data: number[], opts: ElboOptions = {}): ElboResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeElbo };
diff --git a/src/bayes/em.ts b/src/bayes/em.ts
new file mode 100644
index 000000000..8cc7410e0
--- /dev/null
+++ b/src/bayes/em.ts
@@ -0,0 +1,22 @@
+/** Em module — tsb analytics library. */
+
+/** Options for Em. */
+export interface EmOptions { tol?: number; maxIter?: number; }
+
+/** Result from Em. */
+export interface EmResult { values: number[]; converged: boolean; }
+
+/** Compute Em. */
+export function computeEm(data: number[], opts: EmOptions = {}): EmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEm };
diff --git a/src/bayes/entropy.ts b/src/bayes/entropy.ts
new file mode 100644
index 000000000..d313aeafb
--- /dev/null
+++ b/src/bayes/entropy.ts
@@ -0,0 +1,22 @@
+/** Entropy module — tsb analytics library. */
+
+/** Options for Entropy. */
+export interface EntropyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Entropy. */
+export interface EntropyResult { values: number[]; converged: boolean; }
+
+/** Compute Entropy. */
+export function computeEntropy(data: number[], opts: EntropyOptions = {}): EntropyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEntropy };
diff --git a/src/bayes/evidence.ts b/src/bayes/evidence.ts
new file mode 100644
index 000000000..a1e871d4b
--- /dev/null
+++ b/src/bayes/evidence.ts
@@ -0,0 +1,22 @@
+/** Evidence module — tsb analytics library. */
+
+/** Options for Evidence. */
+export interface EvidenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Evidence. */
+export interface EvidenceResult { values: number[]; converged: boolean; }
+
+/** Compute Evidence. */
+export function computeEvidence(data: number[], opts: EvidenceOptions = {}): EvidenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEvidence };
diff --git a/src/bayes/experimental.ts b/src/bayes/experimental.ts
new file mode 100644
index 000000000..97d8ea939
--- /dev/null
+++ b/src/bayes/experimental.ts
@@ -0,0 +1,15 @@
+/** Bayes Experimental module — tsb analytics library. */
+export interface Bayes experimentalOptions { tol?: number; maxIter?: number; }
+export interface Bayes experimentalResult { values: number[]; converged: boolean; }
+export function computeBayes experimental(data: number[], opts: Bayes experimentalOptions = {}): Bayes experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes experimental };
diff --git a/src/bayes/experimental_design.ts b/src/bayes/experimental_design.ts
new file mode 100644
index 000000000..fab139179
--- /dev/null
+++ b/src/bayes/experimental_design.ts
@@ -0,0 +1,22 @@
+/** Experimental Design module — tsb analytics library. */
+
+/** Options for Experimental Design. */
+export interface ExperimentalDesignOptions { tol?: number; maxIter?: number; }
+
+/** Result from Experimental Design. */
+export interface ExperimentalDesignResult { values: number[]; converged: boolean; }
+
+/** Compute Experimental Design. */
+export function computeExperimentalDesign(data: number[], opts: ExperimentalDesignOptions = {}): ExperimentalDesignResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExperimentalDesign };
diff --git a/src/bayes/fast.ts b/src/bayes/fast.ts
new file mode 100644
index 000000000..312c30298
--- /dev/null
+++ b/src/bayes/fast.ts
@@ -0,0 +1,15 @@
+/** Bayes Fast module — tsb analytics library. */
+export interface Bayes fastOptions { tol?: number; maxIter?: number; }
+export interface Bayes fastResult { values: number[]; converged: boolean; }
+export function computeBayes fast(data: number[], opts: Bayes fastOptions = {}): Bayes fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes fast };
diff --git a/src/bayes/future.ts b/src/bayes/future.ts
new file mode 100644
index 000000000..af81025ee
--- /dev/null
+++ b/src/bayes/future.ts
@@ -0,0 +1,15 @@
+/** Bayes Future module — tsb analytics library. */
+export interface Bayes futureOptions { tol?: number; maxIter?: number; }
+export interface Bayes futureResult { values: number[]; converged: boolean; }
+export function computeBayes future(data: number[], opts: Bayes futureOptions = {}): Bayes futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes future };
diff --git a/src/bayes/gaussian_process.ts b/src/bayes/gaussian_process.ts
new file mode 100644
index 000000000..c9b70406a
--- /dev/null
+++ b/src/bayes/gaussian_process.ts
@@ -0,0 +1,22 @@
+/** Gaussian Process module — tsb analytics library. */
+
+/** Options for Gaussian Process. */
+export interface GaussianProcessOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gaussian Process. */
+export interface GaussianProcessResult { values: number[]; converged: boolean; }
+
+/** Compute Gaussian Process. */
+export function computeGaussianProcess(data: number[], opts: GaussianProcessOptions = {}): GaussianProcessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGaussianProcess };
diff --git a/src/bayes/gibbs.ts b/src/bayes/gibbs.ts
new file mode 100644
index 000000000..c3be8200c
--- /dev/null
+++ b/src/bayes/gibbs.ts
@@ -0,0 +1,22 @@
+/** Gibbs module — tsb analytics library. */
+
+/** Options for Gibbs. */
+export interface GibbsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gibbs. */
+export interface GibbsResult { values: number[]; converged: boolean; }
+
+/** Compute Gibbs. */
+export function computeGibbs(data: number[], opts: GibbsOptions = {}): GibbsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGibbs };
diff --git a/src/bayes/gpu.ts b/src/bayes/gpu.ts
new file mode 100644
index 000000000..38cd0ee20
--- /dev/null
+++ b/src/bayes/gpu.ts
@@ -0,0 +1,15 @@
+/** Bayes Gpu module — tsb analytics library. */
+export interface Bayes gpuOptions { tol?: number; maxIter?: number; }
+export interface Bayes gpuResult { values: number[]; converged: boolean; }
+export function computeBayes gpu(data: number[], opts: Bayes gpuOptions = {}): Bayes gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes gpu };
diff --git a/src/bayes/hmc.ts b/src/bayes/hmc.ts
new file mode 100644
index 000000000..9bc9020f5
--- /dev/null
+++ b/src/bayes/hmc.ts
@@ -0,0 +1,22 @@
+/** Hmc module — tsb analytics library. */
+
+/** Options for Hmc. */
+export interface HmcOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hmc. */
+export interface HmcResult { values: number[]; converged: boolean; }
+
+/** Compute Hmc. */
+export function computeHmc(data: number[], opts: HmcOptions = {}): HmcResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHmc };
diff --git a/src/bayes/information_gain.ts b/src/bayes/information_gain.ts
new file mode 100644
index 000000000..7b2e3c603
--- /dev/null
+++ b/src/bayes/information_gain.ts
@@ -0,0 +1,22 @@
+/** Information Gain module — tsb analytics library. */
+
+/** Options for Information Gain. */
+export interface InformationGainOptions { tol?: number; maxIter?: number; }
+
+/** Result from Information Gain. */
+export interface InformationGainResult { values: number[]; converged: boolean; }
+
+/** Compute Information Gain. */
+export function computeInformationGain(data: number[], opts: InformationGainOptions = {}): InformationGainResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInformationGain };
diff --git a/src/bayes/kl_divergence.ts b/src/bayes/kl_divergence.ts
new file mode 100644
index 000000000..f47785d15
--- /dev/null
+++ b/src/bayes/kl_divergence.ts
@@ -0,0 +1,22 @@
+/** Kl Divergence module — tsb analytics library. */
+
+/** Options for Kl Divergence. */
+export interface KlDivergenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Kl Divergence. */
+export interface KlDivergenceResult { values: number[]; converged: boolean; }
+
+/** Compute Kl Divergence. */
+export function computeKlDivergence(data: number[], opts: KlDivergenceOptions = {}): KlDivergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKlDivergence };
diff --git a/src/bayes/laplace_approx.ts b/src/bayes/laplace_approx.ts
new file mode 100644
index 000000000..529850884
--- /dev/null
+++ b/src/bayes/laplace_approx.ts
@@ -0,0 +1,22 @@
+/** Laplace Approx module — tsb analytics library. */
+
+/** Options for Laplace Approx. */
+export interface LaplaceApproxOptions { tol?: number; maxIter?: number; }
+
+/** Result from Laplace Approx. */
+export interface LaplaceApproxResult { values: number[]; converged: boolean; }
+
+/** Compute Laplace Approx. */
+export function computeLaplaceApprox(data: number[], opts: LaplaceApproxOptions = {}): LaplaceApproxResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLaplaceApprox };
diff --git a/src/bayes/large.ts b/src/bayes/large.ts
new file mode 100644
index 000000000..0780ac7c3
--- /dev/null
+++ b/src/bayes/large.ts
@@ -0,0 +1,15 @@
+/** Bayes Large module — tsb analytics library. */
+export interface Bayes largeOptions { tol?: number; maxIter?: number; }
+export interface Bayes largeResult { values: number[]; converged: boolean; }
+export function computeBayes large(data: number[], opts: Bayes largeOptions = {}): Bayes largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes large };
diff --git a/src/bayes/legacy.ts b/src/bayes/legacy.ts
new file mode 100644
index 000000000..c83496e5c
--- /dev/null
+++ b/src/bayes/legacy.ts
@@ -0,0 +1,15 @@
+/** Bayes Legacy module — tsb analytics library. */
+export interface Bayes legacyOptions { tol?: number; maxIter?: number; }
+export interface Bayes legacyResult { values: number[]; converged: boolean; }
+export function computeBayes legacy(data: number[], opts: Bayes legacyOptions = {}): Bayes legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes legacy };
diff --git a/src/bayes/likelihood.ts b/src/bayes/likelihood.ts
new file mode 100644
index 000000000..ef8bf2912
--- /dev/null
+++ b/src/bayes/likelihood.ts
@@ -0,0 +1,22 @@
+/** Likelihood module — tsb analytics library. */
+
+/** Options for Likelihood. */
+export interface LikelihoodOptions { tol?: number; maxIter?: number; }
+
+/** Result from Likelihood. */
+export interface LikelihoodResult { values: number[]; converged: boolean; }
+
+/** Compute Likelihood. */
+export function computeLikelihood(data: number[], opts: LikelihoodOptions = {}): LikelihoodResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLikelihood };
diff --git a/src/bayes/lite.ts b/src/bayes/lite.ts
new file mode 100644
index 000000000..b53e42e9a
--- /dev/null
+++ b/src/bayes/lite.ts
@@ -0,0 +1,15 @@
+/** Bayes Lite module — tsb analytics library. */
+export interface Bayes liteOptions { tol?: number; maxIter?: number; }
+export interface Bayes liteResult { values: number[]; converged: boolean; }
+export function computeBayes lite(data: number[], opts: Bayes liteOptions = {}): Bayes liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes lite };
diff --git a/src/bayes/mcmc.ts b/src/bayes/mcmc.ts
new file mode 100644
index 000000000..8f6178807
--- /dev/null
+++ b/src/bayes/mcmc.ts
@@ -0,0 +1,22 @@
+/** Mcmc module — tsb analytics library. */
+
+/** Options for Mcmc. */
+export interface McmcOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mcmc. */
+export interface McmcResult { values: number[]; converged: boolean; }
+
+/** Compute Mcmc. */
+export function computeMcmc(data: number[], opts: McmcOptions = {}): McmcResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMcmc };
diff --git a/src/bayes/mh.ts b/src/bayes/mh.ts
new file mode 100644
index 000000000..f1de10ad4
--- /dev/null
+++ b/src/bayes/mh.ts
@@ -0,0 +1,22 @@
+/** Mh module — tsb analytics library. */
+
+/** Options for Mh. */
+export interface MhOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mh. */
+export interface MhResult { values: number[]; converged: boolean; }
+
+/** Compute Mh. */
+export function computeMh(data: number[], opts: MhOptions = {}): MhResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMh };
diff --git a/src/bayes/mini.ts b/src/bayes/mini.ts
new file mode 100644
index 000000000..bf6443038
--- /dev/null
+++ b/src/bayes/mini.ts
@@ -0,0 +1,15 @@
+/** Bayes Mini module — tsb analytics library. */
+export interface Bayes miniOptions { tol?: number; maxIter?: number; }
+export interface Bayes miniResult { values: number[]; converged: boolean; }
+export function computeBayes mini(data: number[], opts: Bayes miniOptions = {}): Bayes miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes mini };
diff --git a/src/bayes/mutual_information.ts b/src/bayes/mutual_information.ts
new file mode 100644
index 000000000..b65a069c5
--- /dev/null
+++ b/src/bayes/mutual_information.ts
@@ -0,0 +1,22 @@
+/** Mutual Information module — tsb analytics library. */
+
+/** Options for Mutual Information. */
+export interface MutualInformationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mutual Information. */
+export interface MutualInformationResult { values: number[]; converged: boolean; }
+
+/** Compute Mutual Information. */
+export function computeMutualInformation(data: number[], opts: MutualInformationOptions = {}): MutualInformationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMutualInformation };
diff --git a/src/bayes/next.ts b/src/bayes/next.ts
new file mode 100644
index 000000000..c98e94a74
--- /dev/null
+++ b/src/bayes/next.ts
@@ -0,0 +1,15 @@
+/** Bayes Next module — tsb analytics library. */
+export interface Bayes nextOptions { tol?: number; maxIter?: number; }
+export interface Bayes nextResult { values: number[]; converged: boolean; }
+export function computeBayes next(data: number[], opts: Bayes nextOptions = {}): Bayes nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes next };
diff --git a/src/bayes/normalizing_flow.ts b/src/bayes/normalizing_flow.ts
new file mode 100644
index 000000000..17d92c020
--- /dev/null
+++ b/src/bayes/normalizing_flow.ts
@@ -0,0 +1,22 @@
+/** Normalizing Flow module — tsb analytics library. */
+
+/** Options for Normalizing Flow. */
+export interface NormalizingFlowOptions { tol?: number; maxIter?: number; }
+
+/** Result from Normalizing Flow. */
+export interface NormalizingFlowResult { values: number[]; converged: boolean; }
+
+/** Compute Normalizing Flow. */
+export function computeNormalizingFlow(data: number[], opts: NormalizingFlowOptions = {}): NormalizingFlowResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNormalizingFlow };
diff --git a/src/bayes/nuts.ts b/src/bayes/nuts.ts
new file mode 100644
index 000000000..3da262432
--- /dev/null
+++ b/src/bayes/nuts.ts
@@ -0,0 +1,22 @@
+/** Nuts module — tsb analytics library. */
+
+/** Options for Nuts. */
+export interface NutsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nuts. */
+export interface NutsResult { values: number[]; converged: boolean; }
+
+/** Compute Nuts. */
+export function computeNuts(data: number[], opts: NutsOptions = {}): NutsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNuts };
diff --git a/src/bayes/online.ts b/src/bayes/online.ts
new file mode 100644
index 000000000..085f10e40
--- /dev/null
+++ b/src/bayes/online.ts
@@ -0,0 +1,15 @@
+/** Bayes Online module — tsb analytics library. */
+export interface Bayes onlineOptions { tol?: number; maxIter?: number; }
+export interface Bayes onlineResult { values: number[]; converged: boolean; }
+export function computeBayes online(data: number[], opts: Bayes onlineOptions = {}): Bayes onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes online };
diff --git a/src/bayes/parallel.ts b/src/bayes/parallel.ts
new file mode 100644
index 000000000..636863b2e
--- /dev/null
+++ b/src/bayes/parallel.ts
@@ -0,0 +1,15 @@
+/** Bayes Parallel module — tsb analytics library. */
+export interface Bayes parallelOptions { tol?: number; maxIter?: number; }
+export interface Bayes parallelResult { values: number[]; converged: boolean; }
+export function computeBayes parallel(data: number[], opts: Bayes parallelOptions = {}): Bayes parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes parallel };
diff --git a/src/bayes/plus.ts b/src/bayes/plus.ts
new file mode 100644
index 000000000..51e5f3384
--- /dev/null
+++ b/src/bayes/plus.ts
@@ -0,0 +1,15 @@
+/** Bayes Plus module — tsb analytics library. */
+export interface Bayes plusOptions { tol?: number; maxIter?: number; }
+export interface Bayes plusResult { values: number[]; converged: boolean; }
+export function computeBayes plus(data: number[], opts: Bayes plusOptions = {}): Bayes plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes plus };
diff --git a/src/bayes/posterior.ts b/src/bayes/posterior.ts
new file mode 100644
index 000000000..c1ca04e6a
--- /dev/null
+++ b/src/bayes/posterior.ts
@@ -0,0 +1,22 @@
+/** Posterior module — tsb analytics library. */
+
+/** Options for Posterior. */
+export interface PosteriorOptions { tol?: number; maxIter?: number; }
+
+/** Result from Posterior. */
+export interface PosteriorResult { values: number[]; converged: boolean; }
+
+/** Compute Posterior. */
+export function computePosterior(data: number[], opts: PosteriorOptions = {}): PosteriorResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePosterior };
diff --git a/src/bayes/predictive.ts b/src/bayes/predictive.ts
new file mode 100644
index 000000000..4ecd4ccd7
--- /dev/null
+++ b/src/bayes/predictive.ts
@@ -0,0 +1,22 @@
+/** Predictive module — tsb analytics library. */
+
+/** Options for Predictive. */
+export interface PredictiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Predictive. */
+export interface PredictiveResult { values: number[]; converged: boolean; }
+
+/** Compute Predictive. */
+export function computePredictive(data: number[], opts: PredictiveOptions = {}): PredictiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePredictive };
diff --git a/src/bayes/prior.ts b/src/bayes/prior.ts
new file mode 100644
index 000000000..d66c4fb79
--- /dev/null
+++ b/src/bayes/prior.ts
@@ -0,0 +1,22 @@
+/** Prior module — tsb analytics library. */
+
+/** Options for Prior. */
+export interface PriorOptions { tol?: number; maxIter?: number; }
+
+/** Result from Prior. */
+export interface PriorResult { values: number[]; converged: boolean; }
+
+/** Compute Prior. */
+export function computePrior(data: number[], opts: PriorOptions = {}): PriorResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrior };
diff --git a/src/bayes/pro.ts b/src/bayes/pro.ts
new file mode 100644
index 000000000..9fbc8c453
--- /dev/null
+++ b/src/bayes/pro.ts
@@ -0,0 +1,15 @@
+/** Bayes Pro module — tsb analytics library. */
+export interface Bayes proOptions { tol?: number; maxIter?: number; }
+export interface Bayes proResult { values: number[]; converged: boolean; }
+export function computeBayes pro(data: number[], opts: Bayes proOptions = {}): Bayes proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes pro };
diff --git a/src/bayes/robust.ts b/src/bayes/robust.ts
new file mode 100644
index 000000000..030d676a6
--- /dev/null
+++ b/src/bayes/robust.ts
@@ -0,0 +1,15 @@
+/** Bayes Robust module — tsb analytics library. */
+export interface Bayes robustOptions { tol?: number; maxIter?: number; }
+export interface Bayes robustResult { values: number[]; converged: boolean; }
+export function computeBayes robust(data: number[], opts: Bayes robustOptions = {}): Bayes robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes robust };
diff --git a/src/bayes/score_matching.ts b/src/bayes/score_matching.ts
new file mode 100644
index 000000000..4bc77a8a0
--- /dev/null
+++ b/src/bayes/score_matching.ts
@@ -0,0 +1,22 @@
+/** Score Matching module — tsb analytics library. */
+
+/** Options for Score Matching. */
+export interface ScoreMatchingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Score Matching. */
+export interface ScoreMatchingResult { values: number[]; converged: boolean; }
+
+/** Compute Score Matching. */
+export function computeScoreMatching(data: number[], opts: ScoreMatchingOptions = {}): ScoreMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeScoreMatching };
diff --git a/src/bayes/small.ts b/src/bayes/small.ts
new file mode 100644
index 000000000..fa6aef650
--- /dev/null
+++ b/src/bayes/small.ts
@@ -0,0 +1,15 @@
+/** Bayes Small module — tsb analytics library. */
+export interface Bayes smallOptions { tol?: number; maxIter?: number; }
+export interface Bayes smallResult { values: number[]; converged: boolean; }
+export function computeBayes small(data: number[], opts: Bayes smallOptions = {}): Bayes smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes small };
diff --git a/src/bayes/smc.ts b/src/bayes/smc.ts
new file mode 100644
index 000000000..ee89912d8
--- /dev/null
+++ b/src/bayes/smc.ts
@@ -0,0 +1,22 @@
+/** Smc module — tsb analytics library. */
+
+/** Options for Smc. */
+export interface SmcOptions { tol?: number; maxIter?: number; }
+
+/** Result from Smc. */
+export interface SmcResult { values: number[]; converged: boolean; }
+
+/** Compute Smc. */
+export function computeSmc(data: number[], opts: SmcOptions = {}): SmcResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSmc };
diff --git a/src/bayes/sparse.ts b/src/bayes/sparse.ts
new file mode 100644
index 000000000..2fb541e8c
--- /dev/null
+++ b/src/bayes/sparse.ts
@@ -0,0 +1,15 @@
+/** Bayes Sparse module — tsb analytics library. */
+export interface Bayes sparseOptions { tol?: number; maxIter?: number; }
+export interface Bayes sparseResult { values: number[]; converged: boolean; }
+export function computeBayes sparse(data: number[], opts: Bayes sparseOptions = {}): Bayes sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes sparse };
diff --git a/src/bayes/stable.ts b/src/bayes/stable.ts
new file mode 100644
index 000000000..f423bb2df
--- /dev/null
+++ b/src/bayes/stable.ts
@@ -0,0 +1,15 @@
+/** Bayes Stable module — tsb analytics library. */
+export interface Bayes stableOptions { tol?: number; maxIter?: number; }
+export interface Bayes stableResult { values: number[]; converged: boolean; }
+export function computeBayes stable(data: number[], opts: Bayes stableOptions = {}): Bayes stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes stable };
diff --git a/src/bayes/streaming.ts b/src/bayes/streaming.ts
new file mode 100644
index 000000000..5c46ed98a
--- /dev/null
+++ b/src/bayes/streaming.ts
@@ -0,0 +1,15 @@
+/** Bayes Streaming module — tsb analytics library. */
+export interface Bayes streamingOptions { tol?: number; maxIter?: number; }
+export interface Bayes streamingResult { values: number[]; converged: boolean; }
+export function computeBayes streaming(data: number[], opts: Bayes streamingOptions = {}): Bayes streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes streaming };
diff --git a/src/bayes/v2.ts b/src/bayes/v2.ts
new file mode 100644
index 000000000..b09895a5b
--- /dev/null
+++ b/src/bayes/v2.ts
@@ -0,0 +1,15 @@
+/** Bayes V2 module — tsb analytics library. */
+export interface Bayes v2Options { tol?: number; maxIter?: number; }
+export interface Bayes v2Result { values: number[]; converged: boolean; }
+export function computeBayes v2(data: number[], opts: Bayes v2Options = {}): Bayes v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes v2 };
diff --git a/src/bayes/v3.ts b/src/bayes/v3.ts
new file mode 100644
index 000000000..a4464a743
--- /dev/null
+++ b/src/bayes/v3.ts
@@ -0,0 +1,15 @@
+/** Bayes V3 module — tsb analytics library. */
+export interface Bayes v3Options { tol?: number; maxIter?: number; }
+export interface Bayes v3Result { values: number[]; converged: boolean; }
+export function computeBayes v3(data: number[], opts: Bayes v3Options = {}): Bayes v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes v3 };
diff --git a/src/bayes/vae_bayes.ts b/src/bayes/vae_bayes.ts
new file mode 100644
index 000000000..7638ab243
--- /dev/null
+++ b/src/bayes/vae_bayes.ts
@@ -0,0 +1,22 @@
+/** Vae Bayes module — tsb analytics library. */
+
+/** Options for Vae Bayes. */
+export interface VaeBayesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vae Bayes. */
+export interface VaeBayesResult { values: number[]; converged: boolean; }
+
+/** Compute Vae Bayes. */
+export function computeVaeBayes(data: number[], opts: VaeBayesOptions = {}): VaeBayesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVaeBayes };
diff --git a/src/bayes/variational_bayes.ts b/src/bayes/variational_bayes.ts
new file mode 100644
index 000000000..9b8e97bd7
--- /dev/null
+++ b/src/bayes/variational_bayes.ts
@@ -0,0 +1,22 @@
+/** Variational Bayes module — tsb analytics library. */
+
+/** Options for Variational Bayes. */
+export interface VariationalBayesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Variational Bayes. */
+export interface VariationalBayesResult { values: number[]; converged: boolean; }
+
+/** Compute Variational Bayes. */
+export function computeVariationalBayes(data: number[], opts: VariationalBayesOptions = {}): VariationalBayesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVariationalBayes };
diff --git a/src/bayes/wasm.ts b/src/bayes/wasm.ts
new file mode 100644
index 000000000..7b0aae777
--- /dev/null
+++ b/src/bayes/wasm.ts
@@ -0,0 +1,15 @@
+/** Bayes Wasm module — tsb analytics library. */
+export interface Bayes wasmOptions { tol?: number; maxIter?: number; }
+export interface Bayes wasmResult { values: number[]; converged: boolean; }
+export function computeBayes wasm(data: number[], opts: Bayes wasmOptions = {}): Bayes wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes wasm };
diff --git a/src/bayes/xlarge.ts b/src/bayes/xlarge.ts
new file mode 100644
index 000000000..4f0899704
--- /dev/null
+++ b/src/bayes/xlarge.ts
@@ -0,0 +1,15 @@
+/** Bayes Xlarge module — tsb analytics library. */
+export interface Bayes xlargeOptions { tol?: number; maxIter?: number; }
+export interface Bayes xlargeResult { values: number[]; converged: boolean; }
+export function computeBayes xlarge(data: number[], opts: Bayes xlargeOptions = {}): Bayes xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBayes xlarge };
diff --git a/src/bio/admixture.ts b/src/bio/admixture.ts
new file mode 100644
index 000000000..8591c8ccd
--- /dev/null
+++ b/src/bio/admixture.ts
@@ -0,0 +1,22 @@
+/** Admixture module — tsb analytics library. */
+
+/** Options for Admixture. */
+export interface AdmixtureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Admixture. */
+export interface AdmixtureResult { values: number[]; converged: boolean; }
+
+/** Compute Admixture. */
+export function computeAdmixture(data: number[], opts: AdmixtureOptions = {}): AdmixtureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAdmixture };
diff --git a/src/bio/advanced.ts b/src/bio/advanced.ts
new file mode 100644
index 000000000..68cf91856
--- /dev/null
+++ b/src/bio/advanced.ts
@@ -0,0 +1,15 @@
+/** Bio Advanced module — tsb analytics library. */
+export interface Bio advancedOptions { tol?: number; maxIter?: number; }
+export interface Bio advancedResult { values: number[]; converged: boolean; }
+export function computeBio advanced(data: number[], opts: Bio advancedOptions = {}): Bio advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio advanced };
diff --git a/src/bio/alignment.ts b/src/bio/alignment.ts
new file mode 100644
index 000000000..d9072c480
--- /dev/null
+++ b/src/bio/alignment.ts
@@ -0,0 +1,22 @@
+/** Alignment module — tsb analytics library. */
+
+/** Options for Alignment. */
+export interface AlignmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Alignment. */
+export interface AlignmentResult { values: number[]; converged: boolean; }
+
+/** Compute Alignment. */
+export function computeAlignment(data: number[], opts: AlignmentOptions = {}): AlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAlignment };
diff --git a/src/bio/ancestry.ts b/src/bio/ancestry.ts
new file mode 100644
index 000000000..6b787accb
--- /dev/null
+++ b/src/bio/ancestry.ts
@@ -0,0 +1,22 @@
+/** Ancestry module — tsb analytics library. */
+
+/** Options for Ancestry. */
+export interface AncestryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ancestry. */
+export interface AncestryResult { values: number[]; converged: boolean; }
+
+/** Compute Ancestry. */
+export function computeAncestry(data: number[], opts: AncestryOptions = {}): AncestryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAncestry };
diff --git a/src/bio/base2.ts b/src/bio/base2.ts
new file mode 100644
index 000000000..6041b6d31
--- /dev/null
+++ b/src/bio/base2.ts
@@ -0,0 +1,15 @@
+/** Bio Base2 module — tsb analytics library. */
+export interface Bio base2Options { tol?: number; maxIter?: number; }
+export interface Bio base2Result { values: number[]; converged: boolean; }
+export function computeBio base2(data: number[], opts: Bio base2Options = {}): Bio base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio base2 };
diff --git a/src/bio/batch.ts b/src/bio/batch.ts
new file mode 100644
index 000000000..02b400022
--- /dev/null
+++ b/src/bio/batch.ts
@@ -0,0 +1,15 @@
+/** Bio Batch module — tsb analytics library. */
+export interface Bio batchOptions { tol?: number; maxIter?: number; }
+export interface Bio batchResult { values: number[]; converged: boolean; }
+export function computeBio batch(data: number[], opts: Bio batchOptions = {}): Bio batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio batch };
diff --git a/src/bio/bayesian_phylo.ts b/src/bio/bayesian_phylo.ts
new file mode 100644
index 000000000..2cde71fe6
--- /dev/null
+++ b/src/bio/bayesian_phylo.ts
@@ -0,0 +1,22 @@
+/** Bayesian Phylo module — tsb analytics library. */
+
+/** Options for Bayesian Phylo. */
+export interface BayesianPhyloOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bayesian Phylo. */
+export interface BayesianPhyloResult { values: number[]; converged: boolean; }
+
+/** Compute Bayesian Phylo. */
+export function computeBayesianPhylo(data: number[], opts: BayesianPhyloOptions = {}): BayesianPhyloResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBayesianPhylo };
diff --git a/src/bio/beta.ts b/src/bio/beta.ts
new file mode 100644
index 000000000..0cd11e32c
--- /dev/null
+++ b/src/bio/beta.ts
@@ -0,0 +1,15 @@
+/** Bio Beta module — tsb analytics library. */
+export interface Bio betaOptions { tol?: number; maxIter?: number; }
+export interface Bio betaResult { values: number[]; converged: boolean; }
+export function computeBio beta(data: number[], opts: Bio betaOptions = {}): Bio betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio beta };
diff --git a/src/bio/coalescent.ts b/src/bio/coalescent.ts
new file mode 100644
index 000000000..2689ae842
--- /dev/null
+++ b/src/bio/coalescent.ts
@@ -0,0 +1,22 @@
+/** Coalescent module — tsb analytics library. */
+
+/** Options for Coalescent. */
+export interface CoalescentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coalescent. */
+export interface CoalescentResult { values: number[]; converged: boolean; }
+
+/** Compute Coalescent. */
+export function computeCoalescent(data: number[], opts: CoalescentOptions = {}): CoalescentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCoalescent };
diff --git a/src/bio/comparative.ts b/src/bio/comparative.ts
new file mode 100644
index 000000000..8a4490aa8
--- /dev/null
+++ b/src/bio/comparative.ts
@@ -0,0 +1,22 @@
+/** Comparative module — tsb analytics library. */
+
+/** Options for Comparative. */
+export interface ComparativeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Comparative. */
+export interface ComparativeResult { values: number[]; converged: boolean; }
+
+/** Compute Comparative. */
+export function computeComparative(data: number[], opts: ComparativeOptions = {}): ComparativeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeComparative };
diff --git a/src/bio/cpu.ts b/src/bio/cpu.ts
new file mode 100644
index 000000000..597ccdd8f
--- /dev/null
+++ b/src/bio/cpu.ts
@@ -0,0 +1,15 @@
+/** Bio Cpu module — tsb analytics library. */
+export interface Bio cpuOptions { tol?: number; maxIter?: number; }
+export interface Bio cpuResult { values: number[]; converged: boolean; }
+export function computeBio cpu(data: number[], opts: Bio cpuOptions = {}): Bio cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio cpu };
diff --git a/src/bio/demography_bio.ts b/src/bio/demography_bio.ts
new file mode 100644
index 000000000..02db6f65a
--- /dev/null
+++ b/src/bio/demography_bio.ts
@@ -0,0 +1,22 @@
+/** Demography Bio module — tsb analytics library. */
+
+/** Options for Demography Bio. */
+export interface DemographyBioOptions { tol?: number; maxIter?: number; }
+
+/** Result from Demography Bio. */
+export interface DemographyBioResult { values: number[]; converged: boolean; }
+
+/** Compute Demography Bio. */
+export function computeDemographyBio(data: number[], opts: DemographyBioOptions = {}): DemographyBioResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDemographyBio };
diff --git a/src/bio/dense.ts b/src/bio/dense.ts
new file mode 100644
index 000000000..aaa5487c1
--- /dev/null
+++ b/src/bio/dense.ts
@@ -0,0 +1,15 @@
+/** Bio Dense module — tsb analytics library. */
+export interface Bio denseOptions { tol?: number; maxIter?: number; }
+export interface Bio denseResult { values: number[]; converged: boolean; }
+export function computeBio dense(data: number[], opts: Bio denseOptions = {}): Bio denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio dense };
diff --git a/src/bio/distributed.ts b/src/bio/distributed.ts
new file mode 100644
index 000000000..0817ed309
--- /dev/null
+++ b/src/bio/distributed.ts
@@ -0,0 +1,15 @@
+/** Bio Distributed module — tsb analytics library. */
+export interface Bio distributedOptions { tol?: number; maxIter?: number; }
+export interface Bio distributedResult { values: number[]; converged: boolean; }
+export function computeBio distributed(data: number[], opts: Bio distributedOptions = {}): Bio distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio distributed };
diff --git a/src/bio/docking.ts b/src/bio/docking.ts
new file mode 100644
index 000000000..f2850a1b5
--- /dev/null
+++ b/src/bio/docking.ts
@@ -0,0 +1,22 @@
+/** Docking module — tsb analytics library. */
+
+/** Options for Docking. */
+export interface DockingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Docking. */
+export interface DockingResult { values: number[]; converged: boolean; }
+
+/** Compute Docking. */
+export function computeDocking(data: number[], opts: DockingOptions = {}): DockingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDocking };
diff --git a/src/bio/eqtl.ts b/src/bio/eqtl.ts
new file mode 100644
index 000000000..c224b9d6d
--- /dev/null
+++ b/src/bio/eqtl.ts
@@ -0,0 +1,22 @@
+/** Eqtl module — tsb analytics library. */
+
+/** Options for Eqtl. */
+export interface EqtlOptions { tol?: number; maxIter?: number; }
+
+/** Result from Eqtl. */
+export interface EqtlResult { values: number[]; converged: boolean; }
+
+/** Compute Eqtl. */
+export function computeEqtl(data: number[], opts: EqtlOptions = {}): EqtlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEqtl };
diff --git a/src/bio/experimental.ts b/src/bio/experimental.ts
new file mode 100644
index 000000000..08a2f51f7
--- /dev/null
+++ b/src/bio/experimental.ts
@@ -0,0 +1,15 @@
+/** Bio Experimental module — tsb analytics library. */
+export interface Bio experimentalOptions { tol?: number; maxIter?: number; }
+export interface Bio experimentalResult { values: number[]; converged: boolean; }
+export function computeBio experimental(data: number[], opts: Bio experimentalOptions = {}): Bio experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio experimental };
diff --git a/src/bio/expression.ts b/src/bio/expression.ts
new file mode 100644
index 000000000..001df1cd9
--- /dev/null
+++ b/src/bio/expression.ts
@@ -0,0 +1,22 @@
+/** Expression module — tsb analytics library. */
+
+/** Options for Expression. */
+export interface ExpressionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Expression. */
+export interface ExpressionResult { values: number[]; converged: boolean; }
+
+/** Compute Expression. */
+export function computeExpression(data: number[], opts: ExpressionOptions = {}): ExpressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExpression };
diff --git a/src/bio/fast.ts b/src/bio/fast.ts
new file mode 100644
index 000000000..d1c7da8e5
--- /dev/null
+++ b/src/bio/fast.ts
@@ -0,0 +1,15 @@
+/** Bio Fast module — tsb analytics library. */
+export interface Bio fastOptions { tol?: number; maxIter?: number; }
+export interface Bio fastResult { values: number[]; converged: boolean; }
+export function computeBio fast(data: number[], opts: Bio fastOptions = {}): Bio fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio fast };
diff --git a/src/bio/folding.ts b/src/bio/folding.ts
new file mode 100644
index 000000000..e54b3c360
--- /dev/null
+++ b/src/bio/folding.ts
@@ -0,0 +1,22 @@
+/** Folding module — tsb analytics library. */
+
+/** Options for Folding. */
+export interface FoldingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Folding. */
+export interface FoldingResult { values: number[]; converged: boolean; }
+
+/** Compute Folding. */
+export function computeFolding(data: number[], opts: FoldingOptions = {}): FoldingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFolding };
diff --git a/src/bio/functional.ts b/src/bio/functional.ts
new file mode 100644
index 000000000..d5ed05e47
--- /dev/null
+++ b/src/bio/functional.ts
@@ -0,0 +1,22 @@
+/** Functional module — tsb analytics library. */
+
+/** Options for Functional. */
+export interface FunctionalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Functional. */
+export interface FunctionalResult { values: number[]; converged: boolean; }
+
+/** Compute Functional. */
+export function computeFunctional(data: number[], opts: FunctionalOptions = {}): FunctionalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFunctional };
diff --git a/src/bio/future.ts b/src/bio/future.ts
new file mode 100644
index 000000000..ffd18bb60
--- /dev/null
+++ b/src/bio/future.ts
@@ -0,0 +1,15 @@
+/** Bio Future module — tsb analytics library. */
+export interface Bio futureOptions { tol?: number; maxIter?: number; }
+export interface Bio futureResult { values: number[]; converged: boolean; }
+export function computeBio future(data: number[], opts: Bio futureOptions = {}): Bio futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio future };
diff --git a/src/bio/genome.ts b/src/bio/genome.ts
new file mode 100644
index 000000000..c3879cd59
--- /dev/null
+++ b/src/bio/genome.ts
@@ -0,0 +1,22 @@
+/** Genome module — tsb analytics library. */
+
+/** Options for Genome. */
+export interface GenomeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Genome. */
+export interface GenomeResult { values: number[]; converged: boolean; }
+
+/** Compute Genome. */
+export function computeGenome(data: number[], opts: GenomeOptions = {}): GenomeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGenome };
diff --git a/src/bio/gpu.ts b/src/bio/gpu.ts
new file mode 100644
index 000000000..652afde2b
--- /dev/null
+++ b/src/bio/gpu.ts
@@ -0,0 +1,15 @@
+/** Bio Gpu module — tsb analytics library. */
+export interface Bio gpuOptions { tol?: number; maxIter?: number; }
+export interface Bio gpuResult { values: number[]; converged: boolean; }
+export function computeBio gpu(data: number[], opts: Bio gpuOptions = {}): Bio gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio gpu };
diff --git a/src/bio/gwas.ts b/src/bio/gwas.ts
new file mode 100644
index 000000000..56ec19ad0
--- /dev/null
+++ b/src/bio/gwas.ts
@@ -0,0 +1,22 @@
+/** Gwas module — tsb analytics library. */
+
+/** Options for Gwas. */
+export interface GwasOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gwas. */
+export interface GwasResult { values: number[]; converged: boolean; }
+
+/** Compute Gwas. */
+export function computeGwas(data: number[], opts: GwasOptions = {}): GwasResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGwas };
diff --git a/src/bio/imputation.ts b/src/bio/imputation.ts
new file mode 100644
index 000000000..41014255e
--- /dev/null
+++ b/src/bio/imputation.ts
@@ -0,0 +1,22 @@
+/** Imputation module — tsb analytics library. */
+
+/** Options for Imputation. */
+export interface ImputationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Imputation. */
+export interface ImputationResult { values: number[]; converged: boolean; }
+
+/** Compute Imputation. */
+export function computeImputation(data: number[], opts: ImputationOptions = {}): ImputationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeImputation };
diff --git a/src/bio/large.ts b/src/bio/large.ts
new file mode 100644
index 000000000..93c7ef567
--- /dev/null
+++ b/src/bio/large.ts
@@ -0,0 +1,15 @@
+/** Bio Large module — tsb analytics library. */
+export interface Bio largeOptions { tol?: number; maxIter?: number; }
+export interface Bio largeResult { values: number[]; converged: boolean; }
+export function computeBio large(data: number[], opts: Bio largeOptions = {}): Bio largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio large };
diff --git a/src/bio/legacy.ts b/src/bio/legacy.ts
new file mode 100644
index 000000000..ce7f81ab6
--- /dev/null
+++ b/src/bio/legacy.ts
@@ -0,0 +1,15 @@
+/** Bio Legacy module — tsb analytics library. */
+export interface Bio legacyOptions { tol?: number; maxIter?: number; }
+export interface Bio legacyResult { values: number[]; converged: boolean; }
+export function computeBio legacy(data: number[], opts: Bio legacyOptions = {}): Bio legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio legacy };
diff --git a/src/bio/lite.ts b/src/bio/lite.ts
new file mode 100644
index 000000000..acab1c5ec
--- /dev/null
+++ b/src/bio/lite.ts
@@ -0,0 +1,15 @@
+/** Bio Lite module — tsb analytics library. */
+export interface Bio liteOptions { tol?: number; maxIter?: number; }
+export interface Bio liteResult { values: number[]; converged: boolean; }
+export function computeBio lite(data: number[], opts: Bio liteOptions = {}): Bio liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio lite };
diff --git a/src/bio/metabolomics.ts b/src/bio/metabolomics.ts
new file mode 100644
index 000000000..599e7880a
--- /dev/null
+++ b/src/bio/metabolomics.ts
@@ -0,0 +1,22 @@
+/** Metabolomics module — tsb analytics library. */
+
+/** Options for Metabolomics. */
+export interface MetabolomicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Metabolomics. */
+export interface MetabolomicsResult { values: number[]; converged: boolean; }
+
+/** Compute Metabolomics. */
+export function computeMetabolomics(data: number[], opts: MetabolomicsOptions = {}): MetabolomicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMetabolomics };
diff --git a/src/bio/migration.ts b/src/bio/migration.ts
new file mode 100644
index 000000000..4b3a750e0
--- /dev/null
+++ b/src/bio/migration.ts
@@ -0,0 +1,22 @@
+/** Migration module — tsb analytics library. */
+
+/** Options for Migration. */
+export interface MigrationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Migration. */
+export interface MigrationResult { values: number[]; converged: boolean; }
+
+/** Compute Migration. */
+export function computeMigration(data: number[], opts: MigrationOptions = {}): MigrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMigration };
diff --git a/src/bio/mini.ts b/src/bio/mini.ts
new file mode 100644
index 000000000..7d3bea7c4
--- /dev/null
+++ b/src/bio/mini.ts
@@ -0,0 +1,15 @@
+/** Bio Mini module — tsb analytics library. */
+export interface Bio miniOptions { tol?: number; maxIter?: number; }
+export interface Bio miniResult { values: number[]; converged: boolean; }
+export function computeBio mini(data: number[], opts: Bio miniOptions = {}): Bio miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio mini };
diff --git a/src/bio/next.ts b/src/bio/next.ts
new file mode 100644
index 000000000..fd626de49
--- /dev/null
+++ b/src/bio/next.ts
@@ -0,0 +1,15 @@
+/** Bio Next module — tsb analytics library. */
+export interface Bio nextOptions { tol?: number; maxIter?: number; }
+export interface Bio nextResult { values: number[]; converged: boolean; }
+export function computeBio next(data: number[], opts: Bio nextOptions = {}): Bio nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio next };
diff --git a/src/bio/online.ts b/src/bio/online.ts
new file mode 100644
index 000000000..0648332c5
--- /dev/null
+++ b/src/bio/online.ts
@@ -0,0 +1,15 @@
+/** Bio Online module — tsb analytics library. */
+export interface Bio onlineOptions { tol?: number; maxIter?: number; }
+export interface Bio onlineResult { values: number[]; converged: boolean; }
+export function computeBio online(data: number[], opts: Bio onlineOptions = {}): Bio onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio online };
diff --git a/src/bio/ontology.ts b/src/bio/ontology.ts
new file mode 100644
index 000000000..2fb2c89cd
--- /dev/null
+++ b/src/bio/ontology.ts
@@ -0,0 +1,22 @@
+/** Ontology module — tsb analytics library. */
+
+/** Options for Ontology. */
+export interface OntologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ontology. */
+export interface OntologyResult { values: number[]; converged: boolean; }
+
+/** Compute Ontology. */
+export function computeOntology(data: number[], opts: OntologyOptions = {}): OntologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOntology };
diff --git a/src/bio/parallel.ts b/src/bio/parallel.ts
new file mode 100644
index 000000000..574eab73b
--- /dev/null
+++ b/src/bio/parallel.ts
@@ -0,0 +1,15 @@
+/** Bio Parallel module — tsb analytics library. */
+export interface Bio parallelOptions { tol?: number; maxIter?: number; }
+export interface Bio parallelResult { values: number[]; converged: boolean; }
+export function computeBio parallel(data: number[], opts: Bio parallelOptions = {}): Bio parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio parallel };
diff --git a/src/bio/pathway.ts b/src/bio/pathway.ts
new file mode 100644
index 000000000..343cb312e
--- /dev/null
+++ b/src/bio/pathway.ts
@@ -0,0 +1,22 @@
+/** Pathway module — tsb analytics library. */
+
+/** Options for Pathway. */
+export interface PathwayOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pathway. */
+export interface PathwayResult { values: number[]; converged: boolean; }
+
+/** Compute Pathway. */
+export function computePathway(data: number[], opts: PathwayOptions = {}): PathwayResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePathway };
diff --git a/src/bio/phylogenetics.ts b/src/bio/phylogenetics.ts
new file mode 100644
index 000000000..88b124fc7
--- /dev/null
+++ b/src/bio/phylogenetics.ts
@@ -0,0 +1,22 @@
+/** Phylogenetics module — tsb analytics library. */
+
+/** Options for Phylogenetics. */
+export interface PhylogeneticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Phylogenetics. */
+export interface PhylogeneticsResult { values: number[]; converged: boolean; }
+
+/** Compute Phylogenetics. */
+export function computePhylogenetics(data: number[], opts: PhylogeneticsOptions = {}): PhylogeneticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhylogenetics };
diff --git a/src/bio/plus.ts b/src/bio/plus.ts
new file mode 100644
index 000000000..0dd830266
--- /dev/null
+++ b/src/bio/plus.ts
@@ -0,0 +1,15 @@
+/** Bio Plus module — tsb analytics library. */
+export interface Bio plusOptions { tol?: number; maxIter?: number; }
+export interface Bio plusResult { values: number[]; converged: boolean; }
+export function computeBio plus(data: number[], opts: Bio plusOptions = {}): Bio plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio plus };
diff --git a/src/bio/pro.ts b/src/bio/pro.ts
new file mode 100644
index 000000000..13d0b8619
--- /dev/null
+++ b/src/bio/pro.ts
@@ -0,0 +1,15 @@
+/** Bio Pro module — tsb analytics library. */
+export interface Bio proOptions { tol?: number; maxIter?: number; }
+export interface Bio proResult { values: number[]; converged: boolean; }
+export function computeBio pro(data: number[], opts: Bio proOptions = {}): Bio proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio pro };
diff --git a/src/bio/protein.ts b/src/bio/protein.ts
new file mode 100644
index 000000000..c6995339e
--- /dev/null
+++ b/src/bio/protein.ts
@@ -0,0 +1,22 @@
+/** Protein module — tsb analytics library. */
+
+/** Options for Protein. */
+export interface ProteinOptions { tol?: number; maxIter?: number; }
+
+/** Result from Protein. */
+export interface ProteinResult { values: number[]; converged: boolean; }
+
+/** Compute Protein. */
+export function computeProtein(data: number[], opts: ProteinOptions = {}): ProteinResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProtein };
diff --git a/src/bio/proteomics.ts b/src/bio/proteomics.ts
new file mode 100644
index 000000000..674f243ef
--- /dev/null
+++ b/src/bio/proteomics.ts
@@ -0,0 +1,22 @@
+/** Proteomics module — tsb analytics library. */
+
+/** Options for Proteomics. */
+export interface ProteomicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Proteomics. */
+export interface ProteomicsResult { values: number[]; converged: boolean; }
+
+/** Compute Proteomics. */
+export function computeProteomics(data: number[], opts: ProteomicsOptions = {}): ProteomicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProteomics };
diff --git a/src/bio/prs.ts b/src/bio/prs.ts
new file mode 100644
index 000000000..69d32e0f7
--- /dev/null
+++ b/src/bio/prs.ts
@@ -0,0 +1,22 @@
+/** Prs module — tsb analytics library. */
+
+/** Options for Prs. */
+export interface PrsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Prs. */
+export interface PrsResult { values: number[]; converged: boolean; }
+
+/** Compute Prs. */
+export function computePrs(data: number[], opts: PrsOptions = {}): PrsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrs };
diff --git a/src/bio/qtl.ts b/src/bio/qtl.ts
new file mode 100644
index 000000000..1cfd400eb
--- /dev/null
+++ b/src/bio/qtl.ts
@@ -0,0 +1,22 @@
+/** Qtl module — tsb analytics library. */
+
+/** Options for Qtl. */
+export interface QtlOptions { tol?: number; maxIter?: number; }
+
+/** Result from Qtl. */
+export interface QtlResult { values: number[]; converged: boolean; }
+
+/** Compute Qtl. */
+export function computeQtl(data: number[], opts: QtlOptions = {}): QtlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQtl };
diff --git a/src/bio/robust.ts b/src/bio/robust.ts
new file mode 100644
index 000000000..5d83e0052
--- /dev/null
+++ b/src/bio/robust.ts
@@ -0,0 +1,15 @@
+/** Bio Robust module — tsb analytics library. */
+export interface Bio robustOptions { tol?: number; maxIter?: number; }
+export interface Bio robustResult { values: number[]; converged: boolean; }
+export function computeBio robust(data: number[], opts: Bio robustOptions = {}): Bio robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio robust };
diff --git a/src/bio/selection.ts b/src/bio/selection.ts
new file mode 100644
index 000000000..162f83f29
--- /dev/null
+++ b/src/bio/selection.ts
@@ -0,0 +1,22 @@
+/** Selection module — tsb analytics library. */
+
+/** Options for Selection. */
+export interface SelectionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Selection. */
+export interface SelectionResult { values: number[]; converged: boolean; }
+
+/** Compute Selection. */
+export function computeSelection(data: number[], opts: SelectionOptions = {}): SelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSelection };
diff --git a/src/bio/sequence.ts b/src/bio/sequence.ts
new file mode 100644
index 000000000..3472f1aed
--- /dev/null
+++ b/src/bio/sequence.ts
@@ -0,0 +1,22 @@
+/** Sequence module — tsb analytics library. */
+
+/** Options for Sequence. */
+export interface SequenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sequence. */
+export interface SequenceResult { values: number[]; converged: boolean; }
+
+/** Compute Sequence. */
+export function computeSequence(data: number[], opts: SequenceOptions = {}): SequenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSequence };
diff --git a/src/bio/small.ts b/src/bio/small.ts
new file mode 100644
index 000000000..7cbae3078
--- /dev/null
+++ b/src/bio/small.ts
@@ -0,0 +1,15 @@
+/** Bio Small module — tsb analytics library. */
+export interface Bio smallOptions { tol?: number; maxIter?: number; }
+export interface Bio smallResult { values: number[]; converged: boolean; }
+export function computeBio small(data: number[], opts: Bio smallOptions = {}): Bio smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio small };
diff --git a/src/bio/snp.ts b/src/bio/snp.ts
new file mode 100644
index 000000000..236e506fa
--- /dev/null
+++ b/src/bio/snp.ts
@@ -0,0 +1,22 @@
+/** Snp module — tsb analytics library. */
+
+/** Options for Snp. */
+export interface SnpOptions { tol?: number; maxIter?: number; }
+
+/** Result from Snp. */
+export interface SnpResult { values: number[]; converged: boolean; }
+
+/** Compute Snp. */
+export function computeSnp(data: number[], opts: SnpOptions = {}): SnpResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSnp };
diff --git a/src/bio/sparse.ts b/src/bio/sparse.ts
new file mode 100644
index 000000000..53ed78386
--- /dev/null
+++ b/src/bio/sparse.ts
@@ -0,0 +1,15 @@
+/** Bio Sparse module — tsb analytics library. */
+export interface Bio sparseOptions { tol?: number; maxIter?: number; }
+export interface Bio sparseResult { values: number[]; converged: boolean; }
+export function computeBio sparse(data: number[], opts: Bio sparseOptions = {}): Bio sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio sparse };
diff --git a/src/bio/stable.ts b/src/bio/stable.ts
new file mode 100644
index 000000000..a954af285
--- /dev/null
+++ b/src/bio/stable.ts
@@ -0,0 +1,15 @@
+/** Bio Stable module — tsb analytics library. */
+export interface Bio stableOptions { tol?: number; maxIter?: number; }
+export interface Bio stableResult { values: number[]; converged: boolean; }
+export function computeBio stable(data: number[], opts: Bio stableOptions = {}): Bio stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio stable };
diff --git a/src/bio/streaming.ts b/src/bio/streaming.ts
new file mode 100644
index 000000000..a0e3e2509
--- /dev/null
+++ b/src/bio/streaming.ts
@@ -0,0 +1,15 @@
+/** Bio Streaming module — tsb analytics library. */
+export interface Bio streamingOptions { tol?: number; maxIter?: number; }
+export interface Bio streamingResult { values: number[]; converged: boolean; }
+export function computeBio streaming(data: number[], opts: Bio streamingOptions = {}): Bio streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio streaming };
diff --git a/src/bio/structure.ts b/src/bio/structure.ts
new file mode 100644
index 000000000..162813c5c
--- /dev/null
+++ b/src/bio/structure.ts
@@ -0,0 +1,22 @@
+/** Structure module — tsb analytics library. */
+
+/** Options for Structure. */
+export interface StructureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Structure. */
+export interface StructureResult { values: number[]; converged: boolean; }
+
+/** Compute Structure. */
+export function computeStructure(data: number[], opts: StructureOptions = {}): StructureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStructure };
diff --git a/src/bio/transcriptomics.ts b/src/bio/transcriptomics.ts
new file mode 100644
index 000000000..505f52ff0
--- /dev/null
+++ b/src/bio/transcriptomics.ts
@@ -0,0 +1,22 @@
+/** Transcriptomics module — tsb analytics library. */
+
+/** Options for Transcriptomics. */
+export interface TranscriptomicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Transcriptomics. */
+export interface TranscriptomicsResult { values: number[]; converged: boolean; }
+
+/** Compute Transcriptomics. */
+export function computeTranscriptomics(data: number[], opts: TranscriptomicsOptions = {}): TranscriptomicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTranscriptomics };
diff --git a/src/bio/v2.ts b/src/bio/v2.ts
new file mode 100644
index 000000000..26def4442
--- /dev/null
+++ b/src/bio/v2.ts
@@ -0,0 +1,15 @@
+/** Bio V2 module — tsb analytics library. */
+export interface Bio v2Options { tol?: number; maxIter?: number; }
+export interface Bio v2Result { values: number[]; converged: boolean; }
+export function computeBio v2(data: number[], opts: Bio v2Options = {}): Bio v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio v2 };
diff --git a/src/bio/v3.ts b/src/bio/v3.ts
new file mode 100644
index 000000000..aecb29a22
--- /dev/null
+++ b/src/bio/v3.ts
@@ -0,0 +1,15 @@
+/** Bio V3 module — tsb analytics library. */
+export interface Bio v3Options { tol?: number; maxIter?: number; }
+export interface Bio v3Result { values: number[]; converged: boolean; }
+export function computeBio v3(data: number[], opts: Bio v3Options = {}): Bio v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio v3 };
diff --git a/src/bio/variant.ts b/src/bio/variant.ts
new file mode 100644
index 000000000..dfaac5633
--- /dev/null
+++ b/src/bio/variant.ts
@@ -0,0 +1,22 @@
+/** Variant module — tsb analytics library. */
+
+/** Options for Variant. */
+export interface VariantOptions { tol?: number; maxIter?: number; }
+
+/** Result from Variant. */
+export interface VariantResult { values: number[]; converged: boolean; }
+
+/** Compute Variant. */
+export function computeVariant(data: number[], opts: VariantOptions = {}): VariantResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVariant };
diff --git a/src/bio/wasm.ts b/src/bio/wasm.ts
new file mode 100644
index 000000000..cd659303e
--- /dev/null
+++ b/src/bio/wasm.ts
@@ -0,0 +1,15 @@
+/** Bio Wasm module — tsb analytics library. */
+export interface Bio wasmOptions { tol?: number; maxIter?: number; }
+export interface Bio wasmResult { values: number[]; converged: boolean; }
+export function computeBio wasm(data: number[], opts: Bio wasmOptions = {}): Bio wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio wasm };
diff --git a/src/bio/xlarge.ts b/src/bio/xlarge.ts
new file mode 100644
index 000000000..d050d3656
--- /dev/null
+++ b/src/bio/xlarge.ts
@@ -0,0 +1,15 @@
+/** Bio Xlarge module — tsb analytics library. */
+export interface Bio xlargeOptions { tol?: number; maxIter?: number; }
+export interface Bio xlargeResult { values: number[]; converged: boolean; }
+export function computeBio xlarge(data: number[], opts: Bio xlargeOptions = {}): Bio xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBio xlarge };
diff --git a/src/biochemistry_sci/adaptation.ts b/src/biochemistry_sci/adaptation.ts
new file mode 100644
index 000000000..801d96318
--- /dev/null
+++ b/src/biochemistry_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci adaptation module — tsb analytics library. */
+export interface BiochemistrySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciAdaptation(data: number[], opts: BiochemistrySciAdaptationOptions = {}): BiochemistrySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciAdaptation };
diff --git a/src/biochemistry_sci/aggregation.ts b/src/biochemistry_sci/aggregation.ts
new file mode 100644
index 000000000..5b130472e
--- /dev/null
+++ b/src/biochemistry_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci aggregation module — tsb analytics library. */
+export interface BiochemistrySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciAggregationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciAggregation(data: number[], opts: BiochemistrySciAggregationOptions = {}): BiochemistrySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciAggregation };
diff --git a/src/biochemistry_sci/algebra.ts b/src/biochemistry_sci/algebra.ts
new file mode 100644
index 000000000..4f2a59abf
--- /dev/null
+++ b/src/biochemistry_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci algebra module — tsb analytics library. */
+export interface BiochemistrySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciAlgebra(data: number[], opts: BiochemistrySciAlgebraOptions = {}): BiochemistrySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciAlgebra };
diff --git a/src/biochemistry_sci/alignment.ts b/src/biochemistry_sci/alignment.ts
new file mode 100644
index 000000000..8feacd4da
--- /dev/null
+++ b/src/biochemistry_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci alignment module — tsb analytics library. */
+export interface BiochemistrySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciAlignment(data: number[], opts: BiochemistrySciAlignmentOptions = {}): BiochemistrySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciAlignment };
diff --git a/src/biochemistry_sci/analysis.ts b/src/biochemistry_sci/analysis.ts
new file mode 100644
index 000000000..ce251332c
--- /dev/null
+++ b/src/biochemistry_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci analysis module — tsb analytics library. */
+export interface BiochemistrySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciAnalysis(data: number[], opts: BiochemistrySciAnalysisOptions = {}): BiochemistrySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciAnalysis };
diff --git a/src/biochemistry_sci/augmentation.ts b/src/biochemistry_sci/augmentation.ts
new file mode 100644
index 000000000..fa15058b7
--- /dev/null
+++ b/src/biochemistry_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci augmentation module — tsb analytics library. */
+export interface BiochemistrySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciAugmentation(data: number[], opts: BiochemistrySciAugmentationOptions = {}): BiochemistrySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciAugmentation };
diff --git a/src/biochemistry_sci/bagging.ts b/src/biochemistry_sci/bagging.ts
new file mode 100644
index 000000000..cd0a81998
--- /dev/null
+++ b/src/biochemistry_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci bagging module — tsb analytics library. */
+export interface BiochemistrySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciBaggingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciBagging(data: number[], opts: BiochemistrySciBaggingOptions = {}): BiochemistrySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciBagging };
diff --git a/src/biochemistry_sci/basis.ts b/src/biochemistry_sci/basis.ts
new file mode 100644
index 000000000..2ae4ab5c8
--- /dev/null
+++ b/src/biochemistry_sci/basis.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci basis module — tsb analytics library. */
+export interface BiochemistrySciBasisOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciBasisResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciBasis(data: number[], opts: BiochemistrySciBasisOptions = {}): BiochemistrySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciBasis };
diff --git a/src/biochemistry_sci/benchmarking.ts b/src/biochemistry_sci/benchmarking.ts
new file mode 100644
index 000000000..ff3d2cf97
--- /dev/null
+++ b/src/biochemistry_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci benchmarking module — tsb analytics library. */
+export interface BiochemistrySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciBenchmarking(data: number[], opts: BiochemistrySciBenchmarkingOptions = {}): BiochemistrySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciBenchmarking };
diff --git a/src/biochemistry_sci/blending.ts b/src/biochemistry_sci/blending.ts
new file mode 100644
index 000000000..bcc6d3071
--- /dev/null
+++ b/src/biochemistry_sci/blending.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci blending module — tsb analytics library. */
+export interface BiochemistrySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciBlendingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciBlending(data: number[], opts: BiochemistrySciBlendingOptions = {}): BiochemistrySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciBlending };
diff --git a/src/biochemistry_sci/boosting.ts b/src/biochemistry_sci/boosting.ts
new file mode 100644
index 000000000..cfd7efac2
--- /dev/null
+++ b/src/biochemistry_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci boosting module — tsb analytics library. */
+export interface BiochemistrySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciBoostingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciBoosting(data: number[], opts: BiochemistrySciBoostingOptions = {}): BiochemistrySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciBoosting };
diff --git a/src/biochemistry_sci/bootstrap.ts b/src/biochemistry_sci/bootstrap.ts
new file mode 100644
index 000000000..2853bdf91
--- /dev/null
+++ b/src/biochemistry_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci bootstrap module — tsb analytics library. */
+export interface BiochemistrySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciBootstrap(data: number[], opts: BiochemistrySciBootstrapOptions = {}): BiochemistrySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciBootstrap };
diff --git a/src/biochemistry_sci/calculus.ts b/src/biochemistry_sci/calculus.ts
new file mode 100644
index 000000000..9ef246fce
--- /dev/null
+++ b/src/biochemistry_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci calculus module — tsb analytics library. */
+export interface BiochemistrySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciCalculusResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciCalculus(data: number[], opts: BiochemistrySciCalculusOptions = {}): BiochemistrySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciCalculus };
diff --git a/src/biochemistry_sci/calibration.ts b/src/biochemistry_sci/calibration.ts
new file mode 100644
index 000000000..8bd7ca89f
--- /dev/null
+++ b/src/biochemistry_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci calibration module — tsb analytics library. */
+export interface BiochemistrySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciCalibration(data: number[], opts: BiochemistrySciCalibrationOptions = {}): BiochemistrySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciCalibration };
diff --git a/src/biochemistry_sci/characterization.ts b/src/biochemistry_sci/characterization.ts
new file mode 100644
index 000000000..de81e56c9
--- /dev/null
+++ b/src/biochemistry_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci characterization module — tsb analytics library. */
+export interface BiochemistrySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciCharacterization(data: number[], opts: BiochemistrySciCharacterizationOptions = {}): BiochemistrySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciCharacterization };
diff --git a/src/biochemistry_sci/classification.ts b/src/biochemistry_sci/classification.ts
new file mode 100644
index 000000000..b3fbd81ef
--- /dev/null
+++ b/src/biochemistry_sci/classification.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci classification module — tsb analytics library. */
+export interface BiochemistrySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciClassificationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciClassification(data: number[], opts: BiochemistrySciClassificationOptions = {}): BiochemistrySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciClassification };
diff --git a/src/biochemistry_sci/clustering.ts b/src/biochemistry_sci/clustering.ts
new file mode 100644
index 000000000..db81d9d02
--- /dev/null
+++ b/src/biochemistry_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci clustering module — tsb analytics library. */
+export interface BiochemistrySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciClusteringResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciClustering(data: number[], opts: BiochemistrySciClusteringOptions = {}): BiochemistrySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciClustering };
diff --git a/src/biochemistry_sci/compression.ts b/src/biochemistry_sci/compression.ts
new file mode 100644
index 000000000..23eec74e3
--- /dev/null
+++ b/src/biochemistry_sci/compression.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci compression module — tsb analytics library. */
+export interface BiochemistrySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciCompressionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciCompression(data: number[], opts: BiochemistrySciCompressionOptions = {}): BiochemistrySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciCompression };
diff --git a/src/biochemistry_sci/continuous.ts b/src/biochemistry_sci/continuous.ts
new file mode 100644
index 000000000..7e8c21d69
--- /dev/null
+++ b/src/biochemistry_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci continuous module — tsb analytics library. */
+export interface BiochemistrySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciContinuousResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciContinuous(data: number[], opts: BiochemistrySciContinuousOptions = {}): BiochemistrySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciContinuous };
diff --git a/src/biochemistry_sci/control.ts b/src/biochemistry_sci/control.ts
new file mode 100644
index 000000000..2141445ae
--- /dev/null
+++ b/src/biochemistry_sci/control.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci control module — tsb analytics library. */
+export interface BiochemistrySciControlOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciControlResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciControl(data: number[], opts: BiochemistrySciControlOptions = {}): BiochemistrySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciControl };
diff --git a/src/biochemistry_sci/convergence.ts b/src/biochemistry_sci/convergence.ts
new file mode 100644
index 000000000..acc577202
--- /dev/null
+++ b/src/biochemistry_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci convergence module — tsb analytics library. */
+export interface BiochemistrySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciConvergence(data: number[], opts: BiochemistrySciConvergenceOptions = {}): BiochemistrySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciConvergence };
diff --git a/src/biochemistry_sci/convex.ts b/src/biochemistry_sci/convex.ts
new file mode 100644
index 000000000..d1bc34000
--- /dev/null
+++ b/src/biochemistry_sci/convex.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci convex module — tsb analytics library. */
+export interface BiochemistrySciConvexOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciConvexResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciConvex(data: number[], opts: BiochemistrySciConvexOptions = {}): BiochemistrySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciConvex };
diff --git a/src/biochemistry_sci/correlation.ts b/src/biochemistry_sci/correlation.ts
new file mode 100644
index 000000000..59c67f4e9
--- /dev/null
+++ b/src/biochemistry_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci correlation module — tsb analytics library. */
+export interface BiochemistrySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciCorrelation(data: number[], opts: BiochemistrySciCorrelationOptions = {}): BiochemistrySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciCorrelation };
diff --git a/src/biochemistry_sci/covariance.ts b/src/biochemistry_sci/covariance.ts
new file mode 100644
index 000000000..9c86022e1
--- /dev/null
+++ b/src/biochemistry_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci covariance module — tsb analytics library. */
+export interface BiochemistrySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciCovariance(data: number[], opts: BiochemistrySciCovarianceOptions = {}): BiochemistrySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciCovariance };
diff --git a/src/biochemistry_sci/cross_validation.ts b/src/biochemistry_sci/cross_validation.ts
new file mode 100644
index 000000000..f4cd77dc6
--- /dev/null
+++ b/src/biochemistry_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci cross_validation module — tsb analytics library. */
+export interface BiochemistrySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciCrossValidation(data: number[], opts: BiochemistrySciCrossValidationOptions = {}): BiochemistrySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciCrossValidation };
diff --git a/src/biochemistry_sci/decoding.ts b/src/biochemistry_sci/decoding.ts
new file mode 100644
index 000000000..453e8f6ec
--- /dev/null
+++ b/src/biochemistry_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci decoding module — tsb analytics library. */
+export interface BiochemistrySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDecodingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDecoding(data: number[], opts: BiochemistrySciDecodingOptions = {}): BiochemistrySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDecoding };
diff --git a/src/biochemistry_sci/decomposition.ts b/src/biochemistry_sci/decomposition.ts
new file mode 100644
index 000000000..8056b67cb
--- /dev/null
+++ b/src/biochemistry_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci decomposition module — tsb analytics library. */
+export interface BiochemistrySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDecomposition(data: number[], opts: BiochemistrySciDecompositionOptions = {}): BiochemistrySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDecomposition };
diff --git a/src/biochemistry_sci/detection.ts b/src/biochemistry_sci/detection.ts
new file mode 100644
index 000000000..f3ce77478
--- /dev/null
+++ b/src/biochemistry_sci/detection.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci detection module — tsb analytics library. */
+export interface BiochemistrySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDetectionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDetection(data: number[], opts: BiochemistrySciDetectionOptions = {}): BiochemistrySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDetection };
diff --git a/src/biochemistry_sci/deterministic.ts b/src/biochemistry_sci/deterministic.ts
new file mode 100644
index 000000000..ef059813f
--- /dev/null
+++ b/src/biochemistry_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci deterministic module — tsb analytics library. */
+export interface BiochemistrySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDeterministic(data: number[], opts: BiochemistrySciDeterministicOptions = {}): BiochemistrySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDeterministic };
diff --git a/src/biochemistry_sci/diagnostics.ts b/src/biochemistry_sci/diagnostics.ts
new file mode 100644
index 000000000..08c6c93fa
--- /dev/null
+++ b/src/biochemistry_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci diagnostics module — tsb analytics library. */
+export interface BiochemistrySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDiagnostics(data: number[], opts: BiochemistrySciDiagnosticsOptions = {}): BiochemistrySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDiagnostics };
diff --git a/src/biochemistry_sci/differential.ts b/src/biochemistry_sci/differential.ts
new file mode 100644
index 000000000..264393a46
--- /dev/null
+++ b/src/biochemistry_sci/differential.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci differential module — tsb analytics library. */
+export interface BiochemistrySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDifferential(data: number[], opts: BiochemistrySciDifferentialOptions = {}): BiochemistrySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDifferential };
diff --git a/src/biochemistry_sci/discrete.ts b/src/biochemistry_sci/discrete.ts
new file mode 100644
index 000000000..98bb2eee2
--- /dev/null
+++ b/src/biochemistry_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci discrete module — tsb analytics library. */
+export interface BiochemistrySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDiscrete(data: number[], opts: BiochemistrySciDiscreteOptions = {}): BiochemistrySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDiscrete };
diff --git a/src/biochemistry_sci/distribution.ts b/src/biochemistry_sci/distribution.ts
new file mode 100644
index 000000000..9516307be
--- /dev/null
+++ b/src/biochemistry_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci distribution module — tsb analytics library. */
+export interface BiochemistrySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDistributionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDistribution(data: number[], opts: BiochemistrySciDistributionOptions = {}): BiochemistrySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDistribution };
diff --git a/src/biochemistry_sci/dynamic.ts b/src/biochemistry_sci/dynamic.ts
new file mode 100644
index 000000000..6da0ccd70
--- /dev/null
+++ b/src/biochemistry_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci dynamic module — tsb analytics library. */
+export interface BiochemistrySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciDynamicResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciDynamic(data: number[], opts: BiochemistrySciDynamicOptions = {}): BiochemistrySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciDynamic };
diff --git a/src/biochemistry_sci/embedding.ts b/src/biochemistry_sci/embedding.ts
new file mode 100644
index 000000000..67c502cff
--- /dev/null
+++ b/src/biochemistry_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci embedding module — tsb analytics library. */
+export interface BiochemistrySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciEmbedding(data: number[], opts: BiochemistrySciEmbeddingOptions = {}): BiochemistrySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciEmbedding };
diff --git a/src/biochemistry_sci/encoding.ts b/src/biochemistry_sci/encoding.ts
new file mode 100644
index 000000000..007f79cba
--- /dev/null
+++ b/src/biochemistry_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci encoding module — tsb analytics library. */
+export interface BiochemistrySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciEncodingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciEncoding(data: number[], opts: BiochemistrySciEncodingOptions = {}): BiochemistrySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciEncoding };
diff --git a/src/biochemistry_sci/ensemble.ts b/src/biochemistry_sci/ensemble.ts
new file mode 100644
index 000000000..8654b7698
--- /dev/null
+++ b/src/biochemistry_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci ensemble module — tsb analytics library. */
+export interface BiochemistrySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciEnsemble(data: number[], opts: BiochemistrySciEnsembleOptions = {}): BiochemistrySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciEnsemble };
diff --git a/src/biochemistry_sci/estimation.ts b/src/biochemistry_sci/estimation.ts
new file mode 100644
index 000000000..3f89246fa
--- /dev/null
+++ b/src/biochemistry_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci estimation module — tsb analytics library. */
+export interface BiochemistrySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciEstimationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciEstimation(data: number[], opts: BiochemistrySciEstimationOptions = {}): BiochemistrySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciEstimation };
diff --git a/src/biochemistry_sci/evaluation.ts b/src/biochemistry_sci/evaluation.ts
new file mode 100644
index 000000000..12d7938e7
--- /dev/null
+++ b/src/biochemistry_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci evaluation module — tsb analytics library. */
+export interface BiochemistrySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciEvaluation(data: number[], opts: BiochemistrySciEvaluationOptions = {}): BiochemistrySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciEvaluation };
diff --git a/src/biochemistry_sci/extrapolation.ts b/src/biochemistry_sci/extrapolation.ts
new file mode 100644
index 000000000..3feb7a670
--- /dev/null
+++ b/src/biochemistry_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci extrapolation module — tsb analytics library. */
+export interface BiochemistrySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciExtrapolation(data: number[], opts: BiochemistrySciExtrapolationOptions = {}): BiochemistrySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciExtrapolation };
diff --git a/src/biochemistry_sci/features.ts b/src/biochemistry_sci/features.ts
new file mode 100644
index 000000000..674cd39d2
--- /dev/null
+++ b/src/biochemistry_sci/features.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci features module — tsb analytics library. */
+export interface BiochemistrySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciFeatures(data: number[], opts: BiochemistrySciFeaturesOptions = {}): BiochemistrySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciFeatures };
diff --git a/src/biochemistry_sci/feedback.ts b/src/biochemistry_sci/feedback.ts
new file mode 100644
index 000000000..e18dd53a4
--- /dev/null
+++ b/src/biochemistry_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci feedback module — tsb analytics library. */
+export interface BiochemistrySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciFeedback(data: number[], opts: BiochemistrySciFeedbackOptions = {}): BiochemistrySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciFeedback };
diff --git a/src/biochemistry_sci/filtering.ts b/src/biochemistry_sci/filtering.ts
new file mode 100644
index 000000000..fcc96914c
--- /dev/null
+++ b/src/biochemistry_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci filtering module — tsb analytics library. */
+export interface BiochemistrySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciFilteringResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciFiltering(data: number[], opts: BiochemistrySciFilteringOptions = {}): BiochemistrySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciFiltering };
diff --git a/src/biochemistry_sci/fourier.ts b/src/biochemistry_sci/fourier.ts
new file mode 100644
index 000000000..1bcba8c6b
--- /dev/null
+++ b/src/biochemistry_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci fourier module — tsb analytics library. */
+export interface BiochemistrySciFourierOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciFourierResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciFourier(data: number[], opts: BiochemistrySciFourierOptions = {}): BiochemistrySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciFourier };
diff --git a/src/biochemistry_sci/fusion.ts b/src/biochemistry_sci/fusion.ts
new file mode 100644
index 000000000..56a7353ca
--- /dev/null
+++ b/src/biochemistry_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci fusion module — tsb analytics library. */
+export interface BiochemistrySciFusionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciFusionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciFusion(data: number[], opts: BiochemistrySciFusionOptions = {}): BiochemistrySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciFusion };
diff --git a/src/biochemistry_sci/generation.ts b/src/biochemistry_sci/generation.ts
new file mode 100644
index 000000000..02f53f977
--- /dev/null
+++ b/src/biochemistry_sci/generation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci generation module — tsb analytics library. */
+export interface BiochemistrySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciGenerationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciGeneration(data: number[], opts: BiochemistrySciGenerationOptions = {}): BiochemistrySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciGeneration };
diff --git a/src/biochemistry_sci/geometry.ts b/src/biochemistry_sci/geometry.ts
new file mode 100644
index 000000000..45e47e28c
--- /dev/null
+++ b/src/biochemistry_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci geometry module — tsb analytics library. */
+export interface BiochemistrySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciGeometryResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciGeometry(data: number[], opts: BiochemistrySciGeometryOptions = {}): BiochemistrySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciGeometry };
diff --git a/src/biochemistry_sci/gradient.ts b/src/biochemistry_sci/gradient.ts
new file mode 100644
index 000000000..1cb4e1e52
--- /dev/null
+++ b/src/biochemistry_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci gradient module — tsb analytics library. */
+export interface BiochemistrySciGradientOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciGradientResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciGradient(data: number[], opts: BiochemistrySciGradientOptions = {}): BiochemistrySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciGradient };
diff --git a/src/biochemistry_sci/hessian.ts b/src/biochemistry_sci/hessian.ts
new file mode 100644
index 000000000..38da601c8
--- /dev/null
+++ b/src/biochemistry_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci hessian module — tsb analytics library. */
+export interface BiochemistrySciHessianOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciHessianResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciHessian(data: number[], opts: BiochemistrySciHessianOptions = {}): BiochemistrySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciHessian };
diff --git a/src/biochemistry_sci/hypothesis.ts b/src/biochemistry_sci/hypothesis.ts
new file mode 100644
index 000000000..e669654b9
--- /dev/null
+++ b/src/biochemistry_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci hypothesis module — tsb analytics library. */
+export interface BiochemistrySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciHypothesis(data: number[], opts: BiochemistrySciHypothesisOptions = {}): BiochemistrySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciHypothesis };
diff --git a/src/biochemistry_sci/inference.ts b/src/biochemistry_sci/inference.ts
new file mode 100644
index 000000000..e013b6451
--- /dev/null
+++ b/src/biochemistry_sci/inference.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci inference module — tsb analytics library. */
+export interface BiochemistrySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciInferenceResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciInference(data: number[], opts: BiochemistrySciInferenceOptions = {}): BiochemistrySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciInference };
diff --git a/src/biochemistry_sci/inference2.ts b/src/biochemistry_sci/inference2.ts
new file mode 100644
index 000000000..68286c898
--- /dev/null
+++ b/src/biochemistry_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci inference2 module — tsb analytics library. */
+export interface BiochemistrySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciInferenceResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciInference(data: number[], opts: BiochemistrySciInferenceOptions = {}): BiochemistrySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciInference };
diff --git a/src/biochemistry_sci/integral.ts b/src/biochemistry_sci/integral.ts
new file mode 100644
index 000000000..efccd8bcf
--- /dev/null
+++ b/src/biochemistry_sci/integral.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci integral module — tsb analytics library. */
+export interface BiochemistrySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciIntegralResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciIntegral(data: number[], opts: BiochemistrySciIntegralOptions = {}): BiochemistrySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciIntegral };
diff --git a/src/biochemistry_sci/integration.ts b/src/biochemistry_sci/integration.ts
new file mode 100644
index 000000000..f979e8042
--- /dev/null
+++ b/src/biochemistry_sci/integration.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci integration module — tsb analytics library. */
+export interface BiochemistrySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciIntegration(data: number[], opts: BiochemistrySciIntegrationOptions = {}): BiochemistrySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciIntegration };
diff --git a/src/biochemistry_sci/interpolation.ts b/src/biochemistry_sci/interpolation.ts
new file mode 100644
index 000000000..ea1b854d9
--- /dev/null
+++ b/src/biochemistry_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci interpolation module — tsb analytics library. */
+export interface BiochemistrySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciInterpolation(data: number[], opts: BiochemistrySciInterpolationOptions = {}): BiochemistrySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciInterpolation };
diff --git a/src/biochemistry_sci/jacobian.ts b/src/biochemistry_sci/jacobian.ts
new file mode 100644
index 000000000..61d595dfd
--- /dev/null
+++ b/src/biochemistry_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci jacobian module — tsb analytics library. */
+export interface BiochemistrySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciJacobianResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciJacobian(data: number[], opts: BiochemistrySciJacobianOptions = {}): BiochemistrySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciJacobian };
diff --git a/src/biochemistry_sci/kernel.ts b/src/biochemistry_sci/kernel.ts
new file mode 100644
index 000000000..aca77b65c
--- /dev/null
+++ b/src/biochemistry_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci kernel module — tsb analytics library. */
+export interface BiochemistrySciKernelOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciKernelResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciKernel(data: number[], opts: BiochemistrySciKernelOptions = {}): BiochemistrySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciKernel };
diff --git a/src/biochemistry_sci/laplacian.ts b/src/biochemistry_sci/laplacian.ts
new file mode 100644
index 000000000..cb1d93b24
--- /dev/null
+++ b/src/biochemistry_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci laplacian module — tsb analytics library. */
+export interface BiochemistrySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciLaplacian(data: number[], opts: BiochemistrySciLaplacianOptions = {}): BiochemistrySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciLaplacian };
diff --git a/src/biochemistry_sci/learning.ts b/src/biochemistry_sci/learning.ts
new file mode 100644
index 000000000..b4bb235a2
--- /dev/null
+++ b/src/biochemistry_sci/learning.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci learning module — tsb analytics library. */
+export interface BiochemistrySciLearningOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciLearningResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciLearning(data: number[], opts: BiochemistrySciLearningOptions = {}): BiochemistrySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciLearning };
diff --git a/src/biochemistry_sci/linear.ts b/src/biochemistry_sci/linear.ts
new file mode 100644
index 000000000..eb04b166c
--- /dev/null
+++ b/src/biochemistry_sci/linear.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci linear module — tsb analytics library. */
+export interface BiochemistrySciLinearOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciLinearResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciLinear(data: number[], opts: BiochemistrySciLinearOptions = {}): BiochemistrySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciLinear };
diff --git a/src/biochemistry_sci/manifold.ts b/src/biochemistry_sci/manifold.ts
new file mode 100644
index 000000000..a52bf9895
--- /dev/null
+++ b/src/biochemistry_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci manifold module — tsb analytics library. */
+export interface BiochemistrySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciManifoldResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciManifold(data: number[], opts: BiochemistrySciManifoldOptions = {}): BiochemistrySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciManifold };
diff --git a/src/biochemistry_sci/matching.ts b/src/biochemistry_sci/matching.ts
new file mode 100644
index 000000000..7f5e3d15f
--- /dev/null
+++ b/src/biochemistry_sci/matching.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci matching module — tsb analytics library. */
+export interface BiochemistrySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciMatchingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciMatching(data: number[], opts: BiochemistrySciMatchingOptions = {}): BiochemistrySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciMatching };
diff --git a/src/biochemistry_sci/measurement.ts b/src/biochemistry_sci/measurement.ts
new file mode 100644
index 000000000..8aeede0d4
--- /dev/null
+++ b/src/biochemistry_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci measurement module — tsb analytics library. */
+export interface BiochemistrySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciMeasurement(data: number[], opts: BiochemistrySciMeasurementOptions = {}): BiochemistrySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciMeasurement };
diff --git a/src/biochemistry_sci/metrics.ts b/src/biochemistry_sci/metrics.ts
new file mode 100644
index 000000000..ea2d2d61e
--- /dev/null
+++ b/src/biochemistry_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci metrics module — tsb analytics library. */
+export interface BiochemistrySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciMetricsResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciMetrics(data: number[], opts: BiochemistrySciMetricsOptions = {}): BiochemistrySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciMetrics };
diff --git a/src/biochemistry_sci/modeling.ts b/src/biochemistry_sci/modeling.ts
new file mode 100644
index 000000000..18ccb445c
--- /dev/null
+++ b/src/biochemistry_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci modeling module — tsb analytics library. */
+export interface BiochemistrySciModelingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciModelingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciModeling(data: number[], opts: BiochemistrySciModelingOptions = {}): BiochemistrySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciModeling };
diff --git a/src/biochemistry_sci/monitoring.ts b/src/biochemistry_sci/monitoring.ts
new file mode 100644
index 000000000..5946b9a08
--- /dev/null
+++ b/src/biochemistry_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci monitoring module — tsb analytics library. */
+export interface BiochemistrySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciMonitoring(data: number[], opts: BiochemistrySciMonitoringOptions = {}): BiochemistrySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciMonitoring };
diff --git a/src/biochemistry_sci/nonlinear.ts b/src/biochemistry_sci/nonlinear.ts
new file mode 100644
index 000000000..2a0fa91fe
--- /dev/null
+++ b/src/biochemistry_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci nonlinear module — tsb analytics library. */
+export interface BiochemistrySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciNonlinear(data: number[], opts: BiochemistrySciNonlinearOptions = {}): BiochemistrySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciNonlinear };
diff --git a/src/biochemistry_sci/normalization.ts b/src/biochemistry_sci/normalization.ts
new file mode 100644
index 000000000..8938db610
--- /dev/null
+++ b/src/biochemistry_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci normalization module — tsb analytics library. */
+export interface BiochemistrySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciNormalization(data: number[], opts: BiochemistrySciNormalizationOptions = {}): BiochemistrySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciNormalization };
diff --git a/src/biochemistry_sci/optimization.ts b/src/biochemistry_sci/optimization.ts
new file mode 100644
index 000000000..178d973d4
--- /dev/null
+++ b/src/biochemistry_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci optimization module — tsb analytics library. */
+export interface BiochemistrySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciOptimization(data: number[], opts: BiochemistrySciOptimizationOptions = {}): BiochemistrySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciOptimization };
diff --git a/src/biochemistry_sci/patterns.ts b/src/biochemistry_sci/patterns.ts
new file mode 100644
index 000000000..e5eda314f
--- /dev/null
+++ b/src/biochemistry_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci patterns module — tsb analytics library. */
+export interface BiochemistrySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciPatternsResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciPatterns(data: number[], opts: BiochemistrySciPatternsOptions = {}): BiochemistrySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciPatterns };
diff --git a/src/biochemistry_sci/permutation.ts b/src/biochemistry_sci/permutation.ts
new file mode 100644
index 000000000..2db7f2426
--- /dev/null
+++ b/src/biochemistry_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci permutation module — tsb analytics library. */
+export interface BiochemistrySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciPermutationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciPermutation(data: number[], opts: BiochemistrySciPermutationOptions = {}): BiochemistrySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciPermutation };
diff --git a/src/biochemistry_sci/prediction.ts b/src/biochemistry_sci/prediction.ts
new file mode 100644
index 000000000..7a25c6c9b
--- /dev/null
+++ b/src/biochemistry_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci prediction module — tsb analytics library. */
+export interface BiochemistrySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciPredictionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciPrediction(data: number[], opts: BiochemistrySciPredictionOptions = {}): BiochemistrySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciPrediction };
diff --git a/src/biochemistry_sci/processing.ts b/src/biochemistry_sci/processing.ts
new file mode 100644
index 000000000..7dfb19208
--- /dev/null
+++ b/src/biochemistry_sci/processing.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci processing module — tsb analytics library. */
+export interface BiochemistrySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciProcessingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciProcessing(data: number[], opts: BiochemistrySciProcessingOptions = {}): BiochemistrySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciProcessing };
diff --git a/src/biochemistry_sci/profiling.ts b/src/biochemistry_sci/profiling.ts
new file mode 100644
index 000000000..e45b0702e
--- /dev/null
+++ b/src/biochemistry_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci profiling module — tsb analytics library. */
+export interface BiochemistrySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciProfilingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciProfiling(data: number[], opts: BiochemistrySciProfilingOptions = {}): BiochemistrySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciProfiling };
diff --git a/src/biochemistry_sci/projection.ts b/src/biochemistry_sci/projection.ts
new file mode 100644
index 000000000..c6b4fe93b
--- /dev/null
+++ b/src/biochemistry_sci/projection.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci projection module — tsb analytics library. */
+export interface BiochemistrySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciProjectionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciProjection(data: number[], opts: BiochemistrySciProjectionOptions = {}): BiochemistrySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciProjection };
diff --git a/src/biochemistry_sci/ranking.ts b/src/biochemistry_sci/ranking.ts
new file mode 100644
index 000000000..ac45fc07b
--- /dev/null
+++ b/src/biochemistry_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci ranking module — tsb analytics library. */
+export interface BiochemistrySciRankingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciRankingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciRanking(data: number[], opts: BiochemistrySciRankingOptions = {}): BiochemistrySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciRanking };
diff --git a/src/biochemistry_sci/reconstruction.ts b/src/biochemistry_sci/reconstruction.ts
new file mode 100644
index 000000000..c5fa09c11
--- /dev/null
+++ b/src/biochemistry_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci reconstruction module — tsb analytics library. */
+export interface BiochemistrySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciReconstruction(data: number[], opts: BiochemistrySciReconstructionOptions = {}): BiochemistrySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciReconstruction };
diff --git a/src/biochemistry_sci/registration.ts b/src/biochemistry_sci/registration.ts
new file mode 100644
index 000000000..80cd02fb4
--- /dev/null
+++ b/src/biochemistry_sci/registration.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci registration module — tsb analytics library. */
+export interface BiochemistrySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciRegistration(data: number[], opts: BiochemistrySciRegistrationOptions = {}): BiochemistrySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciRegistration };
diff --git a/src/biochemistry_sci/regression.ts b/src/biochemistry_sci/regression.ts
new file mode 100644
index 000000000..d85c4e86e
--- /dev/null
+++ b/src/biochemistry_sci/regression.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci regression module — tsb analytics library. */
+export interface BiochemistrySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciRegressionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciRegression(data: number[], opts: BiochemistrySciRegressionOptions = {}): BiochemistrySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciRegression };
diff --git a/src/biochemistry_sci/regularization.ts b/src/biochemistry_sci/regularization.ts
new file mode 100644
index 000000000..5bdd14f50
--- /dev/null
+++ b/src/biochemistry_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci regularization module — tsb analytics library. */
+export interface BiochemistrySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciRegularization(data: number[], opts: BiochemistrySciRegularizationOptions = {}): BiochemistrySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciRegularization };
diff --git a/src/biochemistry_sci/robustness.ts b/src/biochemistry_sci/robustness.ts
new file mode 100644
index 000000000..525415bde
--- /dev/null
+++ b/src/biochemistry_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci robustness module — tsb analytics library. */
+export interface BiochemistrySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciRobustness(data: number[], opts: BiochemistrySciRobustnessOptions = {}): BiochemistrySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciRobustness };
diff --git a/src/biochemistry_sci/sampling.ts b/src/biochemistry_sci/sampling.ts
new file mode 100644
index 000000000..cd0b5cb7b
--- /dev/null
+++ b/src/biochemistry_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci sampling module — tsb analytics library. */
+export interface BiochemistrySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciSamplingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciSampling(data: number[], opts: BiochemistrySciSamplingOptions = {}): BiochemistrySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciSampling };
diff --git a/src/biochemistry_sci/sampling2.ts b/src/biochemistry_sci/sampling2.ts
new file mode 100644
index 000000000..e589a456c
--- /dev/null
+++ b/src/biochemistry_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci sampling2 module — tsb analytics library. */
+export interface BiochemistrySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciSamplingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciSampling(data: number[], opts: BiochemistrySciSamplingOptions = {}): BiochemistrySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciSampling };
diff --git a/src/biochemistry_sci/scaling.ts b/src/biochemistry_sci/scaling.ts
new file mode 100644
index 000000000..249e9b37c
--- /dev/null
+++ b/src/biochemistry_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci scaling module — tsb analytics library. */
+export interface BiochemistrySciScalingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciScalingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciScaling(data: number[], opts: BiochemistrySciScalingOptions = {}): BiochemistrySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciScaling };
diff --git a/src/biochemistry_sci/scoring.ts b/src/biochemistry_sci/scoring.ts
new file mode 100644
index 000000000..f8089dab1
--- /dev/null
+++ b/src/biochemistry_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci scoring module — tsb analytics library. */
+export interface BiochemistrySciScoringOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciScoringResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciScoring(data: number[], opts: BiochemistrySciScoringOptions = {}): BiochemistrySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciScoring };
diff --git a/src/biochemistry_sci/segmentation.ts b/src/biochemistry_sci/segmentation.ts
new file mode 100644
index 000000000..9e5e7cce0
--- /dev/null
+++ b/src/biochemistry_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci segmentation module — tsb analytics library. */
+export interface BiochemistrySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciSegmentation(data: number[], opts: BiochemistrySciSegmentationOptions = {}): BiochemistrySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciSegmentation };
diff --git a/src/biochemistry_sci/selection.ts b/src/biochemistry_sci/selection.ts
new file mode 100644
index 000000000..4138a4048
--- /dev/null
+++ b/src/biochemistry_sci/selection.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci selection module — tsb analytics library. */
+export interface BiochemistrySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciSelectionResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciSelection(data: number[], opts: BiochemistrySciSelectionOptions = {}): BiochemistrySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciSelection };
diff --git a/src/biochemistry_sci/sensitivity.ts b/src/biochemistry_sci/sensitivity.ts
new file mode 100644
index 000000000..24acd6b2c
--- /dev/null
+++ b/src/biochemistry_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci sensitivity module — tsb analytics library. */
+export interface BiochemistrySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciSensitivity(data: number[], opts: BiochemistrySciSensitivityOptions = {}): BiochemistrySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciSensitivity };
diff --git a/src/biochemistry_sci/simulation.ts b/src/biochemistry_sci/simulation.ts
new file mode 100644
index 000000000..3cc49d9fb
--- /dev/null
+++ b/src/biochemistry_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci simulation module — tsb analytics library. */
+export interface BiochemistrySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciSimulationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciSimulation(data: number[], opts: BiochemistrySciSimulationOptions = {}): BiochemistrySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciSimulation };
diff --git a/src/biochemistry_sci/smoothing.ts b/src/biochemistry_sci/smoothing.ts
new file mode 100644
index 000000000..36cafb329
--- /dev/null
+++ b/src/biochemistry_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci smoothing module — tsb analytics library. */
+export interface BiochemistrySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciSmoothing(data: number[], opts: BiochemistrySciSmoothingOptions = {}): BiochemistrySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciSmoothing };
diff --git a/src/biochemistry_sci/stability.ts b/src/biochemistry_sci/stability.ts
new file mode 100644
index 000000000..aa209ed2e
--- /dev/null
+++ b/src/biochemistry_sci/stability.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci stability module — tsb analytics library. */
+export interface BiochemistrySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciStabilityResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciStability(data: number[], opts: BiochemistrySciStabilityOptions = {}): BiochemistrySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciStability };
diff --git a/src/biochemistry_sci/stacking.ts b/src/biochemistry_sci/stacking.ts
new file mode 100644
index 000000000..f9ccf5f7c
--- /dev/null
+++ b/src/biochemistry_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci stacking module — tsb analytics library. */
+export interface BiochemistrySciStackingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciStackingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciStacking(data: number[], opts: BiochemistrySciStackingOptions = {}): BiochemistrySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciStacking };
diff --git a/src/biochemistry_sci/standardization.ts b/src/biochemistry_sci/standardization.ts
new file mode 100644
index 000000000..ea679f859
--- /dev/null
+++ b/src/biochemistry_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci standardization module — tsb analytics library. */
+export interface BiochemistrySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciStandardization(data: number[], opts: BiochemistrySciStandardizationOptions = {}): BiochemistrySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciStandardization };
diff --git a/src/biochemistry_sci/static.ts b/src/biochemistry_sci/static.ts
new file mode 100644
index 000000000..fd2380e55
--- /dev/null
+++ b/src/biochemistry_sci/static.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci static module — tsb analytics library. */
+export interface BiochemistrySciStaticOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciStaticResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciStatic(data: number[], opts: BiochemistrySciStaticOptions = {}): BiochemistrySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciStatic };
diff --git a/src/biochemistry_sci/stochastic.ts b/src/biochemistry_sci/stochastic.ts
new file mode 100644
index 000000000..ed9b0a0e7
--- /dev/null
+++ b/src/biochemistry_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci stochastic module — tsb analytics library. */
+export interface BiochemistrySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciStochasticResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciStochastic(data: number[], opts: BiochemistrySciStochasticOptions = {}): BiochemistrySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciStochastic };
diff --git a/src/biochemistry_sci/synthesis.ts b/src/biochemistry_sci/synthesis.ts
new file mode 100644
index 000000000..7d051ff4e
--- /dev/null
+++ b/src/biochemistry_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci synthesis module — tsb analytics library. */
+export interface BiochemistrySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciSynthesis(data: number[], opts: BiochemistrySciSynthesisOptions = {}): BiochemistrySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciSynthesis };
diff --git a/src/biochemistry_sci/topology.ts b/src/biochemistry_sci/topology.ts
new file mode 100644
index 000000000..b9239ae4a
--- /dev/null
+++ b/src/biochemistry_sci/topology.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci topology module — tsb analytics library. */
+export interface BiochemistrySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciTopologyResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciTopology(data: number[], opts: BiochemistrySciTopologyOptions = {}): BiochemistrySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciTopology };
diff --git a/src/biochemistry_sci/tracking.ts b/src/biochemistry_sci/tracking.ts
new file mode 100644
index 000000000..a685069b4
--- /dev/null
+++ b/src/biochemistry_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci tracking module — tsb analytics library. */
+export interface BiochemistrySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciTrackingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciTracking(data: number[], opts: BiochemistrySciTrackingOptions = {}): BiochemistrySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciTracking };
diff --git a/src/biochemistry_sci/transform.ts b/src/biochemistry_sci/transform.ts
new file mode 100644
index 000000000..85358d3a3
--- /dev/null
+++ b/src/biochemistry_sci/transform.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci transform module — tsb analytics library. */
+export interface BiochemistrySciTransformOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciTransformResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciTransform(data: number[], opts: BiochemistrySciTransformOptions = {}): BiochemistrySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciTransform };
diff --git a/src/biochemistry_sci/uncertainty.ts b/src/biochemistry_sci/uncertainty.ts
new file mode 100644
index 000000000..fd41a2933
--- /dev/null
+++ b/src/biochemistry_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci uncertainty module — tsb analytics library. */
+export interface BiochemistrySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciUncertainty(data: number[], opts: BiochemistrySciUncertaintyOptions = {}): BiochemistrySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciUncertainty };
diff --git a/src/biochemistry_sci/validation.ts b/src/biochemistry_sci/validation.ts
new file mode 100644
index 000000000..6f7f5c8cf
--- /dev/null
+++ b/src/biochemistry_sci/validation.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci validation module — tsb analytics library. */
+export interface BiochemistrySciValidationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciValidationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciValidation(data: number[], opts: BiochemistrySciValidationOptions = {}): BiochemistrySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciValidation };
diff --git a/src/biochemistry_sci/verification.ts b/src/biochemistry_sci/verification.ts
new file mode 100644
index 000000000..c5dfd6b4e
--- /dev/null
+++ b/src/biochemistry_sci/verification.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci verification module — tsb analytics library. */
+export interface BiochemistrySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciVerificationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciVerification(data: number[], opts: BiochemistrySciVerificationOptions = {}): BiochemistrySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciVerification };
diff --git a/src/biochemistry_sci/visualization.ts b/src/biochemistry_sci/visualization.ts
new file mode 100644
index 000000000..ac1fd5760
--- /dev/null
+++ b/src/biochemistry_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci visualization module — tsb analytics library. */
+export interface BiochemistrySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciVisualization(data: number[], opts: BiochemistrySciVisualizationOptions = {}): BiochemistrySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciVisualization };
diff --git a/src/biochemistry_sci/voting.ts b/src/biochemistry_sci/voting.ts
new file mode 100644
index 000000000..002581529
--- /dev/null
+++ b/src/biochemistry_sci/voting.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci voting module — tsb analytics library. */
+export interface BiochemistrySciVotingOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciVotingResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciVoting(data: number[], opts: BiochemistrySciVotingOptions = {}): BiochemistrySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciVoting };
diff --git a/src/biochemistry_sci/wavelet.ts b/src/biochemistry_sci/wavelet.ts
new file mode 100644
index 000000000..30b1bad8f
--- /dev/null
+++ b/src/biochemistry_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** biochemistry_sci wavelet module — tsb analytics library. */
+export interface BiochemistrySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface BiochemistrySciWaveletResult { values: number[]; converged: boolean; }
+export function computeBiochemistrySciWavelet(data: number[], opts: BiochemistrySciWaveletOptions = {}): BiochemistrySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiochemistrySciWavelet };
diff --git a/src/biomechanics/adaptation.ts b/src/biomechanics/adaptation.ts
new file mode 100644
index 000000000..79670f435
--- /dev/null
+++ b/src/biomechanics/adaptation.ts
@@ -0,0 +1,14 @@
+/** biomechanics adaptation module — tsb analytics library. */
+export interface BiomechanicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsAdaptation(data: number[], opts: BiomechanicsAdaptationOptions = {}): BiomechanicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsAdaptation };
diff --git a/src/biomechanics/aggregation.ts b/src/biomechanics/aggregation.ts
new file mode 100644
index 000000000..3e028e29a
--- /dev/null
+++ b/src/biomechanics/aggregation.ts
@@ -0,0 +1,14 @@
+/** biomechanics aggregation module — tsb analytics library. */
+export interface BiomechanicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsAggregationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsAggregation(data: number[], opts: BiomechanicsAggregationOptions = {}): BiomechanicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsAggregation };
diff --git a/src/biomechanics/algebra.ts b/src/biomechanics/algebra.ts
new file mode 100644
index 000000000..8a53c6957
--- /dev/null
+++ b/src/biomechanics/algebra.ts
@@ -0,0 +1,14 @@
+/** biomechanics algebra module — tsb analytics library. */
+export interface BiomechanicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsAlgebra(data: number[], opts: BiomechanicsAlgebraOptions = {}): BiomechanicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsAlgebra };
diff --git a/src/biomechanics/alignment.ts b/src/biomechanics/alignment.ts
new file mode 100644
index 000000000..b66b5d926
--- /dev/null
+++ b/src/biomechanics/alignment.ts
@@ -0,0 +1,14 @@
+/** biomechanics alignment module — tsb analytics library. */
+export interface BiomechanicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsAlignment(data: number[], opts: BiomechanicsAlignmentOptions = {}): BiomechanicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsAlignment };
diff --git a/src/biomechanics/analysis.ts b/src/biomechanics/analysis.ts
new file mode 100644
index 000000000..ae9fbab0d
--- /dev/null
+++ b/src/biomechanics/analysis.ts
@@ -0,0 +1,14 @@
+/** biomechanics analysis module — tsb analytics library. */
+export interface BiomechanicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsAnalysis(data: number[], opts: BiomechanicsAnalysisOptions = {}): BiomechanicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsAnalysis };
diff --git a/src/biomechanics/augmentation.ts b/src/biomechanics/augmentation.ts
new file mode 100644
index 000000000..686a9855b
--- /dev/null
+++ b/src/biomechanics/augmentation.ts
@@ -0,0 +1,14 @@
+/** biomechanics augmentation module — tsb analytics library. */
+export interface BiomechanicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsAugmentation(data: number[], opts: BiomechanicsAugmentationOptions = {}): BiomechanicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsAugmentation };
diff --git a/src/biomechanics/bagging.ts b/src/biomechanics/bagging.ts
new file mode 100644
index 000000000..6d15fd202
--- /dev/null
+++ b/src/biomechanics/bagging.ts
@@ -0,0 +1,14 @@
+/** biomechanics bagging module — tsb analytics library. */
+export interface BiomechanicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsBaggingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsBagging(data: number[], opts: BiomechanicsBaggingOptions = {}): BiomechanicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsBagging };
diff --git a/src/biomechanics/basis.ts b/src/biomechanics/basis.ts
new file mode 100644
index 000000000..5e126d8f4
--- /dev/null
+++ b/src/biomechanics/basis.ts
@@ -0,0 +1,14 @@
+/** biomechanics basis module — tsb analytics library. */
+export interface BiomechanicsBasisOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsBasisResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsBasis(data: number[], opts: BiomechanicsBasisOptions = {}): BiomechanicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsBasis };
diff --git a/src/biomechanics/benchmarking.ts b/src/biomechanics/benchmarking.ts
new file mode 100644
index 000000000..2443a2c09
--- /dev/null
+++ b/src/biomechanics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** biomechanics benchmarking module — tsb analytics library. */
+export interface BiomechanicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsBenchmarking(data: number[], opts: BiomechanicsBenchmarkingOptions = {}): BiomechanicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsBenchmarking };
diff --git a/src/biomechanics/blending.ts b/src/biomechanics/blending.ts
new file mode 100644
index 000000000..3edbf7712
--- /dev/null
+++ b/src/biomechanics/blending.ts
@@ -0,0 +1,14 @@
+/** biomechanics blending module — tsb analytics library. */
+export interface BiomechanicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsBlendingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsBlending(data: number[], opts: BiomechanicsBlendingOptions = {}): BiomechanicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsBlending };
diff --git a/src/biomechanics/boosting.ts b/src/biomechanics/boosting.ts
new file mode 100644
index 000000000..796179261
--- /dev/null
+++ b/src/biomechanics/boosting.ts
@@ -0,0 +1,14 @@
+/** biomechanics boosting module — tsb analytics library. */
+export interface BiomechanicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsBoostingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsBoosting(data: number[], opts: BiomechanicsBoostingOptions = {}): BiomechanicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsBoosting };
diff --git a/src/biomechanics/bootstrap.ts b/src/biomechanics/bootstrap.ts
new file mode 100644
index 000000000..1d22ee6b7
--- /dev/null
+++ b/src/biomechanics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** biomechanics bootstrap module — tsb analytics library. */
+export interface BiomechanicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsBootstrap(data: number[], opts: BiomechanicsBootstrapOptions = {}): BiomechanicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsBootstrap };
diff --git a/src/biomechanics/calculus.ts b/src/biomechanics/calculus.ts
new file mode 100644
index 000000000..96c0a04fd
--- /dev/null
+++ b/src/biomechanics/calculus.ts
@@ -0,0 +1,14 @@
+/** biomechanics calculus module — tsb analytics library. */
+export interface BiomechanicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsCalculusResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsCalculus(data: number[], opts: BiomechanicsCalculusOptions = {}): BiomechanicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsCalculus };
diff --git a/src/biomechanics/calibration.ts b/src/biomechanics/calibration.ts
new file mode 100644
index 000000000..988090749
--- /dev/null
+++ b/src/biomechanics/calibration.ts
@@ -0,0 +1,14 @@
+/** biomechanics calibration module — tsb analytics library. */
+export interface BiomechanicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsCalibration(data: number[], opts: BiomechanicsCalibrationOptions = {}): BiomechanicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsCalibration };
diff --git a/src/biomechanics/characterization.ts b/src/biomechanics/characterization.ts
new file mode 100644
index 000000000..f245c5999
--- /dev/null
+++ b/src/biomechanics/characterization.ts
@@ -0,0 +1,14 @@
+/** biomechanics characterization module — tsb analytics library. */
+export interface BiomechanicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsCharacterization(data: number[], opts: BiomechanicsCharacterizationOptions = {}): BiomechanicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsCharacterization };
diff --git a/src/biomechanics/classification.ts b/src/biomechanics/classification.ts
new file mode 100644
index 000000000..59de2fd02
--- /dev/null
+++ b/src/biomechanics/classification.ts
@@ -0,0 +1,14 @@
+/** biomechanics classification module — tsb analytics library. */
+export interface BiomechanicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsClassificationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsClassification(data: number[], opts: BiomechanicsClassificationOptions = {}): BiomechanicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsClassification };
diff --git a/src/biomechanics/clustering.ts b/src/biomechanics/clustering.ts
new file mode 100644
index 000000000..fd0a2936b
--- /dev/null
+++ b/src/biomechanics/clustering.ts
@@ -0,0 +1,14 @@
+/** biomechanics clustering module — tsb analytics library. */
+export interface BiomechanicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsClusteringResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsClustering(data: number[], opts: BiomechanicsClusteringOptions = {}): BiomechanicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsClustering };
diff --git a/src/biomechanics/compression.ts b/src/biomechanics/compression.ts
new file mode 100644
index 000000000..4e8870211
--- /dev/null
+++ b/src/biomechanics/compression.ts
@@ -0,0 +1,14 @@
+/** biomechanics compression module — tsb analytics library. */
+export interface BiomechanicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsCompressionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsCompression(data: number[], opts: BiomechanicsCompressionOptions = {}): BiomechanicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsCompression };
diff --git a/src/biomechanics/continuous.ts b/src/biomechanics/continuous.ts
new file mode 100644
index 000000000..3f853637e
--- /dev/null
+++ b/src/biomechanics/continuous.ts
@@ -0,0 +1,14 @@
+/** biomechanics continuous module — tsb analytics library. */
+export interface BiomechanicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsContinuousResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsContinuous(data: number[], opts: BiomechanicsContinuousOptions = {}): BiomechanicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsContinuous };
diff --git a/src/biomechanics/control.ts b/src/biomechanics/control.ts
new file mode 100644
index 000000000..455991463
--- /dev/null
+++ b/src/biomechanics/control.ts
@@ -0,0 +1,14 @@
+/** biomechanics control module — tsb analytics library. */
+export interface BiomechanicsControlOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsControlResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsControl(data: number[], opts: BiomechanicsControlOptions = {}): BiomechanicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsControl };
diff --git a/src/biomechanics/convergence.ts b/src/biomechanics/convergence.ts
new file mode 100644
index 000000000..b2b1b3e5b
--- /dev/null
+++ b/src/biomechanics/convergence.ts
@@ -0,0 +1,14 @@
+/** biomechanics convergence module — tsb analytics library. */
+export interface BiomechanicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsConvergence(data: number[], opts: BiomechanicsConvergenceOptions = {}): BiomechanicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsConvergence };
diff --git a/src/biomechanics/convex.ts b/src/biomechanics/convex.ts
new file mode 100644
index 000000000..fee047c14
--- /dev/null
+++ b/src/biomechanics/convex.ts
@@ -0,0 +1,14 @@
+/** biomechanics convex module — tsb analytics library. */
+export interface BiomechanicsConvexOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsConvexResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsConvex(data: number[], opts: BiomechanicsConvexOptions = {}): BiomechanicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsConvex };
diff --git a/src/biomechanics/correlation.ts b/src/biomechanics/correlation.ts
new file mode 100644
index 000000000..380a12264
--- /dev/null
+++ b/src/biomechanics/correlation.ts
@@ -0,0 +1,14 @@
+/** biomechanics correlation module — tsb analytics library. */
+export interface BiomechanicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsCorrelation(data: number[], opts: BiomechanicsCorrelationOptions = {}): BiomechanicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsCorrelation };
diff --git a/src/biomechanics/covariance.ts b/src/biomechanics/covariance.ts
new file mode 100644
index 000000000..ac9ce5f14
--- /dev/null
+++ b/src/biomechanics/covariance.ts
@@ -0,0 +1,14 @@
+/** biomechanics covariance module — tsb analytics library. */
+export interface BiomechanicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsCovariance(data: number[], opts: BiomechanicsCovarianceOptions = {}): BiomechanicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsCovariance };
diff --git a/src/biomechanics/cross_validation.ts b/src/biomechanics/cross_validation.ts
new file mode 100644
index 000000000..336018177
--- /dev/null
+++ b/src/biomechanics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** biomechanics cross_validation module — tsb analytics library. */
+export interface BiomechanicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsCrossValidation(data: number[], opts: BiomechanicsCrossValidationOptions = {}): BiomechanicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsCrossValidation };
diff --git a/src/biomechanics/decoding.ts b/src/biomechanics/decoding.ts
new file mode 100644
index 000000000..3ad972cf7
--- /dev/null
+++ b/src/biomechanics/decoding.ts
@@ -0,0 +1,14 @@
+/** biomechanics decoding module — tsb analytics library. */
+export interface BiomechanicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDecodingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDecoding(data: number[], opts: BiomechanicsDecodingOptions = {}): BiomechanicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDecoding };
diff --git a/src/biomechanics/decomposition.ts b/src/biomechanics/decomposition.ts
new file mode 100644
index 000000000..fe25c3a4f
--- /dev/null
+++ b/src/biomechanics/decomposition.ts
@@ -0,0 +1,14 @@
+/** biomechanics decomposition module — tsb analytics library. */
+export interface BiomechanicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDecomposition(data: number[], opts: BiomechanicsDecompositionOptions = {}): BiomechanicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDecomposition };
diff --git a/src/biomechanics/detection.ts b/src/biomechanics/detection.ts
new file mode 100644
index 000000000..7117f8094
--- /dev/null
+++ b/src/biomechanics/detection.ts
@@ -0,0 +1,14 @@
+/** biomechanics detection module — tsb analytics library. */
+export interface BiomechanicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDetectionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDetection(data: number[], opts: BiomechanicsDetectionOptions = {}): BiomechanicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDetection };
diff --git a/src/biomechanics/deterministic.ts b/src/biomechanics/deterministic.ts
new file mode 100644
index 000000000..c2336fd87
--- /dev/null
+++ b/src/biomechanics/deterministic.ts
@@ -0,0 +1,14 @@
+/** biomechanics deterministic module — tsb analytics library. */
+export interface BiomechanicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDeterministic(data: number[], opts: BiomechanicsDeterministicOptions = {}): BiomechanicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDeterministic };
diff --git a/src/biomechanics/diagnostics.ts b/src/biomechanics/diagnostics.ts
new file mode 100644
index 000000000..3b4e3f39d
--- /dev/null
+++ b/src/biomechanics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** biomechanics diagnostics module — tsb analytics library. */
+export interface BiomechanicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDiagnostics(data: number[], opts: BiomechanicsDiagnosticsOptions = {}): BiomechanicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDiagnostics };
diff --git a/src/biomechanics/differential.ts b/src/biomechanics/differential.ts
new file mode 100644
index 000000000..130916c04
--- /dev/null
+++ b/src/biomechanics/differential.ts
@@ -0,0 +1,14 @@
+/** biomechanics differential module — tsb analytics library. */
+export interface BiomechanicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDifferential(data: number[], opts: BiomechanicsDifferentialOptions = {}): BiomechanicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDifferential };
diff --git a/src/biomechanics/discrete.ts b/src/biomechanics/discrete.ts
new file mode 100644
index 000000000..955c6ee77
--- /dev/null
+++ b/src/biomechanics/discrete.ts
@@ -0,0 +1,14 @@
+/** biomechanics discrete module — tsb analytics library. */
+export interface BiomechanicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDiscrete(data: number[], opts: BiomechanicsDiscreteOptions = {}): BiomechanicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDiscrete };
diff --git a/src/biomechanics/distribution.ts b/src/biomechanics/distribution.ts
new file mode 100644
index 000000000..ce3374fd2
--- /dev/null
+++ b/src/biomechanics/distribution.ts
@@ -0,0 +1,14 @@
+/** biomechanics distribution module — tsb analytics library. */
+export interface BiomechanicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDistributionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDistribution(data: number[], opts: BiomechanicsDistributionOptions = {}): BiomechanicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDistribution };
diff --git a/src/biomechanics/dynamic.ts b/src/biomechanics/dynamic.ts
new file mode 100644
index 000000000..c9e9bd89b
--- /dev/null
+++ b/src/biomechanics/dynamic.ts
@@ -0,0 +1,14 @@
+/** biomechanics dynamic module — tsb analytics library. */
+export interface BiomechanicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsDynamicResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsDynamic(data: number[], opts: BiomechanicsDynamicOptions = {}): BiomechanicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsDynamic };
diff --git a/src/biomechanics/embedding.ts b/src/biomechanics/embedding.ts
new file mode 100644
index 000000000..4477ee876
--- /dev/null
+++ b/src/biomechanics/embedding.ts
@@ -0,0 +1,14 @@
+/** biomechanics embedding module — tsb analytics library. */
+export interface BiomechanicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsEmbedding(data: number[], opts: BiomechanicsEmbeddingOptions = {}): BiomechanicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsEmbedding };
diff --git a/src/biomechanics/encoding.ts b/src/biomechanics/encoding.ts
new file mode 100644
index 000000000..17004a260
--- /dev/null
+++ b/src/biomechanics/encoding.ts
@@ -0,0 +1,14 @@
+/** biomechanics encoding module — tsb analytics library. */
+export interface BiomechanicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsEncodingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsEncoding(data: number[], opts: BiomechanicsEncodingOptions = {}): BiomechanicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsEncoding };
diff --git a/src/biomechanics/ensemble.ts b/src/biomechanics/ensemble.ts
new file mode 100644
index 000000000..38db116d0
--- /dev/null
+++ b/src/biomechanics/ensemble.ts
@@ -0,0 +1,14 @@
+/** biomechanics ensemble module — tsb analytics library. */
+export interface BiomechanicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsEnsemble(data: number[], opts: BiomechanicsEnsembleOptions = {}): BiomechanicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsEnsemble };
diff --git a/src/biomechanics/estimation.ts b/src/biomechanics/estimation.ts
new file mode 100644
index 000000000..e7343a9e2
--- /dev/null
+++ b/src/biomechanics/estimation.ts
@@ -0,0 +1,14 @@
+/** biomechanics estimation module — tsb analytics library. */
+export interface BiomechanicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsEstimationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsEstimation(data: number[], opts: BiomechanicsEstimationOptions = {}): BiomechanicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsEstimation };
diff --git a/src/biomechanics/evaluation.ts b/src/biomechanics/evaluation.ts
new file mode 100644
index 000000000..7938e4a7f
--- /dev/null
+++ b/src/biomechanics/evaluation.ts
@@ -0,0 +1,14 @@
+/** biomechanics evaluation module — tsb analytics library. */
+export interface BiomechanicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsEvaluation(data: number[], opts: BiomechanicsEvaluationOptions = {}): BiomechanicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsEvaluation };
diff --git a/src/biomechanics/extrapolation.ts b/src/biomechanics/extrapolation.ts
new file mode 100644
index 000000000..5d3055319
--- /dev/null
+++ b/src/biomechanics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** biomechanics extrapolation module — tsb analytics library. */
+export interface BiomechanicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsExtrapolation(data: number[], opts: BiomechanicsExtrapolationOptions = {}): BiomechanicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsExtrapolation };
diff --git a/src/biomechanics/features.ts b/src/biomechanics/features.ts
new file mode 100644
index 000000000..5a94363d9
--- /dev/null
+++ b/src/biomechanics/features.ts
@@ -0,0 +1,14 @@
+/** biomechanics features module — tsb analytics library. */
+export interface BiomechanicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsFeatures(data: number[], opts: BiomechanicsFeaturesOptions = {}): BiomechanicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsFeatures };
diff --git a/src/biomechanics/feedback.ts b/src/biomechanics/feedback.ts
new file mode 100644
index 000000000..a0a4deb7d
--- /dev/null
+++ b/src/biomechanics/feedback.ts
@@ -0,0 +1,14 @@
+/** biomechanics feedback module — tsb analytics library. */
+export interface BiomechanicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsFeedback(data: number[], opts: BiomechanicsFeedbackOptions = {}): BiomechanicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsFeedback };
diff --git a/src/biomechanics/filtering.ts b/src/biomechanics/filtering.ts
new file mode 100644
index 000000000..a93fea407
--- /dev/null
+++ b/src/biomechanics/filtering.ts
@@ -0,0 +1,14 @@
+/** biomechanics filtering module — tsb analytics library. */
+export interface BiomechanicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsFilteringResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsFiltering(data: number[], opts: BiomechanicsFilteringOptions = {}): BiomechanicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsFiltering };
diff --git a/src/biomechanics/fourier.ts b/src/biomechanics/fourier.ts
new file mode 100644
index 000000000..332daf618
--- /dev/null
+++ b/src/biomechanics/fourier.ts
@@ -0,0 +1,14 @@
+/** biomechanics fourier module — tsb analytics library. */
+export interface BiomechanicsFourierOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsFourierResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsFourier(data: number[], opts: BiomechanicsFourierOptions = {}): BiomechanicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsFourier };
diff --git a/src/biomechanics/fusion.ts b/src/biomechanics/fusion.ts
new file mode 100644
index 000000000..367e9b0dc
--- /dev/null
+++ b/src/biomechanics/fusion.ts
@@ -0,0 +1,14 @@
+/** biomechanics fusion module — tsb analytics library. */
+export interface BiomechanicsFusionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsFusionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsFusion(data: number[], opts: BiomechanicsFusionOptions = {}): BiomechanicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsFusion };
diff --git a/src/biomechanics/generation.ts b/src/biomechanics/generation.ts
new file mode 100644
index 000000000..e7c141457
--- /dev/null
+++ b/src/biomechanics/generation.ts
@@ -0,0 +1,14 @@
+/** biomechanics generation module — tsb analytics library. */
+export interface BiomechanicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsGenerationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsGeneration(data: number[], opts: BiomechanicsGenerationOptions = {}): BiomechanicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsGeneration };
diff --git a/src/biomechanics/geometry.ts b/src/biomechanics/geometry.ts
new file mode 100644
index 000000000..232e0b0cd
--- /dev/null
+++ b/src/biomechanics/geometry.ts
@@ -0,0 +1,14 @@
+/** biomechanics geometry module — tsb analytics library. */
+export interface BiomechanicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsGeometryResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsGeometry(data: number[], opts: BiomechanicsGeometryOptions = {}): BiomechanicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsGeometry };
diff --git a/src/biomechanics/gradient.ts b/src/biomechanics/gradient.ts
new file mode 100644
index 000000000..79c16d72e
--- /dev/null
+++ b/src/biomechanics/gradient.ts
@@ -0,0 +1,14 @@
+/** biomechanics gradient module — tsb analytics library. */
+export interface BiomechanicsGradientOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsGradientResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsGradient(data: number[], opts: BiomechanicsGradientOptions = {}): BiomechanicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsGradient };
diff --git a/src/biomechanics/hessian.ts b/src/biomechanics/hessian.ts
new file mode 100644
index 000000000..7337bf16f
--- /dev/null
+++ b/src/biomechanics/hessian.ts
@@ -0,0 +1,14 @@
+/** biomechanics hessian module — tsb analytics library. */
+export interface BiomechanicsHessianOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsHessianResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsHessian(data: number[], opts: BiomechanicsHessianOptions = {}): BiomechanicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsHessian };
diff --git a/src/biomechanics/hypothesis.ts b/src/biomechanics/hypothesis.ts
new file mode 100644
index 000000000..65e8331b2
--- /dev/null
+++ b/src/biomechanics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** biomechanics hypothesis module — tsb analytics library. */
+export interface BiomechanicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsHypothesis(data: number[], opts: BiomechanicsHypothesisOptions = {}): BiomechanicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsHypothesis };
diff --git a/src/biomechanics/inference.ts b/src/biomechanics/inference.ts
new file mode 100644
index 000000000..74b92ba41
--- /dev/null
+++ b/src/biomechanics/inference.ts
@@ -0,0 +1,14 @@
+/** biomechanics inference module — tsb analytics library. */
+export interface BiomechanicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsInferenceResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsInference(data: number[], opts: BiomechanicsInferenceOptions = {}): BiomechanicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsInference };
diff --git a/src/biomechanics/inference2.ts b/src/biomechanics/inference2.ts
new file mode 100644
index 000000000..9b356bdbb
--- /dev/null
+++ b/src/biomechanics/inference2.ts
@@ -0,0 +1,14 @@
+/** biomechanics inference2 module — tsb analytics library. */
+export interface BiomechanicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsInferenceResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsInference(data: number[], opts: BiomechanicsInferenceOptions = {}): BiomechanicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsInference };
diff --git a/src/biomechanics/integral.ts b/src/biomechanics/integral.ts
new file mode 100644
index 000000000..184d24894
--- /dev/null
+++ b/src/biomechanics/integral.ts
@@ -0,0 +1,14 @@
+/** biomechanics integral module — tsb analytics library. */
+export interface BiomechanicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsIntegralResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsIntegral(data: number[], opts: BiomechanicsIntegralOptions = {}): BiomechanicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsIntegral };
diff --git a/src/biomechanics/integration.ts b/src/biomechanics/integration.ts
new file mode 100644
index 000000000..175a51228
--- /dev/null
+++ b/src/biomechanics/integration.ts
@@ -0,0 +1,14 @@
+/** biomechanics integration module — tsb analytics library. */
+export interface BiomechanicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsIntegration(data: number[], opts: BiomechanicsIntegrationOptions = {}): BiomechanicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsIntegration };
diff --git a/src/biomechanics/interpolation.ts b/src/biomechanics/interpolation.ts
new file mode 100644
index 000000000..2045ea666
--- /dev/null
+++ b/src/biomechanics/interpolation.ts
@@ -0,0 +1,14 @@
+/** biomechanics interpolation module — tsb analytics library. */
+export interface BiomechanicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsInterpolation(data: number[], opts: BiomechanicsInterpolationOptions = {}): BiomechanicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsInterpolation };
diff --git a/src/biomechanics/jacobian.ts b/src/biomechanics/jacobian.ts
new file mode 100644
index 000000000..2cf2acc30
--- /dev/null
+++ b/src/biomechanics/jacobian.ts
@@ -0,0 +1,14 @@
+/** biomechanics jacobian module — tsb analytics library. */
+export interface BiomechanicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsJacobianResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsJacobian(data: number[], opts: BiomechanicsJacobianOptions = {}): BiomechanicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsJacobian };
diff --git a/src/biomechanics/kernel.ts b/src/biomechanics/kernel.ts
new file mode 100644
index 000000000..1987e5330
--- /dev/null
+++ b/src/biomechanics/kernel.ts
@@ -0,0 +1,14 @@
+/** biomechanics kernel module — tsb analytics library. */
+export interface BiomechanicsKernelOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsKernelResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsKernel(data: number[], opts: BiomechanicsKernelOptions = {}): BiomechanicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsKernel };
diff --git a/src/biomechanics/laplacian.ts b/src/biomechanics/laplacian.ts
new file mode 100644
index 000000000..cdd89c426
--- /dev/null
+++ b/src/biomechanics/laplacian.ts
@@ -0,0 +1,14 @@
+/** biomechanics laplacian module — tsb analytics library. */
+export interface BiomechanicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsLaplacian(data: number[], opts: BiomechanicsLaplacianOptions = {}): BiomechanicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsLaplacian };
diff --git a/src/biomechanics/learning.ts b/src/biomechanics/learning.ts
new file mode 100644
index 000000000..29f07a488
--- /dev/null
+++ b/src/biomechanics/learning.ts
@@ -0,0 +1,14 @@
+/** biomechanics learning module — tsb analytics library. */
+export interface BiomechanicsLearningOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsLearningResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsLearning(data: number[], opts: BiomechanicsLearningOptions = {}): BiomechanicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsLearning };
diff --git a/src/biomechanics/linear.ts b/src/biomechanics/linear.ts
new file mode 100644
index 000000000..005896906
--- /dev/null
+++ b/src/biomechanics/linear.ts
@@ -0,0 +1,14 @@
+/** biomechanics linear module — tsb analytics library. */
+export interface BiomechanicsLinearOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsLinearResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsLinear(data: number[], opts: BiomechanicsLinearOptions = {}): BiomechanicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsLinear };
diff --git a/src/biomechanics/manifold.ts b/src/biomechanics/manifold.ts
new file mode 100644
index 000000000..641117741
--- /dev/null
+++ b/src/biomechanics/manifold.ts
@@ -0,0 +1,14 @@
+/** biomechanics manifold module — tsb analytics library. */
+export interface BiomechanicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsManifoldResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsManifold(data: number[], opts: BiomechanicsManifoldOptions = {}): BiomechanicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsManifold };
diff --git a/src/biomechanics/matching.ts b/src/biomechanics/matching.ts
new file mode 100644
index 000000000..4dcd023d4
--- /dev/null
+++ b/src/biomechanics/matching.ts
@@ -0,0 +1,14 @@
+/** biomechanics matching module — tsb analytics library. */
+export interface BiomechanicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsMatchingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsMatching(data: number[], opts: BiomechanicsMatchingOptions = {}): BiomechanicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsMatching };
diff --git a/src/biomechanics/measurement.ts b/src/biomechanics/measurement.ts
new file mode 100644
index 000000000..1a83b85e4
--- /dev/null
+++ b/src/biomechanics/measurement.ts
@@ -0,0 +1,14 @@
+/** biomechanics measurement module — tsb analytics library. */
+export interface BiomechanicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsMeasurement(data: number[], opts: BiomechanicsMeasurementOptions = {}): BiomechanicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsMeasurement };
diff --git a/src/biomechanics/metrics.ts b/src/biomechanics/metrics.ts
new file mode 100644
index 000000000..14100a2b8
--- /dev/null
+++ b/src/biomechanics/metrics.ts
@@ -0,0 +1,14 @@
+/** biomechanics metrics module — tsb analytics library. */
+export interface BiomechanicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsMetricsResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsMetrics(data: number[], opts: BiomechanicsMetricsOptions = {}): BiomechanicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsMetrics };
diff --git a/src/biomechanics/modeling.ts b/src/biomechanics/modeling.ts
new file mode 100644
index 000000000..6d12e2b87
--- /dev/null
+++ b/src/biomechanics/modeling.ts
@@ -0,0 +1,14 @@
+/** biomechanics modeling module — tsb analytics library. */
+export interface BiomechanicsModelingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsModelingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsModeling(data: number[], opts: BiomechanicsModelingOptions = {}): BiomechanicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsModeling };
diff --git a/src/biomechanics/monitoring.ts b/src/biomechanics/monitoring.ts
new file mode 100644
index 000000000..c1a555427
--- /dev/null
+++ b/src/biomechanics/monitoring.ts
@@ -0,0 +1,14 @@
+/** biomechanics monitoring module — tsb analytics library. */
+export interface BiomechanicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsMonitoring(data: number[], opts: BiomechanicsMonitoringOptions = {}): BiomechanicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsMonitoring };
diff --git a/src/biomechanics/nonlinear.ts b/src/biomechanics/nonlinear.ts
new file mode 100644
index 000000000..743b99467
--- /dev/null
+++ b/src/biomechanics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** biomechanics nonlinear module — tsb analytics library. */
+export interface BiomechanicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsNonlinear(data: number[], opts: BiomechanicsNonlinearOptions = {}): BiomechanicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsNonlinear };
diff --git a/src/biomechanics/normalization.ts b/src/biomechanics/normalization.ts
new file mode 100644
index 000000000..0a550f71f
--- /dev/null
+++ b/src/biomechanics/normalization.ts
@@ -0,0 +1,14 @@
+/** biomechanics normalization module — tsb analytics library. */
+export interface BiomechanicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsNormalization(data: number[], opts: BiomechanicsNormalizationOptions = {}): BiomechanicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsNormalization };
diff --git a/src/biomechanics/optimization.ts b/src/biomechanics/optimization.ts
new file mode 100644
index 000000000..c2e85c726
--- /dev/null
+++ b/src/biomechanics/optimization.ts
@@ -0,0 +1,14 @@
+/** biomechanics optimization module — tsb analytics library. */
+export interface BiomechanicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsOptimization(data: number[], opts: BiomechanicsOptimizationOptions = {}): BiomechanicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsOptimization };
diff --git a/src/biomechanics/patterns.ts b/src/biomechanics/patterns.ts
new file mode 100644
index 000000000..4686d8fe8
--- /dev/null
+++ b/src/biomechanics/patterns.ts
@@ -0,0 +1,14 @@
+/** biomechanics patterns module — tsb analytics library. */
+export interface BiomechanicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsPatternsResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsPatterns(data: number[], opts: BiomechanicsPatternsOptions = {}): BiomechanicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsPatterns };
diff --git a/src/biomechanics/permutation.ts b/src/biomechanics/permutation.ts
new file mode 100644
index 000000000..3d5c7d1b5
--- /dev/null
+++ b/src/biomechanics/permutation.ts
@@ -0,0 +1,14 @@
+/** biomechanics permutation module — tsb analytics library. */
+export interface BiomechanicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsPermutationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsPermutation(data: number[], opts: BiomechanicsPermutationOptions = {}): BiomechanicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsPermutation };
diff --git a/src/biomechanics/prediction.ts b/src/biomechanics/prediction.ts
new file mode 100644
index 000000000..cce20da9c
--- /dev/null
+++ b/src/biomechanics/prediction.ts
@@ -0,0 +1,14 @@
+/** biomechanics prediction module — tsb analytics library. */
+export interface BiomechanicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsPredictionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsPrediction(data: number[], opts: BiomechanicsPredictionOptions = {}): BiomechanicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsPrediction };
diff --git a/src/biomechanics/processing.ts b/src/biomechanics/processing.ts
new file mode 100644
index 000000000..4dc6afd77
--- /dev/null
+++ b/src/biomechanics/processing.ts
@@ -0,0 +1,14 @@
+/** biomechanics processing module — tsb analytics library. */
+export interface BiomechanicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsProcessingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsProcessing(data: number[], opts: BiomechanicsProcessingOptions = {}): BiomechanicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsProcessing };
diff --git a/src/biomechanics/profiling.ts b/src/biomechanics/profiling.ts
new file mode 100644
index 000000000..1cecd6130
--- /dev/null
+++ b/src/biomechanics/profiling.ts
@@ -0,0 +1,14 @@
+/** biomechanics profiling module — tsb analytics library. */
+export interface BiomechanicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsProfilingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsProfiling(data: number[], opts: BiomechanicsProfilingOptions = {}): BiomechanicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsProfiling };
diff --git a/src/biomechanics/projection.ts b/src/biomechanics/projection.ts
new file mode 100644
index 000000000..e078ed5c3
--- /dev/null
+++ b/src/biomechanics/projection.ts
@@ -0,0 +1,14 @@
+/** biomechanics projection module — tsb analytics library. */
+export interface BiomechanicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsProjectionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsProjection(data: number[], opts: BiomechanicsProjectionOptions = {}): BiomechanicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsProjection };
diff --git a/src/biomechanics/ranking.ts b/src/biomechanics/ranking.ts
new file mode 100644
index 000000000..5050788b2
--- /dev/null
+++ b/src/biomechanics/ranking.ts
@@ -0,0 +1,14 @@
+/** biomechanics ranking module — tsb analytics library. */
+export interface BiomechanicsRankingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsRankingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsRanking(data: number[], opts: BiomechanicsRankingOptions = {}): BiomechanicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsRanking };
diff --git a/src/biomechanics/reconstruction.ts b/src/biomechanics/reconstruction.ts
new file mode 100644
index 000000000..b14920d94
--- /dev/null
+++ b/src/biomechanics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** biomechanics reconstruction module — tsb analytics library. */
+export interface BiomechanicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsReconstruction(data: number[], opts: BiomechanicsReconstructionOptions = {}): BiomechanicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsReconstruction };
diff --git a/src/biomechanics/registration.ts b/src/biomechanics/registration.ts
new file mode 100644
index 000000000..98f35f7b2
--- /dev/null
+++ b/src/biomechanics/registration.ts
@@ -0,0 +1,14 @@
+/** biomechanics registration module — tsb analytics library. */
+export interface BiomechanicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsRegistration(data: number[], opts: BiomechanicsRegistrationOptions = {}): BiomechanicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsRegistration };
diff --git a/src/biomechanics/regression.ts b/src/biomechanics/regression.ts
new file mode 100644
index 000000000..90582484e
--- /dev/null
+++ b/src/biomechanics/regression.ts
@@ -0,0 +1,14 @@
+/** biomechanics regression module — tsb analytics library. */
+export interface BiomechanicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsRegressionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsRegression(data: number[], opts: BiomechanicsRegressionOptions = {}): BiomechanicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsRegression };
diff --git a/src/biomechanics/regularization.ts b/src/biomechanics/regularization.ts
new file mode 100644
index 000000000..daeacc995
--- /dev/null
+++ b/src/biomechanics/regularization.ts
@@ -0,0 +1,14 @@
+/** biomechanics regularization module — tsb analytics library. */
+export interface BiomechanicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsRegularization(data: number[], opts: BiomechanicsRegularizationOptions = {}): BiomechanicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsRegularization };
diff --git a/src/biomechanics/robustness.ts b/src/biomechanics/robustness.ts
new file mode 100644
index 000000000..38b0bd72b
--- /dev/null
+++ b/src/biomechanics/robustness.ts
@@ -0,0 +1,14 @@
+/** biomechanics robustness module — tsb analytics library. */
+export interface BiomechanicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsRobustness(data: number[], opts: BiomechanicsRobustnessOptions = {}): BiomechanicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsRobustness };
diff --git a/src/biomechanics/sampling.ts b/src/biomechanics/sampling.ts
new file mode 100644
index 000000000..de546601b
--- /dev/null
+++ b/src/biomechanics/sampling.ts
@@ -0,0 +1,14 @@
+/** biomechanics sampling module — tsb analytics library. */
+export interface BiomechanicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsSamplingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsSampling(data: number[], opts: BiomechanicsSamplingOptions = {}): BiomechanicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsSampling };
diff --git a/src/biomechanics/sampling2.ts b/src/biomechanics/sampling2.ts
new file mode 100644
index 000000000..92a90cd1e
--- /dev/null
+++ b/src/biomechanics/sampling2.ts
@@ -0,0 +1,14 @@
+/** biomechanics sampling2 module — tsb analytics library. */
+export interface BiomechanicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsSamplingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsSampling(data: number[], opts: BiomechanicsSamplingOptions = {}): BiomechanicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsSampling };
diff --git a/src/biomechanics/scaling.ts b/src/biomechanics/scaling.ts
new file mode 100644
index 000000000..cf607ddb9
--- /dev/null
+++ b/src/biomechanics/scaling.ts
@@ -0,0 +1,14 @@
+/** biomechanics scaling module — tsb analytics library. */
+export interface BiomechanicsScalingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsScalingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsScaling(data: number[], opts: BiomechanicsScalingOptions = {}): BiomechanicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsScaling };
diff --git a/src/biomechanics/scoring.ts b/src/biomechanics/scoring.ts
new file mode 100644
index 000000000..59200d2cb
--- /dev/null
+++ b/src/biomechanics/scoring.ts
@@ -0,0 +1,14 @@
+/** biomechanics scoring module — tsb analytics library. */
+export interface BiomechanicsScoringOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsScoringResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsScoring(data: number[], opts: BiomechanicsScoringOptions = {}): BiomechanicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsScoring };
diff --git a/src/biomechanics/segmentation.ts b/src/biomechanics/segmentation.ts
new file mode 100644
index 000000000..78ef23712
--- /dev/null
+++ b/src/biomechanics/segmentation.ts
@@ -0,0 +1,14 @@
+/** biomechanics segmentation module — tsb analytics library. */
+export interface BiomechanicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsSegmentation(data: number[], opts: BiomechanicsSegmentationOptions = {}): BiomechanicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsSegmentation };
diff --git a/src/biomechanics/selection.ts b/src/biomechanics/selection.ts
new file mode 100644
index 000000000..68ea8a25a
--- /dev/null
+++ b/src/biomechanics/selection.ts
@@ -0,0 +1,14 @@
+/** biomechanics selection module — tsb analytics library. */
+export interface BiomechanicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsSelectionResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsSelection(data: number[], opts: BiomechanicsSelectionOptions = {}): BiomechanicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsSelection };
diff --git a/src/biomechanics/sensitivity.ts b/src/biomechanics/sensitivity.ts
new file mode 100644
index 000000000..260c295bf
--- /dev/null
+++ b/src/biomechanics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** biomechanics sensitivity module — tsb analytics library. */
+export interface BiomechanicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsSensitivity(data: number[], opts: BiomechanicsSensitivityOptions = {}): BiomechanicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsSensitivity };
diff --git a/src/biomechanics/simulation.ts b/src/biomechanics/simulation.ts
new file mode 100644
index 000000000..29d027b7f
--- /dev/null
+++ b/src/biomechanics/simulation.ts
@@ -0,0 +1,14 @@
+/** biomechanics simulation module — tsb analytics library. */
+export interface BiomechanicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsSimulationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsSimulation(data: number[], opts: BiomechanicsSimulationOptions = {}): BiomechanicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsSimulation };
diff --git a/src/biomechanics/smoothing.ts b/src/biomechanics/smoothing.ts
new file mode 100644
index 000000000..e98eff8f7
--- /dev/null
+++ b/src/biomechanics/smoothing.ts
@@ -0,0 +1,14 @@
+/** biomechanics smoothing module — tsb analytics library. */
+export interface BiomechanicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsSmoothing(data: number[], opts: BiomechanicsSmoothingOptions = {}): BiomechanicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsSmoothing };
diff --git a/src/biomechanics/stability.ts b/src/biomechanics/stability.ts
new file mode 100644
index 000000000..988ee205a
--- /dev/null
+++ b/src/biomechanics/stability.ts
@@ -0,0 +1,14 @@
+/** biomechanics stability module — tsb analytics library. */
+export interface BiomechanicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsStabilityResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsStability(data: number[], opts: BiomechanicsStabilityOptions = {}): BiomechanicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsStability };
diff --git a/src/biomechanics/stacking.ts b/src/biomechanics/stacking.ts
new file mode 100644
index 000000000..e1c7d7cb4
--- /dev/null
+++ b/src/biomechanics/stacking.ts
@@ -0,0 +1,14 @@
+/** biomechanics stacking module — tsb analytics library. */
+export interface BiomechanicsStackingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsStackingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsStacking(data: number[], opts: BiomechanicsStackingOptions = {}): BiomechanicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsStacking };
diff --git a/src/biomechanics/standardization.ts b/src/biomechanics/standardization.ts
new file mode 100644
index 000000000..1e561d726
--- /dev/null
+++ b/src/biomechanics/standardization.ts
@@ -0,0 +1,14 @@
+/** biomechanics standardization module — tsb analytics library. */
+export interface BiomechanicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsStandardization(data: number[], opts: BiomechanicsStandardizationOptions = {}): BiomechanicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsStandardization };
diff --git a/src/biomechanics/static.ts b/src/biomechanics/static.ts
new file mode 100644
index 000000000..c8e4e44ed
--- /dev/null
+++ b/src/biomechanics/static.ts
@@ -0,0 +1,14 @@
+/** biomechanics static module — tsb analytics library. */
+export interface BiomechanicsStaticOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsStaticResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsStatic(data: number[], opts: BiomechanicsStaticOptions = {}): BiomechanicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsStatic };
diff --git a/src/biomechanics/stochastic.ts b/src/biomechanics/stochastic.ts
new file mode 100644
index 000000000..6549e0d7a
--- /dev/null
+++ b/src/biomechanics/stochastic.ts
@@ -0,0 +1,14 @@
+/** biomechanics stochastic module — tsb analytics library. */
+export interface BiomechanicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsStochasticResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsStochastic(data: number[], opts: BiomechanicsStochasticOptions = {}): BiomechanicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsStochastic };
diff --git a/src/biomechanics/synthesis.ts b/src/biomechanics/synthesis.ts
new file mode 100644
index 000000000..53545c463
--- /dev/null
+++ b/src/biomechanics/synthesis.ts
@@ -0,0 +1,14 @@
+/** biomechanics synthesis module — tsb analytics library. */
+export interface BiomechanicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsSynthesis(data: number[], opts: BiomechanicsSynthesisOptions = {}): BiomechanicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsSynthesis };
diff --git a/src/biomechanics/topology.ts b/src/biomechanics/topology.ts
new file mode 100644
index 000000000..a3c925aa6
--- /dev/null
+++ b/src/biomechanics/topology.ts
@@ -0,0 +1,14 @@
+/** biomechanics topology module — tsb analytics library. */
+export interface BiomechanicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsTopologyResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsTopology(data: number[], opts: BiomechanicsTopologyOptions = {}): BiomechanicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsTopology };
diff --git a/src/biomechanics/tracking.ts b/src/biomechanics/tracking.ts
new file mode 100644
index 000000000..14b409f92
--- /dev/null
+++ b/src/biomechanics/tracking.ts
@@ -0,0 +1,14 @@
+/** biomechanics tracking module — tsb analytics library. */
+export interface BiomechanicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsTrackingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsTracking(data: number[], opts: BiomechanicsTrackingOptions = {}): BiomechanicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsTracking };
diff --git a/src/biomechanics/transform.ts b/src/biomechanics/transform.ts
new file mode 100644
index 000000000..d7dadabe8
--- /dev/null
+++ b/src/biomechanics/transform.ts
@@ -0,0 +1,14 @@
+/** biomechanics transform module — tsb analytics library. */
+export interface BiomechanicsTransformOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsTransformResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsTransform(data: number[], opts: BiomechanicsTransformOptions = {}): BiomechanicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsTransform };
diff --git a/src/biomechanics/uncertainty.ts b/src/biomechanics/uncertainty.ts
new file mode 100644
index 000000000..9e1a3f97c
--- /dev/null
+++ b/src/biomechanics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** biomechanics uncertainty module — tsb analytics library. */
+export interface BiomechanicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsUncertainty(data: number[], opts: BiomechanicsUncertaintyOptions = {}): BiomechanicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsUncertainty };
diff --git a/src/biomechanics/validation.ts b/src/biomechanics/validation.ts
new file mode 100644
index 000000000..4a857ebf5
--- /dev/null
+++ b/src/biomechanics/validation.ts
@@ -0,0 +1,14 @@
+/** biomechanics validation module — tsb analytics library. */
+export interface BiomechanicsValidationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsValidationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsValidation(data: number[], opts: BiomechanicsValidationOptions = {}): BiomechanicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsValidation };
diff --git a/src/biomechanics/verification.ts b/src/biomechanics/verification.ts
new file mode 100644
index 000000000..e7c039e5d
--- /dev/null
+++ b/src/biomechanics/verification.ts
@@ -0,0 +1,14 @@
+/** biomechanics verification module — tsb analytics library. */
+export interface BiomechanicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsVerificationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsVerification(data: number[], opts: BiomechanicsVerificationOptions = {}): BiomechanicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsVerification };
diff --git a/src/biomechanics/visualization.ts b/src/biomechanics/visualization.ts
new file mode 100644
index 000000000..7640ce1be
--- /dev/null
+++ b/src/biomechanics/visualization.ts
@@ -0,0 +1,14 @@
+/** biomechanics visualization module — tsb analytics library. */
+export interface BiomechanicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsVisualization(data: number[], opts: BiomechanicsVisualizationOptions = {}): BiomechanicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsVisualization };
diff --git a/src/biomechanics/voting.ts b/src/biomechanics/voting.ts
new file mode 100644
index 000000000..07486ad1e
--- /dev/null
+++ b/src/biomechanics/voting.ts
@@ -0,0 +1,14 @@
+/** biomechanics voting module — tsb analytics library. */
+export interface BiomechanicsVotingOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsVotingResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsVoting(data: number[], opts: BiomechanicsVotingOptions = {}): BiomechanicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsVoting };
diff --git a/src/biomechanics/wavelet.ts b/src/biomechanics/wavelet.ts
new file mode 100644
index 000000000..da7c14c32
--- /dev/null
+++ b/src/biomechanics/wavelet.ts
@@ -0,0 +1,14 @@
+/** biomechanics wavelet module — tsb analytics library. */
+export interface BiomechanicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface BiomechanicsWaveletResult { values: number[]; converged: boolean; }
+export function computeBiomechanicsWavelet(data: number[], opts: BiomechanicsWaveletOptions = {}): BiomechanicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeBiomechanicsWavelet };
diff --git a/src/cardiology_sci/adaptation.ts b/src/cardiology_sci/adaptation.ts
new file mode 100644
index 000000000..d0fe846bc
--- /dev/null
+++ b/src/cardiology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci adaptation module — tsb analytics library. */
+export interface CardiologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciAdaptation(data: number[], opts: CardiologySciAdaptationOptions = {}): CardiologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciAdaptation };
diff --git a/src/cardiology_sci/aggregation.ts b/src/cardiology_sci/aggregation.ts
new file mode 100644
index 000000000..c8a433220
--- /dev/null
+++ b/src/cardiology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci aggregation module — tsb analytics library. */
+export interface CardiologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciAggregation(data: number[], opts: CardiologySciAggregationOptions = {}): CardiologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciAggregation };
diff --git a/src/cardiology_sci/algebra.ts b/src/cardiology_sci/algebra.ts
new file mode 100644
index 000000000..bdab1b0bf
--- /dev/null
+++ b/src/cardiology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci algebra module — tsb analytics library. */
+export interface CardiologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeCardiologySciAlgebra(data: number[], opts: CardiologySciAlgebraOptions = {}): CardiologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciAlgebra };
diff --git a/src/cardiology_sci/alignment.ts b/src/cardiology_sci/alignment.ts
new file mode 100644
index 000000000..99fa198e9
--- /dev/null
+++ b/src/cardiology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci alignment module — tsb analytics library. */
+export interface CardiologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeCardiologySciAlignment(data: number[], opts: CardiologySciAlignmentOptions = {}): CardiologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciAlignment };
diff --git a/src/cardiology_sci/analysis.ts b/src/cardiology_sci/analysis.ts
new file mode 100644
index 000000000..d6ce8ad37
--- /dev/null
+++ b/src/cardiology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci analysis module — tsb analytics library. */
+export interface CardiologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeCardiologySciAnalysis(data: number[], opts: CardiologySciAnalysisOptions = {}): CardiologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciAnalysis };
diff --git a/src/cardiology_sci/augmentation.ts b/src/cardiology_sci/augmentation.ts
new file mode 100644
index 000000000..c83bda8f8
--- /dev/null
+++ b/src/cardiology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci augmentation module — tsb analytics library. */
+export interface CardiologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciAugmentation(data: number[], opts: CardiologySciAugmentationOptions = {}): CardiologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciAugmentation };
diff --git a/src/cardiology_sci/bagging.ts b/src/cardiology_sci/bagging.ts
new file mode 100644
index 000000000..868207887
--- /dev/null
+++ b/src/cardiology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci bagging module — tsb analytics library. */
+export interface CardiologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciBagging(data: number[], opts: CardiologySciBaggingOptions = {}): CardiologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciBagging };
diff --git a/src/cardiology_sci/basis.ts b/src/cardiology_sci/basis.ts
new file mode 100644
index 000000000..4a89c5e30
--- /dev/null
+++ b/src/cardiology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci basis module — tsb analytics library. */
+export interface CardiologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciBasisResult { values: number[]; converged: boolean; }
+export function computeCardiologySciBasis(data: number[], opts: CardiologySciBasisOptions = {}): CardiologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciBasis };
diff --git a/src/cardiology_sci/benchmarking.ts b/src/cardiology_sci/benchmarking.ts
new file mode 100644
index 000000000..ca1f5ff3c
--- /dev/null
+++ b/src/cardiology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci benchmarking module — tsb analytics library. */
+export interface CardiologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciBenchmarking(data: number[], opts: CardiologySciBenchmarkingOptions = {}): CardiologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciBenchmarking };
diff --git a/src/cardiology_sci/blending.ts b/src/cardiology_sci/blending.ts
new file mode 100644
index 000000000..c092f3dd5
--- /dev/null
+++ b/src/cardiology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci blending module — tsb analytics library. */
+export interface CardiologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciBlending(data: number[], opts: CardiologySciBlendingOptions = {}): CardiologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciBlending };
diff --git a/src/cardiology_sci/boosting.ts b/src/cardiology_sci/boosting.ts
new file mode 100644
index 000000000..3e0068407
--- /dev/null
+++ b/src/cardiology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci boosting module — tsb analytics library. */
+export interface CardiologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciBoosting(data: number[], opts: CardiologySciBoostingOptions = {}): CardiologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciBoosting };
diff --git a/src/cardiology_sci/bootstrap.ts b/src/cardiology_sci/bootstrap.ts
new file mode 100644
index 000000000..3a1f7da94
--- /dev/null
+++ b/src/cardiology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci bootstrap module — tsb analytics library. */
+export interface CardiologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeCardiologySciBootstrap(data: number[], opts: CardiologySciBootstrapOptions = {}): CardiologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciBootstrap };
diff --git a/src/cardiology_sci/calculus.ts b/src/cardiology_sci/calculus.ts
new file mode 100644
index 000000000..37c16c562
--- /dev/null
+++ b/src/cardiology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci calculus module — tsb analytics library. */
+export interface CardiologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeCardiologySciCalculus(data: number[], opts: CardiologySciCalculusOptions = {}): CardiologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciCalculus };
diff --git a/src/cardiology_sci/calibration.ts b/src/cardiology_sci/calibration.ts
new file mode 100644
index 000000000..5e988f6f7
--- /dev/null
+++ b/src/cardiology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci calibration module — tsb analytics library. */
+export interface CardiologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciCalibration(data: number[], opts: CardiologySciCalibrationOptions = {}): CardiologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciCalibration };
diff --git a/src/cardiology_sci/characterization.ts b/src/cardiology_sci/characterization.ts
new file mode 100644
index 000000000..7b05d8f44
--- /dev/null
+++ b/src/cardiology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci characterization module — tsb analytics library. */
+export interface CardiologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciCharacterization(data: number[], opts: CardiologySciCharacterizationOptions = {}): CardiologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciCharacterization };
diff --git a/src/cardiology_sci/classification.ts b/src/cardiology_sci/classification.ts
new file mode 100644
index 000000000..845bac850
--- /dev/null
+++ b/src/cardiology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci classification module — tsb analytics library. */
+export interface CardiologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciClassification(data: number[], opts: CardiologySciClassificationOptions = {}): CardiologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciClassification };
diff --git a/src/cardiology_sci/clustering.ts b/src/cardiology_sci/clustering.ts
new file mode 100644
index 000000000..7c8cd7aa8
--- /dev/null
+++ b/src/cardiology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci clustering module — tsb analytics library. */
+export interface CardiologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeCardiologySciClustering(data: number[], opts: CardiologySciClusteringOptions = {}): CardiologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciClustering };
diff --git a/src/cardiology_sci/compression.ts b/src/cardiology_sci/compression.ts
new file mode 100644
index 000000000..e2addac5f
--- /dev/null
+++ b/src/cardiology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci compression module — tsb analytics library. */
+export interface CardiologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciCompression(data: number[], opts: CardiologySciCompressionOptions = {}): CardiologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciCompression };
diff --git a/src/cardiology_sci/continuous.ts b/src/cardiology_sci/continuous.ts
new file mode 100644
index 000000000..c99bb8126
--- /dev/null
+++ b/src/cardiology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci continuous module — tsb analytics library. */
+export interface CardiologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeCardiologySciContinuous(data: number[], opts: CardiologySciContinuousOptions = {}): CardiologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciContinuous };
diff --git a/src/cardiology_sci/control.ts b/src/cardiology_sci/control.ts
new file mode 100644
index 000000000..4daa25e70
--- /dev/null
+++ b/src/cardiology_sci/control.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci control module — tsb analytics library. */
+export interface CardiologySciControlOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciControlResult { values: number[]; converged: boolean; }
+export function computeCardiologySciControl(data: number[], opts: CardiologySciControlOptions = {}): CardiologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciControl };
diff --git a/src/cardiology_sci/convergence.ts b/src/cardiology_sci/convergence.ts
new file mode 100644
index 000000000..74def55af
--- /dev/null
+++ b/src/cardiology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci convergence module — tsb analytics library. */
+export interface CardiologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeCardiologySciConvergence(data: number[], opts: CardiologySciConvergenceOptions = {}): CardiologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciConvergence };
diff --git a/src/cardiology_sci/convex.ts b/src/cardiology_sci/convex.ts
new file mode 100644
index 000000000..4637d2f3e
--- /dev/null
+++ b/src/cardiology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci convex module — tsb analytics library. */
+export interface CardiologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciConvexResult { values: number[]; converged: boolean; }
+export function computeCardiologySciConvex(data: number[], opts: CardiologySciConvexOptions = {}): CardiologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciConvex };
diff --git a/src/cardiology_sci/correlation.ts b/src/cardiology_sci/correlation.ts
new file mode 100644
index 000000000..498b824b0
--- /dev/null
+++ b/src/cardiology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci correlation module — tsb analytics library. */
+export interface CardiologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciCorrelation(data: number[], opts: CardiologySciCorrelationOptions = {}): CardiologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciCorrelation };
diff --git a/src/cardiology_sci/covariance.ts b/src/cardiology_sci/covariance.ts
new file mode 100644
index 000000000..2a4a3ebd1
--- /dev/null
+++ b/src/cardiology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci covariance module — tsb analytics library. */
+export interface CardiologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeCardiologySciCovariance(data: number[], opts: CardiologySciCovarianceOptions = {}): CardiologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciCovariance };
diff --git a/src/cardiology_sci/cross_validation.ts b/src/cardiology_sci/cross_validation.ts
new file mode 100644
index 000000000..77f14227e
--- /dev/null
+++ b/src/cardiology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci cross_validation module — tsb analytics library. */
+export interface CardiologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciCrossValidation(data: number[], opts: CardiologySciCrossValidationOptions = {}): CardiologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciCrossValidation };
diff --git a/src/cardiology_sci/decoding.ts b/src/cardiology_sci/decoding.ts
new file mode 100644
index 000000000..f44774c8a
--- /dev/null
+++ b/src/cardiology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci decoding module — tsb analytics library. */
+export interface CardiologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDecoding(data: number[], opts: CardiologySciDecodingOptions = {}): CardiologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDecoding };
diff --git a/src/cardiology_sci/decomposition.ts b/src/cardiology_sci/decomposition.ts
new file mode 100644
index 000000000..2452fad38
--- /dev/null
+++ b/src/cardiology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci decomposition module — tsb analytics library. */
+export interface CardiologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDecomposition(data: number[], opts: CardiologySciDecompositionOptions = {}): CardiologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDecomposition };
diff --git a/src/cardiology_sci/detection.ts b/src/cardiology_sci/detection.ts
new file mode 100644
index 000000000..a7dd515a4
--- /dev/null
+++ b/src/cardiology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci detection module — tsb analytics library. */
+export interface CardiologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDetection(data: number[], opts: CardiologySciDetectionOptions = {}): CardiologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDetection };
diff --git a/src/cardiology_sci/deterministic.ts b/src/cardiology_sci/deterministic.ts
new file mode 100644
index 000000000..03abe66e9
--- /dev/null
+++ b/src/cardiology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci deterministic module — tsb analytics library. */
+export interface CardiologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDeterministic(data: number[], opts: CardiologySciDeterministicOptions = {}): CardiologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDeterministic };
diff --git a/src/cardiology_sci/diagnostics.ts b/src/cardiology_sci/diagnostics.ts
new file mode 100644
index 000000000..f5dec2128
--- /dev/null
+++ b/src/cardiology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci diagnostics module — tsb analytics library. */
+export interface CardiologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDiagnostics(data: number[], opts: CardiologySciDiagnosticsOptions = {}): CardiologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDiagnostics };
diff --git a/src/cardiology_sci/differential.ts b/src/cardiology_sci/differential.ts
new file mode 100644
index 000000000..1ca4e645f
--- /dev/null
+++ b/src/cardiology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci differential module — tsb analytics library. */
+export interface CardiologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDifferential(data: number[], opts: CardiologySciDifferentialOptions = {}): CardiologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDifferential };
diff --git a/src/cardiology_sci/discrete.ts b/src/cardiology_sci/discrete.ts
new file mode 100644
index 000000000..b5e54f99b
--- /dev/null
+++ b/src/cardiology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci discrete module — tsb analytics library. */
+export interface CardiologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDiscrete(data: number[], opts: CardiologySciDiscreteOptions = {}): CardiologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDiscrete };
diff --git a/src/cardiology_sci/distribution.ts b/src/cardiology_sci/distribution.ts
new file mode 100644
index 000000000..af97cc550
--- /dev/null
+++ b/src/cardiology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci distribution module — tsb analytics library. */
+export interface CardiologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDistribution(data: number[], opts: CardiologySciDistributionOptions = {}): CardiologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDistribution };
diff --git a/src/cardiology_sci/dynamic.ts b/src/cardiology_sci/dynamic.ts
new file mode 100644
index 000000000..69490866b
--- /dev/null
+++ b/src/cardiology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci dynamic module — tsb analytics library. */
+export interface CardiologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeCardiologySciDynamic(data: number[], opts: CardiologySciDynamicOptions = {}): CardiologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciDynamic };
diff --git a/src/cardiology_sci/embedding.ts b/src/cardiology_sci/embedding.ts
new file mode 100644
index 000000000..2cfd0b391
--- /dev/null
+++ b/src/cardiology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci embedding module — tsb analytics library. */
+export interface CardiologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciEmbedding(data: number[], opts: CardiologySciEmbeddingOptions = {}): CardiologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciEmbedding };
diff --git a/src/cardiology_sci/encoding.ts b/src/cardiology_sci/encoding.ts
new file mode 100644
index 000000000..961b9cb20
--- /dev/null
+++ b/src/cardiology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci encoding module — tsb analytics library. */
+export interface CardiologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciEncoding(data: number[], opts: CardiologySciEncodingOptions = {}): CardiologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciEncoding };
diff --git a/src/cardiology_sci/ensemble.ts b/src/cardiology_sci/ensemble.ts
new file mode 100644
index 000000000..51cf0303e
--- /dev/null
+++ b/src/cardiology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci ensemble module — tsb analytics library. */
+export interface CardiologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeCardiologySciEnsemble(data: number[], opts: CardiologySciEnsembleOptions = {}): CardiologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciEnsemble };
diff --git a/src/cardiology_sci/estimation.ts b/src/cardiology_sci/estimation.ts
new file mode 100644
index 000000000..36755491c
--- /dev/null
+++ b/src/cardiology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci estimation module — tsb analytics library. */
+export interface CardiologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciEstimation(data: number[], opts: CardiologySciEstimationOptions = {}): CardiologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciEstimation };
diff --git a/src/cardiology_sci/evaluation.ts b/src/cardiology_sci/evaluation.ts
new file mode 100644
index 000000000..376178371
--- /dev/null
+++ b/src/cardiology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci evaluation module — tsb analytics library. */
+export interface CardiologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciEvaluation(data: number[], opts: CardiologySciEvaluationOptions = {}): CardiologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciEvaluation };
diff --git a/src/cardiology_sci/extrapolation.ts b/src/cardiology_sci/extrapolation.ts
new file mode 100644
index 000000000..e9d3c5d0c
--- /dev/null
+++ b/src/cardiology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci extrapolation module — tsb analytics library. */
+export interface CardiologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciExtrapolation(data: number[], opts: CardiologySciExtrapolationOptions = {}): CardiologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciExtrapolation };
diff --git a/src/cardiology_sci/features.ts b/src/cardiology_sci/features.ts
new file mode 100644
index 000000000..72636f3dc
--- /dev/null
+++ b/src/cardiology_sci/features.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci features module — tsb analytics library. */
+export interface CardiologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeCardiologySciFeatures(data: number[], opts: CardiologySciFeaturesOptions = {}): CardiologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciFeatures };
diff --git a/src/cardiology_sci/feedback.ts b/src/cardiology_sci/feedback.ts
new file mode 100644
index 000000000..171bf003c
--- /dev/null
+++ b/src/cardiology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci feedback module — tsb analytics library. */
+export interface CardiologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeCardiologySciFeedback(data: number[], opts: CardiologySciFeedbackOptions = {}): CardiologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciFeedback };
diff --git a/src/cardiology_sci/filtering.ts b/src/cardiology_sci/filtering.ts
new file mode 100644
index 000000000..eea15a342
--- /dev/null
+++ b/src/cardiology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci filtering module — tsb analytics library. */
+export interface CardiologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeCardiologySciFiltering(data: number[], opts: CardiologySciFilteringOptions = {}): CardiologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciFiltering };
diff --git a/src/cardiology_sci/fourier.ts b/src/cardiology_sci/fourier.ts
new file mode 100644
index 000000000..b08c0a262
--- /dev/null
+++ b/src/cardiology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci fourier module — tsb analytics library. */
+export interface CardiologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciFourierResult { values: number[]; converged: boolean; }
+export function computeCardiologySciFourier(data: number[], opts: CardiologySciFourierOptions = {}): CardiologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciFourier };
diff --git a/src/cardiology_sci/fusion.ts b/src/cardiology_sci/fusion.ts
new file mode 100644
index 000000000..4bba2b1e0
--- /dev/null
+++ b/src/cardiology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci fusion module — tsb analytics library. */
+export interface CardiologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciFusionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciFusion(data: number[], opts: CardiologySciFusionOptions = {}): CardiologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciFusion };
diff --git a/src/cardiology_sci/generation.ts b/src/cardiology_sci/generation.ts
new file mode 100644
index 000000000..d28e70f6d
--- /dev/null
+++ b/src/cardiology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci generation module — tsb analytics library. */
+export interface CardiologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciGeneration(data: number[], opts: CardiologySciGenerationOptions = {}): CardiologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciGeneration };
diff --git a/src/cardiology_sci/geometry.ts b/src/cardiology_sci/geometry.ts
new file mode 100644
index 000000000..b6caede03
--- /dev/null
+++ b/src/cardiology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci geometry module — tsb analytics library. */
+export interface CardiologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeCardiologySciGeometry(data: number[], opts: CardiologySciGeometryOptions = {}): CardiologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciGeometry };
diff --git a/src/cardiology_sci/gradient.ts b/src/cardiology_sci/gradient.ts
new file mode 100644
index 000000000..c18b35287
--- /dev/null
+++ b/src/cardiology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci gradient module — tsb analytics library. */
+export interface CardiologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciGradientResult { values: number[]; converged: boolean; }
+export function computeCardiologySciGradient(data: number[], opts: CardiologySciGradientOptions = {}): CardiologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciGradient };
diff --git a/src/cardiology_sci/hessian.ts b/src/cardiology_sci/hessian.ts
new file mode 100644
index 000000000..7691054eb
--- /dev/null
+++ b/src/cardiology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci hessian module — tsb analytics library. */
+export interface CardiologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciHessianResult { values: number[]; converged: boolean; }
+export function computeCardiologySciHessian(data: number[], opts: CardiologySciHessianOptions = {}): CardiologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciHessian };
diff --git a/src/cardiology_sci/hypothesis.ts b/src/cardiology_sci/hypothesis.ts
new file mode 100644
index 000000000..2b6355502
--- /dev/null
+++ b/src/cardiology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci hypothesis module — tsb analytics library. */
+export interface CardiologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeCardiologySciHypothesis(data: number[], opts: CardiologySciHypothesisOptions = {}): CardiologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciHypothesis };
diff --git a/src/cardiology_sci/inference.ts b/src/cardiology_sci/inference.ts
new file mode 100644
index 000000000..385b49217
--- /dev/null
+++ b/src/cardiology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci inference module — tsb analytics library. */
+export interface CardiologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeCardiologySciInference(data: number[], opts: CardiologySciInferenceOptions = {}): CardiologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciInference };
diff --git a/src/cardiology_sci/inference2.ts b/src/cardiology_sci/inference2.ts
new file mode 100644
index 000000000..32985915d
--- /dev/null
+++ b/src/cardiology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci inference2 module — tsb analytics library. */
+export interface CardiologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeCardiologySciInference(data: number[], opts: CardiologySciInferenceOptions = {}): CardiologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciInference };
diff --git a/src/cardiology_sci/integral.ts b/src/cardiology_sci/integral.ts
new file mode 100644
index 000000000..b55abc2a5
--- /dev/null
+++ b/src/cardiology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci integral module — tsb analytics library. */
+export interface CardiologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeCardiologySciIntegral(data: number[], opts: CardiologySciIntegralOptions = {}): CardiologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciIntegral };
diff --git a/src/cardiology_sci/integration.ts b/src/cardiology_sci/integration.ts
new file mode 100644
index 000000000..428566b52
--- /dev/null
+++ b/src/cardiology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci integration module — tsb analytics library. */
+export interface CardiologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciIntegration(data: number[], opts: CardiologySciIntegrationOptions = {}): CardiologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciIntegration };
diff --git a/src/cardiology_sci/interpolation.ts b/src/cardiology_sci/interpolation.ts
new file mode 100644
index 000000000..16e5e5dd7
--- /dev/null
+++ b/src/cardiology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci interpolation module — tsb analytics library. */
+export interface CardiologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciInterpolation(data: number[], opts: CardiologySciInterpolationOptions = {}): CardiologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciInterpolation };
diff --git a/src/cardiology_sci/jacobian.ts b/src/cardiology_sci/jacobian.ts
new file mode 100644
index 000000000..6e1476f53
--- /dev/null
+++ b/src/cardiology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci jacobian module — tsb analytics library. */
+export interface CardiologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeCardiologySciJacobian(data: number[], opts: CardiologySciJacobianOptions = {}): CardiologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciJacobian };
diff --git a/src/cardiology_sci/kernel.ts b/src/cardiology_sci/kernel.ts
new file mode 100644
index 000000000..50a35c8f6
--- /dev/null
+++ b/src/cardiology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci kernel module — tsb analytics library. */
+export interface CardiologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciKernelResult { values: number[]; converged: boolean; }
+export function computeCardiologySciKernel(data: number[], opts: CardiologySciKernelOptions = {}): CardiologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciKernel };
diff --git a/src/cardiology_sci/laplacian.ts b/src/cardiology_sci/laplacian.ts
new file mode 100644
index 000000000..0bf5f7bd4
--- /dev/null
+++ b/src/cardiology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci laplacian module — tsb analytics library. */
+export interface CardiologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeCardiologySciLaplacian(data: number[], opts: CardiologySciLaplacianOptions = {}): CardiologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciLaplacian };
diff --git a/src/cardiology_sci/learning.ts b/src/cardiology_sci/learning.ts
new file mode 100644
index 000000000..c23a745a7
--- /dev/null
+++ b/src/cardiology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci learning module — tsb analytics library. */
+export interface CardiologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciLearningResult { values: number[]; converged: boolean; }
+export function computeCardiologySciLearning(data: number[], opts: CardiologySciLearningOptions = {}): CardiologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciLearning };
diff --git a/src/cardiology_sci/linear.ts b/src/cardiology_sci/linear.ts
new file mode 100644
index 000000000..1f1bc979a
--- /dev/null
+++ b/src/cardiology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci linear module — tsb analytics library. */
+export interface CardiologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciLinearResult { values: number[]; converged: boolean; }
+export function computeCardiologySciLinear(data: number[], opts: CardiologySciLinearOptions = {}): CardiologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciLinear };
diff --git a/src/cardiology_sci/manifold.ts b/src/cardiology_sci/manifold.ts
new file mode 100644
index 000000000..b9ab76de5
--- /dev/null
+++ b/src/cardiology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci manifold module — tsb analytics library. */
+export interface CardiologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeCardiologySciManifold(data: number[], opts: CardiologySciManifoldOptions = {}): CardiologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciManifold };
diff --git a/src/cardiology_sci/matching.ts b/src/cardiology_sci/matching.ts
new file mode 100644
index 000000000..e1601980f
--- /dev/null
+++ b/src/cardiology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci matching module — tsb analytics library. */
+export interface CardiologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciMatching(data: number[], opts: CardiologySciMatchingOptions = {}): CardiologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciMatching };
diff --git a/src/cardiology_sci/measurement.ts b/src/cardiology_sci/measurement.ts
new file mode 100644
index 000000000..023bd5237
--- /dev/null
+++ b/src/cardiology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci measurement module — tsb analytics library. */
+export interface CardiologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeCardiologySciMeasurement(data: number[], opts: CardiologySciMeasurementOptions = {}): CardiologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciMeasurement };
diff --git a/src/cardiology_sci/metrics.ts b/src/cardiology_sci/metrics.ts
new file mode 100644
index 000000000..69434c36a
--- /dev/null
+++ b/src/cardiology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci metrics module — tsb analytics library. */
+export interface CardiologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeCardiologySciMetrics(data: number[], opts: CardiologySciMetricsOptions = {}): CardiologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciMetrics };
diff --git a/src/cardiology_sci/modeling.ts b/src/cardiology_sci/modeling.ts
new file mode 100644
index 000000000..968571bb0
--- /dev/null
+++ b/src/cardiology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci modeling module — tsb analytics library. */
+export interface CardiologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciModelingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciModeling(data: number[], opts: CardiologySciModelingOptions = {}): CardiologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciModeling };
diff --git a/src/cardiology_sci/monitoring.ts b/src/cardiology_sci/monitoring.ts
new file mode 100644
index 000000000..efd218f9f
--- /dev/null
+++ b/src/cardiology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci monitoring module — tsb analytics library. */
+export interface CardiologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeCardiologySciMonitoring(data: number[], opts: CardiologySciMonitoringOptions = {}): CardiologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciMonitoring };
diff --git a/src/cardiology_sci/nonlinear.ts b/src/cardiology_sci/nonlinear.ts
new file mode 100644
index 000000000..9386038cc
--- /dev/null
+++ b/src/cardiology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci nonlinear module — tsb analytics library. */
+export interface CardiologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeCardiologySciNonlinear(data: number[], opts: CardiologySciNonlinearOptions = {}): CardiologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciNonlinear };
diff --git a/src/cardiology_sci/normalization.ts b/src/cardiology_sci/normalization.ts
new file mode 100644
index 000000000..7c57ebc0e
--- /dev/null
+++ b/src/cardiology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci normalization module — tsb analytics library. */
+export interface CardiologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciNormalization(data: number[], opts: CardiologySciNormalizationOptions = {}): CardiologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciNormalization };
diff --git a/src/cardiology_sci/optimization.ts b/src/cardiology_sci/optimization.ts
new file mode 100644
index 000000000..43fbcc46f
--- /dev/null
+++ b/src/cardiology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci optimization module — tsb analytics library. */
+export interface CardiologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciOptimization(data: number[], opts: CardiologySciOptimizationOptions = {}): CardiologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciOptimization };
diff --git a/src/cardiology_sci/patterns.ts b/src/cardiology_sci/patterns.ts
new file mode 100644
index 000000000..e32eef6ca
--- /dev/null
+++ b/src/cardiology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci patterns module — tsb analytics library. */
+export interface CardiologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeCardiologySciPatterns(data: number[], opts: CardiologySciPatternsOptions = {}): CardiologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciPatterns };
diff --git a/src/cardiology_sci/permutation.ts b/src/cardiology_sci/permutation.ts
new file mode 100644
index 000000000..946149038
--- /dev/null
+++ b/src/cardiology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci permutation module — tsb analytics library. */
+export interface CardiologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciPermutation(data: number[], opts: CardiologySciPermutationOptions = {}): CardiologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciPermutation };
diff --git a/src/cardiology_sci/prediction.ts b/src/cardiology_sci/prediction.ts
new file mode 100644
index 000000000..f8f50cfa4
--- /dev/null
+++ b/src/cardiology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci prediction module — tsb analytics library. */
+export interface CardiologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciPrediction(data: number[], opts: CardiologySciPredictionOptions = {}): CardiologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciPrediction };
diff --git a/src/cardiology_sci/processing.ts b/src/cardiology_sci/processing.ts
new file mode 100644
index 000000000..da8325905
--- /dev/null
+++ b/src/cardiology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci processing module — tsb analytics library. */
+export interface CardiologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciProcessing(data: number[], opts: CardiologySciProcessingOptions = {}): CardiologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciProcessing };
diff --git a/src/cardiology_sci/profiling.ts b/src/cardiology_sci/profiling.ts
new file mode 100644
index 000000000..49460bd0b
--- /dev/null
+++ b/src/cardiology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci profiling module — tsb analytics library. */
+export interface CardiologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciProfiling(data: number[], opts: CardiologySciProfilingOptions = {}): CardiologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciProfiling };
diff --git a/src/cardiology_sci/projection.ts b/src/cardiology_sci/projection.ts
new file mode 100644
index 000000000..47a00bb07
--- /dev/null
+++ b/src/cardiology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci projection module — tsb analytics library. */
+export interface CardiologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciProjection(data: number[], opts: CardiologySciProjectionOptions = {}): CardiologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciProjection };
diff --git a/src/cardiology_sci/ranking.ts b/src/cardiology_sci/ranking.ts
new file mode 100644
index 000000000..41a0866d6
--- /dev/null
+++ b/src/cardiology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci ranking module — tsb analytics library. */
+export interface CardiologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciRankingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciRanking(data: number[], opts: CardiologySciRankingOptions = {}): CardiologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciRanking };
diff --git a/src/cardiology_sci/reconstruction.ts b/src/cardiology_sci/reconstruction.ts
new file mode 100644
index 000000000..b67db87d8
--- /dev/null
+++ b/src/cardiology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci reconstruction module — tsb analytics library. */
+export interface CardiologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciReconstruction(data: number[], opts: CardiologySciReconstructionOptions = {}): CardiologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciReconstruction };
diff --git a/src/cardiology_sci/registration.ts b/src/cardiology_sci/registration.ts
new file mode 100644
index 000000000..31b22a568
--- /dev/null
+++ b/src/cardiology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci registration module — tsb analytics library. */
+export interface CardiologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciRegistration(data: number[], opts: CardiologySciRegistrationOptions = {}): CardiologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciRegistration };
diff --git a/src/cardiology_sci/regression.ts b/src/cardiology_sci/regression.ts
new file mode 100644
index 000000000..c8f70b420
--- /dev/null
+++ b/src/cardiology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci regression module — tsb analytics library. */
+export interface CardiologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciRegression(data: number[], opts: CardiologySciRegressionOptions = {}): CardiologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciRegression };
diff --git a/src/cardiology_sci/regularization.ts b/src/cardiology_sci/regularization.ts
new file mode 100644
index 000000000..2b933f296
--- /dev/null
+++ b/src/cardiology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci regularization module — tsb analytics library. */
+export interface CardiologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciRegularization(data: number[], opts: CardiologySciRegularizationOptions = {}): CardiologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciRegularization };
diff --git a/src/cardiology_sci/robustness.ts b/src/cardiology_sci/robustness.ts
new file mode 100644
index 000000000..88b4feb13
--- /dev/null
+++ b/src/cardiology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci robustness module — tsb analytics library. */
+export interface CardiologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeCardiologySciRobustness(data: number[], opts: CardiologySciRobustnessOptions = {}): CardiologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciRobustness };
diff --git a/src/cardiology_sci/sampling.ts b/src/cardiology_sci/sampling.ts
new file mode 100644
index 000000000..ef90c4c2c
--- /dev/null
+++ b/src/cardiology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci sampling module — tsb analytics library. */
+export interface CardiologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciSampling(data: number[], opts: CardiologySciSamplingOptions = {}): CardiologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciSampling };
diff --git a/src/cardiology_sci/sampling2.ts b/src/cardiology_sci/sampling2.ts
new file mode 100644
index 000000000..fa6db4a04
--- /dev/null
+++ b/src/cardiology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci sampling2 module — tsb analytics library. */
+export interface CardiologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciSampling(data: number[], opts: CardiologySciSamplingOptions = {}): CardiologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciSampling };
diff --git a/src/cardiology_sci/scaling.ts b/src/cardiology_sci/scaling.ts
new file mode 100644
index 000000000..15bc2aa9d
--- /dev/null
+++ b/src/cardiology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci scaling module — tsb analytics library. */
+export interface CardiologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciScalingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciScaling(data: number[], opts: CardiologySciScalingOptions = {}): CardiologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciScaling };
diff --git a/src/cardiology_sci/scoring.ts b/src/cardiology_sci/scoring.ts
new file mode 100644
index 000000000..5d91717b0
--- /dev/null
+++ b/src/cardiology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci scoring module — tsb analytics library. */
+export interface CardiologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciScoringResult { values: number[]; converged: boolean; }
+export function computeCardiologySciScoring(data: number[], opts: CardiologySciScoringOptions = {}): CardiologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciScoring };
diff --git a/src/cardiology_sci/segmentation.ts b/src/cardiology_sci/segmentation.ts
new file mode 100644
index 000000000..ce9615303
--- /dev/null
+++ b/src/cardiology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci segmentation module — tsb analytics library. */
+export interface CardiologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciSegmentation(data: number[], opts: CardiologySciSegmentationOptions = {}): CardiologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciSegmentation };
diff --git a/src/cardiology_sci/selection.ts b/src/cardiology_sci/selection.ts
new file mode 100644
index 000000000..b9b62991e
--- /dev/null
+++ b/src/cardiology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci selection module — tsb analytics library. */
+export interface CardiologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeCardiologySciSelection(data: number[], opts: CardiologySciSelectionOptions = {}): CardiologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciSelection };
diff --git a/src/cardiology_sci/sensitivity.ts b/src/cardiology_sci/sensitivity.ts
new file mode 100644
index 000000000..0fa7f25ee
--- /dev/null
+++ b/src/cardiology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci sensitivity module — tsb analytics library. */
+export interface CardiologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeCardiologySciSensitivity(data: number[], opts: CardiologySciSensitivityOptions = {}): CardiologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciSensitivity };
diff --git a/src/cardiology_sci/simulation.ts b/src/cardiology_sci/simulation.ts
new file mode 100644
index 000000000..376760a28
--- /dev/null
+++ b/src/cardiology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci simulation module — tsb analytics library. */
+export interface CardiologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciSimulation(data: number[], opts: CardiologySciSimulationOptions = {}): CardiologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciSimulation };
diff --git a/src/cardiology_sci/smoothing.ts b/src/cardiology_sci/smoothing.ts
new file mode 100644
index 000000000..b0e512a27
--- /dev/null
+++ b/src/cardiology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci smoothing module — tsb analytics library. */
+export interface CardiologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciSmoothing(data: number[], opts: CardiologySciSmoothingOptions = {}): CardiologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciSmoothing };
diff --git a/src/cardiology_sci/stability.ts b/src/cardiology_sci/stability.ts
new file mode 100644
index 000000000..dca9a8471
--- /dev/null
+++ b/src/cardiology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci stability module — tsb analytics library. */
+export interface CardiologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeCardiologySciStability(data: number[], opts: CardiologySciStabilityOptions = {}): CardiologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciStability };
diff --git a/src/cardiology_sci/stacking.ts b/src/cardiology_sci/stacking.ts
new file mode 100644
index 000000000..2e9bcf4e2
--- /dev/null
+++ b/src/cardiology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci stacking module — tsb analytics library. */
+export interface CardiologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciStackingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciStacking(data: number[], opts: CardiologySciStackingOptions = {}): CardiologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciStacking };
diff --git a/src/cardiology_sci/standardization.ts b/src/cardiology_sci/standardization.ts
new file mode 100644
index 000000000..de2cae83a
--- /dev/null
+++ b/src/cardiology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci standardization module — tsb analytics library. */
+export interface CardiologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciStandardization(data: number[], opts: CardiologySciStandardizationOptions = {}): CardiologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciStandardization };
diff --git a/src/cardiology_sci/static.ts b/src/cardiology_sci/static.ts
new file mode 100644
index 000000000..a1326b24f
--- /dev/null
+++ b/src/cardiology_sci/static.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci static module — tsb analytics library. */
+export interface CardiologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciStaticResult { values: number[]; converged: boolean; }
+export function computeCardiologySciStatic(data: number[], opts: CardiologySciStaticOptions = {}): CardiologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciStatic };
diff --git a/src/cardiology_sci/stochastic.ts b/src/cardiology_sci/stochastic.ts
new file mode 100644
index 000000000..03045cdb0
--- /dev/null
+++ b/src/cardiology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci stochastic module — tsb analytics library. */
+export interface CardiologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeCardiologySciStochastic(data: number[], opts: CardiologySciStochasticOptions = {}): CardiologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciStochastic };
diff --git a/src/cardiology_sci/synthesis.ts b/src/cardiology_sci/synthesis.ts
new file mode 100644
index 000000000..df8753d3d
--- /dev/null
+++ b/src/cardiology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci synthesis module — tsb analytics library. */
+export interface CardiologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeCardiologySciSynthesis(data: number[], opts: CardiologySciSynthesisOptions = {}): CardiologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciSynthesis };
diff --git a/src/cardiology_sci/topology.ts b/src/cardiology_sci/topology.ts
new file mode 100644
index 000000000..ada1bbcaa
--- /dev/null
+++ b/src/cardiology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci topology module — tsb analytics library. */
+export interface CardiologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeCardiologySciTopology(data: number[], opts: CardiologySciTopologyOptions = {}): CardiologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciTopology };
diff --git a/src/cardiology_sci/tracking.ts b/src/cardiology_sci/tracking.ts
new file mode 100644
index 000000000..67705ac11
--- /dev/null
+++ b/src/cardiology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci tracking module — tsb analytics library. */
+export interface CardiologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciTracking(data: number[], opts: CardiologySciTrackingOptions = {}): CardiologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciTracking };
diff --git a/src/cardiology_sci/transform.ts b/src/cardiology_sci/transform.ts
new file mode 100644
index 000000000..c4d9cbd0e
--- /dev/null
+++ b/src/cardiology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci transform module — tsb analytics library. */
+export interface CardiologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciTransformResult { values: number[]; converged: boolean; }
+export function computeCardiologySciTransform(data: number[], opts: CardiologySciTransformOptions = {}): CardiologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciTransform };
diff --git a/src/cardiology_sci/uncertainty.ts b/src/cardiology_sci/uncertainty.ts
new file mode 100644
index 000000000..5befd27d1
--- /dev/null
+++ b/src/cardiology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci uncertainty module — tsb analytics library. */
+export interface CardiologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCardiologySciUncertainty(data: number[], opts: CardiologySciUncertaintyOptions = {}): CardiologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciUncertainty };
diff --git a/src/cardiology_sci/validation.ts b/src/cardiology_sci/validation.ts
new file mode 100644
index 000000000..fb9e73f67
--- /dev/null
+++ b/src/cardiology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci validation module — tsb analytics library. */
+export interface CardiologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciValidationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciValidation(data: number[], opts: CardiologySciValidationOptions = {}): CardiologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciValidation };
diff --git a/src/cardiology_sci/verification.ts b/src/cardiology_sci/verification.ts
new file mode 100644
index 000000000..f2e6e47f5
--- /dev/null
+++ b/src/cardiology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci verification module — tsb analytics library. */
+export interface CardiologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciVerification(data: number[], opts: CardiologySciVerificationOptions = {}): CardiologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciVerification };
diff --git a/src/cardiology_sci/visualization.ts b/src/cardiology_sci/visualization.ts
new file mode 100644
index 000000000..ea4059d3d
--- /dev/null
+++ b/src/cardiology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci visualization module — tsb analytics library. */
+export interface CardiologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeCardiologySciVisualization(data: number[], opts: CardiologySciVisualizationOptions = {}): CardiologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciVisualization };
diff --git a/src/cardiology_sci/voting.ts b/src/cardiology_sci/voting.ts
new file mode 100644
index 000000000..efb6b1540
--- /dev/null
+++ b/src/cardiology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci voting module — tsb analytics library. */
+export interface CardiologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciVotingResult { values: number[]; converged: boolean; }
+export function computeCardiologySciVoting(data: number[], opts: CardiologySciVotingOptions = {}): CardiologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciVoting };
diff --git a/src/cardiology_sci/wavelet.ts b/src/cardiology_sci/wavelet.ts
new file mode 100644
index 000000000..e1597859a
--- /dev/null
+++ b/src/cardiology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** cardiology_sci wavelet module — tsb analytics library. */
+export interface CardiologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface CardiologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeCardiologySciWavelet(data: number[], opts: CardiologySciWaveletOptions = {}): CardiologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCardiologySciWavelet };
diff --git a/src/causal/advanced.ts b/src/causal/advanced.ts
new file mode 100644
index 000000000..b3b35768c
--- /dev/null
+++ b/src/causal/advanced.ts
@@ -0,0 +1,15 @@
+/** Causal Advanced module — tsb analytics library. */
+export interface Causal advancedOptions { tol?: number; maxIter?: number; }
+export interface Causal advancedResult { values: number[]; converged: boolean; }
+export function computeCausal advanced(data: number[], opts: Causal advancedOptions = {}): Causal advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal advanced };
diff --git a/src/causal/backdoor.ts b/src/causal/backdoor.ts
new file mode 100644
index 000000000..f5cdae4e1
--- /dev/null
+++ b/src/causal/backdoor.ts
@@ -0,0 +1,22 @@
+/** Backdoor module — tsb analytics library. */
+
+/** Options for Backdoor. */
+export interface BackdoorOptions { tol?: number; maxIter?: number; }
+
+/** Result from Backdoor. */
+export interface BackdoorResult { values: number[]; converged: boolean; }
+
+/** Compute Backdoor. */
+export function computeBackdoor(data: number[], opts: BackdoorOptions = {}): BackdoorResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBackdoor };
diff --git a/src/causal/base2.ts b/src/causal/base2.ts
new file mode 100644
index 000000000..6d3286408
--- /dev/null
+++ b/src/causal/base2.ts
@@ -0,0 +1,15 @@
+/** Causal Base2 module — tsb analytics library. */
+export interface Causal base2Options { tol?: number; maxIter?: number; }
+export interface Causal base2Result { values: number[]; converged: boolean; }
+export function computeCausal base2(data: number[], opts: Causal base2Options = {}): Causal base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal base2 };
diff --git a/src/causal/batch.ts b/src/causal/batch.ts
new file mode 100644
index 000000000..5feaef175
--- /dev/null
+++ b/src/causal/batch.ts
@@ -0,0 +1,15 @@
+/** Causal Batch module — tsb analytics library. */
+export interface Causal batchOptions { tol?: number; maxIter?: number; }
+export interface Causal batchResult { values: number[]; converged: boolean; }
+export function computeCausal batch(data: number[], opts: Causal batchOptions = {}): Causal batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal batch };
diff --git a/src/causal/beta.ts b/src/causal/beta.ts
new file mode 100644
index 000000000..1329a8f53
--- /dev/null
+++ b/src/causal/beta.ts
@@ -0,0 +1,15 @@
+/** Causal Beta module — tsb analytics library. */
+export interface Causal betaOptions { tol?: number; maxIter?: number; }
+export interface Causal betaResult { values: number[]; converged: boolean; }
+export function computeCausal beta(data: number[], opts: Causal betaOptions = {}): Causal betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal beta };
diff --git a/src/causal/comparative_case_study.ts b/src/causal/comparative_case_study.ts
new file mode 100644
index 000000000..fc58a4eaa
--- /dev/null
+++ b/src/causal/comparative_case_study.ts
@@ -0,0 +1,22 @@
+/** Comparative Case Study module — tsb analytics library. */
+
+/** Options for Comparative Case Study. */
+export interface ComparativeCaseStudyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Comparative Case Study. */
+export interface ComparativeCaseStudyResult { values: number[]; converged: boolean; }
+
+/** Compute Comparative Case Study. */
+export function computeComparativeCaseStudy(data: number[], opts: ComparativeCaseStudyOptions = {}): ComparativeCaseStudyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeComparativeCaseStudy };
diff --git a/src/causal/confounding.ts b/src/causal/confounding.ts
new file mode 100644
index 000000000..4115bd4dd
--- /dev/null
+++ b/src/causal/confounding.ts
@@ -0,0 +1,22 @@
+/** Confounding module — tsb analytics library. */
+
+/** Options for Confounding. */
+export interface ConfoundingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Confounding. */
+export interface ConfoundingResult { values: number[]; converged: boolean; }
+
+/** Compute Confounding. */
+export function computeConfounding(data: number[], opts: ConfoundingOptions = {}): ConfoundingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConfounding };
diff --git a/src/causal/counterfactual.ts b/src/causal/counterfactual.ts
new file mode 100644
index 000000000..697fd8ceb
--- /dev/null
+++ b/src/causal/counterfactual.ts
@@ -0,0 +1,22 @@
+/** Counterfactual module — tsb analytics library. */
+
+/** Options for Counterfactual. */
+export interface CounterfactualOptions { tol?: number; maxIter?: number; }
+
+/** Result from Counterfactual. */
+export interface CounterfactualResult { values: number[]; converged: boolean; }
+
+/** Compute Counterfactual. */
+export function computeCounterfactual(data: number[], opts: CounterfactualOptions = {}): CounterfactualResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCounterfactual };
diff --git a/src/causal/cpu.ts b/src/causal/cpu.ts
new file mode 100644
index 000000000..901c0bcaf
--- /dev/null
+++ b/src/causal/cpu.ts
@@ -0,0 +1,15 @@
+/** Causal Cpu module — tsb analytics library. */
+export interface Causal cpuOptions { tol?: number; maxIter?: number; }
+export interface Causal cpuResult { values: number[]; converged: boolean; }
+export function computeCausal cpu(data: number[], opts: Causal cpuOptions = {}): Causal cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal cpu };
diff --git a/src/causal/dag.ts b/src/causal/dag.ts
new file mode 100644
index 000000000..b7c5cf435
--- /dev/null
+++ b/src/causal/dag.ts
@@ -0,0 +1,22 @@
+/** Dag module — tsb analytics library. */
+
+/** Options for Dag. */
+export interface DagOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dag. */
+export interface DagResult { values: number[]; converged: boolean; }
+
+/** Compute Dag. */
+export function computeDag(data: number[], opts: DagOptions = {}): DagResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDag };
diff --git a/src/causal/dense.ts b/src/causal/dense.ts
new file mode 100644
index 000000000..60e3c8c30
--- /dev/null
+++ b/src/causal/dense.ts
@@ -0,0 +1,15 @@
+/** Causal Dense module — tsb analytics library. */
+export interface Causal denseOptions { tol?: number; maxIter?: number; }
+export interface Causal denseResult { values: number[]; converged: boolean; }
+export function computeCausal dense(data: number[], opts: Causal denseOptions = {}): Causal denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal dense };
diff --git a/src/causal/did.ts b/src/causal/did.ts
new file mode 100644
index 000000000..53b4b8c9b
--- /dev/null
+++ b/src/causal/did.ts
@@ -0,0 +1,22 @@
+/** Did module — tsb analytics library. */
+
+/** Options for Did. */
+export interface DidOptions { tol?: number; maxIter?: number; }
+
+/** Result from Did. */
+export interface DidResult { values: number[]; converged: boolean; }
+
+/** Compute Did. */
+export function computeDid(data: number[], opts: DidOptions = {}): DidResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDid };
diff --git a/src/causal/distributed.ts b/src/causal/distributed.ts
new file mode 100644
index 000000000..bdd5167b4
--- /dev/null
+++ b/src/causal/distributed.ts
@@ -0,0 +1,15 @@
+/** Causal Distributed module — tsb analytics library. */
+export interface Causal distributedOptions { tol?: number; maxIter?: number; }
+export interface Causal distributedResult { values: number[]; converged: boolean; }
+export function computeCausal distributed(data: number[], opts: Causal distributedOptions = {}): Causal distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal distributed };
diff --git a/src/causal/distributional.ts b/src/causal/distributional.ts
new file mode 100644
index 000000000..0d9945bd8
--- /dev/null
+++ b/src/causal/distributional.ts
@@ -0,0 +1,22 @@
+/** Distributional module — tsb analytics library. */
+
+/** Options for Distributional. */
+export interface DistributionalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Distributional. */
+export interface DistributionalResult { values: number[]; converged: boolean; }
+
+/** Compute Distributional. */
+export function computeDistributional(data: number[], opts: DistributionalOptions = {}): DistributionalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDistributional };
diff --git a/src/causal/do_calculus.ts b/src/causal/do_calculus.ts
new file mode 100644
index 000000000..d8f314f47
--- /dev/null
+++ b/src/causal/do_calculus.ts
@@ -0,0 +1,22 @@
+/** Do Calculus module — tsb analytics library. */
+
+/** Options for Do Calculus. */
+export interface DoCalculusOptions { tol?: number; maxIter?: number; }
+
+/** Result from Do Calculus. */
+export interface DoCalculusResult { values: number[]; converged: boolean; }
+
+/** Compute Do Calculus. */
+export function computeDoCalculus(data: number[], opts: DoCalculusOptions = {}): DoCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDoCalculus };
diff --git a/src/causal/experimental.ts b/src/causal/experimental.ts
new file mode 100644
index 000000000..7fe5c8741
--- /dev/null
+++ b/src/causal/experimental.ts
@@ -0,0 +1,15 @@
+/** Causal Experimental module — tsb analytics library. */
+export interface Causal experimentalOptions { tol?: number; maxIter?: number; }
+export interface Causal experimentalResult { values: number[]; converged: boolean; }
+export function computeCausal experimental(data: number[], opts: Causal experimentalOptions = {}): Causal experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal experimental };
diff --git a/src/causal/falsification.ts b/src/causal/falsification.ts
new file mode 100644
index 000000000..de10ea44e
--- /dev/null
+++ b/src/causal/falsification.ts
@@ -0,0 +1,22 @@
+/** Falsification module — tsb analytics library. */
+
+/** Options for Falsification. */
+export interface FalsificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Falsification. */
+export interface FalsificationResult { values: number[]; converged: boolean; }
+
+/** Compute Falsification. */
+export function computeFalsification(data: number[], opts: FalsificationOptions = {}): FalsificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFalsification };
diff --git a/src/causal/fast.ts b/src/causal/fast.ts
new file mode 100644
index 000000000..3f7ac9644
--- /dev/null
+++ b/src/causal/fast.ts
@@ -0,0 +1,15 @@
+/** Causal Fast module — tsb analytics library. */
+export interface Causal fastOptions { tol?: number; maxIter?: number; }
+export interface Causal fastResult { values: number[]; converged: boolean; }
+export function computeCausal fast(data: number[], opts: Causal fastOptions = {}): Causal fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal fast };
diff --git a/src/causal/frontdoor.ts b/src/causal/frontdoor.ts
new file mode 100644
index 000000000..4325e0d5b
--- /dev/null
+++ b/src/causal/frontdoor.ts
@@ -0,0 +1,22 @@
+/** Frontdoor module — tsb analytics library. */
+
+/** Options for Frontdoor. */
+export interface FrontdoorOptions { tol?: number; maxIter?: number; }
+
+/** Result from Frontdoor. */
+export interface FrontdoorResult { values: number[]; converged: boolean; }
+
+/** Compute Frontdoor. */
+export function computeFrontdoor(data: number[], opts: FrontdoorOptions = {}): FrontdoorResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFrontdoor };
diff --git a/src/causal/future.ts b/src/causal/future.ts
new file mode 100644
index 000000000..9bf54012b
--- /dev/null
+++ b/src/causal/future.ts
@@ -0,0 +1,15 @@
+/** Causal Future module — tsb analytics library. */
+export interface Causal futureOptions { tol?: number; maxIter?: number; }
+export interface Causal futureResult { values: number[]; converged: boolean; }
+export function computeCausal future(data: number[], opts: Causal futureOptions = {}): Causal futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal future };
diff --git a/src/causal/gpu.ts b/src/causal/gpu.ts
new file mode 100644
index 000000000..93c6aef5f
--- /dev/null
+++ b/src/causal/gpu.ts
@@ -0,0 +1,15 @@
+/** Causal Gpu module — tsb analytics library. */
+export interface Causal gpuOptions { tol?: number; maxIter?: number; }
+export interface Causal gpuResult { values: number[]; converged: boolean; }
+export function computeCausal gpu(data: number[], opts: Causal gpuOptions = {}): Causal gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal gpu };
diff --git a/src/causal/heterogeneous_treatment.ts b/src/causal/heterogeneous_treatment.ts
new file mode 100644
index 000000000..2aedb9fdc
--- /dev/null
+++ b/src/causal/heterogeneous_treatment.ts
@@ -0,0 +1,22 @@
+/** Heterogeneous Treatment module — tsb analytics library. */
+
+/** Options for Heterogeneous Treatment. */
+export interface HeterogeneousTreatmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Heterogeneous Treatment. */
+export interface HeterogeneousTreatmentResult { values: number[]; converged: boolean; }
+
+/** Compute Heterogeneous Treatment. */
+export function computeHeterogeneousTreatment(data: number[], opts: HeterogeneousTreatmentOptions = {}): HeterogeneousTreatmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHeterogeneousTreatment };
diff --git a/src/causal/identification.ts b/src/causal/identification.ts
new file mode 100644
index 000000000..e3e0be607
--- /dev/null
+++ b/src/causal/identification.ts
@@ -0,0 +1,22 @@
+/** Identification module — tsb analytics library. */
+
+/** Options for Identification. */
+export interface IdentificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Identification. */
+export interface IdentificationResult { values: number[]; converged: boolean; }
+
+/** Compute Identification. */
+export function computeIdentification(data: number[], opts: IdentificationOptions = {}): IdentificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIdentification };
diff --git a/src/causal/interrupted_time_series.ts b/src/causal/interrupted_time_series.ts
new file mode 100644
index 000000000..678349ee2
--- /dev/null
+++ b/src/causal/interrupted_time_series.ts
@@ -0,0 +1,22 @@
+/** Interrupted Time Series module — tsb analytics library. */
+
+/** Options for Interrupted Time Series. */
+export interface InterruptedTimeSeriesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Interrupted Time Series. */
+export interface InterruptedTimeSeriesResult { values: number[]; converged: boolean; }
+
+/** Compute Interrupted Time Series. */
+export function computeInterruptedTimeSeries(data: number[], opts: InterruptedTimeSeriesOptions = {}): InterruptedTimeSeriesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInterruptedTimeSeries };
diff --git a/src/causal/iv.ts b/src/causal/iv.ts
new file mode 100644
index 000000000..1b756ecd0
--- /dev/null
+++ b/src/causal/iv.ts
@@ -0,0 +1,22 @@
+/** Iv module — tsb analytics library. */
+
+/** Options for Iv. */
+export interface IvOptions { tol?: number; maxIter?: number; }
+
+/** Result from Iv. */
+export interface IvResult { values: number[]; converged: boolean; }
+
+/** Compute Iv. */
+export function computeIv(data: number[], opts: IvOptions = {}): IvResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIv };
diff --git a/src/causal/large.ts b/src/causal/large.ts
new file mode 100644
index 000000000..dd4f8d128
--- /dev/null
+++ b/src/causal/large.ts
@@ -0,0 +1,15 @@
+/** Causal Large module — tsb analytics library. */
+export interface Causal largeOptions { tol?: number; maxIter?: number; }
+export interface Causal largeResult { values: number[]; converged: boolean; }
+export function computeCausal large(data: number[], opts: Causal largeOptions = {}): Causal largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal large };
diff --git a/src/causal/legacy.ts b/src/causal/legacy.ts
new file mode 100644
index 000000000..57a21bb32
--- /dev/null
+++ b/src/causal/legacy.ts
@@ -0,0 +1,15 @@
+/** Causal Legacy module — tsb analytics library. */
+export interface Causal legacyOptions { tol?: number; maxIter?: number; }
+export interface Causal legacyResult { values: number[]; converged: boolean; }
+export function computeCausal legacy(data: number[], opts: Causal legacyOptions = {}): Causal legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal legacy };
diff --git a/src/causal/lite.ts b/src/causal/lite.ts
new file mode 100644
index 000000000..a6307bc10
--- /dev/null
+++ b/src/causal/lite.ts
@@ -0,0 +1,15 @@
+/** Causal Lite module — tsb analytics library. */
+export interface Causal liteOptions { tol?: number; maxIter?: number; }
+export interface Causal liteResult { values: number[]; converged: boolean; }
+export function computeCausal lite(data: number[], opts: Causal liteOptions = {}): Causal liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal lite };
diff --git a/src/causal/local_average_treatment.ts b/src/causal/local_average_treatment.ts
new file mode 100644
index 000000000..08bf5644a
--- /dev/null
+++ b/src/causal/local_average_treatment.ts
@@ -0,0 +1,22 @@
+/** Local Average Treatment module — tsb analytics library. */
+
+/** Options for Local Average Treatment. */
+export interface LocalAverageTreatmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Local Average Treatment. */
+export interface LocalAverageTreatmentResult { values: number[]; converged: boolean; }
+
+/** Compute Local Average Treatment. */
+export function computeLocalAverageTreatment(data: number[], opts: LocalAverageTreatmentOptions = {}): LocalAverageTreatmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLocalAverageTreatment };
diff --git a/src/causal/marginal_treatment.ts b/src/causal/marginal_treatment.ts
new file mode 100644
index 000000000..023fd5c26
--- /dev/null
+++ b/src/causal/marginal_treatment.ts
@@ -0,0 +1,22 @@
+/** Marginal Treatment module — tsb analytics library. */
+
+/** Options for Marginal Treatment. */
+export interface MarginalTreatmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Marginal Treatment. */
+export interface MarginalTreatmentResult { values: number[]; converged: boolean; }
+
+/** Compute Marginal Treatment. */
+export function computeMarginalTreatment(data: number[], opts: MarginalTreatmentOptions = {}): MarginalTreatmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMarginalTreatment };
diff --git a/src/causal/matching.ts b/src/causal/matching.ts
new file mode 100644
index 000000000..c60f8d3e0
--- /dev/null
+++ b/src/causal/matching.ts
@@ -0,0 +1,22 @@
+/** Matching module — tsb analytics library. */
+
+/** Options for Matching. */
+export interface MatchingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Matching. */
+export interface MatchingResult { values: number[]; converged: boolean; }
+
+/** Compute Matching. */
+export function computeMatching(data: number[], opts: MatchingOptions = {}): MatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMatching };
diff --git a/src/causal/mechanism.ts b/src/causal/mechanism.ts
new file mode 100644
index 000000000..7e52ea2f2
--- /dev/null
+++ b/src/causal/mechanism.ts
@@ -0,0 +1,22 @@
+/** Mechanism module — tsb analytics library. */
+
+/** Options for Mechanism. */
+export interface MechanismOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mechanism. */
+export interface MechanismResult { values: number[]; converged: boolean; }
+
+/** Compute Mechanism. */
+export function computeMechanism(data: number[], opts: MechanismOptions = {}): MechanismResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMechanism };
diff --git a/src/causal/mediation.ts b/src/causal/mediation.ts
new file mode 100644
index 000000000..b29549384
--- /dev/null
+++ b/src/causal/mediation.ts
@@ -0,0 +1,22 @@
+/** Mediation module — tsb analytics library. */
+
+/** Options for Mediation. */
+export interface MediationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mediation. */
+export interface MediationResult { values: number[]; converged: boolean; }
+
+/** Compute Mediation. */
+export function computeMediation(data: number[], opts: MediationOptions = {}): MediationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMediation };
diff --git a/src/causal/mini.ts b/src/causal/mini.ts
new file mode 100644
index 000000000..d4facbc3b
--- /dev/null
+++ b/src/causal/mini.ts
@@ -0,0 +1,15 @@
+/** Causal Mini module — tsb analytics library. */
+export interface Causal miniOptions { tol?: number; maxIter?: number; }
+export interface Causal miniResult { values: number[]; converged: boolean; }
+export function computeCausal mini(data: number[], opts: Causal miniOptions = {}): Causal miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal mini };
diff --git a/src/causal/natural_experiment.ts b/src/causal/natural_experiment.ts
new file mode 100644
index 000000000..5049d8a7d
--- /dev/null
+++ b/src/causal/natural_experiment.ts
@@ -0,0 +1,22 @@
+/** Natural Experiment module — tsb analytics library. */
+
+/** Options for Natural Experiment. */
+export interface NaturalExperimentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Natural Experiment. */
+export interface NaturalExperimentResult { values: number[]; converged: boolean; }
+
+/** Compute Natural Experiment. */
+export function computeNaturalExperiment(data: number[], opts: NaturalExperimentOptions = {}): NaturalExperimentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNaturalExperiment };
diff --git a/src/causal/next.ts b/src/causal/next.ts
new file mode 100644
index 000000000..73b083703
--- /dev/null
+++ b/src/causal/next.ts
@@ -0,0 +1,15 @@
+/** Causal Next module — tsb analytics library. */
+export interface Causal nextOptions { tol?: number; maxIter?: number; }
+export interface Causal nextResult { values: number[]; converged: boolean; }
+export function computeCausal next(data: number[], opts: Causal nextOptions = {}): Causal nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal next };
diff --git a/src/causal/online.ts b/src/causal/online.ts
new file mode 100644
index 000000000..0fb73c786
--- /dev/null
+++ b/src/causal/online.ts
@@ -0,0 +1,15 @@
+/** Causal Online module — tsb analytics library. */
+export interface Causal onlineOptions { tol?: number; maxIter?: number; }
+export interface Causal onlineResult { values: number[]; converged: boolean; }
+export function computeCausal online(data: number[], opts: Causal onlineOptions = {}): Causal onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal online };
diff --git a/src/causal/parallel.ts b/src/causal/parallel.ts
new file mode 100644
index 000000000..2994564f7
--- /dev/null
+++ b/src/causal/parallel.ts
@@ -0,0 +1,15 @@
+/** Causal Parallel module — tsb analytics library. */
+export interface Causal parallelOptions { tol?: number; maxIter?: number; }
+export interface Causal parallelResult { values: number[]; converged: boolean; }
+export function computeCausal parallel(data: number[], opts: Causal parallelOptions = {}): Causal parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal parallel };
diff --git a/src/causal/placebo.ts b/src/causal/placebo.ts
new file mode 100644
index 000000000..3a3da5b77
--- /dev/null
+++ b/src/causal/placebo.ts
@@ -0,0 +1,22 @@
+/** Placebo module — tsb analytics library. */
+
+/** Options for Placebo. */
+export interface PlaceboOptions { tol?: number; maxIter?: number; }
+
+/** Result from Placebo. */
+export interface PlaceboResult { values: number[]; converged: boolean; }
+
+/** Compute Placebo. */
+export function computePlacebo(data: number[], opts: PlaceboOptions = {}): PlaceboResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePlacebo };
diff --git a/src/causal/plus.ts b/src/causal/plus.ts
new file mode 100644
index 000000000..d2f7cb26a
--- /dev/null
+++ b/src/causal/plus.ts
@@ -0,0 +1,15 @@
+/** Causal Plus module — tsb analytics library. */
+export interface Causal plusOptions { tol?: number; maxIter?: number; }
+export interface Causal plusResult { values: number[]; converged: boolean; }
+export function computeCausal plus(data: number[], opts: Causal plusOptions = {}): Causal plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal plus };
diff --git a/src/causal/policy.ts b/src/causal/policy.ts
new file mode 100644
index 000000000..cf41f468b
--- /dev/null
+++ b/src/causal/policy.ts
@@ -0,0 +1,22 @@
+/** Policy module — tsb analytics library. */
+
+/** Options for Policy. */
+export interface PolicyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Policy. */
+export interface PolicyResult { values: number[]; converged: boolean; }
+
+/** Compute Policy. */
+export function computePolicy(data: number[], opts: PolicyOptions = {}): PolicyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePolicy };
diff --git a/src/causal/principal_stratification.ts b/src/causal/principal_stratification.ts
new file mode 100644
index 000000000..4e7b04fa9
--- /dev/null
+++ b/src/causal/principal_stratification.ts
@@ -0,0 +1,22 @@
+/** Principal Stratification module — tsb analytics library. */
+
+/** Options for Principal Stratification. */
+export interface PrincipalStratificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Principal Stratification. */
+export interface PrincipalStratificationResult { values: number[]; converged: boolean; }
+
+/** Compute Principal Stratification. */
+export function computePrincipalStratification(data: number[], opts: PrincipalStratificationOptions = {}): PrincipalStratificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrincipalStratification };
diff --git a/src/causal/pro.ts b/src/causal/pro.ts
new file mode 100644
index 000000000..74acd9aa0
--- /dev/null
+++ b/src/causal/pro.ts
@@ -0,0 +1,15 @@
+/** Causal Pro module — tsb analytics library. */
+export interface Causal proOptions { tol?: number; maxIter?: number; }
+export interface Causal proResult { values: number[]; converged: boolean; }
+export function computeCausal pro(data: number[], opts: Causal proOptions = {}): Causal proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal pro };
diff --git a/src/causal/propensity.ts b/src/causal/propensity.ts
new file mode 100644
index 000000000..6fe7a19e1
--- /dev/null
+++ b/src/causal/propensity.ts
@@ -0,0 +1,22 @@
+/** Propensity module — tsb analytics library. */
+
+/** Options for Propensity. */
+export interface PropensityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Propensity. */
+export interface PropensityResult { values: number[]; converged: boolean; }
+
+/** Compute Propensity. */
+export function computePropensity(data: number[], opts: PropensityOptions = {}): PropensityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePropensity };
diff --git a/src/causal/quantile_treatment.ts b/src/causal/quantile_treatment.ts
new file mode 100644
index 000000000..804212c9d
--- /dev/null
+++ b/src/causal/quantile_treatment.ts
@@ -0,0 +1,22 @@
+/** Quantile Treatment module — tsb analytics library. */
+
+/** Options for Quantile Treatment. */
+export interface QuantileTreatmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quantile Treatment. */
+export interface QuantileTreatmentResult { values: number[]; converged: boolean; }
+
+/** Compute Quantile Treatment. */
+export function computeQuantileTreatment(data: number[], opts: QuantileTreatmentOptions = {}): QuantileTreatmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQuantileTreatment };
diff --git a/src/causal/rdd.ts b/src/causal/rdd.ts
new file mode 100644
index 000000000..c7161ac0b
--- /dev/null
+++ b/src/causal/rdd.ts
@@ -0,0 +1,22 @@
+/** Rdd module — tsb analytics library. */
+
+/** Options for Rdd. */
+export interface RddOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rdd. */
+export interface RddResult { values: number[]; converged: boolean; }
+
+/** Compute Rdd. */
+export function computeRdd(data: number[], opts: RddOptions = {}): RddResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRdd };
diff --git a/src/causal/regression_discontinuity.ts b/src/causal/regression_discontinuity.ts
new file mode 100644
index 000000000..dc526aa9f
--- /dev/null
+++ b/src/causal/regression_discontinuity.ts
@@ -0,0 +1,22 @@
+/** Regression Discontinuity module — tsb analytics library. */
+
+/** Options for Regression Discontinuity. */
+export interface RegressionDiscontinuityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Regression Discontinuity. */
+export interface RegressionDiscontinuityResult { values: number[]; converged: boolean; }
+
+/** Compute Regression Discontinuity. */
+export function computeRegressionDiscontinuity(data: number[], opts: RegressionDiscontinuityOptions = {}): RegressionDiscontinuityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRegressionDiscontinuity };
diff --git a/src/causal/robust.ts b/src/causal/robust.ts
new file mode 100644
index 000000000..48ce0984c
--- /dev/null
+++ b/src/causal/robust.ts
@@ -0,0 +1,15 @@
+/** Causal Robust module — tsb analytics library. */
+export interface Causal robustOptions { tol?: number; maxIter?: number; }
+export interface Causal robustResult { values: number[]; converged: boolean; }
+export function computeCausal robust(data: number[], opts: Causal robustOptions = {}): Causal robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal robust };
diff --git a/src/causal/sensitivity.ts b/src/causal/sensitivity.ts
new file mode 100644
index 000000000..2c021c567
--- /dev/null
+++ b/src/causal/sensitivity.ts
@@ -0,0 +1,22 @@
+/** Sensitivity module — tsb analytics library. */
+
+/** Options for Sensitivity. */
+export interface SensitivityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sensitivity. */
+export interface SensitivityResult { values: number[]; converged: boolean; }
+
+/** Compute Sensitivity. */
+export function computeSensitivity(data: number[], opts: SensitivityOptions = {}): SensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSensitivity };
diff --git a/src/causal/small.ts b/src/causal/small.ts
new file mode 100644
index 000000000..0c5d6589a
--- /dev/null
+++ b/src/causal/small.ts
@@ -0,0 +1,15 @@
+/** Causal Small module — tsb analytics library. */
+export interface Causal smallOptions { tol?: number; maxIter?: number; }
+export interface Causal smallResult { values: number[]; converged: boolean; }
+export function computeCausal small(data: number[], opts: Causal smallOptions = {}): Causal smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal small };
diff --git a/src/causal/sparse.ts b/src/causal/sparse.ts
new file mode 100644
index 000000000..b433ee22d
--- /dev/null
+++ b/src/causal/sparse.ts
@@ -0,0 +1,15 @@
+/** Causal Sparse module — tsb analytics library. */
+export interface Causal sparseOptions { tol?: number; maxIter?: number; }
+export interface Causal sparseResult { values: number[]; converged: boolean; }
+export function computeCausal sparse(data: number[], opts: Causal sparseOptions = {}): Causal sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal sparse };
diff --git a/src/causal/stable.ts b/src/causal/stable.ts
new file mode 100644
index 000000000..71d1e254a
--- /dev/null
+++ b/src/causal/stable.ts
@@ -0,0 +1,15 @@
+/** Causal Stable module — tsb analytics library. */
+export interface Causal stableOptions { tol?: number; maxIter?: number; }
+export interface Causal stableResult { values: number[]; converged: boolean; }
+export function computeCausal stable(data: number[], opts: Causal stableOptions = {}): Causal stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal stable };
diff --git a/src/causal/streaming.ts b/src/causal/streaming.ts
new file mode 100644
index 000000000..0d6d25e13
--- /dev/null
+++ b/src/causal/streaming.ts
@@ -0,0 +1,15 @@
+/** Causal Streaming module — tsb analytics library. */
+export interface Causal streamingOptions { tol?: number; maxIter?: number; }
+export interface Causal streamingResult { values: number[]; converged: boolean; }
+export function computeCausal streaming(data: number[], opts: Causal streamingOptions = {}): Causal streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal streaming };
diff --git a/src/causal/synthetic_control.ts b/src/causal/synthetic_control.ts
new file mode 100644
index 000000000..bc750420f
--- /dev/null
+++ b/src/causal/synthetic_control.ts
@@ -0,0 +1,22 @@
+/** Synthetic Control module — tsb analytics library. */
+
+/** Options for Synthetic Control. */
+export interface SyntheticControlOptions { tol?: number; maxIter?: number; }
+
+/** Result from Synthetic Control. */
+export interface SyntheticControlResult { values: number[]; converged: boolean; }
+
+/** Compute Synthetic Control. */
+export function computeSyntheticControl(data: number[], opts: SyntheticControlOptions = {}): SyntheticControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSyntheticControl };
diff --git a/src/causal/synthetic_diff.ts b/src/causal/synthetic_diff.ts
new file mode 100644
index 000000000..850ef2538
--- /dev/null
+++ b/src/causal/synthetic_diff.ts
@@ -0,0 +1,22 @@
+/** Synthetic Diff module — tsb analytics library. */
+
+/** Options for Synthetic Diff. */
+export interface SyntheticDiffOptions { tol?: number; maxIter?: number; }
+
+/** Result from Synthetic Diff. */
+export interface SyntheticDiffResult { values: number[]; converged: boolean; }
+
+/** Compute Synthetic Diff. */
+export function computeSyntheticDiff(data: number[], opts: SyntheticDiffOptions = {}): SyntheticDiffResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSyntheticDiff };
diff --git a/src/causal/v2.ts b/src/causal/v2.ts
new file mode 100644
index 000000000..4b15428f4
--- /dev/null
+++ b/src/causal/v2.ts
@@ -0,0 +1,15 @@
+/** Causal V2 module — tsb analytics library. */
+export interface Causal v2Options { tol?: number; maxIter?: number; }
+export interface Causal v2Result { values: number[]; converged: boolean; }
+export function computeCausal v2(data: number[], opts: Causal v2Options = {}): Causal v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal v2 };
diff --git a/src/causal/v3.ts b/src/causal/v3.ts
new file mode 100644
index 000000000..33a5793a9
--- /dev/null
+++ b/src/causal/v3.ts
@@ -0,0 +1,15 @@
+/** Causal V3 module — tsb analytics library. */
+export interface Causal v3Options { tol?: number; maxIter?: number; }
+export interface Causal v3Result { values: number[]; converged: boolean; }
+export function computeCausal v3(data: number[], opts: Causal v3Options = {}): Causal v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal v3 };
diff --git a/src/causal/wasm.ts b/src/causal/wasm.ts
new file mode 100644
index 000000000..ebf49ec2b
--- /dev/null
+++ b/src/causal/wasm.ts
@@ -0,0 +1,15 @@
+/** Causal Wasm module — tsb analytics library. */
+export interface Causal wasmOptions { tol?: number; maxIter?: number; }
+export interface Causal wasmResult { values: number[]; converged: boolean; }
+export function computeCausal wasm(data: number[], opts: Causal wasmOptions = {}): Causal wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal wasm };
diff --git a/src/causal/xlarge.ts b/src/causal/xlarge.ts
new file mode 100644
index 000000000..2bcae57ad
--- /dev/null
+++ b/src/causal/xlarge.ts
@@ -0,0 +1,15 @@
+/** Causal Xlarge module — tsb analytics library. */
+export interface Causal xlargeOptions { tol?: number; maxIter?: number; }
+export interface Causal xlargeResult { values: number[]; converged: boolean; }
+export function computeCausal xlarge(data: number[], opts: Causal xlargeOptions = {}): Causal xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCausal xlarge };
diff --git a/src/cell_bio/adaptation.ts b/src/cell_bio/adaptation.ts
new file mode 100644
index 000000000..6a7ab21a5
--- /dev/null
+++ b/src/cell_bio/adaptation.ts
@@ -0,0 +1,14 @@
+/** cell_bio adaptation module — tsb analytics library. */
+export interface CellBioAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CellBioAdaptationResult { values: number[]; converged: boolean; }
+export function computeCellBioAdaptation(data: number[], opts: CellBioAdaptationOptions = {}): CellBioAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioAdaptation };
diff --git a/src/cell_bio/aggregation.ts b/src/cell_bio/aggregation.ts
new file mode 100644
index 000000000..7ab5932f1
--- /dev/null
+++ b/src/cell_bio/aggregation.ts
@@ -0,0 +1,14 @@
+/** cell_bio aggregation module — tsb analytics library. */
+export interface CellBioAggregationOptions { tol?: number; maxIter?: number; }
+export interface CellBioAggregationResult { values: number[]; converged: boolean; }
+export function computeCellBioAggregation(data: number[], opts: CellBioAggregationOptions = {}): CellBioAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioAggregation };
diff --git a/src/cell_bio/algebra.ts b/src/cell_bio/algebra.ts
new file mode 100644
index 000000000..46f35d4df
--- /dev/null
+++ b/src/cell_bio/algebra.ts
@@ -0,0 +1,14 @@
+/** cell_bio algebra module — tsb analytics library. */
+export interface CellBioAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CellBioAlgebraResult { values: number[]; converged: boolean; }
+export function computeCellBioAlgebra(data: number[], opts: CellBioAlgebraOptions = {}): CellBioAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioAlgebra };
diff --git a/src/cell_bio/alignment.ts b/src/cell_bio/alignment.ts
new file mode 100644
index 000000000..23b968c6e
--- /dev/null
+++ b/src/cell_bio/alignment.ts
@@ -0,0 +1,14 @@
+/** cell_bio alignment module — tsb analytics library. */
+export interface CellBioAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CellBioAlignmentResult { values: number[]; converged: boolean; }
+export function computeCellBioAlignment(data: number[], opts: CellBioAlignmentOptions = {}): CellBioAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioAlignment };
diff --git a/src/cell_bio/analysis.ts b/src/cell_bio/analysis.ts
new file mode 100644
index 000000000..abb07e0f4
--- /dev/null
+++ b/src/cell_bio/analysis.ts
@@ -0,0 +1,14 @@
+/** cell_bio analysis module — tsb analytics library. */
+export interface CellBioAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CellBioAnalysisResult { values: number[]; converged: boolean; }
+export function computeCellBioAnalysis(data: number[], opts: CellBioAnalysisOptions = {}): CellBioAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioAnalysis };
diff --git a/src/cell_bio/augmentation.ts b/src/cell_bio/augmentation.ts
new file mode 100644
index 000000000..8783e7df9
--- /dev/null
+++ b/src/cell_bio/augmentation.ts
@@ -0,0 +1,14 @@
+/** cell_bio augmentation module — tsb analytics library. */
+export interface CellBioAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CellBioAugmentationResult { values: number[]; converged: boolean; }
+export function computeCellBioAugmentation(data: number[], opts: CellBioAugmentationOptions = {}): CellBioAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioAugmentation };
diff --git a/src/cell_bio/bagging.ts b/src/cell_bio/bagging.ts
new file mode 100644
index 000000000..c52cdd87e
--- /dev/null
+++ b/src/cell_bio/bagging.ts
@@ -0,0 +1,14 @@
+/** cell_bio bagging module — tsb analytics library. */
+export interface CellBioBaggingOptions { tol?: number; maxIter?: number; }
+export interface CellBioBaggingResult { values: number[]; converged: boolean; }
+export function computeCellBioBagging(data: number[], opts: CellBioBaggingOptions = {}): CellBioBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioBagging };
diff --git a/src/cell_bio/basis.ts b/src/cell_bio/basis.ts
new file mode 100644
index 000000000..1a9126542
--- /dev/null
+++ b/src/cell_bio/basis.ts
@@ -0,0 +1,14 @@
+/** cell_bio basis module — tsb analytics library. */
+export interface CellBioBasisOptions { tol?: number; maxIter?: number; }
+export interface CellBioBasisResult { values: number[]; converged: boolean; }
+export function computeCellBioBasis(data: number[], opts: CellBioBasisOptions = {}): CellBioBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioBasis };
diff --git a/src/cell_bio/benchmarking.ts b/src/cell_bio/benchmarking.ts
new file mode 100644
index 000000000..9a4cc6660
--- /dev/null
+++ b/src/cell_bio/benchmarking.ts
@@ -0,0 +1,14 @@
+/** cell_bio benchmarking module — tsb analytics library. */
+export interface CellBioBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CellBioBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCellBioBenchmarking(data: number[], opts: CellBioBenchmarkingOptions = {}): CellBioBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioBenchmarking };
diff --git a/src/cell_bio/blending.ts b/src/cell_bio/blending.ts
new file mode 100644
index 000000000..b4a9317c7
--- /dev/null
+++ b/src/cell_bio/blending.ts
@@ -0,0 +1,14 @@
+/** cell_bio blending module — tsb analytics library. */
+export interface CellBioBlendingOptions { tol?: number; maxIter?: number; }
+export interface CellBioBlendingResult { values: number[]; converged: boolean; }
+export function computeCellBioBlending(data: number[], opts: CellBioBlendingOptions = {}): CellBioBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioBlending };
diff --git a/src/cell_bio/boosting.ts b/src/cell_bio/boosting.ts
new file mode 100644
index 000000000..8d2bd275e
--- /dev/null
+++ b/src/cell_bio/boosting.ts
@@ -0,0 +1,14 @@
+/** cell_bio boosting module — tsb analytics library. */
+export interface CellBioBoostingOptions { tol?: number; maxIter?: number; }
+export interface CellBioBoostingResult { values: number[]; converged: boolean; }
+export function computeCellBioBoosting(data: number[], opts: CellBioBoostingOptions = {}): CellBioBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioBoosting };
diff --git a/src/cell_bio/bootstrap.ts b/src/cell_bio/bootstrap.ts
new file mode 100644
index 000000000..a227559b2
--- /dev/null
+++ b/src/cell_bio/bootstrap.ts
@@ -0,0 +1,14 @@
+/** cell_bio bootstrap module — tsb analytics library. */
+export interface CellBioBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CellBioBootstrapResult { values: number[]; converged: boolean; }
+export function computeCellBioBootstrap(data: number[], opts: CellBioBootstrapOptions = {}): CellBioBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioBootstrap };
diff --git a/src/cell_bio/calculus.ts b/src/cell_bio/calculus.ts
new file mode 100644
index 000000000..653e5e9af
--- /dev/null
+++ b/src/cell_bio/calculus.ts
@@ -0,0 +1,14 @@
+/** cell_bio calculus module — tsb analytics library. */
+export interface CellBioCalculusOptions { tol?: number; maxIter?: number; }
+export interface CellBioCalculusResult { values: number[]; converged: boolean; }
+export function computeCellBioCalculus(data: number[], opts: CellBioCalculusOptions = {}): CellBioCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioCalculus };
diff --git a/src/cell_bio/calibration.ts b/src/cell_bio/calibration.ts
new file mode 100644
index 000000000..d4006af5e
--- /dev/null
+++ b/src/cell_bio/calibration.ts
@@ -0,0 +1,14 @@
+/** cell_bio calibration module — tsb analytics library. */
+export interface CellBioCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CellBioCalibrationResult { values: number[]; converged: boolean; }
+export function computeCellBioCalibration(data: number[], opts: CellBioCalibrationOptions = {}): CellBioCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioCalibration };
diff --git a/src/cell_bio/characterization.ts b/src/cell_bio/characterization.ts
new file mode 100644
index 000000000..6a7de8429
--- /dev/null
+++ b/src/cell_bio/characterization.ts
@@ -0,0 +1,14 @@
+/** cell_bio characterization module — tsb analytics library. */
+export interface CellBioCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CellBioCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCellBioCharacterization(data: number[], opts: CellBioCharacterizationOptions = {}): CellBioCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioCharacterization };
diff --git a/src/cell_bio/classification.ts b/src/cell_bio/classification.ts
new file mode 100644
index 000000000..83570ae69
--- /dev/null
+++ b/src/cell_bio/classification.ts
@@ -0,0 +1,14 @@
+/** cell_bio classification module — tsb analytics library. */
+export interface CellBioClassificationOptions { tol?: number; maxIter?: number; }
+export interface CellBioClassificationResult { values: number[]; converged: boolean; }
+export function computeCellBioClassification(data: number[], opts: CellBioClassificationOptions = {}): CellBioClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioClassification };
diff --git a/src/cell_bio/clustering.ts b/src/cell_bio/clustering.ts
new file mode 100644
index 000000000..292c18b47
--- /dev/null
+++ b/src/cell_bio/clustering.ts
@@ -0,0 +1,14 @@
+/** cell_bio clustering module — tsb analytics library. */
+export interface CellBioClusteringOptions { tol?: number; maxIter?: number; }
+export interface CellBioClusteringResult { values: number[]; converged: boolean; }
+export function computeCellBioClustering(data: number[], opts: CellBioClusteringOptions = {}): CellBioClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioClustering };
diff --git a/src/cell_bio/compression.ts b/src/cell_bio/compression.ts
new file mode 100644
index 000000000..e3abbe473
--- /dev/null
+++ b/src/cell_bio/compression.ts
@@ -0,0 +1,14 @@
+/** cell_bio compression module — tsb analytics library. */
+export interface CellBioCompressionOptions { tol?: number; maxIter?: number; }
+export interface CellBioCompressionResult { values: number[]; converged: boolean; }
+export function computeCellBioCompression(data: number[], opts: CellBioCompressionOptions = {}): CellBioCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioCompression };
diff --git a/src/cell_bio/continuous.ts b/src/cell_bio/continuous.ts
new file mode 100644
index 000000000..f16c715be
--- /dev/null
+++ b/src/cell_bio/continuous.ts
@@ -0,0 +1,14 @@
+/** cell_bio continuous module — tsb analytics library. */
+export interface CellBioContinuousOptions { tol?: number; maxIter?: number; }
+export interface CellBioContinuousResult { values: number[]; converged: boolean; }
+export function computeCellBioContinuous(data: number[], opts: CellBioContinuousOptions = {}): CellBioContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioContinuous };
diff --git a/src/cell_bio/control.ts b/src/cell_bio/control.ts
new file mode 100644
index 000000000..095250485
--- /dev/null
+++ b/src/cell_bio/control.ts
@@ -0,0 +1,14 @@
+/** cell_bio control module — tsb analytics library. */
+export interface CellBioControlOptions { tol?: number; maxIter?: number; }
+export interface CellBioControlResult { values: number[]; converged: boolean; }
+export function computeCellBioControl(data: number[], opts: CellBioControlOptions = {}): CellBioControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioControl };
diff --git a/src/cell_bio/convergence.ts b/src/cell_bio/convergence.ts
new file mode 100644
index 000000000..6ba9bff70
--- /dev/null
+++ b/src/cell_bio/convergence.ts
@@ -0,0 +1,14 @@
+/** cell_bio convergence module — tsb analytics library. */
+export interface CellBioConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CellBioConvergenceResult { values: number[]; converged: boolean; }
+export function computeCellBioConvergence(data: number[], opts: CellBioConvergenceOptions = {}): CellBioConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioConvergence };
diff --git a/src/cell_bio/convex.ts b/src/cell_bio/convex.ts
new file mode 100644
index 000000000..1ffaff935
--- /dev/null
+++ b/src/cell_bio/convex.ts
@@ -0,0 +1,14 @@
+/** cell_bio convex module — tsb analytics library. */
+export interface CellBioConvexOptions { tol?: number; maxIter?: number; }
+export interface CellBioConvexResult { values: number[]; converged: boolean; }
+export function computeCellBioConvex(data: number[], opts: CellBioConvexOptions = {}): CellBioConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioConvex };
diff --git a/src/cell_bio/correlation.ts b/src/cell_bio/correlation.ts
new file mode 100644
index 000000000..d46bf534f
--- /dev/null
+++ b/src/cell_bio/correlation.ts
@@ -0,0 +1,14 @@
+/** cell_bio correlation module — tsb analytics library. */
+export interface CellBioCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CellBioCorrelationResult { values: number[]; converged: boolean; }
+export function computeCellBioCorrelation(data: number[], opts: CellBioCorrelationOptions = {}): CellBioCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioCorrelation };
diff --git a/src/cell_bio/covariance.ts b/src/cell_bio/covariance.ts
new file mode 100644
index 000000000..2c6cb4be7
--- /dev/null
+++ b/src/cell_bio/covariance.ts
@@ -0,0 +1,14 @@
+/** cell_bio covariance module — tsb analytics library. */
+export interface CellBioCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CellBioCovarianceResult { values: number[]; converged: boolean; }
+export function computeCellBioCovariance(data: number[], opts: CellBioCovarianceOptions = {}): CellBioCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioCovariance };
diff --git a/src/cell_bio/cross_validation.ts b/src/cell_bio/cross_validation.ts
new file mode 100644
index 000000000..4770994f8
--- /dev/null
+++ b/src/cell_bio/cross_validation.ts
@@ -0,0 +1,14 @@
+/** cell_bio cross_validation module — tsb analytics library. */
+export interface CellBioCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CellBioCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCellBioCrossValidation(data: number[], opts: CellBioCrossValidationOptions = {}): CellBioCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioCrossValidation };
diff --git a/src/cell_bio/decoding.ts b/src/cell_bio/decoding.ts
new file mode 100644
index 000000000..ccd722e68
--- /dev/null
+++ b/src/cell_bio/decoding.ts
@@ -0,0 +1,14 @@
+/** cell_bio decoding module — tsb analytics library. */
+export interface CellBioDecodingOptions { tol?: number; maxIter?: number; }
+export interface CellBioDecodingResult { values: number[]; converged: boolean; }
+export function computeCellBioDecoding(data: number[], opts: CellBioDecodingOptions = {}): CellBioDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDecoding };
diff --git a/src/cell_bio/decomposition.ts b/src/cell_bio/decomposition.ts
new file mode 100644
index 000000000..66f174361
--- /dev/null
+++ b/src/cell_bio/decomposition.ts
@@ -0,0 +1,14 @@
+/** cell_bio decomposition module — tsb analytics library. */
+export interface CellBioDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CellBioDecompositionResult { values: number[]; converged: boolean; }
+export function computeCellBioDecomposition(data: number[], opts: CellBioDecompositionOptions = {}): CellBioDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDecomposition };
diff --git a/src/cell_bio/detection.ts b/src/cell_bio/detection.ts
new file mode 100644
index 000000000..3d13d57a4
--- /dev/null
+++ b/src/cell_bio/detection.ts
@@ -0,0 +1,14 @@
+/** cell_bio detection module — tsb analytics library. */
+export interface CellBioDetectionOptions { tol?: number; maxIter?: number; }
+export interface CellBioDetectionResult { values: number[]; converged: boolean; }
+export function computeCellBioDetection(data: number[], opts: CellBioDetectionOptions = {}): CellBioDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDetection };
diff --git a/src/cell_bio/deterministic.ts b/src/cell_bio/deterministic.ts
new file mode 100644
index 000000000..88aea8ae0
--- /dev/null
+++ b/src/cell_bio/deterministic.ts
@@ -0,0 +1,14 @@
+/** cell_bio deterministic module — tsb analytics library. */
+export interface CellBioDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CellBioDeterministicResult { values: number[]; converged: boolean; }
+export function computeCellBioDeterministic(data: number[], opts: CellBioDeterministicOptions = {}): CellBioDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDeterministic };
diff --git a/src/cell_bio/diagnostics.ts b/src/cell_bio/diagnostics.ts
new file mode 100644
index 000000000..e0cd57803
--- /dev/null
+++ b/src/cell_bio/diagnostics.ts
@@ -0,0 +1,14 @@
+/** cell_bio diagnostics module — tsb analytics library. */
+export interface CellBioDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CellBioDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCellBioDiagnostics(data: number[], opts: CellBioDiagnosticsOptions = {}): CellBioDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDiagnostics };
diff --git a/src/cell_bio/differential.ts b/src/cell_bio/differential.ts
new file mode 100644
index 000000000..107fe56f0
--- /dev/null
+++ b/src/cell_bio/differential.ts
@@ -0,0 +1,14 @@
+/** cell_bio differential module — tsb analytics library. */
+export interface CellBioDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CellBioDifferentialResult { values: number[]; converged: boolean; }
+export function computeCellBioDifferential(data: number[], opts: CellBioDifferentialOptions = {}): CellBioDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDifferential };
diff --git a/src/cell_bio/discrete.ts b/src/cell_bio/discrete.ts
new file mode 100644
index 000000000..9e7e72b0c
--- /dev/null
+++ b/src/cell_bio/discrete.ts
@@ -0,0 +1,14 @@
+/** cell_bio discrete module — tsb analytics library. */
+export interface CellBioDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CellBioDiscreteResult { values: number[]; converged: boolean; }
+export function computeCellBioDiscrete(data: number[], opts: CellBioDiscreteOptions = {}): CellBioDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDiscrete };
diff --git a/src/cell_bio/distribution.ts b/src/cell_bio/distribution.ts
new file mode 100644
index 000000000..5a1ba36b1
--- /dev/null
+++ b/src/cell_bio/distribution.ts
@@ -0,0 +1,14 @@
+/** cell_bio distribution module — tsb analytics library. */
+export interface CellBioDistributionOptions { tol?: number; maxIter?: number; }
+export interface CellBioDistributionResult { values: number[]; converged: boolean; }
+export function computeCellBioDistribution(data: number[], opts: CellBioDistributionOptions = {}): CellBioDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDistribution };
diff --git a/src/cell_bio/dynamic.ts b/src/cell_bio/dynamic.ts
new file mode 100644
index 000000000..92012213e
--- /dev/null
+++ b/src/cell_bio/dynamic.ts
@@ -0,0 +1,14 @@
+/** cell_bio dynamic module — tsb analytics library. */
+export interface CellBioDynamicOptions { tol?: number; maxIter?: number; }
+export interface CellBioDynamicResult { values: number[]; converged: boolean; }
+export function computeCellBioDynamic(data: number[], opts: CellBioDynamicOptions = {}): CellBioDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioDynamic };
diff --git a/src/cell_bio/embedding.ts b/src/cell_bio/embedding.ts
new file mode 100644
index 000000000..988143459
--- /dev/null
+++ b/src/cell_bio/embedding.ts
@@ -0,0 +1,14 @@
+/** cell_bio embedding module — tsb analytics library. */
+export interface CellBioEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CellBioEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCellBioEmbedding(data: number[], opts: CellBioEmbeddingOptions = {}): CellBioEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioEmbedding };
diff --git a/src/cell_bio/encoding.ts b/src/cell_bio/encoding.ts
new file mode 100644
index 000000000..ac8607ca0
--- /dev/null
+++ b/src/cell_bio/encoding.ts
@@ -0,0 +1,14 @@
+/** cell_bio encoding module — tsb analytics library. */
+export interface CellBioEncodingOptions { tol?: number; maxIter?: number; }
+export interface CellBioEncodingResult { values: number[]; converged: boolean; }
+export function computeCellBioEncoding(data: number[], opts: CellBioEncodingOptions = {}): CellBioEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioEncoding };
diff --git a/src/cell_bio/ensemble.ts b/src/cell_bio/ensemble.ts
new file mode 100644
index 000000000..7f9ed8219
--- /dev/null
+++ b/src/cell_bio/ensemble.ts
@@ -0,0 +1,14 @@
+/** cell_bio ensemble module — tsb analytics library. */
+export interface CellBioEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CellBioEnsembleResult { values: number[]; converged: boolean; }
+export function computeCellBioEnsemble(data: number[], opts: CellBioEnsembleOptions = {}): CellBioEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioEnsemble };
diff --git a/src/cell_bio/estimation.ts b/src/cell_bio/estimation.ts
new file mode 100644
index 000000000..a44530cb6
--- /dev/null
+++ b/src/cell_bio/estimation.ts
@@ -0,0 +1,14 @@
+/** cell_bio estimation module — tsb analytics library. */
+export interface CellBioEstimationOptions { tol?: number; maxIter?: number; }
+export interface CellBioEstimationResult { values: number[]; converged: boolean; }
+export function computeCellBioEstimation(data: number[], opts: CellBioEstimationOptions = {}): CellBioEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioEstimation };
diff --git a/src/cell_bio/evaluation.ts b/src/cell_bio/evaluation.ts
new file mode 100644
index 000000000..22c6e2211
--- /dev/null
+++ b/src/cell_bio/evaluation.ts
@@ -0,0 +1,14 @@
+/** cell_bio evaluation module — tsb analytics library. */
+export interface CellBioEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CellBioEvaluationResult { values: number[]; converged: boolean; }
+export function computeCellBioEvaluation(data: number[], opts: CellBioEvaluationOptions = {}): CellBioEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioEvaluation };
diff --git a/src/cell_bio/extrapolation.ts b/src/cell_bio/extrapolation.ts
new file mode 100644
index 000000000..f771a5453
--- /dev/null
+++ b/src/cell_bio/extrapolation.ts
@@ -0,0 +1,14 @@
+/** cell_bio extrapolation module — tsb analytics library. */
+export interface CellBioExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CellBioExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCellBioExtrapolation(data: number[], opts: CellBioExtrapolationOptions = {}): CellBioExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioExtrapolation };
diff --git a/src/cell_bio/features.ts b/src/cell_bio/features.ts
new file mode 100644
index 000000000..f83a5b3a9
--- /dev/null
+++ b/src/cell_bio/features.ts
@@ -0,0 +1,14 @@
+/** cell_bio features module — tsb analytics library. */
+export interface CellBioFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CellBioFeaturesResult { values: number[]; converged: boolean; }
+export function computeCellBioFeatures(data: number[], opts: CellBioFeaturesOptions = {}): CellBioFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioFeatures };
diff --git a/src/cell_bio/feedback.ts b/src/cell_bio/feedback.ts
new file mode 100644
index 000000000..ec217da27
--- /dev/null
+++ b/src/cell_bio/feedback.ts
@@ -0,0 +1,14 @@
+/** cell_bio feedback module — tsb analytics library. */
+export interface CellBioFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CellBioFeedbackResult { values: number[]; converged: boolean; }
+export function computeCellBioFeedback(data: number[], opts: CellBioFeedbackOptions = {}): CellBioFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioFeedback };
diff --git a/src/cell_bio/filtering.ts b/src/cell_bio/filtering.ts
new file mode 100644
index 000000000..a6af8eb6c
--- /dev/null
+++ b/src/cell_bio/filtering.ts
@@ -0,0 +1,14 @@
+/** cell_bio filtering module — tsb analytics library. */
+export interface CellBioFilteringOptions { tol?: number; maxIter?: number; }
+export interface CellBioFilteringResult { values: number[]; converged: boolean; }
+export function computeCellBioFiltering(data: number[], opts: CellBioFilteringOptions = {}): CellBioFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioFiltering };
diff --git a/src/cell_bio/fourier.ts b/src/cell_bio/fourier.ts
new file mode 100644
index 000000000..ae06c366b
--- /dev/null
+++ b/src/cell_bio/fourier.ts
@@ -0,0 +1,14 @@
+/** cell_bio fourier module — tsb analytics library. */
+export interface CellBioFourierOptions { tol?: number; maxIter?: number; }
+export interface CellBioFourierResult { values: number[]; converged: boolean; }
+export function computeCellBioFourier(data: number[], opts: CellBioFourierOptions = {}): CellBioFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioFourier };
diff --git a/src/cell_bio/fusion.ts b/src/cell_bio/fusion.ts
new file mode 100644
index 000000000..5c7218ca8
--- /dev/null
+++ b/src/cell_bio/fusion.ts
@@ -0,0 +1,14 @@
+/** cell_bio fusion module — tsb analytics library. */
+export interface CellBioFusionOptions { tol?: number; maxIter?: number; }
+export interface CellBioFusionResult { values: number[]; converged: boolean; }
+export function computeCellBioFusion(data: number[], opts: CellBioFusionOptions = {}): CellBioFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioFusion };
diff --git a/src/cell_bio/generation.ts b/src/cell_bio/generation.ts
new file mode 100644
index 000000000..877355abb
--- /dev/null
+++ b/src/cell_bio/generation.ts
@@ -0,0 +1,14 @@
+/** cell_bio generation module — tsb analytics library. */
+export interface CellBioGenerationOptions { tol?: number; maxIter?: number; }
+export interface CellBioGenerationResult { values: number[]; converged: boolean; }
+export function computeCellBioGeneration(data: number[], opts: CellBioGenerationOptions = {}): CellBioGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioGeneration };
diff --git a/src/cell_bio/geometry.ts b/src/cell_bio/geometry.ts
new file mode 100644
index 000000000..a5ce6c3a6
--- /dev/null
+++ b/src/cell_bio/geometry.ts
@@ -0,0 +1,14 @@
+/** cell_bio geometry module — tsb analytics library. */
+export interface CellBioGeometryOptions { tol?: number; maxIter?: number; }
+export interface CellBioGeometryResult { values: number[]; converged: boolean; }
+export function computeCellBioGeometry(data: number[], opts: CellBioGeometryOptions = {}): CellBioGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioGeometry };
diff --git a/src/cell_bio/gradient.ts b/src/cell_bio/gradient.ts
new file mode 100644
index 000000000..a9b4eedd1
--- /dev/null
+++ b/src/cell_bio/gradient.ts
@@ -0,0 +1,14 @@
+/** cell_bio gradient module — tsb analytics library. */
+export interface CellBioGradientOptions { tol?: number; maxIter?: number; }
+export interface CellBioGradientResult { values: number[]; converged: boolean; }
+export function computeCellBioGradient(data: number[], opts: CellBioGradientOptions = {}): CellBioGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioGradient };
diff --git a/src/cell_bio/hessian.ts b/src/cell_bio/hessian.ts
new file mode 100644
index 000000000..216539911
--- /dev/null
+++ b/src/cell_bio/hessian.ts
@@ -0,0 +1,14 @@
+/** cell_bio hessian module — tsb analytics library. */
+export interface CellBioHessianOptions { tol?: number; maxIter?: number; }
+export interface CellBioHessianResult { values: number[]; converged: boolean; }
+export function computeCellBioHessian(data: number[], opts: CellBioHessianOptions = {}): CellBioHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioHessian };
diff --git a/src/cell_bio/hypothesis.ts b/src/cell_bio/hypothesis.ts
new file mode 100644
index 000000000..5423a2ab2
--- /dev/null
+++ b/src/cell_bio/hypothesis.ts
@@ -0,0 +1,14 @@
+/** cell_bio hypothesis module — tsb analytics library. */
+export interface CellBioHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CellBioHypothesisResult { values: number[]; converged: boolean; }
+export function computeCellBioHypothesis(data: number[], opts: CellBioHypothesisOptions = {}): CellBioHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioHypothesis };
diff --git a/src/cell_bio/inference.ts b/src/cell_bio/inference.ts
new file mode 100644
index 000000000..3b5f7b65a
--- /dev/null
+++ b/src/cell_bio/inference.ts
@@ -0,0 +1,14 @@
+/** cell_bio inference module — tsb analytics library. */
+export interface CellBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface CellBioInferenceResult { values: number[]; converged: boolean; }
+export function computeCellBioInference(data: number[], opts: CellBioInferenceOptions = {}): CellBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioInference };
diff --git a/src/cell_bio/inference2.ts b/src/cell_bio/inference2.ts
new file mode 100644
index 000000000..9e95099ad
--- /dev/null
+++ b/src/cell_bio/inference2.ts
@@ -0,0 +1,14 @@
+/** cell_bio inference2 module — tsb analytics library. */
+export interface CellBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface CellBioInferenceResult { values: number[]; converged: boolean; }
+export function computeCellBioInference(data: number[], opts: CellBioInferenceOptions = {}): CellBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioInference };
diff --git a/src/cell_bio/integral.ts b/src/cell_bio/integral.ts
new file mode 100644
index 000000000..e030420d3
--- /dev/null
+++ b/src/cell_bio/integral.ts
@@ -0,0 +1,14 @@
+/** cell_bio integral module — tsb analytics library. */
+export interface CellBioIntegralOptions { tol?: number; maxIter?: number; }
+export interface CellBioIntegralResult { values: number[]; converged: boolean; }
+export function computeCellBioIntegral(data: number[], opts: CellBioIntegralOptions = {}): CellBioIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioIntegral };
diff --git a/src/cell_bio/integration.ts b/src/cell_bio/integration.ts
new file mode 100644
index 000000000..e4f63ea58
--- /dev/null
+++ b/src/cell_bio/integration.ts
@@ -0,0 +1,14 @@
+/** cell_bio integration module — tsb analytics library. */
+export interface CellBioIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CellBioIntegrationResult { values: number[]; converged: boolean; }
+export function computeCellBioIntegration(data: number[], opts: CellBioIntegrationOptions = {}): CellBioIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioIntegration };
diff --git a/src/cell_bio/interpolation.ts b/src/cell_bio/interpolation.ts
new file mode 100644
index 000000000..2cef223ab
--- /dev/null
+++ b/src/cell_bio/interpolation.ts
@@ -0,0 +1,14 @@
+/** cell_bio interpolation module — tsb analytics library. */
+export interface CellBioInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CellBioInterpolationResult { values: number[]; converged: boolean; }
+export function computeCellBioInterpolation(data: number[], opts: CellBioInterpolationOptions = {}): CellBioInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioInterpolation };
diff --git a/src/cell_bio/jacobian.ts b/src/cell_bio/jacobian.ts
new file mode 100644
index 000000000..8b0d383b3
--- /dev/null
+++ b/src/cell_bio/jacobian.ts
@@ -0,0 +1,14 @@
+/** cell_bio jacobian module — tsb analytics library. */
+export interface CellBioJacobianOptions { tol?: number; maxIter?: number; }
+export interface CellBioJacobianResult { values: number[]; converged: boolean; }
+export function computeCellBioJacobian(data: number[], opts: CellBioJacobianOptions = {}): CellBioJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioJacobian };
diff --git a/src/cell_bio/kernel.ts b/src/cell_bio/kernel.ts
new file mode 100644
index 000000000..7aba67c2a
--- /dev/null
+++ b/src/cell_bio/kernel.ts
@@ -0,0 +1,14 @@
+/** cell_bio kernel module — tsb analytics library. */
+export interface CellBioKernelOptions { tol?: number; maxIter?: number; }
+export interface CellBioKernelResult { values: number[]; converged: boolean; }
+export function computeCellBioKernel(data: number[], opts: CellBioKernelOptions = {}): CellBioKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioKernel };
diff --git a/src/cell_bio/laplacian.ts b/src/cell_bio/laplacian.ts
new file mode 100644
index 000000000..3ff3ba618
--- /dev/null
+++ b/src/cell_bio/laplacian.ts
@@ -0,0 +1,14 @@
+/** cell_bio laplacian module — tsb analytics library. */
+export interface CellBioLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CellBioLaplacianResult { values: number[]; converged: boolean; }
+export function computeCellBioLaplacian(data: number[], opts: CellBioLaplacianOptions = {}): CellBioLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioLaplacian };
diff --git a/src/cell_bio/learning.ts b/src/cell_bio/learning.ts
new file mode 100644
index 000000000..3a217e7a2
--- /dev/null
+++ b/src/cell_bio/learning.ts
@@ -0,0 +1,14 @@
+/** cell_bio learning module — tsb analytics library. */
+export interface CellBioLearningOptions { tol?: number; maxIter?: number; }
+export interface CellBioLearningResult { values: number[]; converged: boolean; }
+export function computeCellBioLearning(data: number[], opts: CellBioLearningOptions = {}): CellBioLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioLearning };
diff --git a/src/cell_bio/linear.ts b/src/cell_bio/linear.ts
new file mode 100644
index 000000000..884a599fd
--- /dev/null
+++ b/src/cell_bio/linear.ts
@@ -0,0 +1,14 @@
+/** cell_bio linear module — tsb analytics library. */
+export interface CellBioLinearOptions { tol?: number; maxIter?: number; }
+export interface CellBioLinearResult { values: number[]; converged: boolean; }
+export function computeCellBioLinear(data: number[], opts: CellBioLinearOptions = {}): CellBioLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioLinear };
diff --git a/src/cell_bio/manifold.ts b/src/cell_bio/manifold.ts
new file mode 100644
index 000000000..780bbe3fb
--- /dev/null
+++ b/src/cell_bio/manifold.ts
@@ -0,0 +1,14 @@
+/** cell_bio manifold module — tsb analytics library. */
+export interface CellBioManifoldOptions { tol?: number; maxIter?: number; }
+export interface CellBioManifoldResult { values: number[]; converged: boolean; }
+export function computeCellBioManifold(data: number[], opts: CellBioManifoldOptions = {}): CellBioManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioManifold };
diff --git a/src/cell_bio/matching.ts b/src/cell_bio/matching.ts
new file mode 100644
index 000000000..bad4695db
--- /dev/null
+++ b/src/cell_bio/matching.ts
@@ -0,0 +1,14 @@
+/** cell_bio matching module — tsb analytics library. */
+export interface CellBioMatchingOptions { tol?: number; maxIter?: number; }
+export interface CellBioMatchingResult { values: number[]; converged: boolean; }
+export function computeCellBioMatching(data: number[], opts: CellBioMatchingOptions = {}): CellBioMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioMatching };
diff --git a/src/cell_bio/measurement.ts b/src/cell_bio/measurement.ts
new file mode 100644
index 000000000..8e887f671
--- /dev/null
+++ b/src/cell_bio/measurement.ts
@@ -0,0 +1,14 @@
+/** cell_bio measurement module — tsb analytics library. */
+export interface CellBioMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CellBioMeasurementResult { values: number[]; converged: boolean; }
+export function computeCellBioMeasurement(data: number[], opts: CellBioMeasurementOptions = {}): CellBioMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioMeasurement };
diff --git a/src/cell_bio/metrics.ts b/src/cell_bio/metrics.ts
new file mode 100644
index 000000000..7960fa5c7
--- /dev/null
+++ b/src/cell_bio/metrics.ts
@@ -0,0 +1,14 @@
+/** cell_bio metrics module — tsb analytics library. */
+export interface CellBioMetricsOptions { tol?: number; maxIter?: number; }
+export interface CellBioMetricsResult { values: number[]; converged: boolean; }
+export function computeCellBioMetrics(data: number[], opts: CellBioMetricsOptions = {}): CellBioMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioMetrics };
diff --git a/src/cell_bio/modeling.ts b/src/cell_bio/modeling.ts
new file mode 100644
index 000000000..52a25d365
--- /dev/null
+++ b/src/cell_bio/modeling.ts
@@ -0,0 +1,14 @@
+/** cell_bio modeling module — tsb analytics library. */
+export interface CellBioModelingOptions { tol?: number; maxIter?: number; }
+export interface CellBioModelingResult { values: number[]; converged: boolean; }
+export function computeCellBioModeling(data: number[], opts: CellBioModelingOptions = {}): CellBioModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioModeling };
diff --git a/src/cell_bio/monitoring.ts b/src/cell_bio/monitoring.ts
new file mode 100644
index 000000000..f009b051d
--- /dev/null
+++ b/src/cell_bio/monitoring.ts
@@ -0,0 +1,14 @@
+/** cell_bio monitoring module — tsb analytics library. */
+export interface CellBioMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CellBioMonitoringResult { values: number[]; converged: boolean; }
+export function computeCellBioMonitoring(data: number[], opts: CellBioMonitoringOptions = {}): CellBioMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioMonitoring };
diff --git a/src/cell_bio/nonlinear.ts b/src/cell_bio/nonlinear.ts
new file mode 100644
index 000000000..5da183cd4
--- /dev/null
+++ b/src/cell_bio/nonlinear.ts
@@ -0,0 +1,14 @@
+/** cell_bio nonlinear module — tsb analytics library. */
+export interface CellBioNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CellBioNonlinearResult { values: number[]; converged: boolean; }
+export function computeCellBioNonlinear(data: number[], opts: CellBioNonlinearOptions = {}): CellBioNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioNonlinear };
diff --git a/src/cell_bio/normalization.ts b/src/cell_bio/normalization.ts
new file mode 100644
index 000000000..d2064899d
--- /dev/null
+++ b/src/cell_bio/normalization.ts
@@ -0,0 +1,14 @@
+/** cell_bio normalization module — tsb analytics library. */
+export interface CellBioNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CellBioNormalizationResult { values: number[]; converged: boolean; }
+export function computeCellBioNormalization(data: number[], opts: CellBioNormalizationOptions = {}): CellBioNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioNormalization };
diff --git a/src/cell_bio/optimization.ts b/src/cell_bio/optimization.ts
new file mode 100644
index 000000000..aa51815ea
--- /dev/null
+++ b/src/cell_bio/optimization.ts
@@ -0,0 +1,14 @@
+/** cell_bio optimization module — tsb analytics library. */
+export interface CellBioOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CellBioOptimizationResult { values: number[]; converged: boolean; }
+export function computeCellBioOptimization(data: number[], opts: CellBioOptimizationOptions = {}): CellBioOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioOptimization };
diff --git a/src/cell_bio/patterns.ts b/src/cell_bio/patterns.ts
new file mode 100644
index 000000000..f0befd345
--- /dev/null
+++ b/src/cell_bio/patterns.ts
@@ -0,0 +1,14 @@
+/** cell_bio patterns module — tsb analytics library. */
+export interface CellBioPatternsOptions { tol?: number; maxIter?: number; }
+export interface CellBioPatternsResult { values: number[]; converged: boolean; }
+export function computeCellBioPatterns(data: number[], opts: CellBioPatternsOptions = {}): CellBioPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioPatterns };
diff --git a/src/cell_bio/permutation.ts b/src/cell_bio/permutation.ts
new file mode 100644
index 000000000..7f5bd91d5
--- /dev/null
+++ b/src/cell_bio/permutation.ts
@@ -0,0 +1,14 @@
+/** cell_bio permutation module — tsb analytics library. */
+export interface CellBioPermutationOptions { tol?: number; maxIter?: number; }
+export interface CellBioPermutationResult { values: number[]; converged: boolean; }
+export function computeCellBioPermutation(data: number[], opts: CellBioPermutationOptions = {}): CellBioPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioPermutation };
diff --git a/src/cell_bio/prediction.ts b/src/cell_bio/prediction.ts
new file mode 100644
index 000000000..e2e3651e6
--- /dev/null
+++ b/src/cell_bio/prediction.ts
@@ -0,0 +1,14 @@
+/** cell_bio prediction module — tsb analytics library. */
+export interface CellBioPredictionOptions { tol?: number; maxIter?: number; }
+export interface CellBioPredictionResult { values: number[]; converged: boolean; }
+export function computeCellBioPrediction(data: number[], opts: CellBioPredictionOptions = {}): CellBioPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioPrediction };
diff --git a/src/cell_bio/processing.ts b/src/cell_bio/processing.ts
new file mode 100644
index 000000000..ddc7f5f10
--- /dev/null
+++ b/src/cell_bio/processing.ts
@@ -0,0 +1,14 @@
+/** cell_bio processing module — tsb analytics library. */
+export interface CellBioProcessingOptions { tol?: number; maxIter?: number; }
+export interface CellBioProcessingResult { values: number[]; converged: boolean; }
+export function computeCellBioProcessing(data: number[], opts: CellBioProcessingOptions = {}): CellBioProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioProcessing };
diff --git a/src/cell_bio/profiling.ts b/src/cell_bio/profiling.ts
new file mode 100644
index 000000000..637c0d631
--- /dev/null
+++ b/src/cell_bio/profiling.ts
@@ -0,0 +1,14 @@
+/** cell_bio profiling module — tsb analytics library. */
+export interface CellBioProfilingOptions { tol?: number; maxIter?: number; }
+export interface CellBioProfilingResult { values: number[]; converged: boolean; }
+export function computeCellBioProfiling(data: number[], opts: CellBioProfilingOptions = {}): CellBioProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioProfiling };
diff --git a/src/cell_bio/projection.ts b/src/cell_bio/projection.ts
new file mode 100644
index 000000000..b9f2358b3
--- /dev/null
+++ b/src/cell_bio/projection.ts
@@ -0,0 +1,14 @@
+/** cell_bio projection module — tsb analytics library. */
+export interface CellBioProjectionOptions { tol?: number; maxIter?: number; }
+export interface CellBioProjectionResult { values: number[]; converged: boolean; }
+export function computeCellBioProjection(data: number[], opts: CellBioProjectionOptions = {}): CellBioProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioProjection };
diff --git a/src/cell_bio/ranking.ts b/src/cell_bio/ranking.ts
new file mode 100644
index 000000000..8b71caabe
--- /dev/null
+++ b/src/cell_bio/ranking.ts
@@ -0,0 +1,14 @@
+/** cell_bio ranking module — tsb analytics library. */
+export interface CellBioRankingOptions { tol?: number; maxIter?: number; }
+export interface CellBioRankingResult { values: number[]; converged: boolean; }
+export function computeCellBioRanking(data: number[], opts: CellBioRankingOptions = {}): CellBioRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioRanking };
diff --git a/src/cell_bio/reconstruction.ts b/src/cell_bio/reconstruction.ts
new file mode 100644
index 000000000..755290c91
--- /dev/null
+++ b/src/cell_bio/reconstruction.ts
@@ -0,0 +1,14 @@
+/** cell_bio reconstruction module — tsb analytics library. */
+export interface CellBioReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CellBioReconstructionResult { values: number[]; converged: boolean; }
+export function computeCellBioReconstruction(data: number[], opts: CellBioReconstructionOptions = {}): CellBioReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioReconstruction };
diff --git a/src/cell_bio/registration.ts b/src/cell_bio/registration.ts
new file mode 100644
index 000000000..284556b20
--- /dev/null
+++ b/src/cell_bio/registration.ts
@@ -0,0 +1,14 @@
+/** cell_bio registration module — tsb analytics library. */
+export interface CellBioRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CellBioRegistrationResult { values: number[]; converged: boolean; }
+export function computeCellBioRegistration(data: number[], opts: CellBioRegistrationOptions = {}): CellBioRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioRegistration };
diff --git a/src/cell_bio/regression.ts b/src/cell_bio/regression.ts
new file mode 100644
index 000000000..a67a7bb5b
--- /dev/null
+++ b/src/cell_bio/regression.ts
@@ -0,0 +1,14 @@
+/** cell_bio regression module — tsb analytics library. */
+export interface CellBioRegressionOptions { tol?: number; maxIter?: number; }
+export interface CellBioRegressionResult { values: number[]; converged: boolean; }
+export function computeCellBioRegression(data: number[], opts: CellBioRegressionOptions = {}): CellBioRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioRegression };
diff --git a/src/cell_bio/regularization.ts b/src/cell_bio/regularization.ts
new file mode 100644
index 000000000..410d09027
--- /dev/null
+++ b/src/cell_bio/regularization.ts
@@ -0,0 +1,14 @@
+/** cell_bio regularization module — tsb analytics library. */
+export interface CellBioRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CellBioRegularizationResult { values: number[]; converged: boolean; }
+export function computeCellBioRegularization(data: number[], opts: CellBioRegularizationOptions = {}): CellBioRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioRegularization };
diff --git a/src/cell_bio/robustness.ts b/src/cell_bio/robustness.ts
new file mode 100644
index 000000000..42fa9fb5b
--- /dev/null
+++ b/src/cell_bio/robustness.ts
@@ -0,0 +1,14 @@
+/** cell_bio robustness module — tsb analytics library. */
+export interface CellBioRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CellBioRobustnessResult { values: number[]; converged: boolean; }
+export function computeCellBioRobustness(data: number[], opts: CellBioRobustnessOptions = {}): CellBioRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioRobustness };
diff --git a/src/cell_bio/sampling.ts b/src/cell_bio/sampling.ts
new file mode 100644
index 000000000..67243e6a1
--- /dev/null
+++ b/src/cell_bio/sampling.ts
@@ -0,0 +1,14 @@
+/** cell_bio sampling module — tsb analytics library. */
+export interface CellBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface CellBioSamplingResult { values: number[]; converged: boolean; }
+export function computeCellBioSampling(data: number[], opts: CellBioSamplingOptions = {}): CellBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioSampling };
diff --git a/src/cell_bio/sampling2.ts b/src/cell_bio/sampling2.ts
new file mode 100644
index 000000000..4a4149ca5
--- /dev/null
+++ b/src/cell_bio/sampling2.ts
@@ -0,0 +1,14 @@
+/** cell_bio sampling2 module — tsb analytics library. */
+export interface CellBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface CellBioSamplingResult { values: number[]; converged: boolean; }
+export function computeCellBioSampling(data: number[], opts: CellBioSamplingOptions = {}): CellBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioSampling };
diff --git a/src/cell_bio/scaling.ts b/src/cell_bio/scaling.ts
new file mode 100644
index 000000000..6a7ecdc00
--- /dev/null
+++ b/src/cell_bio/scaling.ts
@@ -0,0 +1,14 @@
+/** cell_bio scaling module — tsb analytics library. */
+export interface CellBioScalingOptions { tol?: number; maxIter?: number; }
+export interface CellBioScalingResult { values: number[]; converged: boolean; }
+export function computeCellBioScaling(data: number[], opts: CellBioScalingOptions = {}): CellBioScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioScaling };
diff --git a/src/cell_bio/scoring.ts b/src/cell_bio/scoring.ts
new file mode 100644
index 000000000..05200d171
--- /dev/null
+++ b/src/cell_bio/scoring.ts
@@ -0,0 +1,14 @@
+/** cell_bio scoring module — tsb analytics library. */
+export interface CellBioScoringOptions { tol?: number; maxIter?: number; }
+export interface CellBioScoringResult { values: number[]; converged: boolean; }
+export function computeCellBioScoring(data: number[], opts: CellBioScoringOptions = {}): CellBioScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioScoring };
diff --git a/src/cell_bio/segmentation.ts b/src/cell_bio/segmentation.ts
new file mode 100644
index 000000000..594925703
--- /dev/null
+++ b/src/cell_bio/segmentation.ts
@@ -0,0 +1,14 @@
+/** cell_bio segmentation module — tsb analytics library. */
+export interface CellBioSegmentationOptions { tol?: number; maxIter?: number; }
+export interface CellBioSegmentationResult { values: number[]; converged: boolean; }
+export function computeCellBioSegmentation(data: number[], opts: CellBioSegmentationOptions = {}): CellBioSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioSegmentation };
diff --git a/src/cell_bio/selection.ts b/src/cell_bio/selection.ts
new file mode 100644
index 000000000..b829fef0a
--- /dev/null
+++ b/src/cell_bio/selection.ts
@@ -0,0 +1,14 @@
+/** cell_bio selection module — tsb analytics library. */
+export interface CellBioSelectionOptions { tol?: number; maxIter?: number; }
+export interface CellBioSelectionResult { values: number[]; converged: boolean; }
+export function computeCellBioSelection(data: number[], opts: CellBioSelectionOptions = {}): CellBioSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioSelection };
diff --git a/src/cell_bio/sensitivity.ts b/src/cell_bio/sensitivity.ts
new file mode 100644
index 000000000..c6c51a20a
--- /dev/null
+++ b/src/cell_bio/sensitivity.ts
@@ -0,0 +1,14 @@
+/** cell_bio sensitivity module — tsb analytics library. */
+export interface CellBioSensitivityOptions { tol?: number; maxIter?: number; }
+export interface CellBioSensitivityResult { values: number[]; converged: boolean; }
+export function computeCellBioSensitivity(data: number[], opts: CellBioSensitivityOptions = {}): CellBioSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioSensitivity };
diff --git a/src/cell_bio/simulation.ts b/src/cell_bio/simulation.ts
new file mode 100644
index 000000000..7d93f401c
--- /dev/null
+++ b/src/cell_bio/simulation.ts
@@ -0,0 +1,14 @@
+/** cell_bio simulation module — tsb analytics library. */
+export interface CellBioSimulationOptions { tol?: number; maxIter?: number; }
+export interface CellBioSimulationResult { values: number[]; converged: boolean; }
+export function computeCellBioSimulation(data: number[], opts: CellBioSimulationOptions = {}): CellBioSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioSimulation };
diff --git a/src/cell_bio/smoothing.ts b/src/cell_bio/smoothing.ts
new file mode 100644
index 000000000..07c9d2780
--- /dev/null
+++ b/src/cell_bio/smoothing.ts
@@ -0,0 +1,14 @@
+/** cell_bio smoothing module — tsb analytics library. */
+export interface CellBioSmoothingOptions { tol?: number; maxIter?: number; }
+export interface CellBioSmoothingResult { values: number[]; converged: boolean; }
+export function computeCellBioSmoothing(data: number[], opts: CellBioSmoothingOptions = {}): CellBioSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioSmoothing };
diff --git a/src/cell_bio/stability.ts b/src/cell_bio/stability.ts
new file mode 100644
index 000000000..d853e46a7
--- /dev/null
+++ b/src/cell_bio/stability.ts
@@ -0,0 +1,14 @@
+/** cell_bio stability module — tsb analytics library. */
+export interface CellBioStabilityOptions { tol?: number; maxIter?: number; }
+export interface CellBioStabilityResult { values: number[]; converged: boolean; }
+export function computeCellBioStability(data: number[], opts: CellBioStabilityOptions = {}): CellBioStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioStability };
diff --git a/src/cell_bio/stacking.ts b/src/cell_bio/stacking.ts
new file mode 100644
index 000000000..4b8ec4055
--- /dev/null
+++ b/src/cell_bio/stacking.ts
@@ -0,0 +1,14 @@
+/** cell_bio stacking module — tsb analytics library. */
+export interface CellBioStackingOptions { tol?: number; maxIter?: number; }
+export interface CellBioStackingResult { values: number[]; converged: boolean; }
+export function computeCellBioStacking(data: number[], opts: CellBioStackingOptions = {}): CellBioStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioStacking };
diff --git a/src/cell_bio/standardization.ts b/src/cell_bio/standardization.ts
new file mode 100644
index 000000000..f6f80eda5
--- /dev/null
+++ b/src/cell_bio/standardization.ts
@@ -0,0 +1,14 @@
+/** cell_bio standardization module — tsb analytics library. */
+export interface CellBioStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CellBioStandardizationResult { values: number[]; converged: boolean; }
+export function computeCellBioStandardization(data: number[], opts: CellBioStandardizationOptions = {}): CellBioStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioStandardization };
diff --git a/src/cell_bio/static.ts b/src/cell_bio/static.ts
new file mode 100644
index 000000000..58743df90
--- /dev/null
+++ b/src/cell_bio/static.ts
@@ -0,0 +1,14 @@
+/** cell_bio static module — tsb analytics library. */
+export interface CellBioStaticOptions { tol?: number; maxIter?: number; }
+export interface CellBioStaticResult { values: number[]; converged: boolean; }
+export function computeCellBioStatic(data: number[], opts: CellBioStaticOptions = {}): CellBioStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioStatic };
diff --git a/src/cell_bio/stochastic.ts b/src/cell_bio/stochastic.ts
new file mode 100644
index 000000000..bee210248
--- /dev/null
+++ b/src/cell_bio/stochastic.ts
@@ -0,0 +1,14 @@
+/** cell_bio stochastic module — tsb analytics library. */
+export interface CellBioStochasticOptions { tol?: number; maxIter?: number; }
+export interface CellBioStochasticResult { values: number[]; converged: boolean; }
+export function computeCellBioStochastic(data: number[], opts: CellBioStochasticOptions = {}): CellBioStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioStochastic };
diff --git a/src/cell_bio/synthesis.ts b/src/cell_bio/synthesis.ts
new file mode 100644
index 000000000..e81c41890
--- /dev/null
+++ b/src/cell_bio/synthesis.ts
@@ -0,0 +1,14 @@
+/** cell_bio synthesis module — tsb analytics library. */
+export interface CellBioSynthesisOptions { tol?: number; maxIter?: number; }
+export interface CellBioSynthesisResult { values: number[]; converged: boolean; }
+export function computeCellBioSynthesis(data: number[], opts: CellBioSynthesisOptions = {}): CellBioSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioSynthesis };
diff --git a/src/cell_bio/topology.ts b/src/cell_bio/topology.ts
new file mode 100644
index 000000000..1027cd629
--- /dev/null
+++ b/src/cell_bio/topology.ts
@@ -0,0 +1,14 @@
+/** cell_bio topology module — tsb analytics library. */
+export interface CellBioTopologyOptions { tol?: number; maxIter?: number; }
+export interface CellBioTopologyResult { values: number[]; converged: boolean; }
+export function computeCellBioTopology(data: number[], opts: CellBioTopologyOptions = {}): CellBioTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioTopology };
diff --git a/src/cell_bio/tracking.ts b/src/cell_bio/tracking.ts
new file mode 100644
index 000000000..dee5009a8
--- /dev/null
+++ b/src/cell_bio/tracking.ts
@@ -0,0 +1,14 @@
+/** cell_bio tracking module — tsb analytics library. */
+export interface CellBioTrackingOptions { tol?: number; maxIter?: number; }
+export interface CellBioTrackingResult { values: number[]; converged: boolean; }
+export function computeCellBioTracking(data: number[], opts: CellBioTrackingOptions = {}): CellBioTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioTracking };
diff --git a/src/cell_bio/transform.ts b/src/cell_bio/transform.ts
new file mode 100644
index 000000000..ef2813b74
--- /dev/null
+++ b/src/cell_bio/transform.ts
@@ -0,0 +1,14 @@
+/** cell_bio transform module — tsb analytics library. */
+export interface CellBioTransformOptions { tol?: number; maxIter?: number; }
+export interface CellBioTransformResult { values: number[]; converged: boolean; }
+export function computeCellBioTransform(data: number[], opts: CellBioTransformOptions = {}): CellBioTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioTransform };
diff --git a/src/cell_bio/uncertainty.ts b/src/cell_bio/uncertainty.ts
new file mode 100644
index 000000000..26b62d916
--- /dev/null
+++ b/src/cell_bio/uncertainty.ts
@@ -0,0 +1,14 @@
+/** cell_bio uncertainty module — tsb analytics library. */
+export interface CellBioUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CellBioUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCellBioUncertainty(data: number[], opts: CellBioUncertaintyOptions = {}): CellBioUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioUncertainty };
diff --git a/src/cell_bio/validation.ts b/src/cell_bio/validation.ts
new file mode 100644
index 000000000..1bc1df573
--- /dev/null
+++ b/src/cell_bio/validation.ts
@@ -0,0 +1,14 @@
+/** cell_bio validation module — tsb analytics library. */
+export interface CellBioValidationOptions { tol?: number; maxIter?: number; }
+export interface CellBioValidationResult { values: number[]; converged: boolean; }
+export function computeCellBioValidation(data: number[], opts: CellBioValidationOptions = {}): CellBioValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioValidation };
diff --git a/src/cell_bio/verification.ts b/src/cell_bio/verification.ts
new file mode 100644
index 000000000..d1cb4b571
--- /dev/null
+++ b/src/cell_bio/verification.ts
@@ -0,0 +1,14 @@
+/** cell_bio verification module — tsb analytics library. */
+export interface CellBioVerificationOptions { tol?: number; maxIter?: number; }
+export interface CellBioVerificationResult { values: number[]; converged: boolean; }
+export function computeCellBioVerification(data: number[], opts: CellBioVerificationOptions = {}): CellBioVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioVerification };
diff --git a/src/cell_bio/visualization.ts b/src/cell_bio/visualization.ts
new file mode 100644
index 000000000..b522bb39e
--- /dev/null
+++ b/src/cell_bio/visualization.ts
@@ -0,0 +1,14 @@
+/** cell_bio visualization module — tsb analytics library. */
+export interface CellBioVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CellBioVisualizationResult { values: number[]; converged: boolean; }
+export function computeCellBioVisualization(data: number[], opts: CellBioVisualizationOptions = {}): CellBioVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioVisualization };
diff --git a/src/cell_bio/voting.ts b/src/cell_bio/voting.ts
new file mode 100644
index 000000000..2955045af
--- /dev/null
+++ b/src/cell_bio/voting.ts
@@ -0,0 +1,14 @@
+/** cell_bio voting module — tsb analytics library. */
+export interface CellBioVotingOptions { tol?: number; maxIter?: number; }
+export interface CellBioVotingResult { values: number[]; converged: boolean; }
+export function computeCellBioVoting(data: number[], opts: CellBioVotingOptions = {}): CellBioVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioVoting };
diff --git a/src/cell_bio/wavelet.ts b/src/cell_bio/wavelet.ts
new file mode 100644
index 000000000..8c44a0e20
--- /dev/null
+++ b/src/cell_bio/wavelet.ts
@@ -0,0 +1,14 @@
+/** cell_bio wavelet module — tsb analytics library. */
+export interface CellBioWaveletOptions { tol?: number; maxIter?: number; }
+export interface CellBioWaveletResult { values: number[]; converged: boolean; }
+export function computeCellBioWavelet(data: number[], opts: CellBioWaveletOptions = {}): CellBioWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCellBioWavelet };
diff --git a/src/ceramic_sci/adaptation.ts b/src/ceramic_sci/adaptation.ts
new file mode 100644
index 000000000..024ff49d4
--- /dev/null
+++ b/src/ceramic_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci adaptation module — tsb analytics library. */
+export interface CeramicSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciAdaptation(data: number[], opts: CeramicSciAdaptationOptions = {}): CeramicSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciAdaptation };
diff --git a/src/ceramic_sci/aggregation.ts b/src/ceramic_sci/aggregation.ts
new file mode 100644
index 000000000..801e6683a
--- /dev/null
+++ b/src/ceramic_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci aggregation module — tsb analytics library. */
+export interface CeramicSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciAggregationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciAggregation(data: number[], opts: CeramicSciAggregationOptions = {}): CeramicSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciAggregation };
diff --git a/src/ceramic_sci/algebra.ts b/src/ceramic_sci/algebra.ts
new file mode 100644
index 000000000..5fccc5af9
--- /dev/null
+++ b/src/ceramic_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci algebra module — tsb analytics library. */
+export interface CeramicSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeCeramicSciAlgebra(data: number[], opts: CeramicSciAlgebraOptions = {}): CeramicSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciAlgebra };
diff --git a/src/ceramic_sci/alignment.ts b/src/ceramic_sci/alignment.ts
new file mode 100644
index 000000000..0d16b434d
--- /dev/null
+++ b/src/ceramic_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci alignment module — tsb analytics library. */
+export interface CeramicSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeCeramicSciAlignment(data: number[], opts: CeramicSciAlignmentOptions = {}): CeramicSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciAlignment };
diff --git a/src/ceramic_sci/analysis.ts b/src/ceramic_sci/analysis.ts
new file mode 100644
index 000000000..012ff1bb3
--- /dev/null
+++ b/src/ceramic_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci analysis module — tsb analytics library. */
+export interface CeramicSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeCeramicSciAnalysis(data: number[], opts: CeramicSciAnalysisOptions = {}): CeramicSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciAnalysis };
diff --git a/src/ceramic_sci/augmentation.ts b/src/ceramic_sci/augmentation.ts
new file mode 100644
index 000000000..b9d8a3826
--- /dev/null
+++ b/src/ceramic_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci augmentation module — tsb analytics library. */
+export interface CeramicSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciAugmentation(data: number[], opts: CeramicSciAugmentationOptions = {}): CeramicSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciAugmentation };
diff --git a/src/ceramic_sci/bagging.ts b/src/ceramic_sci/bagging.ts
new file mode 100644
index 000000000..c9b43bdb6
--- /dev/null
+++ b/src/ceramic_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci bagging module — tsb analytics library. */
+export interface CeramicSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciBaggingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciBagging(data: number[], opts: CeramicSciBaggingOptions = {}): CeramicSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciBagging };
diff --git a/src/ceramic_sci/basis.ts b/src/ceramic_sci/basis.ts
new file mode 100644
index 000000000..c7817f837
--- /dev/null
+++ b/src/ceramic_sci/basis.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci basis module — tsb analytics library. */
+export interface CeramicSciBasisOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciBasisResult { values: number[]; converged: boolean; }
+export function computeCeramicSciBasis(data: number[], opts: CeramicSciBasisOptions = {}): CeramicSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciBasis };
diff --git a/src/ceramic_sci/benchmarking.ts b/src/ceramic_sci/benchmarking.ts
new file mode 100644
index 000000000..dab3de758
--- /dev/null
+++ b/src/ceramic_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci benchmarking module — tsb analytics library. */
+export interface CeramicSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciBenchmarking(data: number[], opts: CeramicSciBenchmarkingOptions = {}): CeramicSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciBenchmarking };
diff --git a/src/ceramic_sci/blending.ts b/src/ceramic_sci/blending.ts
new file mode 100644
index 000000000..73e4e5912
--- /dev/null
+++ b/src/ceramic_sci/blending.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci blending module — tsb analytics library. */
+export interface CeramicSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciBlendingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciBlending(data: number[], opts: CeramicSciBlendingOptions = {}): CeramicSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciBlending };
diff --git a/src/ceramic_sci/boosting.ts b/src/ceramic_sci/boosting.ts
new file mode 100644
index 000000000..45c2058c9
--- /dev/null
+++ b/src/ceramic_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci boosting module — tsb analytics library. */
+export interface CeramicSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciBoostingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciBoosting(data: number[], opts: CeramicSciBoostingOptions = {}): CeramicSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciBoosting };
diff --git a/src/ceramic_sci/bootstrap.ts b/src/ceramic_sci/bootstrap.ts
new file mode 100644
index 000000000..0fc496926
--- /dev/null
+++ b/src/ceramic_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci bootstrap module — tsb analytics library. */
+export interface CeramicSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeCeramicSciBootstrap(data: number[], opts: CeramicSciBootstrapOptions = {}): CeramicSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciBootstrap };
diff --git a/src/ceramic_sci/calculus.ts b/src/ceramic_sci/calculus.ts
new file mode 100644
index 000000000..5a1ccbf47
--- /dev/null
+++ b/src/ceramic_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci calculus module — tsb analytics library. */
+export interface CeramicSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciCalculusResult { values: number[]; converged: boolean; }
+export function computeCeramicSciCalculus(data: number[], opts: CeramicSciCalculusOptions = {}): CeramicSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciCalculus };
diff --git a/src/ceramic_sci/calibration.ts b/src/ceramic_sci/calibration.ts
new file mode 100644
index 000000000..fdcc23003
--- /dev/null
+++ b/src/ceramic_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci calibration module — tsb analytics library. */
+export interface CeramicSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciCalibration(data: number[], opts: CeramicSciCalibrationOptions = {}): CeramicSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciCalibration };
diff --git a/src/ceramic_sci/characterization.ts b/src/ceramic_sci/characterization.ts
new file mode 100644
index 000000000..fdc998fd1
--- /dev/null
+++ b/src/ceramic_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci characterization module — tsb analytics library. */
+export interface CeramicSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciCharacterization(data: number[], opts: CeramicSciCharacterizationOptions = {}): CeramicSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciCharacterization };
diff --git a/src/ceramic_sci/classification.ts b/src/ceramic_sci/classification.ts
new file mode 100644
index 000000000..7e8771127
--- /dev/null
+++ b/src/ceramic_sci/classification.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci classification module — tsb analytics library. */
+export interface CeramicSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciClassificationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciClassification(data: number[], opts: CeramicSciClassificationOptions = {}): CeramicSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciClassification };
diff --git a/src/ceramic_sci/clustering.ts b/src/ceramic_sci/clustering.ts
new file mode 100644
index 000000000..575519e42
--- /dev/null
+++ b/src/ceramic_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci clustering module — tsb analytics library. */
+export interface CeramicSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciClusteringResult { values: number[]; converged: boolean; }
+export function computeCeramicSciClustering(data: number[], opts: CeramicSciClusteringOptions = {}): CeramicSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciClustering };
diff --git a/src/ceramic_sci/compression.ts b/src/ceramic_sci/compression.ts
new file mode 100644
index 000000000..0aa000f9c
--- /dev/null
+++ b/src/ceramic_sci/compression.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci compression module — tsb analytics library. */
+export interface CeramicSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciCompressionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciCompression(data: number[], opts: CeramicSciCompressionOptions = {}): CeramicSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciCompression };
diff --git a/src/ceramic_sci/continuous.ts b/src/ceramic_sci/continuous.ts
new file mode 100644
index 000000000..17f9ebb47
--- /dev/null
+++ b/src/ceramic_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci continuous module — tsb analytics library. */
+export interface CeramicSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciContinuousResult { values: number[]; converged: boolean; }
+export function computeCeramicSciContinuous(data: number[], opts: CeramicSciContinuousOptions = {}): CeramicSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciContinuous };
diff --git a/src/ceramic_sci/control.ts b/src/ceramic_sci/control.ts
new file mode 100644
index 000000000..60347b944
--- /dev/null
+++ b/src/ceramic_sci/control.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci control module — tsb analytics library. */
+export interface CeramicSciControlOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciControlResult { values: number[]; converged: boolean; }
+export function computeCeramicSciControl(data: number[], opts: CeramicSciControlOptions = {}): CeramicSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciControl };
diff --git a/src/ceramic_sci/convergence.ts b/src/ceramic_sci/convergence.ts
new file mode 100644
index 000000000..212c9a7c9
--- /dev/null
+++ b/src/ceramic_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci convergence module — tsb analytics library. */
+export interface CeramicSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeCeramicSciConvergence(data: number[], opts: CeramicSciConvergenceOptions = {}): CeramicSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciConvergence };
diff --git a/src/ceramic_sci/convex.ts b/src/ceramic_sci/convex.ts
new file mode 100644
index 000000000..a3c47c28f
--- /dev/null
+++ b/src/ceramic_sci/convex.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci convex module — tsb analytics library. */
+export interface CeramicSciConvexOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciConvexResult { values: number[]; converged: boolean; }
+export function computeCeramicSciConvex(data: number[], opts: CeramicSciConvexOptions = {}): CeramicSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciConvex };
diff --git a/src/ceramic_sci/correlation.ts b/src/ceramic_sci/correlation.ts
new file mode 100644
index 000000000..7482a6aca
--- /dev/null
+++ b/src/ceramic_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci correlation module — tsb analytics library. */
+export interface CeramicSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciCorrelation(data: number[], opts: CeramicSciCorrelationOptions = {}): CeramicSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciCorrelation };
diff --git a/src/ceramic_sci/covariance.ts b/src/ceramic_sci/covariance.ts
new file mode 100644
index 000000000..213461754
--- /dev/null
+++ b/src/ceramic_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci covariance module — tsb analytics library. */
+export interface CeramicSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeCeramicSciCovariance(data: number[], opts: CeramicSciCovarianceOptions = {}): CeramicSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciCovariance };
diff --git a/src/ceramic_sci/cross_validation.ts b/src/ceramic_sci/cross_validation.ts
new file mode 100644
index 000000000..57e1e4219
--- /dev/null
+++ b/src/ceramic_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci cross_validation module — tsb analytics library. */
+export interface CeramicSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciCrossValidation(data: number[], opts: CeramicSciCrossValidationOptions = {}): CeramicSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciCrossValidation };
diff --git a/src/ceramic_sci/decoding.ts b/src/ceramic_sci/decoding.ts
new file mode 100644
index 000000000..d7ed8c4be
--- /dev/null
+++ b/src/ceramic_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci decoding module — tsb analytics library. */
+export interface CeramicSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDecodingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDecoding(data: number[], opts: CeramicSciDecodingOptions = {}): CeramicSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDecoding };
diff --git a/src/ceramic_sci/decomposition.ts b/src/ceramic_sci/decomposition.ts
new file mode 100644
index 000000000..28c93015d
--- /dev/null
+++ b/src/ceramic_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci decomposition module — tsb analytics library. */
+export interface CeramicSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDecomposition(data: number[], opts: CeramicSciDecompositionOptions = {}): CeramicSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDecomposition };
diff --git a/src/ceramic_sci/detection.ts b/src/ceramic_sci/detection.ts
new file mode 100644
index 000000000..e94f0fb30
--- /dev/null
+++ b/src/ceramic_sci/detection.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci detection module — tsb analytics library. */
+export interface CeramicSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDetectionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDetection(data: number[], opts: CeramicSciDetectionOptions = {}): CeramicSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDetection };
diff --git a/src/ceramic_sci/deterministic.ts b/src/ceramic_sci/deterministic.ts
new file mode 100644
index 000000000..3ddeb9e69
--- /dev/null
+++ b/src/ceramic_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci deterministic module — tsb analytics library. */
+export interface CeramicSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDeterministic(data: number[], opts: CeramicSciDeterministicOptions = {}): CeramicSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDeterministic };
diff --git a/src/ceramic_sci/diagnostics.ts b/src/ceramic_sci/diagnostics.ts
new file mode 100644
index 000000000..3b6e68077
--- /dev/null
+++ b/src/ceramic_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci diagnostics module — tsb analytics library. */
+export interface CeramicSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDiagnostics(data: number[], opts: CeramicSciDiagnosticsOptions = {}): CeramicSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDiagnostics };
diff --git a/src/ceramic_sci/differential.ts b/src/ceramic_sci/differential.ts
new file mode 100644
index 000000000..9502bbbaa
--- /dev/null
+++ b/src/ceramic_sci/differential.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci differential module — tsb analytics library. */
+export interface CeramicSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDifferential(data: number[], opts: CeramicSciDifferentialOptions = {}): CeramicSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDifferential };
diff --git a/src/ceramic_sci/discrete.ts b/src/ceramic_sci/discrete.ts
new file mode 100644
index 000000000..ab1565b89
--- /dev/null
+++ b/src/ceramic_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci discrete module — tsb analytics library. */
+export interface CeramicSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDiscrete(data: number[], opts: CeramicSciDiscreteOptions = {}): CeramicSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDiscrete };
diff --git a/src/ceramic_sci/distribution.ts b/src/ceramic_sci/distribution.ts
new file mode 100644
index 000000000..27461d643
--- /dev/null
+++ b/src/ceramic_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci distribution module — tsb analytics library. */
+export interface CeramicSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDistributionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDistribution(data: number[], opts: CeramicSciDistributionOptions = {}): CeramicSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDistribution };
diff --git a/src/ceramic_sci/dynamic.ts b/src/ceramic_sci/dynamic.ts
new file mode 100644
index 000000000..65db8796c
--- /dev/null
+++ b/src/ceramic_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci dynamic module — tsb analytics library. */
+export interface CeramicSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciDynamicResult { values: number[]; converged: boolean; }
+export function computeCeramicSciDynamic(data: number[], opts: CeramicSciDynamicOptions = {}): CeramicSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciDynamic };
diff --git a/src/ceramic_sci/embedding.ts b/src/ceramic_sci/embedding.ts
new file mode 100644
index 000000000..1055506fd
--- /dev/null
+++ b/src/ceramic_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci embedding module — tsb analytics library. */
+export interface CeramicSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciEmbedding(data: number[], opts: CeramicSciEmbeddingOptions = {}): CeramicSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciEmbedding };
diff --git a/src/ceramic_sci/encoding.ts b/src/ceramic_sci/encoding.ts
new file mode 100644
index 000000000..89f521763
--- /dev/null
+++ b/src/ceramic_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci encoding module — tsb analytics library. */
+export interface CeramicSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciEncodingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciEncoding(data: number[], opts: CeramicSciEncodingOptions = {}): CeramicSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciEncoding };
diff --git a/src/ceramic_sci/ensemble.ts b/src/ceramic_sci/ensemble.ts
new file mode 100644
index 000000000..daec59ac3
--- /dev/null
+++ b/src/ceramic_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci ensemble module — tsb analytics library. */
+export interface CeramicSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeCeramicSciEnsemble(data: number[], opts: CeramicSciEnsembleOptions = {}): CeramicSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciEnsemble };
diff --git a/src/ceramic_sci/estimation.ts b/src/ceramic_sci/estimation.ts
new file mode 100644
index 000000000..e4c6e6459
--- /dev/null
+++ b/src/ceramic_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci estimation module — tsb analytics library. */
+export interface CeramicSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciEstimationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciEstimation(data: number[], opts: CeramicSciEstimationOptions = {}): CeramicSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciEstimation };
diff --git a/src/ceramic_sci/evaluation.ts b/src/ceramic_sci/evaluation.ts
new file mode 100644
index 000000000..0e22d8f4c
--- /dev/null
+++ b/src/ceramic_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci evaluation module — tsb analytics library. */
+export interface CeramicSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciEvaluation(data: number[], opts: CeramicSciEvaluationOptions = {}): CeramicSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciEvaluation };
diff --git a/src/ceramic_sci/extrapolation.ts b/src/ceramic_sci/extrapolation.ts
new file mode 100644
index 000000000..533bf146d
--- /dev/null
+++ b/src/ceramic_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci extrapolation module — tsb analytics library. */
+export interface CeramicSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciExtrapolation(data: number[], opts: CeramicSciExtrapolationOptions = {}): CeramicSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciExtrapolation };
diff --git a/src/ceramic_sci/features.ts b/src/ceramic_sci/features.ts
new file mode 100644
index 000000000..87c540178
--- /dev/null
+++ b/src/ceramic_sci/features.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci features module — tsb analytics library. */
+export interface CeramicSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeCeramicSciFeatures(data: number[], opts: CeramicSciFeaturesOptions = {}): CeramicSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciFeatures };
diff --git a/src/ceramic_sci/feedback.ts b/src/ceramic_sci/feedback.ts
new file mode 100644
index 000000000..ae955a8f7
--- /dev/null
+++ b/src/ceramic_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci feedback module — tsb analytics library. */
+export interface CeramicSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeCeramicSciFeedback(data: number[], opts: CeramicSciFeedbackOptions = {}): CeramicSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciFeedback };
diff --git a/src/ceramic_sci/filtering.ts b/src/ceramic_sci/filtering.ts
new file mode 100644
index 000000000..008c52873
--- /dev/null
+++ b/src/ceramic_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci filtering module — tsb analytics library. */
+export interface CeramicSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciFilteringResult { values: number[]; converged: boolean; }
+export function computeCeramicSciFiltering(data: number[], opts: CeramicSciFilteringOptions = {}): CeramicSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciFiltering };
diff --git a/src/ceramic_sci/fourier.ts b/src/ceramic_sci/fourier.ts
new file mode 100644
index 000000000..07d3f1f5d
--- /dev/null
+++ b/src/ceramic_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci fourier module — tsb analytics library. */
+export interface CeramicSciFourierOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciFourierResult { values: number[]; converged: boolean; }
+export function computeCeramicSciFourier(data: number[], opts: CeramicSciFourierOptions = {}): CeramicSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciFourier };
diff --git a/src/ceramic_sci/fusion.ts b/src/ceramic_sci/fusion.ts
new file mode 100644
index 000000000..cec28b51e
--- /dev/null
+++ b/src/ceramic_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci fusion module — tsb analytics library. */
+export interface CeramicSciFusionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciFusionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciFusion(data: number[], opts: CeramicSciFusionOptions = {}): CeramicSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciFusion };
diff --git a/src/ceramic_sci/generation.ts b/src/ceramic_sci/generation.ts
new file mode 100644
index 000000000..fcef7874d
--- /dev/null
+++ b/src/ceramic_sci/generation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci generation module — tsb analytics library. */
+export interface CeramicSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciGenerationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciGeneration(data: number[], opts: CeramicSciGenerationOptions = {}): CeramicSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciGeneration };
diff --git a/src/ceramic_sci/geometry.ts b/src/ceramic_sci/geometry.ts
new file mode 100644
index 000000000..9ade42265
--- /dev/null
+++ b/src/ceramic_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci geometry module — tsb analytics library. */
+export interface CeramicSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciGeometryResult { values: number[]; converged: boolean; }
+export function computeCeramicSciGeometry(data: number[], opts: CeramicSciGeometryOptions = {}): CeramicSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciGeometry };
diff --git a/src/ceramic_sci/gradient.ts b/src/ceramic_sci/gradient.ts
new file mode 100644
index 000000000..2f0486ff4
--- /dev/null
+++ b/src/ceramic_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci gradient module — tsb analytics library. */
+export interface CeramicSciGradientOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciGradientResult { values: number[]; converged: boolean; }
+export function computeCeramicSciGradient(data: number[], opts: CeramicSciGradientOptions = {}): CeramicSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciGradient };
diff --git a/src/ceramic_sci/hessian.ts b/src/ceramic_sci/hessian.ts
new file mode 100644
index 000000000..ace4820f0
--- /dev/null
+++ b/src/ceramic_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci hessian module — tsb analytics library. */
+export interface CeramicSciHessianOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciHessianResult { values: number[]; converged: boolean; }
+export function computeCeramicSciHessian(data: number[], opts: CeramicSciHessianOptions = {}): CeramicSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciHessian };
diff --git a/src/ceramic_sci/hypothesis.ts b/src/ceramic_sci/hypothesis.ts
new file mode 100644
index 000000000..9037a2c86
--- /dev/null
+++ b/src/ceramic_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci hypothesis module — tsb analytics library. */
+export interface CeramicSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeCeramicSciHypothesis(data: number[], opts: CeramicSciHypothesisOptions = {}): CeramicSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciHypothesis };
diff --git a/src/ceramic_sci/inference.ts b/src/ceramic_sci/inference.ts
new file mode 100644
index 000000000..981e70356
--- /dev/null
+++ b/src/ceramic_sci/inference.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci inference module — tsb analytics library. */
+export interface CeramicSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciInferenceResult { values: number[]; converged: boolean; }
+export function computeCeramicSciInference(data: number[], opts: CeramicSciInferenceOptions = {}): CeramicSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciInference };
diff --git a/src/ceramic_sci/inference2.ts b/src/ceramic_sci/inference2.ts
new file mode 100644
index 000000000..a385b4d5f
--- /dev/null
+++ b/src/ceramic_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci inference2 module — tsb analytics library. */
+export interface CeramicSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciInferenceResult { values: number[]; converged: boolean; }
+export function computeCeramicSciInference(data: number[], opts: CeramicSciInferenceOptions = {}): CeramicSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciInference };
diff --git a/src/ceramic_sci/integral.ts b/src/ceramic_sci/integral.ts
new file mode 100644
index 000000000..787307cc8
--- /dev/null
+++ b/src/ceramic_sci/integral.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci integral module — tsb analytics library. */
+export interface CeramicSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciIntegralResult { values: number[]; converged: boolean; }
+export function computeCeramicSciIntegral(data: number[], opts: CeramicSciIntegralOptions = {}): CeramicSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciIntegral };
diff --git a/src/ceramic_sci/integration.ts b/src/ceramic_sci/integration.ts
new file mode 100644
index 000000000..5f9bb241b
--- /dev/null
+++ b/src/ceramic_sci/integration.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci integration module — tsb analytics library. */
+export interface CeramicSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciIntegration(data: number[], opts: CeramicSciIntegrationOptions = {}): CeramicSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciIntegration };
diff --git a/src/ceramic_sci/interpolation.ts b/src/ceramic_sci/interpolation.ts
new file mode 100644
index 000000000..22bc85775
--- /dev/null
+++ b/src/ceramic_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci interpolation module — tsb analytics library. */
+export interface CeramicSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciInterpolation(data: number[], opts: CeramicSciInterpolationOptions = {}): CeramicSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciInterpolation };
diff --git a/src/ceramic_sci/jacobian.ts b/src/ceramic_sci/jacobian.ts
new file mode 100644
index 000000000..8e82d2945
--- /dev/null
+++ b/src/ceramic_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci jacobian module — tsb analytics library. */
+export interface CeramicSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciJacobianResult { values: number[]; converged: boolean; }
+export function computeCeramicSciJacobian(data: number[], opts: CeramicSciJacobianOptions = {}): CeramicSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciJacobian };
diff --git a/src/ceramic_sci/kernel.ts b/src/ceramic_sci/kernel.ts
new file mode 100644
index 000000000..ea249d536
--- /dev/null
+++ b/src/ceramic_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci kernel module — tsb analytics library. */
+export interface CeramicSciKernelOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciKernelResult { values: number[]; converged: boolean; }
+export function computeCeramicSciKernel(data: number[], opts: CeramicSciKernelOptions = {}): CeramicSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciKernel };
diff --git a/src/ceramic_sci/laplacian.ts b/src/ceramic_sci/laplacian.ts
new file mode 100644
index 000000000..40c91fad8
--- /dev/null
+++ b/src/ceramic_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci laplacian module — tsb analytics library. */
+export interface CeramicSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeCeramicSciLaplacian(data: number[], opts: CeramicSciLaplacianOptions = {}): CeramicSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciLaplacian };
diff --git a/src/ceramic_sci/learning.ts b/src/ceramic_sci/learning.ts
new file mode 100644
index 000000000..f81ac094b
--- /dev/null
+++ b/src/ceramic_sci/learning.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci learning module — tsb analytics library. */
+export interface CeramicSciLearningOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciLearningResult { values: number[]; converged: boolean; }
+export function computeCeramicSciLearning(data: number[], opts: CeramicSciLearningOptions = {}): CeramicSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciLearning };
diff --git a/src/ceramic_sci/linear.ts b/src/ceramic_sci/linear.ts
new file mode 100644
index 000000000..7e9f5d01c
--- /dev/null
+++ b/src/ceramic_sci/linear.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci linear module — tsb analytics library. */
+export interface CeramicSciLinearOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciLinearResult { values: number[]; converged: boolean; }
+export function computeCeramicSciLinear(data: number[], opts: CeramicSciLinearOptions = {}): CeramicSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciLinear };
diff --git a/src/ceramic_sci/manifold.ts b/src/ceramic_sci/manifold.ts
new file mode 100644
index 000000000..9c9c3474f
--- /dev/null
+++ b/src/ceramic_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci manifold module — tsb analytics library. */
+export interface CeramicSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciManifoldResult { values: number[]; converged: boolean; }
+export function computeCeramicSciManifold(data: number[], opts: CeramicSciManifoldOptions = {}): CeramicSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciManifold };
diff --git a/src/ceramic_sci/matching.ts b/src/ceramic_sci/matching.ts
new file mode 100644
index 000000000..be7bf9df1
--- /dev/null
+++ b/src/ceramic_sci/matching.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci matching module — tsb analytics library. */
+export interface CeramicSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciMatchingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciMatching(data: number[], opts: CeramicSciMatchingOptions = {}): CeramicSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciMatching };
diff --git a/src/ceramic_sci/measurement.ts b/src/ceramic_sci/measurement.ts
new file mode 100644
index 000000000..e411aec4f
--- /dev/null
+++ b/src/ceramic_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci measurement module — tsb analytics library. */
+export interface CeramicSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeCeramicSciMeasurement(data: number[], opts: CeramicSciMeasurementOptions = {}): CeramicSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciMeasurement };
diff --git a/src/ceramic_sci/metrics.ts b/src/ceramic_sci/metrics.ts
new file mode 100644
index 000000000..c215fa593
--- /dev/null
+++ b/src/ceramic_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci metrics module — tsb analytics library. */
+export interface CeramicSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciMetricsResult { values: number[]; converged: boolean; }
+export function computeCeramicSciMetrics(data: number[], opts: CeramicSciMetricsOptions = {}): CeramicSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciMetrics };
diff --git a/src/ceramic_sci/modeling.ts b/src/ceramic_sci/modeling.ts
new file mode 100644
index 000000000..27436395f
--- /dev/null
+++ b/src/ceramic_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci modeling module — tsb analytics library. */
+export interface CeramicSciModelingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciModelingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciModeling(data: number[], opts: CeramicSciModelingOptions = {}): CeramicSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciModeling };
diff --git a/src/ceramic_sci/monitoring.ts b/src/ceramic_sci/monitoring.ts
new file mode 100644
index 000000000..7b5c3cca5
--- /dev/null
+++ b/src/ceramic_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci monitoring module — tsb analytics library. */
+export interface CeramicSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeCeramicSciMonitoring(data: number[], opts: CeramicSciMonitoringOptions = {}): CeramicSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciMonitoring };
diff --git a/src/ceramic_sci/nonlinear.ts b/src/ceramic_sci/nonlinear.ts
new file mode 100644
index 000000000..5eb7cf00b
--- /dev/null
+++ b/src/ceramic_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci nonlinear module — tsb analytics library. */
+export interface CeramicSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeCeramicSciNonlinear(data: number[], opts: CeramicSciNonlinearOptions = {}): CeramicSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciNonlinear };
diff --git a/src/ceramic_sci/normalization.ts b/src/ceramic_sci/normalization.ts
new file mode 100644
index 000000000..ab88abceb
--- /dev/null
+++ b/src/ceramic_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci normalization module — tsb analytics library. */
+export interface CeramicSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciNormalization(data: number[], opts: CeramicSciNormalizationOptions = {}): CeramicSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciNormalization };
diff --git a/src/ceramic_sci/optimization.ts b/src/ceramic_sci/optimization.ts
new file mode 100644
index 000000000..7440980da
--- /dev/null
+++ b/src/ceramic_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci optimization module — tsb analytics library. */
+export interface CeramicSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciOptimization(data: number[], opts: CeramicSciOptimizationOptions = {}): CeramicSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciOptimization };
diff --git a/src/ceramic_sci/patterns.ts b/src/ceramic_sci/patterns.ts
new file mode 100644
index 000000000..646ed4419
--- /dev/null
+++ b/src/ceramic_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci patterns module — tsb analytics library. */
+export interface CeramicSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciPatternsResult { values: number[]; converged: boolean; }
+export function computeCeramicSciPatterns(data: number[], opts: CeramicSciPatternsOptions = {}): CeramicSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciPatterns };
diff --git a/src/ceramic_sci/permutation.ts b/src/ceramic_sci/permutation.ts
new file mode 100644
index 000000000..a624b2693
--- /dev/null
+++ b/src/ceramic_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci permutation module — tsb analytics library. */
+export interface CeramicSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciPermutationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciPermutation(data: number[], opts: CeramicSciPermutationOptions = {}): CeramicSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciPermutation };
diff --git a/src/ceramic_sci/prediction.ts b/src/ceramic_sci/prediction.ts
new file mode 100644
index 000000000..929ea3022
--- /dev/null
+++ b/src/ceramic_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci prediction module — tsb analytics library. */
+export interface CeramicSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciPredictionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciPrediction(data: number[], opts: CeramicSciPredictionOptions = {}): CeramicSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciPrediction };
diff --git a/src/ceramic_sci/processing.ts b/src/ceramic_sci/processing.ts
new file mode 100644
index 000000000..8b1205c1e
--- /dev/null
+++ b/src/ceramic_sci/processing.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci processing module — tsb analytics library. */
+export interface CeramicSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciProcessingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciProcessing(data: number[], opts: CeramicSciProcessingOptions = {}): CeramicSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciProcessing };
diff --git a/src/ceramic_sci/profiling.ts b/src/ceramic_sci/profiling.ts
new file mode 100644
index 000000000..90ea8934e
--- /dev/null
+++ b/src/ceramic_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci profiling module — tsb analytics library. */
+export interface CeramicSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciProfilingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciProfiling(data: number[], opts: CeramicSciProfilingOptions = {}): CeramicSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciProfiling };
diff --git a/src/ceramic_sci/projection.ts b/src/ceramic_sci/projection.ts
new file mode 100644
index 000000000..fe614a6c3
--- /dev/null
+++ b/src/ceramic_sci/projection.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci projection module — tsb analytics library. */
+export interface CeramicSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciProjectionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciProjection(data: number[], opts: CeramicSciProjectionOptions = {}): CeramicSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciProjection };
diff --git a/src/ceramic_sci/ranking.ts b/src/ceramic_sci/ranking.ts
new file mode 100644
index 000000000..3c16418a7
--- /dev/null
+++ b/src/ceramic_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci ranking module — tsb analytics library. */
+export interface CeramicSciRankingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciRankingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciRanking(data: number[], opts: CeramicSciRankingOptions = {}): CeramicSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciRanking };
diff --git a/src/ceramic_sci/reconstruction.ts b/src/ceramic_sci/reconstruction.ts
new file mode 100644
index 000000000..3d058b1f8
--- /dev/null
+++ b/src/ceramic_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci reconstruction module — tsb analytics library. */
+export interface CeramicSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciReconstruction(data: number[], opts: CeramicSciReconstructionOptions = {}): CeramicSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciReconstruction };
diff --git a/src/ceramic_sci/registration.ts b/src/ceramic_sci/registration.ts
new file mode 100644
index 000000000..ccfe31bb4
--- /dev/null
+++ b/src/ceramic_sci/registration.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci registration module — tsb analytics library. */
+export interface CeramicSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciRegistration(data: number[], opts: CeramicSciRegistrationOptions = {}): CeramicSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciRegistration };
diff --git a/src/ceramic_sci/regression.ts b/src/ceramic_sci/regression.ts
new file mode 100644
index 000000000..b18cd2f60
--- /dev/null
+++ b/src/ceramic_sci/regression.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci regression module — tsb analytics library. */
+export interface CeramicSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciRegressionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciRegression(data: number[], opts: CeramicSciRegressionOptions = {}): CeramicSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciRegression };
diff --git a/src/ceramic_sci/regularization.ts b/src/ceramic_sci/regularization.ts
new file mode 100644
index 000000000..216b2c354
--- /dev/null
+++ b/src/ceramic_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci regularization module — tsb analytics library. */
+export interface CeramicSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciRegularization(data: number[], opts: CeramicSciRegularizationOptions = {}): CeramicSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciRegularization };
diff --git a/src/ceramic_sci/robustness.ts b/src/ceramic_sci/robustness.ts
new file mode 100644
index 000000000..ed276facb
--- /dev/null
+++ b/src/ceramic_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci robustness module — tsb analytics library. */
+export interface CeramicSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeCeramicSciRobustness(data: number[], opts: CeramicSciRobustnessOptions = {}): CeramicSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciRobustness };
diff --git a/src/ceramic_sci/sampling.ts b/src/ceramic_sci/sampling.ts
new file mode 100644
index 000000000..10b41b90f
--- /dev/null
+++ b/src/ceramic_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci sampling module — tsb analytics library. */
+export interface CeramicSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciSamplingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciSampling(data: number[], opts: CeramicSciSamplingOptions = {}): CeramicSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciSampling };
diff --git a/src/ceramic_sci/sampling2.ts b/src/ceramic_sci/sampling2.ts
new file mode 100644
index 000000000..b90b8907a
--- /dev/null
+++ b/src/ceramic_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci sampling2 module — tsb analytics library. */
+export interface CeramicSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciSamplingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciSampling(data: number[], opts: CeramicSciSamplingOptions = {}): CeramicSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciSampling };
diff --git a/src/ceramic_sci/scaling.ts b/src/ceramic_sci/scaling.ts
new file mode 100644
index 000000000..e87b7bca7
--- /dev/null
+++ b/src/ceramic_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci scaling module — tsb analytics library. */
+export interface CeramicSciScalingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciScalingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciScaling(data: number[], opts: CeramicSciScalingOptions = {}): CeramicSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciScaling };
diff --git a/src/ceramic_sci/scoring.ts b/src/ceramic_sci/scoring.ts
new file mode 100644
index 000000000..bdbe4274e
--- /dev/null
+++ b/src/ceramic_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci scoring module — tsb analytics library. */
+export interface CeramicSciScoringOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciScoringResult { values: number[]; converged: boolean; }
+export function computeCeramicSciScoring(data: number[], opts: CeramicSciScoringOptions = {}): CeramicSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciScoring };
diff --git a/src/ceramic_sci/segmentation.ts b/src/ceramic_sci/segmentation.ts
new file mode 100644
index 000000000..946510ff6
--- /dev/null
+++ b/src/ceramic_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci segmentation module — tsb analytics library. */
+export interface CeramicSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciSegmentation(data: number[], opts: CeramicSciSegmentationOptions = {}): CeramicSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciSegmentation };
diff --git a/src/ceramic_sci/selection.ts b/src/ceramic_sci/selection.ts
new file mode 100644
index 000000000..f7f820490
--- /dev/null
+++ b/src/ceramic_sci/selection.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci selection module — tsb analytics library. */
+export interface CeramicSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciSelectionResult { values: number[]; converged: boolean; }
+export function computeCeramicSciSelection(data: number[], opts: CeramicSciSelectionOptions = {}): CeramicSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciSelection };
diff --git a/src/ceramic_sci/sensitivity.ts b/src/ceramic_sci/sensitivity.ts
new file mode 100644
index 000000000..4aa76b7ee
--- /dev/null
+++ b/src/ceramic_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci sensitivity module — tsb analytics library. */
+export interface CeramicSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeCeramicSciSensitivity(data: number[], opts: CeramicSciSensitivityOptions = {}): CeramicSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciSensitivity };
diff --git a/src/ceramic_sci/simulation.ts b/src/ceramic_sci/simulation.ts
new file mode 100644
index 000000000..4c2ae3a4b
--- /dev/null
+++ b/src/ceramic_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci simulation module — tsb analytics library. */
+export interface CeramicSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciSimulationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciSimulation(data: number[], opts: CeramicSciSimulationOptions = {}): CeramicSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciSimulation };
diff --git a/src/ceramic_sci/smoothing.ts b/src/ceramic_sci/smoothing.ts
new file mode 100644
index 000000000..3f8d4ad45
--- /dev/null
+++ b/src/ceramic_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci smoothing module — tsb analytics library. */
+export interface CeramicSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciSmoothing(data: number[], opts: CeramicSciSmoothingOptions = {}): CeramicSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciSmoothing };
diff --git a/src/ceramic_sci/stability.ts b/src/ceramic_sci/stability.ts
new file mode 100644
index 000000000..8ccfef51e
--- /dev/null
+++ b/src/ceramic_sci/stability.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci stability module — tsb analytics library. */
+export interface CeramicSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciStabilityResult { values: number[]; converged: boolean; }
+export function computeCeramicSciStability(data: number[], opts: CeramicSciStabilityOptions = {}): CeramicSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciStability };
diff --git a/src/ceramic_sci/stacking.ts b/src/ceramic_sci/stacking.ts
new file mode 100644
index 000000000..eb7262477
--- /dev/null
+++ b/src/ceramic_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci stacking module — tsb analytics library. */
+export interface CeramicSciStackingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciStackingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciStacking(data: number[], opts: CeramicSciStackingOptions = {}): CeramicSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciStacking };
diff --git a/src/ceramic_sci/standardization.ts b/src/ceramic_sci/standardization.ts
new file mode 100644
index 000000000..5dea35569
--- /dev/null
+++ b/src/ceramic_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci standardization module — tsb analytics library. */
+export interface CeramicSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciStandardization(data: number[], opts: CeramicSciStandardizationOptions = {}): CeramicSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciStandardization };
diff --git a/src/ceramic_sci/static.ts b/src/ceramic_sci/static.ts
new file mode 100644
index 000000000..16d8d0f93
--- /dev/null
+++ b/src/ceramic_sci/static.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci static module — tsb analytics library. */
+export interface CeramicSciStaticOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciStaticResult { values: number[]; converged: boolean; }
+export function computeCeramicSciStatic(data: number[], opts: CeramicSciStaticOptions = {}): CeramicSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciStatic };
diff --git a/src/ceramic_sci/stochastic.ts b/src/ceramic_sci/stochastic.ts
new file mode 100644
index 000000000..105c5ace2
--- /dev/null
+++ b/src/ceramic_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci stochastic module — tsb analytics library. */
+export interface CeramicSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciStochasticResult { values: number[]; converged: boolean; }
+export function computeCeramicSciStochastic(data: number[], opts: CeramicSciStochasticOptions = {}): CeramicSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciStochastic };
diff --git a/src/ceramic_sci/synthesis.ts b/src/ceramic_sci/synthesis.ts
new file mode 100644
index 000000000..171edf778
--- /dev/null
+++ b/src/ceramic_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci synthesis module — tsb analytics library. */
+export interface CeramicSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeCeramicSciSynthesis(data: number[], opts: CeramicSciSynthesisOptions = {}): CeramicSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciSynthesis };
diff --git a/src/ceramic_sci/topology.ts b/src/ceramic_sci/topology.ts
new file mode 100644
index 000000000..f816d275c
--- /dev/null
+++ b/src/ceramic_sci/topology.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci topology module — tsb analytics library. */
+export interface CeramicSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciTopologyResult { values: number[]; converged: boolean; }
+export function computeCeramicSciTopology(data: number[], opts: CeramicSciTopologyOptions = {}): CeramicSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciTopology };
diff --git a/src/ceramic_sci/tracking.ts b/src/ceramic_sci/tracking.ts
new file mode 100644
index 000000000..ab63b852b
--- /dev/null
+++ b/src/ceramic_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci tracking module — tsb analytics library. */
+export interface CeramicSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciTrackingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciTracking(data: number[], opts: CeramicSciTrackingOptions = {}): CeramicSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciTracking };
diff --git a/src/ceramic_sci/transform.ts b/src/ceramic_sci/transform.ts
new file mode 100644
index 000000000..968d42448
--- /dev/null
+++ b/src/ceramic_sci/transform.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci transform module — tsb analytics library. */
+export interface CeramicSciTransformOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciTransformResult { values: number[]; converged: boolean; }
+export function computeCeramicSciTransform(data: number[], opts: CeramicSciTransformOptions = {}): CeramicSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciTransform };
diff --git a/src/ceramic_sci/uncertainty.ts b/src/ceramic_sci/uncertainty.ts
new file mode 100644
index 000000000..f72e9c051
--- /dev/null
+++ b/src/ceramic_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci uncertainty module — tsb analytics library. */
+export interface CeramicSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCeramicSciUncertainty(data: number[], opts: CeramicSciUncertaintyOptions = {}): CeramicSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciUncertainty };
diff --git a/src/ceramic_sci/validation.ts b/src/ceramic_sci/validation.ts
new file mode 100644
index 000000000..eff2a428c
--- /dev/null
+++ b/src/ceramic_sci/validation.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci validation module — tsb analytics library. */
+export interface CeramicSciValidationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciValidationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciValidation(data: number[], opts: CeramicSciValidationOptions = {}): CeramicSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciValidation };
diff --git a/src/ceramic_sci/verification.ts b/src/ceramic_sci/verification.ts
new file mode 100644
index 000000000..2aeb68547
--- /dev/null
+++ b/src/ceramic_sci/verification.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci verification module — tsb analytics library. */
+export interface CeramicSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciVerificationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciVerification(data: number[], opts: CeramicSciVerificationOptions = {}): CeramicSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciVerification };
diff --git a/src/ceramic_sci/visualization.ts b/src/ceramic_sci/visualization.ts
new file mode 100644
index 000000000..0cead826c
--- /dev/null
+++ b/src/ceramic_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci visualization module — tsb analytics library. */
+export interface CeramicSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeCeramicSciVisualization(data: number[], opts: CeramicSciVisualizationOptions = {}): CeramicSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciVisualization };
diff --git a/src/ceramic_sci/voting.ts b/src/ceramic_sci/voting.ts
new file mode 100644
index 000000000..addef3b2c
--- /dev/null
+++ b/src/ceramic_sci/voting.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci voting module — tsb analytics library. */
+export interface CeramicSciVotingOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciVotingResult { values: number[]; converged: boolean; }
+export function computeCeramicSciVoting(data: number[], opts: CeramicSciVotingOptions = {}): CeramicSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciVoting };
diff --git a/src/ceramic_sci/wavelet.ts b/src/ceramic_sci/wavelet.ts
new file mode 100644
index 000000000..d443c16d5
--- /dev/null
+++ b/src/ceramic_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** ceramic_sci wavelet module — tsb analytics library. */
+export interface CeramicSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface CeramicSciWaveletResult { values: number[]; converged: boolean; }
+export function computeCeramicSciWavelet(data: number[], opts: CeramicSciWaveletOptions = {}): CeramicSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCeramicSciWavelet };
diff --git a/src/climate/advanced.ts b/src/climate/advanced.ts
new file mode 100644
index 000000000..6425cc9ad
--- /dev/null
+++ b/src/climate/advanced.ts
@@ -0,0 +1,15 @@
+/** Climate Advanced module — tsb analytics library. */
+export interface Climate advancedOptions { tol?: number; maxIter?: number; }
+export interface Climate advancedResult { values: number[]; converged: boolean; }
+export function computeClimate advanced(data: number[], opts: Climate advancedOptions = {}): Climate advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate advanced };
diff --git a/src/climate/aerosol.ts b/src/climate/aerosol.ts
new file mode 100644
index 000000000..264820ae0
--- /dev/null
+++ b/src/climate/aerosol.ts
@@ -0,0 +1,22 @@
+/** Aerosol module — tsb analytics library. */
+
+/** Options for Aerosol. */
+export interface AerosolOptions { tol?: number; maxIter?: number; }
+
+/** Result from Aerosol. */
+export interface AerosolResult { values: number[]; converged: boolean; }
+
+/** Compute Aerosol. */
+export function computeAerosol(data: number[], opts: AerosolOptions = {}): AerosolResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAerosol };
diff --git a/src/climate/albedo.ts b/src/climate/albedo.ts
new file mode 100644
index 000000000..a86c9dbd6
--- /dev/null
+++ b/src/climate/albedo.ts
@@ -0,0 +1,22 @@
+/** Albedo module — tsb analytics library. */
+
+/** Options for Albedo. */
+export interface AlbedoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Albedo. */
+export interface AlbedoResult { values: number[]; converged: boolean; }
+
+/** Compute Albedo. */
+export function computeAlbedo(data: number[], opts: AlbedoOptions = {}): AlbedoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAlbedo };
diff --git a/src/climate/amo.ts b/src/climate/amo.ts
new file mode 100644
index 000000000..697a78483
--- /dev/null
+++ b/src/climate/amo.ts
@@ -0,0 +1,22 @@
+/** Amo module — tsb analytics library. */
+
+/** Options for Amo. */
+export interface AmoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Amo. */
+export interface AmoResult { values: number[]; converged: boolean; }
+
+/** Compute Amo. */
+export function computeAmo(data: number[], opts: AmoOptions = {}): AmoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAmo };
diff --git a/src/climate/attribution_climate.ts b/src/climate/attribution_climate.ts
new file mode 100644
index 000000000..20a70879a
--- /dev/null
+++ b/src/climate/attribution_climate.ts
@@ -0,0 +1,22 @@
+/** Attribution Climate module — tsb analytics library. */
+
+/** Options for Attribution Climate. */
+export interface AttributionClimateOptions { tol?: number; maxIter?: number; }
+
+/** Result from Attribution Climate. */
+export interface AttributionClimateResult { values: number[]; converged: boolean; }
+
+/** Compute Attribution Climate. */
+export function computeAttributionClimate(data: number[], opts: AttributionClimateOptions = {}): AttributionClimateResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAttributionClimate };
diff --git a/src/climate/base2.ts b/src/climate/base2.ts
new file mode 100644
index 000000000..505ae5e7d
--- /dev/null
+++ b/src/climate/base2.ts
@@ -0,0 +1,15 @@
+/** Climate Base2 module — tsb analytics library. */
+export interface Climate base2Options { tol?: number; maxIter?: number; }
+export interface Climate base2Result { values: number[]; converged: boolean; }
+export function computeClimate base2(data: number[], opts: Climate base2Options = {}): Climate base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate base2 };
diff --git a/src/climate/batch.ts b/src/climate/batch.ts
new file mode 100644
index 000000000..2b298ca92
--- /dev/null
+++ b/src/climate/batch.ts
@@ -0,0 +1,15 @@
+/** Climate Batch module — tsb analytics library. */
+export interface Climate batchOptions { tol?: number; maxIter?: number; }
+export interface Climate batchResult { values: number[]; converged: boolean; }
+export function computeClimate batch(data: number[], opts: Climate batchOptions = {}): Climate batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate batch };
diff --git a/src/climate/beta.ts b/src/climate/beta.ts
new file mode 100644
index 000000000..8ba0e4239
--- /dev/null
+++ b/src/climate/beta.ts
@@ -0,0 +1,15 @@
+/** Climate Beta module — tsb analytics library. */
+export interface Climate betaOptions { tol?: number; maxIter?: number; }
+export interface Climate betaResult { values: number[]; converged: boolean; }
+export function computeClimate beta(data: number[], opts: Climate betaOptions = {}): Climate betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate beta };
diff --git a/src/climate/carbon.ts b/src/climate/carbon.ts
new file mode 100644
index 000000000..038519bab
--- /dev/null
+++ b/src/climate/carbon.ts
@@ -0,0 +1,22 @@
+/** Carbon module — tsb analytics library. */
+
+/** Options for Carbon. */
+export interface CarbonOptions { tol?: number; maxIter?: number; }
+
+/** Result from Carbon. */
+export interface CarbonResult { values: number[]; converged: boolean; }
+
+/** Compute Carbon. */
+export function computeCarbon(data: number[], opts: CarbonOptions = {}): CarbonResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCarbon };
diff --git a/src/climate/circulation.ts b/src/climate/circulation.ts
new file mode 100644
index 000000000..0b253cee1
--- /dev/null
+++ b/src/climate/circulation.ts
@@ -0,0 +1,22 @@
+/** Circulation module — tsb analytics library. */
+
+/** Options for Circulation. */
+export interface CirculationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Circulation. */
+export interface CirculationResult { values: number[]; converged: boolean; }
+
+/** Compute Circulation. */
+export function computeCirculation(data: number[], opts: CirculationOptions = {}): CirculationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCirculation };
diff --git a/src/climate/cpu.ts b/src/climate/cpu.ts
new file mode 100644
index 000000000..f8ed3a587
--- /dev/null
+++ b/src/climate/cpu.ts
@@ -0,0 +1,15 @@
+/** Climate Cpu module — tsb analytics library. */
+export interface Climate cpuOptions { tol?: number; maxIter?: number; }
+export interface Climate cpuResult { values: number[]; converged: boolean; }
+export function computeClimate cpu(data: number[], opts: Climate cpuOptions = {}): Climate cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate cpu };
diff --git a/src/climate/dense.ts b/src/climate/dense.ts
new file mode 100644
index 000000000..7af9c1bd5
--- /dev/null
+++ b/src/climate/dense.ts
@@ -0,0 +1,15 @@
+/** Climate Dense module — tsb analytics library. */
+export interface Climate denseOptions { tol?: number; maxIter?: number; }
+export interface Climate denseResult { values: number[]; converged: boolean; }
+export function computeClimate dense(data: number[], opts: Climate denseOptions = {}): Climate denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate dense };
diff --git a/src/climate/distributed.ts b/src/climate/distributed.ts
new file mode 100644
index 000000000..e1ff31727
--- /dev/null
+++ b/src/climate/distributed.ts
@@ -0,0 +1,15 @@
+/** Climate Distributed module — tsb analytics library. */
+export interface Climate distributedOptions { tol?: number; maxIter?: number; }
+export interface Climate distributedResult { values: number[]; converged: boolean; }
+export function computeClimate distributed(data: number[], opts: Climate distributedOptions = {}): Climate distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate distributed };
diff --git a/src/climate/enso.ts b/src/climate/enso.ts
new file mode 100644
index 000000000..c31903825
--- /dev/null
+++ b/src/climate/enso.ts
@@ -0,0 +1,22 @@
+/** Enso module — tsb analytics library. */
+
+/** Options for Enso. */
+export interface EnsoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Enso. */
+export interface EnsoResult { values: number[]; converged: boolean; }
+
+/** Compute Enso. */
+export function computeEnso(data: number[], opts: EnsoOptions = {}): EnsoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEnso };
diff --git a/src/climate/evapotranspiration.ts b/src/climate/evapotranspiration.ts
new file mode 100644
index 000000000..22e8100e3
--- /dev/null
+++ b/src/climate/evapotranspiration.ts
@@ -0,0 +1,22 @@
+/** Evapotranspiration module — tsb analytics library. */
+
+/** Options for Evapotranspiration. */
+export interface EvapotranspirationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Evapotranspiration. */
+export interface EvapotranspirationResult { values: number[]; converged: boolean; }
+
+/** Compute Evapotranspiration. */
+export function computeEvapotranspiration(data: number[], opts: EvapotranspirationOptions = {}): EvapotranspirationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEvapotranspiration };
diff --git a/src/climate/experimental.ts b/src/climate/experimental.ts
new file mode 100644
index 000000000..dc2123775
--- /dev/null
+++ b/src/climate/experimental.ts
@@ -0,0 +1,15 @@
+/** Climate Experimental module — tsb analytics library. */
+export interface Climate experimentalOptions { tol?: number; maxIter?: number; }
+export interface Climate experimentalResult { values: number[]; converged: boolean; }
+export function computeClimate experimental(data: number[], opts: Climate experimentalOptions = {}): Climate experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate experimental };
diff --git a/src/climate/fast.ts b/src/climate/fast.ts
new file mode 100644
index 000000000..443cf63e3
--- /dev/null
+++ b/src/climate/fast.ts
@@ -0,0 +1,15 @@
+/** Climate Fast module — tsb analytics library. */
+export interface Climate fastOptions { tol?: number; maxIter?: number; }
+export interface Climate fastResult { values: number[]; converged: boolean; }
+export function computeClimate fast(data: number[], opts: Climate fastOptions = {}): Climate fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate fast };
diff --git a/src/climate/feedback.ts b/src/climate/feedback.ts
new file mode 100644
index 000000000..47d29cb68
--- /dev/null
+++ b/src/climate/feedback.ts
@@ -0,0 +1,22 @@
+/** Feedback module — tsb analytics library. */
+
+/** Options for Feedback. */
+export interface FeedbackOptions { tol?: number; maxIter?: number; }
+
+/** Result from Feedback. */
+export interface FeedbackResult { values: number[]; converged: boolean; }
+
+/** Compute Feedback. */
+export function computeFeedback(data: number[], opts: FeedbackOptions = {}): FeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFeedback };
diff --git a/src/climate/future.ts b/src/climate/future.ts
new file mode 100644
index 000000000..ca7442a84
--- /dev/null
+++ b/src/climate/future.ts
@@ -0,0 +1,15 @@
+/** Climate Future module — tsb analytics library. */
+export interface Climate futureOptions { tol?: number; maxIter?: number; }
+export interface Climate futureResult { values: number[]; converged: boolean; }
+export function computeClimate future(data: number[], opts: Climate futureOptions = {}): Climate futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate future };
diff --git a/src/climate/gpu.ts b/src/climate/gpu.ts
new file mode 100644
index 000000000..91394fa4d
--- /dev/null
+++ b/src/climate/gpu.ts
@@ -0,0 +1,15 @@
+/** Climate Gpu module — tsb analytics library. */
+export interface Climate gpuOptions { tol?: number; maxIter?: number; }
+export interface Climate gpuResult { values: number[]; converged: boolean; }
+export function computeClimate gpu(data: number[], opts: Climate gpuOptions = {}): Climate gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate gpu };
diff --git a/src/climate/greenhouse.ts b/src/climate/greenhouse.ts
new file mode 100644
index 000000000..ab0f62b16
--- /dev/null
+++ b/src/climate/greenhouse.ts
@@ -0,0 +1,22 @@
+/** Greenhouse module — tsb analytics library. */
+
+/** Options for Greenhouse. */
+export interface GreenhouseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Greenhouse. */
+export interface GreenhouseResult { values: number[]; converged: boolean; }
+
+/** Compute Greenhouse. */
+export function computeGreenhouse(data: number[], opts: GreenhouseOptions = {}): GreenhouseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGreenhouse };
diff --git a/src/climate/humidity.ts b/src/climate/humidity.ts
new file mode 100644
index 000000000..57075fe0f
--- /dev/null
+++ b/src/climate/humidity.ts
@@ -0,0 +1,22 @@
+/** Humidity module — tsb analytics library. */
+
+/** Options for Humidity. */
+export interface HumidityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Humidity. */
+export interface HumidityResult { values: number[]; converged: boolean; }
+
+/** Compute Humidity. */
+export function computeHumidity(data: number[], opts: HumidityOptions = {}): HumidityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHumidity };
diff --git a/src/climate/ice.ts b/src/climate/ice.ts
new file mode 100644
index 000000000..12cc09bb8
--- /dev/null
+++ b/src/climate/ice.ts
@@ -0,0 +1,22 @@
+/** Ice module — tsb analytics library. */
+
+/** Options for Ice. */
+export interface IceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ice. */
+export interface IceResult { values: number[]; converged: boolean; }
+
+/** Compute Ice. */
+export function computeIce(data: number[], opts: IceOptions = {}): IceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIce };
diff --git a/src/climate/large.ts b/src/climate/large.ts
new file mode 100644
index 000000000..24ff80dea
--- /dev/null
+++ b/src/climate/large.ts
@@ -0,0 +1,15 @@
+/** Climate Large module — tsb analytics library. */
+export interface Climate largeOptions { tol?: number; maxIter?: number; }
+export interface Climate largeResult { values: number[]; converged: boolean; }
+export function computeClimate large(data: number[], opts: Climate largeOptions = {}): Climate largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate large };
diff --git a/src/climate/legacy.ts b/src/climate/legacy.ts
new file mode 100644
index 000000000..7652d3f26
--- /dev/null
+++ b/src/climate/legacy.ts
@@ -0,0 +1,15 @@
+/** Climate Legacy module — tsb analytics library. */
+export interface Climate legacyOptions { tol?: number; maxIter?: number; }
+export interface Climate legacyResult { values: number[]; converged: boolean; }
+export function computeClimate legacy(data: number[], opts: Climate legacyOptions = {}): Climate legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate legacy };
diff --git a/src/climate/lite.ts b/src/climate/lite.ts
new file mode 100644
index 000000000..4beee705c
--- /dev/null
+++ b/src/climate/lite.ts
@@ -0,0 +1,15 @@
+/** Climate Lite module — tsb analytics library. */
+export interface Climate liteOptions { tol?: number; maxIter?: number; }
+export interface Climate liteResult { values: number[]; converged: boolean; }
+export function computeClimate lite(data: number[], opts: Climate liteOptions = {}): Climate liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate lite };
diff --git a/src/climate/methane.ts b/src/climate/methane.ts
new file mode 100644
index 000000000..f6ddc9df6
--- /dev/null
+++ b/src/climate/methane.ts
@@ -0,0 +1,22 @@
+/** Methane module — tsb analytics library. */
+
+/** Options for Methane. */
+export interface MethaneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Methane. */
+export interface MethaneResult { values: number[]; converged: boolean; }
+
+/** Compute Methane. */
+export function computeMethane(data: number[], opts: MethaneOptions = {}): MethaneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMethane };
diff --git a/src/climate/mini.ts b/src/climate/mini.ts
new file mode 100644
index 000000000..02723cb2e
--- /dev/null
+++ b/src/climate/mini.ts
@@ -0,0 +1,15 @@
+/** Climate Mini module — tsb analytics library. */
+export interface Climate miniOptions { tol?: number; maxIter?: number; }
+export interface Climate miniResult { values: number[]; converged: boolean; }
+export function computeClimate mini(data: number[], opts: Climate miniOptions = {}): Climate miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate mini };
diff --git a/src/climate/nao.ts b/src/climate/nao.ts
new file mode 100644
index 000000000..bb21f9231
--- /dev/null
+++ b/src/climate/nao.ts
@@ -0,0 +1,22 @@
+/** Nao module — tsb analytics library. */
+
+/** Options for Nao. */
+export interface NaoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nao. */
+export interface NaoResult { values: number[]; converged: boolean; }
+
+/** Compute Nao. */
+export function computeNao(data: number[], opts: NaoOptions = {}): NaoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNao };
diff --git a/src/climate/next.ts b/src/climate/next.ts
new file mode 100644
index 000000000..9b362675f
--- /dev/null
+++ b/src/climate/next.ts
@@ -0,0 +1,15 @@
+/** Climate Next module — tsb analytics library. */
+export interface Climate nextOptions { tol?: number; maxIter?: number; }
+export interface Climate nextResult { values: number[]; converged: boolean; }
+export function computeClimate next(data: number[], opts: Climate nextOptions = {}): Climate nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate next };
diff --git a/src/climate/nitrous_oxide.ts b/src/climate/nitrous_oxide.ts
new file mode 100644
index 000000000..3f1326fd8
--- /dev/null
+++ b/src/climate/nitrous_oxide.ts
@@ -0,0 +1,22 @@
+/** Nitrous Oxide module — tsb analytics library. */
+
+/** Options for Nitrous Oxide. */
+export interface NitrousOxideOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nitrous Oxide. */
+export interface NitrousOxideResult { values: number[]; converged: boolean; }
+
+/** Compute Nitrous Oxide. */
+export function computeNitrousOxide(data: number[], opts: NitrousOxideOptions = {}): NitrousOxideResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNitrousOxide };
diff --git a/src/climate/ocean_heat.ts b/src/climate/ocean_heat.ts
new file mode 100644
index 000000000..2007a4405
--- /dev/null
+++ b/src/climate/ocean_heat.ts
@@ -0,0 +1,22 @@
+/** Ocean Heat module — tsb analytics library. */
+
+/** Options for Ocean Heat. */
+export interface OceanHeatOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ocean Heat. */
+export interface OceanHeatResult { values: number[]; converged: boolean; }
+
+/** Compute Ocean Heat. */
+export function computeOceanHeat(data: number[], opts: OceanHeatOptions = {}): OceanHeatResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOceanHeat };
diff --git a/src/climate/online.ts b/src/climate/online.ts
new file mode 100644
index 000000000..ccee2692d
--- /dev/null
+++ b/src/climate/online.ts
@@ -0,0 +1,15 @@
+/** Climate Online module — tsb analytics library. */
+export interface Climate onlineOptions { tol?: number; maxIter?: number; }
+export interface Climate onlineResult { values: number[]; converged: boolean; }
+export function computeClimate online(data: number[], opts: Climate onlineOptions = {}): Climate onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate online };
diff --git a/src/climate/ozone.ts b/src/climate/ozone.ts
new file mode 100644
index 000000000..c2cfa377b
--- /dev/null
+++ b/src/climate/ozone.ts
@@ -0,0 +1,22 @@
+/** Ozone module — tsb analytics library. */
+
+/** Options for Ozone. */
+export interface OzoneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ozone. */
+export interface OzoneResult { values: number[]; converged: boolean; }
+
+/** Compute Ozone. */
+export function computeOzone(data: number[], opts: OzoneOptions = {}): OzoneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOzone };
diff --git a/src/climate/parallel.ts b/src/climate/parallel.ts
new file mode 100644
index 000000000..93a6599f6
--- /dev/null
+++ b/src/climate/parallel.ts
@@ -0,0 +1,15 @@
+/** Climate Parallel module — tsb analytics library. */
+export interface Climate parallelOptions { tol?: number; maxIter?: number; }
+export interface Climate parallelResult { values: number[]; converged: boolean; }
+export function computeClimate parallel(data: number[], opts: Climate parallelOptions = {}): Climate parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate parallel };
diff --git a/src/climate/pdo.ts b/src/climate/pdo.ts
new file mode 100644
index 000000000..eb1c115d8
--- /dev/null
+++ b/src/climate/pdo.ts
@@ -0,0 +1,22 @@
+/** Pdo module — tsb analytics library. */
+
+/** Options for Pdo. */
+export interface PdoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pdo. */
+export interface PdoResult { values: number[]; converged: boolean; }
+
+/** Compute Pdo. */
+export function computePdo(data: number[], opts: PdoOptions = {}): PdoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePdo };
diff --git a/src/climate/plus.ts b/src/climate/plus.ts
new file mode 100644
index 000000000..f2b8ecf1c
--- /dev/null
+++ b/src/climate/plus.ts
@@ -0,0 +1,15 @@
+/** Climate Plus module — tsb analytics library. */
+export interface Climate plusOptions { tol?: number; maxIter?: number; }
+export interface Climate plusResult { values: number[]; converged: boolean; }
+export function computeClimate plus(data: number[], opts: Climate plusOptions = {}): Climate plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate plus };
diff --git a/src/climate/precipitation.ts b/src/climate/precipitation.ts
new file mode 100644
index 000000000..fcc4aaeb9
--- /dev/null
+++ b/src/climate/precipitation.ts
@@ -0,0 +1,22 @@
+/** Precipitation module — tsb analytics library. */
+
+/** Options for Precipitation. */
+export interface PrecipitationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Precipitation. */
+export interface PrecipitationResult { values: number[]; converged: boolean; }
+
+/** Compute Precipitation. */
+export function computePrecipitation(data: number[], opts: PrecipitationOptions = {}): PrecipitationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrecipitation };
diff --git a/src/climate/pressure.ts b/src/climate/pressure.ts
new file mode 100644
index 000000000..11d9535bf
--- /dev/null
+++ b/src/climate/pressure.ts
@@ -0,0 +1,22 @@
+/** Pressure module — tsb analytics library. */
+
+/** Options for Pressure. */
+export interface PressureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pressure. */
+export interface PressureResult { values: number[]; converged: boolean; }
+
+/** Compute Pressure. */
+export function computePressure(data: number[], opts: PressureOptions = {}): PressureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePressure };
diff --git a/src/climate/pro.ts b/src/climate/pro.ts
new file mode 100644
index 000000000..b0045d089
--- /dev/null
+++ b/src/climate/pro.ts
@@ -0,0 +1,15 @@
+/** Climate Pro module — tsb analytics library. */
+export interface Climate proOptions { tol?: number; maxIter?: number; }
+export interface Climate proResult { values: number[]; converged: boolean; }
+export function computeClimate pro(data: number[], opts: Climate proOptions = {}): Climate proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate pro };
diff --git a/src/climate/qbo.ts b/src/climate/qbo.ts
new file mode 100644
index 000000000..d1c6ea8d8
--- /dev/null
+++ b/src/climate/qbo.ts
@@ -0,0 +1,22 @@
+/** Qbo module — tsb analytics library. */
+
+/** Options for Qbo. */
+export interface QboOptions { tol?: number; maxIter?: number; }
+
+/** Result from Qbo. */
+export interface QboResult { values: number[]; converged: boolean; }
+
+/** Compute Qbo. */
+export function computeQbo(data: number[], opts: QboOptions = {}): QboResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQbo };
diff --git a/src/climate/radiation.ts b/src/climate/radiation.ts
new file mode 100644
index 000000000..aeb017db4
--- /dev/null
+++ b/src/climate/radiation.ts
@@ -0,0 +1,22 @@
+/** Radiation module — tsb analytics library. */
+
+/** Options for Radiation. */
+export interface RadiationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Radiation. */
+export interface RadiationResult { values: number[]; converged: boolean; }
+
+/** Compute Radiation. */
+export function computeRadiation(data: number[], opts: RadiationOptions = {}): RadiationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRadiation };
diff --git a/src/climate/robust.ts b/src/climate/robust.ts
new file mode 100644
index 000000000..b906aaa7f
--- /dev/null
+++ b/src/climate/robust.ts
@@ -0,0 +1,15 @@
+/** Climate Robust module — tsb analytics library. */
+export interface Climate robustOptions { tol?: number; maxIter?: number; }
+export interface Climate robustResult { values: number[]; converged: boolean; }
+export function computeClimate robust(data: number[], opts: Climate robustOptions = {}): Climate robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate robust };
diff --git a/src/climate/sea_level.ts b/src/climate/sea_level.ts
new file mode 100644
index 000000000..9a518cf39
--- /dev/null
+++ b/src/climate/sea_level.ts
@@ -0,0 +1,22 @@
+/** Sea Level module — tsb analytics library. */
+
+/** Options for Sea Level. */
+export interface SeaLevelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sea Level. */
+export interface SeaLevelResult { values: number[]; converged: boolean; }
+
+/** Compute Sea Level. */
+export function computeSeaLevel(data: number[], opts: SeaLevelOptions = {}): SeaLevelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeaLevel };
diff --git a/src/climate/sensitivity.ts b/src/climate/sensitivity.ts
new file mode 100644
index 000000000..2c021c567
--- /dev/null
+++ b/src/climate/sensitivity.ts
@@ -0,0 +1,22 @@
+/** Sensitivity module — tsb analytics library. */
+
+/** Options for Sensitivity. */
+export interface SensitivityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sensitivity. */
+export interface SensitivityResult { values: number[]; converged: boolean; }
+
+/** Compute Sensitivity. */
+export function computeSensitivity(data: number[], opts: SensitivityOptions = {}): SensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSensitivity };
diff --git a/src/climate/small.ts b/src/climate/small.ts
new file mode 100644
index 000000000..7009f9800
--- /dev/null
+++ b/src/climate/small.ts
@@ -0,0 +1,15 @@
+/** Climate Small module — tsb analytics library. */
+export interface Climate smallOptions { tol?: number; maxIter?: number; }
+export interface Climate smallResult { values: number[]; converged: boolean; }
+export function computeClimate small(data: number[], opts: Climate smallOptions = {}): Climate smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate small };
diff --git a/src/climate/snow.ts b/src/climate/snow.ts
new file mode 100644
index 000000000..047e1b4c8
--- /dev/null
+++ b/src/climate/snow.ts
@@ -0,0 +1,22 @@
+/** Snow module — tsb analytics library. */
+
+/** Options for Snow. */
+export interface SnowOptions { tol?: number; maxIter?: number; }
+
+/** Result from Snow. */
+export interface SnowResult { values: number[]; converged: boolean; }
+
+/** Compute Snow. */
+export function computeSnow(data: number[], opts: SnowOptions = {}): SnowResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSnow };
diff --git a/src/climate/soil_moisture.ts b/src/climate/soil_moisture.ts
new file mode 100644
index 000000000..99acf570e
--- /dev/null
+++ b/src/climate/soil_moisture.ts
@@ -0,0 +1,22 @@
+/** Soil Moisture module — tsb analytics library. */
+
+/** Options for Soil Moisture. */
+export interface SoilMoistureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Soil Moisture. */
+export interface SoilMoistureResult { values: number[]; converged: boolean; }
+
+/** Compute Soil Moisture. */
+export function computeSoilMoisture(data: number[], opts: SoilMoistureOptions = {}): SoilMoistureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSoilMoisture };
diff --git a/src/climate/solar.ts b/src/climate/solar.ts
new file mode 100644
index 000000000..59e46f03d
--- /dev/null
+++ b/src/climate/solar.ts
@@ -0,0 +1,22 @@
+/** Solar module — tsb analytics library. */
+
+/** Options for Solar. */
+export interface SolarOptions { tol?: number; maxIter?: number; }
+
+/** Result from Solar. */
+export interface SolarResult { values: number[]; converged: boolean; }
+
+/** Compute Solar. */
+export function computeSolar(data: number[], opts: SolarOptions = {}): SolarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSolar };
diff --git a/src/climate/sparse.ts b/src/climate/sparse.ts
new file mode 100644
index 000000000..6d70c434f
--- /dev/null
+++ b/src/climate/sparse.ts
@@ -0,0 +1,15 @@
+/** Climate Sparse module — tsb analytics library. */
+export interface Climate sparseOptions { tol?: number; maxIter?: number; }
+export interface Climate sparseResult { values: number[]; converged: boolean; }
+export function computeClimate sparse(data: number[], opts: Climate sparseOptions = {}): Climate sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate sparse };
diff --git a/src/climate/stable.ts b/src/climate/stable.ts
new file mode 100644
index 000000000..e23602762
--- /dev/null
+++ b/src/climate/stable.ts
@@ -0,0 +1,15 @@
+/** Climate Stable module — tsb analytics library. */
+export interface Climate stableOptions { tol?: number; maxIter?: number; }
+export interface Climate stableResult { values: number[]; converged: boolean; }
+export function computeClimate stable(data: number[], opts: Climate stableOptions = {}): Climate stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate stable };
diff --git a/src/climate/streaming.ts b/src/climate/streaming.ts
new file mode 100644
index 000000000..00f1ab810
--- /dev/null
+++ b/src/climate/streaming.ts
@@ -0,0 +1,15 @@
+/** Climate Streaming module — tsb analytics library. */
+export interface Climate streamingOptions { tol?: number; maxIter?: number; }
+export interface Climate streamingResult { values: number[]; converged: boolean; }
+export function computeClimate streaming(data: number[], opts: Climate streamingOptions = {}): Climate streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate streaming };
diff --git a/src/climate/teleconnection.ts b/src/climate/teleconnection.ts
new file mode 100644
index 000000000..1f68d39f5
--- /dev/null
+++ b/src/climate/teleconnection.ts
@@ -0,0 +1,22 @@
+/** Teleconnection module — tsb analytics library. */
+
+/** Options for Teleconnection. */
+export interface TeleconnectionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Teleconnection. */
+export interface TeleconnectionResult { values: number[]; converged: boolean; }
+
+/** Compute Teleconnection. */
+export function computeTeleconnection(data: number[], opts: TeleconnectionOptions = {}): TeleconnectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTeleconnection };
diff --git a/src/climate/temperature.ts b/src/climate/temperature.ts
new file mode 100644
index 000000000..0b8c1efeb
--- /dev/null
+++ b/src/climate/temperature.ts
@@ -0,0 +1,22 @@
+/** Temperature module — tsb analytics library. */
+
+/** Options for Temperature. */
+export interface TemperatureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Temperature. */
+export interface TemperatureResult { values: number[]; converged: boolean; }
+
+/** Compute Temperature. */
+export function computeTemperature(data: number[], opts: TemperatureOptions = {}): TemperatureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTemperature };
diff --git a/src/climate/v2.ts b/src/climate/v2.ts
new file mode 100644
index 000000000..81b1b1f26
--- /dev/null
+++ b/src/climate/v2.ts
@@ -0,0 +1,15 @@
+/** Climate V2 module — tsb analytics library. */
+export interface Climate v2Options { tol?: number; maxIter?: number; }
+export interface Climate v2Result { values: number[]; converged: boolean; }
+export function computeClimate v2(data: number[], opts: Climate v2Options = {}): Climate v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate v2 };
diff --git a/src/climate/v3.ts b/src/climate/v3.ts
new file mode 100644
index 000000000..39d3895df
--- /dev/null
+++ b/src/climate/v3.ts
@@ -0,0 +1,15 @@
+/** Climate V3 module — tsb analytics library. */
+export interface Climate v3Options { tol?: number; maxIter?: number; }
+export interface Climate v3Result { values: number[]; converged: boolean; }
+export function computeClimate v3(data: number[], opts: Climate v3Options = {}): Climate v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate v3 };
diff --git a/src/climate/volcanic.ts b/src/climate/volcanic.ts
new file mode 100644
index 000000000..890e767a8
--- /dev/null
+++ b/src/climate/volcanic.ts
@@ -0,0 +1,22 @@
+/** Volcanic module — tsb analytics library. */
+
+/** Options for Volcanic. */
+export interface VolcanicOptions { tol?: number; maxIter?: number; }
+
+/** Result from Volcanic. */
+export interface VolcanicResult { values: number[]; converged: boolean; }
+
+/** Compute Volcanic. */
+export function computeVolcanic(data: number[], opts: VolcanicOptions = {}): VolcanicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVolcanic };
diff --git a/src/climate/wasm.ts b/src/climate/wasm.ts
new file mode 100644
index 000000000..48a8af3d8
--- /dev/null
+++ b/src/climate/wasm.ts
@@ -0,0 +1,15 @@
+/** Climate Wasm module — tsb analytics library. */
+export interface Climate wasmOptions { tol?: number; maxIter?: number; }
+export interface Climate wasmResult { values: number[]; converged: boolean; }
+export function computeClimate wasm(data: number[], opts: Climate wasmOptions = {}): Climate wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate wasm };
diff --git a/src/climate/wind.ts b/src/climate/wind.ts
new file mode 100644
index 000000000..1b1abca4b
--- /dev/null
+++ b/src/climate/wind.ts
@@ -0,0 +1,22 @@
+/** Wind module — tsb analytics library. */
+
+/** Options for Wind. */
+export interface WindOptions { tol?: number; maxIter?: number; }
+
+/** Result from Wind. */
+export interface WindResult { values: number[]; converged: boolean; }
+
+/** Compute Wind. */
+export function computeWind(data: number[], opts: WindOptions = {}): WindResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWind };
diff --git a/src/climate/xlarge.ts b/src/climate/xlarge.ts
new file mode 100644
index 000000000..33f64b083
--- /dev/null
+++ b/src/climate/xlarge.ts
@@ -0,0 +1,15 @@
+/** Climate Xlarge module — tsb analytics library. */
+export interface Climate xlargeOptions { tol?: number; maxIter?: number; }
+export interface Climate xlargeResult { values: number[]; converged: boolean; }
+export function computeClimate xlarge(data: number[], opts: Climate xlargeOptions = {}): Climate xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeClimate xlarge };
diff --git a/src/colloid_sci/adaptation.ts b/src/colloid_sci/adaptation.ts
new file mode 100644
index 000000000..a78eed8b7
--- /dev/null
+++ b/src/colloid_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci adaptation module — tsb analytics library. */
+export interface ColloidSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeColloidSciAdaptation(data: number[], opts: ColloidSciAdaptationOptions = {}): ColloidSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciAdaptation };
diff --git a/src/colloid_sci/aggregation.ts b/src/colloid_sci/aggregation.ts
new file mode 100644
index 000000000..b3b823331
--- /dev/null
+++ b/src/colloid_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci aggregation module — tsb analytics library. */
+export interface ColloidSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciAggregationResult { values: number[]; converged: boolean; }
+export function computeColloidSciAggregation(data: number[], opts: ColloidSciAggregationOptions = {}): ColloidSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciAggregation };
diff --git a/src/colloid_sci/algebra.ts b/src/colloid_sci/algebra.ts
new file mode 100644
index 000000000..a2c855167
--- /dev/null
+++ b/src/colloid_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** colloid_sci algebra module — tsb analytics library. */
+export interface ColloidSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeColloidSciAlgebra(data: number[], opts: ColloidSciAlgebraOptions = {}): ColloidSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciAlgebra };
diff --git a/src/colloid_sci/alignment.ts b/src/colloid_sci/alignment.ts
new file mode 100644
index 000000000..1bba2368c
--- /dev/null
+++ b/src/colloid_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** colloid_sci alignment module — tsb analytics library. */
+export interface ColloidSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeColloidSciAlignment(data: number[], opts: ColloidSciAlignmentOptions = {}): ColloidSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciAlignment };
diff --git a/src/colloid_sci/analysis.ts b/src/colloid_sci/analysis.ts
new file mode 100644
index 000000000..d2eec1087
--- /dev/null
+++ b/src/colloid_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** colloid_sci analysis module — tsb analytics library. */
+export interface ColloidSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeColloidSciAnalysis(data: number[], opts: ColloidSciAnalysisOptions = {}): ColloidSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciAnalysis };
diff --git a/src/colloid_sci/augmentation.ts b/src/colloid_sci/augmentation.ts
new file mode 100644
index 000000000..d78f9cfaf
--- /dev/null
+++ b/src/colloid_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci augmentation module — tsb analytics library. */
+export interface ColloidSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeColloidSciAugmentation(data: number[], opts: ColloidSciAugmentationOptions = {}): ColloidSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciAugmentation };
diff --git a/src/colloid_sci/bagging.ts b/src/colloid_sci/bagging.ts
new file mode 100644
index 000000000..8f8df5308
--- /dev/null
+++ b/src/colloid_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** colloid_sci bagging module — tsb analytics library. */
+export interface ColloidSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciBaggingResult { values: number[]; converged: boolean; }
+export function computeColloidSciBagging(data: number[], opts: ColloidSciBaggingOptions = {}): ColloidSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciBagging };
diff --git a/src/colloid_sci/basis.ts b/src/colloid_sci/basis.ts
new file mode 100644
index 000000000..fbb614991
--- /dev/null
+++ b/src/colloid_sci/basis.ts
@@ -0,0 +1,14 @@
+/** colloid_sci basis module — tsb analytics library. */
+export interface ColloidSciBasisOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciBasisResult { values: number[]; converged: boolean; }
+export function computeColloidSciBasis(data: number[], opts: ColloidSciBasisOptions = {}): ColloidSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciBasis };
diff --git a/src/colloid_sci/benchmarking.ts b/src/colloid_sci/benchmarking.ts
new file mode 100644
index 000000000..67601f294
--- /dev/null
+++ b/src/colloid_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** colloid_sci benchmarking module — tsb analytics library. */
+export interface ColloidSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeColloidSciBenchmarking(data: number[], opts: ColloidSciBenchmarkingOptions = {}): ColloidSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciBenchmarking };
diff --git a/src/colloid_sci/blending.ts b/src/colloid_sci/blending.ts
new file mode 100644
index 000000000..6dc5a7c91
--- /dev/null
+++ b/src/colloid_sci/blending.ts
@@ -0,0 +1,14 @@
+/** colloid_sci blending module — tsb analytics library. */
+export interface ColloidSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciBlendingResult { values: number[]; converged: boolean; }
+export function computeColloidSciBlending(data: number[], opts: ColloidSciBlendingOptions = {}): ColloidSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciBlending };
diff --git a/src/colloid_sci/boosting.ts b/src/colloid_sci/boosting.ts
new file mode 100644
index 000000000..8fcbab415
--- /dev/null
+++ b/src/colloid_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** colloid_sci boosting module — tsb analytics library. */
+export interface ColloidSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciBoostingResult { values: number[]; converged: boolean; }
+export function computeColloidSciBoosting(data: number[], opts: ColloidSciBoostingOptions = {}): ColloidSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciBoosting };
diff --git a/src/colloid_sci/bootstrap.ts b/src/colloid_sci/bootstrap.ts
new file mode 100644
index 000000000..3aaa26106
--- /dev/null
+++ b/src/colloid_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** colloid_sci bootstrap module — tsb analytics library. */
+export interface ColloidSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeColloidSciBootstrap(data: number[], opts: ColloidSciBootstrapOptions = {}): ColloidSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciBootstrap };
diff --git a/src/colloid_sci/calculus.ts b/src/colloid_sci/calculus.ts
new file mode 100644
index 000000000..f6516e6b5
--- /dev/null
+++ b/src/colloid_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** colloid_sci calculus module — tsb analytics library. */
+export interface ColloidSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciCalculusResult { values: number[]; converged: boolean; }
+export function computeColloidSciCalculus(data: number[], opts: ColloidSciCalculusOptions = {}): ColloidSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciCalculus };
diff --git a/src/colloid_sci/calibration.ts b/src/colloid_sci/calibration.ts
new file mode 100644
index 000000000..4f1c8ee9e
--- /dev/null
+++ b/src/colloid_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** colloid_sci calibration module — tsb analytics library. */
+export interface ColloidSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeColloidSciCalibration(data: number[], opts: ColloidSciCalibrationOptions = {}): ColloidSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciCalibration };
diff --git a/src/colloid_sci/characterization.ts b/src/colloid_sci/characterization.ts
new file mode 100644
index 000000000..ebee5586f
--- /dev/null
+++ b/src/colloid_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** colloid_sci characterization module — tsb analytics library. */
+export interface ColloidSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeColloidSciCharacterization(data: number[], opts: ColloidSciCharacterizationOptions = {}): ColloidSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciCharacterization };
diff --git a/src/colloid_sci/classification.ts b/src/colloid_sci/classification.ts
new file mode 100644
index 000000000..cc461122a
--- /dev/null
+++ b/src/colloid_sci/classification.ts
@@ -0,0 +1,14 @@
+/** colloid_sci classification module — tsb analytics library. */
+export interface ColloidSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciClassificationResult { values: number[]; converged: boolean; }
+export function computeColloidSciClassification(data: number[], opts: ColloidSciClassificationOptions = {}): ColloidSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciClassification };
diff --git a/src/colloid_sci/clustering.ts b/src/colloid_sci/clustering.ts
new file mode 100644
index 000000000..5af2ffb31
--- /dev/null
+++ b/src/colloid_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** colloid_sci clustering module — tsb analytics library. */
+export interface ColloidSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciClusteringResult { values: number[]; converged: boolean; }
+export function computeColloidSciClustering(data: number[], opts: ColloidSciClusteringOptions = {}): ColloidSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciClustering };
diff --git a/src/colloid_sci/compression.ts b/src/colloid_sci/compression.ts
new file mode 100644
index 000000000..f5d3c26ca
--- /dev/null
+++ b/src/colloid_sci/compression.ts
@@ -0,0 +1,14 @@
+/** colloid_sci compression module — tsb analytics library. */
+export interface ColloidSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciCompressionResult { values: number[]; converged: boolean; }
+export function computeColloidSciCompression(data: number[], opts: ColloidSciCompressionOptions = {}): ColloidSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciCompression };
diff --git a/src/colloid_sci/continuous.ts b/src/colloid_sci/continuous.ts
new file mode 100644
index 000000000..3106c29af
--- /dev/null
+++ b/src/colloid_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** colloid_sci continuous module — tsb analytics library. */
+export interface ColloidSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciContinuousResult { values: number[]; converged: boolean; }
+export function computeColloidSciContinuous(data: number[], opts: ColloidSciContinuousOptions = {}): ColloidSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciContinuous };
diff --git a/src/colloid_sci/control.ts b/src/colloid_sci/control.ts
new file mode 100644
index 000000000..a66772514
--- /dev/null
+++ b/src/colloid_sci/control.ts
@@ -0,0 +1,14 @@
+/** colloid_sci control module — tsb analytics library. */
+export interface ColloidSciControlOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciControlResult { values: number[]; converged: boolean; }
+export function computeColloidSciControl(data: number[], opts: ColloidSciControlOptions = {}): ColloidSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciControl };
diff --git a/src/colloid_sci/convergence.ts b/src/colloid_sci/convergence.ts
new file mode 100644
index 000000000..d54ede0b4
--- /dev/null
+++ b/src/colloid_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** colloid_sci convergence module — tsb analytics library. */
+export interface ColloidSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeColloidSciConvergence(data: number[], opts: ColloidSciConvergenceOptions = {}): ColloidSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciConvergence };
diff --git a/src/colloid_sci/convex.ts b/src/colloid_sci/convex.ts
new file mode 100644
index 000000000..4dcbd98e9
--- /dev/null
+++ b/src/colloid_sci/convex.ts
@@ -0,0 +1,14 @@
+/** colloid_sci convex module — tsb analytics library. */
+export interface ColloidSciConvexOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciConvexResult { values: number[]; converged: boolean; }
+export function computeColloidSciConvex(data: number[], opts: ColloidSciConvexOptions = {}): ColloidSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciConvex };
diff --git a/src/colloid_sci/correlation.ts b/src/colloid_sci/correlation.ts
new file mode 100644
index 000000000..83318cf32
--- /dev/null
+++ b/src/colloid_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci correlation module — tsb analytics library. */
+export interface ColloidSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeColloidSciCorrelation(data: number[], opts: ColloidSciCorrelationOptions = {}): ColloidSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciCorrelation };
diff --git a/src/colloid_sci/covariance.ts b/src/colloid_sci/covariance.ts
new file mode 100644
index 000000000..4c2193ab1
--- /dev/null
+++ b/src/colloid_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** colloid_sci covariance module — tsb analytics library. */
+export interface ColloidSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeColloidSciCovariance(data: number[], opts: ColloidSciCovarianceOptions = {}): ColloidSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciCovariance };
diff --git a/src/colloid_sci/cross_validation.ts b/src/colloid_sci/cross_validation.ts
new file mode 100644
index 000000000..dd447e457
--- /dev/null
+++ b/src/colloid_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci cross_validation module — tsb analytics library. */
+export interface ColloidSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeColloidSciCrossValidation(data: number[], opts: ColloidSciCrossValidationOptions = {}): ColloidSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciCrossValidation };
diff --git a/src/colloid_sci/decoding.ts b/src/colloid_sci/decoding.ts
new file mode 100644
index 000000000..6e63f6ec7
--- /dev/null
+++ b/src/colloid_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** colloid_sci decoding module — tsb analytics library. */
+export interface ColloidSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDecodingResult { values: number[]; converged: boolean; }
+export function computeColloidSciDecoding(data: number[], opts: ColloidSciDecodingOptions = {}): ColloidSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDecoding };
diff --git a/src/colloid_sci/decomposition.ts b/src/colloid_sci/decomposition.ts
new file mode 100644
index 000000000..ee4744b7c
--- /dev/null
+++ b/src/colloid_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** colloid_sci decomposition module — tsb analytics library. */
+export interface ColloidSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeColloidSciDecomposition(data: number[], opts: ColloidSciDecompositionOptions = {}): ColloidSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDecomposition };
diff --git a/src/colloid_sci/detection.ts b/src/colloid_sci/detection.ts
new file mode 100644
index 000000000..8d46eb519
--- /dev/null
+++ b/src/colloid_sci/detection.ts
@@ -0,0 +1,14 @@
+/** colloid_sci detection module — tsb analytics library. */
+export interface ColloidSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDetectionResult { values: number[]; converged: boolean; }
+export function computeColloidSciDetection(data: number[], opts: ColloidSciDetectionOptions = {}): ColloidSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDetection };
diff --git a/src/colloid_sci/deterministic.ts b/src/colloid_sci/deterministic.ts
new file mode 100644
index 000000000..d2eb66a1a
--- /dev/null
+++ b/src/colloid_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** colloid_sci deterministic module — tsb analytics library. */
+export interface ColloidSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeColloidSciDeterministic(data: number[], opts: ColloidSciDeterministicOptions = {}): ColloidSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDeterministic };
diff --git a/src/colloid_sci/diagnostics.ts b/src/colloid_sci/diagnostics.ts
new file mode 100644
index 000000000..9f856fe42
--- /dev/null
+++ b/src/colloid_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** colloid_sci diagnostics module — tsb analytics library. */
+export interface ColloidSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeColloidSciDiagnostics(data: number[], opts: ColloidSciDiagnosticsOptions = {}): ColloidSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDiagnostics };
diff --git a/src/colloid_sci/differential.ts b/src/colloid_sci/differential.ts
new file mode 100644
index 000000000..0f6299a05
--- /dev/null
+++ b/src/colloid_sci/differential.ts
@@ -0,0 +1,14 @@
+/** colloid_sci differential module — tsb analytics library. */
+export interface ColloidSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeColloidSciDifferential(data: number[], opts: ColloidSciDifferentialOptions = {}): ColloidSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDifferential };
diff --git a/src/colloid_sci/discrete.ts b/src/colloid_sci/discrete.ts
new file mode 100644
index 000000000..5fe25ed4b
--- /dev/null
+++ b/src/colloid_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** colloid_sci discrete module — tsb analytics library. */
+export interface ColloidSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeColloidSciDiscrete(data: number[], opts: ColloidSciDiscreteOptions = {}): ColloidSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDiscrete };
diff --git a/src/colloid_sci/distribution.ts b/src/colloid_sci/distribution.ts
new file mode 100644
index 000000000..bd24d9001
--- /dev/null
+++ b/src/colloid_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** colloid_sci distribution module — tsb analytics library. */
+export interface ColloidSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDistributionResult { values: number[]; converged: boolean; }
+export function computeColloidSciDistribution(data: number[], opts: ColloidSciDistributionOptions = {}): ColloidSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDistribution };
diff --git a/src/colloid_sci/dynamic.ts b/src/colloid_sci/dynamic.ts
new file mode 100644
index 000000000..bc13383f4
--- /dev/null
+++ b/src/colloid_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** colloid_sci dynamic module — tsb analytics library. */
+export interface ColloidSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciDynamicResult { values: number[]; converged: boolean; }
+export function computeColloidSciDynamic(data: number[], opts: ColloidSciDynamicOptions = {}): ColloidSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciDynamic };
diff --git a/src/colloid_sci/embedding.ts b/src/colloid_sci/embedding.ts
new file mode 100644
index 000000000..d0d667d3d
--- /dev/null
+++ b/src/colloid_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** colloid_sci embedding module — tsb analytics library. */
+export interface ColloidSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeColloidSciEmbedding(data: number[], opts: ColloidSciEmbeddingOptions = {}): ColloidSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciEmbedding };
diff --git a/src/colloid_sci/encoding.ts b/src/colloid_sci/encoding.ts
new file mode 100644
index 000000000..ae57fb437
--- /dev/null
+++ b/src/colloid_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** colloid_sci encoding module — tsb analytics library. */
+export interface ColloidSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciEncodingResult { values: number[]; converged: boolean; }
+export function computeColloidSciEncoding(data: number[], opts: ColloidSciEncodingOptions = {}): ColloidSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciEncoding };
diff --git a/src/colloid_sci/ensemble.ts b/src/colloid_sci/ensemble.ts
new file mode 100644
index 000000000..dcc8d269c
--- /dev/null
+++ b/src/colloid_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** colloid_sci ensemble module — tsb analytics library. */
+export interface ColloidSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeColloidSciEnsemble(data: number[], opts: ColloidSciEnsembleOptions = {}): ColloidSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciEnsemble };
diff --git a/src/colloid_sci/estimation.ts b/src/colloid_sci/estimation.ts
new file mode 100644
index 000000000..9b1e74452
--- /dev/null
+++ b/src/colloid_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci estimation module — tsb analytics library. */
+export interface ColloidSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciEstimationResult { values: number[]; converged: boolean; }
+export function computeColloidSciEstimation(data: number[], opts: ColloidSciEstimationOptions = {}): ColloidSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciEstimation };
diff --git a/src/colloid_sci/evaluation.ts b/src/colloid_sci/evaluation.ts
new file mode 100644
index 000000000..b1d7f4125
--- /dev/null
+++ b/src/colloid_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci evaluation module — tsb analytics library. */
+export interface ColloidSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeColloidSciEvaluation(data: number[], opts: ColloidSciEvaluationOptions = {}): ColloidSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciEvaluation };
diff --git a/src/colloid_sci/extrapolation.ts b/src/colloid_sci/extrapolation.ts
new file mode 100644
index 000000000..5d1044633
--- /dev/null
+++ b/src/colloid_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci extrapolation module — tsb analytics library. */
+export interface ColloidSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeColloidSciExtrapolation(data: number[], opts: ColloidSciExtrapolationOptions = {}): ColloidSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciExtrapolation };
diff --git a/src/colloid_sci/features.ts b/src/colloid_sci/features.ts
new file mode 100644
index 000000000..6db1a4886
--- /dev/null
+++ b/src/colloid_sci/features.ts
@@ -0,0 +1,14 @@
+/** colloid_sci features module — tsb analytics library. */
+export interface ColloidSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeColloidSciFeatures(data: number[], opts: ColloidSciFeaturesOptions = {}): ColloidSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciFeatures };
diff --git a/src/colloid_sci/feedback.ts b/src/colloid_sci/feedback.ts
new file mode 100644
index 000000000..bd255683e
--- /dev/null
+++ b/src/colloid_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** colloid_sci feedback module — tsb analytics library. */
+export interface ColloidSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeColloidSciFeedback(data: number[], opts: ColloidSciFeedbackOptions = {}): ColloidSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciFeedback };
diff --git a/src/colloid_sci/filtering.ts b/src/colloid_sci/filtering.ts
new file mode 100644
index 000000000..6128e924a
--- /dev/null
+++ b/src/colloid_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** colloid_sci filtering module — tsb analytics library. */
+export interface ColloidSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciFilteringResult { values: number[]; converged: boolean; }
+export function computeColloidSciFiltering(data: number[], opts: ColloidSciFilteringOptions = {}): ColloidSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciFiltering };
diff --git a/src/colloid_sci/fourier.ts b/src/colloid_sci/fourier.ts
new file mode 100644
index 000000000..14e3947c2
--- /dev/null
+++ b/src/colloid_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** colloid_sci fourier module — tsb analytics library. */
+export interface ColloidSciFourierOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciFourierResult { values: number[]; converged: boolean; }
+export function computeColloidSciFourier(data: number[], opts: ColloidSciFourierOptions = {}): ColloidSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciFourier };
diff --git a/src/colloid_sci/fusion.ts b/src/colloid_sci/fusion.ts
new file mode 100644
index 000000000..750edb65b
--- /dev/null
+++ b/src/colloid_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** colloid_sci fusion module — tsb analytics library. */
+export interface ColloidSciFusionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciFusionResult { values: number[]; converged: boolean; }
+export function computeColloidSciFusion(data: number[], opts: ColloidSciFusionOptions = {}): ColloidSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciFusion };
diff --git a/src/colloid_sci/generation.ts b/src/colloid_sci/generation.ts
new file mode 100644
index 000000000..b87beeb5d
--- /dev/null
+++ b/src/colloid_sci/generation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci generation module — tsb analytics library. */
+export interface ColloidSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciGenerationResult { values: number[]; converged: boolean; }
+export function computeColloidSciGeneration(data: number[], opts: ColloidSciGenerationOptions = {}): ColloidSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciGeneration };
diff --git a/src/colloid_sci/geometry.ts b/src/colloid_sci/geometry.ts
new file mode 100644
index 000000000..932d79497
--- /dev/null
+++ b/src/colloid_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** colloid_sci geometry module — tsb analytics library. */
+export interface ColloidSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciGeometryResult { values: number[]; converged: boolean; }
+export function computeColloidSciGeometry(data: number[], opts: ColloidSciGeometryOptions = {}): ColloidSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciGeometry };
diff --git a/src/colloid_sci/gradient.ts b/src/colloid_sci/gradient.ts
new file mode 100644
index 000000000..1e82d68dd
--- /dev/null
+++ b/src/colloid_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** colloid_sci gradient module — tsb analytics library. */
+export interface ColloidSciGradientOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciGradientResult { values: number[]; converged: boolean; }
+export function computeColloidSciGradient(data: number[], opts: ColloidSciGradientOptions = {}): ColloidSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciGradient };
diff --git a/src/colloid_sci/hessian.ts b/src/colloid_sci/hessian.ts
new file mode 100644
index 000000000..10f2856ef
--- /dev/null
+++ b/src/colloid_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** colloid_sci hessian module — tsb analytics library. */
+export interface ColloidSciHessianOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciHessianResult { values: number[]; converged: boolean; }
+export function computeColloidSciHessian(data: number[], opts: ColloidSciHessianOptions = {}): ColloidSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciHessian };
diff --git a/src/colloid_sci/hypothesis.ts b/src/colloid_sci/hypothesis.ts
new file mode 100644
index 000000000..3c6cf7fbb
--- /dev/null
+++ b/src/colloid_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** colloid_sci hypothesis module — tsb analytics library. */
+export interface ColloidSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeColloidSciHypothesis(data: number[], opts: ColloidSciHypothesisOptions = {}): ColloidSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciHypothesis };
diff --git a/src/colloid_sci/inference.ts b/src/colloid_sci/inference.ts
new file mode 100644
index 000000000..efc73dae2
--- /dev/null
+++ b/src/colloid_sci/inference.ts
@@ -0,0 +1,14 @@
+/** colloid_sci inference module — tsb analytics library. */
+export interface ColloidSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciInferenceResult { values: number[]; converged: boolean; }
+export function computeColloidSciInference(data: number[], opts: ColloidSciInferenceOptions = {}): ColloidSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciInference };
diff --git a/src/colloid_sci/inference2.ts b/src/colloid_sci/inference2.ts
new file mode 100644
index 000000000..d50647178
--- /dev/null
+++ b/src/colloid_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** colloid_sci inference2 module — tsb analytics library. */
+export interface ColloidSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciInferenceResult { values: number[]; converged: boolean; }
+export function computeColloidSciInference(data: number[], opts: ColloidSciInferenceOptions = {}): ColloidSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciInference };
diff --git a/src/colloid_sci/integral.ts b/src/colloid_sci/integral.ts
new file mode 100644
index 000000000..c9709369b
--- /dev/null
+++ b/src/colloid_sci/integral.ts
@@ -0,0 +1,14 @@
+/** colloid_sci integral module — tsb analytics library. */
+export interface ColloidSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciIntegralResult { values: number[]; converged: boolean; }
+export function computeColloidSciIntegral(data: number[], opts: ColloidSciIntegralOptions = {}): ColloidSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciIntegral };
diff --git a/src/colloid_sci/integration.ts b/src/colloid_sci/integration.ts
new file mode 100644
index 000000000..f0e471247
--- /dev/null
+++ b/src/colloid_sci/integration.ts
@@ -0,0 +1,14 @@
+/** colloid_sci integration module — tsb analytics library. */
+export interface ColloidSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeColloidSciIntegration(data: number[], opts: ColloidSciIntegrationOptions = {}): ColloidSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciIntegration };
diff --git a/src/colloid_sci/interpolation.ts b/src/colloid_sci/interpolation.ts
new file mode 100644
index 000000000..3809928c6
--- /dev/null
+++ b/src/colloid_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci interpolation module — tsb analytics library. */
+export interface ColloidSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeColloidSciInterpolation(data: number[], opts: ColloidSciInterpolationOptions = {}): ColloidSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciInterpolation };
diff --git a/src/colloid_sci/jacobian.ts b/src/colloid_sci/jacobian.ts
new file mode 100644
index 000000000..acc56195a
--- /dev/null
+++ b/src/colloid_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** colloid_sci jacobian module — tsb analytics library. */
+export interface ColloidSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciJacobianResult { values: number[]; converged: boolean; }
+export function computeColloidSciJacobian(data: number[], opts: ColloidSciJacobianOptions = {}): ColloidSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciJacobian };
diff --git a/src/colloid_sci/kernel.ts b/src/colloid_sci/kernel.ts
new file mode 100644
index 000000000..cc2295f80
--- /dev/null
+++ b/src/colloid_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** colloid_sci kernel module — tsb analytics library. */
+export interface ColloidSciKernelOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciKernelResult { values: number[]; converged: boolean; }
+export function computeColloidSciKernel(data: number[], opts: ColloidSciKernelOptions = {}): ColloidSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciKernel };
diff --git a/src/colloid_sci/laplacian.ts b/src/colloid_sci/laplacian.ts
new file mode 100644
index 000000000..45f679a25
--- /dev/null
+++ b/src/colloid_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** colloid_sci laplacian module — tsb analytics library. */
+export interface ColloidSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeColloidSciLaplacian(data: number[], opts: ColloidSciLaplacianOptions = {}): ColloidSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciLaplacian };
diff --git a/src/colloid_sci/learning.ts b/src/colloid_sci/learning.ts
new file mode 100644
index 000000000..ce0281b01
--- /dev/null
+++ b/src/colloid_sci/learning.ts
@@ -0,0 +1,14 @@
+/** colloid_sci learning module — tsb analytics library. */
+export interface ColloidSciLearningOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciLearningResult { values: number[]; converged: boolean; }
+export function computeColloidSciLearning(data: number[], opts: ColloidSciLearningOptions = {}): ColloidSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciLearning };
diff --git a/src/colloid_sci/linear.ts b/src/colloid_sci/linear.ts
new file mode 100644
index 000000000..fb657ab52
--- /dev/null
+++ b/src/colloid_sci/linear.ts
@@ -0,0 +1,14 @@
+/** colloid_sci linear module — tsb analytics library. */
+export interface ColloidSciLinearOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciLinearResult { values: number[]; converged: boolean; }
+export function computeColloidSciLinear(data: number[], opts: ColloidSciLinearOptions = {}): ColloidSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciLinear };
diff --git a/src/colloid_sci/manifold.ts b/src/colloid_sci/manifold.ts
new file mode 100644
index 000000000..7afd72053
--- /dev/null
+++ b/src/colloid_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** colloid_sci manifold module — tsb analytics library. */
+export interface ColloidSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciManifoldResult { values: number[]; converged: boolean; }
+export function computeColloidSciManifold(data: number[], opts: ColloidSciManifoldOptions = {}): ColloidSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciManifold };
diff --git a/src/colloid_sci/matching.ts b/src/colloid_sci/matching.ts
new file mode 100644
index 000000000..99a8ef99a
--- /dev/null
+++ b/src/colloid_sci/matching.ts
@@ -0,0 +1,14 @@
+/** colloid_sci matching module — tsb analytics library. */
+export interface ColloidSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciMatchingResult { values: number[]; converged: boolean; }
+export function computeColloidSciMatching(data: number[], opts: ColloidSciMatchingOptions = {}): ColloidSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciMatching };
diff --git a/src/colloid_sci/measurement.ts b/src/colloid_sci/measurement.ts
new file mode 100644
index 000000000..d659fd7d5
--- /dev/null
+++ b/src/colloid_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** colloid_sci measurement module — tsb analytics library. */
+export interface ColloidSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeColloidSciMeasurement(data: number[], opts: ColloidSciMeasurementOptions = {}): ColloidSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciMeasurement };
diff --git a/src/colloid_sci/metrics.ts b/src/colloid_sci/metrics.ts
new file mode 100644
index 000000000..00ec9a43b
--- /dev/null
+++ b/src/colloid_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** colloid_sci metrics module — tsb analytics library. */
+export interface ColloidSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciMetricsResult { values: number[]; converged: boolean; }
+export function computeColloidSciMetrics(data: number[], opts: ColloidSciMetricsOptions = {}): ColloidSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciMetrics };
diff --git a/src/colloid_sci/modeling.ts b/src/colloid_sci/modeling.ts
new file mode 100644
index 000000000..ceff8f826
--- /dev/null
+++ b/src/colloid_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** colloid_sci modeling module — tsb analytics library. */
+export interface ColloidSciModelingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciModelingResult { values: number[]; converged: boolean; }
+export function computeColloidSciModeling(data: number[], opts: ColloidSciModelingOptions = {}): ColloidSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciModeling };
diff --git a/src/colloid_sci/monitoring.ts b/src/colloid_sci/monitoring.ts
new file mode 100644
index 000000000..0cb938a51
--- /dev/null
+++ b/src/colloid_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** colloid_sci monitoring module — tsb analytics library. */
+export interface ColloidSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeColloidSciMonitoring(data: number[], opts: ColloidSciMonitoringOptions = {}): ColloidSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciMonitoring };
diff --git a/src/colloid_sci/nonlinear.ts b/src/colloid_sci/nonlinear.ts
new file mode 100644
index 000000000..03df1cd62
--- /dev/null
+++ b/src/colloid_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** colloid_sci nonlinear module — tsb analytics library. */
+export interface ColloidSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeColloidSciNonlinear(data: number[], opts: ColloidSciNonlinearOptions = {}): ColloidSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciNonlinear };
diff --git a/src/colloid_sci/normalization.ts b/src/colloid_sci/normalization.ts
new file mode 100644
index 000000000..2d8bb2a17
--- /dev/null
+++ b/src/colloid_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** colloid_sci normalization module — tsb analytics library. */
+export interface ColloidSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeColloidSciNormalization(data: number[], opts: ColloidSciNormalizationOptions = {}): ColloidSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciNormalization };
diff --git a/src/colloid_sci/optimization.ts b/src/colloid_sci/optimization.ts
new file mode 100644
index 000000000..011d8ac36
--- /dev/null
+++ b/src/colloid_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** colloid_sci optimization module — tsb analytics library. */
+export interface ColloidSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeColloidSciOptimization(data: number[], opts: ColloidSciOptimizationOptions = {}): ColloidSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciOptimization };
diff --git a/src/colloid_sci/patterns.ts b/src/colloid_sci/patterns.ts
new file mode 100644
index 000000000..39092f655
--- /dev/null
+++ b/src/colloid_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** colloid_sci patterns module — tsb analytics library. */
+export interface ColloidSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciPatternsResult { values: number[]; converged: boolean; }
+export function computeColloidSciPatterns(data: number[], opts: ColloidSciPatternsOptions = {}): ColloidSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciPatterns };
diff --git a/src/colloid_sci/permutation.ts b/src/colloid_sci/permutation.ts
new file mode 100644
index 000000000..f12e17682
--- /dev/null
+++ b/src/colloid_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci permutation module — tsb analytics library. */
+export interface ColloidSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciPermutationResult { values: number[]; converged: boolean; }
+export function computeColloidSciPermutation(data: number[], opts: ColloidSciPermutationOptions = {}): ColloidSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciPermutation };
diff --git a/src/colloid_sci/prediction.ts b/src/colloid_sci/prediction.ts
new file mode 100644
index 000000000..fc1c637be
--- /dev/null
+++ b/src/colloid_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** colloid_sci prediction module — tsb analytics library. */
+export interface ColloidSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciPredictionResult { values: number[]; converged: boolean; }
+export function computeColloidSciPrediction(data: number[], opts: ColloidSciPredictionOptions = {}): ColloidSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciPrediction };
diff --git a/src/colloid_sci/processing.ts b/src/colloid_sci/processing.ts
new file mode 100644
index 000000000..b5ddf2c6e
--- /dev/null
+++ b/src/colloid_sci/processing.ts
@@ -0,0 +1,14 @@
+/** colloid_sci processing module — tsb analytics library. */
+export interface ColloidSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciProcessingResult { values: number[]; converged: boolean; }
+export function computeColloidSciProcessing(data: number[], opts: ColloidSciProcessingOptions = {}): ColloidSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciProcessing };
diff --git a/src/colloid_sci/profiling.ts b/src/colloid_sci/profiling.ts
new file mode 100644
index 000000000..e9dcd3cab
--- /dev/null
+++ b/src/colloid_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** colloid_sci profiling module — tsb analytics library. */
+export interface ColloidSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciProfilingResult { values: number[]; converged: boolean; }
+export function computeColloidSciProfiling(data: number[], opts: ColloidSciProfilingOptions = {}): ColloidSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciProfiling };
diff --git a/src/colloid_sci/projection.ts b/src/colloid_sci/projection.ts
new file mode 100644
index 000000000..bd1a58a36
--- /dev/null
+++ b/src/colloid_sci/projection.ts
@@ -0,0 +1,14 @@
+/** colloid_sci projection module — tsb analytics library. */
+export interface ColloidSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciProjectionResult { values: number[]; converged: boolean; }
+export function computeColloidSciProjection(data: number[], opts: ColloidSciProjectionOptions = {}): ColloidSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciProjection };
diff --git a/src/colloid_sci/ranking.ts b/src/colloid_sci/ranking.ts
new file mode 100644
index 000000000..c981fa1a4
--- /dev/null
+++ b/src/colloid_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** colloid_sci ranking module — tsb analytics library. */
+export interface ColloidSciRankingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciRankingResult { values: number[]; converged: boolean; }
+export function computeColloidSciRanking(data: number[], opts: ColloidSciRankingOptions = {}): ColloidSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciRanking };
diff --git a/src/colloid_sci/reconstruction.ts b/src/colloid_sci/reconstruction.ts
new file mode 100644
index 000000000..94b3b9865
--- /dev/null
+++ b/src/colloid_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** colloid_sci reconstruction module — tsb analytics library. */
+export interface ColloidSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeColloidSciReconstruction(data: number[], opts: ColloidSciReconstructionOptions = {}): ColloidSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciReconstruction };
diff --git a/src/colloid_sci/registration.ts b/src/colloid_sci/registration.ts
new file mode 100644
index 000000000..6c32970b2
--- /dev/null
+++ b/src/colloid_sci/registration.ts
@@ -0,0 +1,14 @@
+/** colloid_sci registration module — tsb analytics library. */
+export interface ColloidSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeColloidSciRegistration(data: number[], opts: ColloidSciRegistrationOptions = {}): ColloidSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciRegistration };
diff --git a/src/colloid_sci/regression.ts b/src/colloid_sci/regression.ts
new file mode 100644
index 000000000..22dd7b4a0
--- /dev/null
+++ b/src/colloid_sci/regression.ts
@@ -0,0 +1,14 @@
+/** colloid_sci regression module — tsb analytics library. */
+export interface ColloidSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciRegressionResult { values: number[]; converged: boolean; }
+export function computeColloidSciRegression(data: number[], opts: ColloidSciRegressionOptions = {}): ColloidSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciRegression };
diff --git a/src/colloid_sci/regularization.ts b/src/colloid_sci/regularization.ts
new file mode 100644
index 000000000..fdc22ac58
--- /dev/null
+++ b/src/colloid_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** colloid_sci regularization module — tsb analytics library. */
+export interface ColloidSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeColloidSciRegularization(data: number[], opts: ColloidSciRegularizationOptions = {}): ColloidSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciRegularization };
diff --git a/src/colloid_sci/robustness.ts b/src/colloid_sci/robustness.ts
new file mode 100644
index 000000000..b096ab424
--- /dev/null
+++ b/src/colloid_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** colloid_sci robustness module — tsb analytics library. */
+export interface ColloidSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeColloidSciRobustness(data: number[], opts: ColloidSciRobustnessOptions = {}): ColloidSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciRobustness };
diff --git a/src/colloid_sci/sampling.ts b/src/colloid_sci/sampling.ts
new file mode 100644
index 000000000..b6cd2da9d
--- /dev/null
+++ b/src/colloid_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** colloid_sci sampling module — tsb analytics library. */
+export interface ColloidSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciSamplingResult { values: number[]; converged: boolean; }
+export function computeColloidSciSampling(data: number[], opts: ColloidSciSamplingOptions = {}): ColloidSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciSampling };
diff --git a/src/colloid_sci/sampling2.ts b/src/colloid_sci/sampling2.ts
new file mode 100644
index 000000000..f18874ee5
--- /dev/null
+++ b/src/colloid_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** colloid_sci sampling2 module — tsb analytics library. */
+export interface ColloidSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciSamplingResult { values: number[]; converged: boolean; }
+export function computeColloidSciSampling(data: number[], opts: ColloidSciSamplingOptions = {}): ColloidSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciSampling };
diff --git a/src/colloid_sci/scaling.ts b/src/colloid_sci/scaling.ts
new file mode 100644
index 000000000..4620d3cea
--- /dev/null
+++ b/src/colloid_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** colloid_sci scaling module — tsb analytics library. */
+export interface ColloidSciScalingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciScalingResult { values: number[]; converged: boolean; }
+export function computeColloidSciScaling(data: number[], opts: ColloidSciScalingOptions = {}): ColloidSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciScaling };
diff --git a/src/colloid_sci/scoring.ts b/src/colloid_sci/scoring.ts
new file mode 100644
index 000000000..cd5cbfc0a
--- /dev/null
+++ b/src/colloid_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** colloid_sci scoring module — tsb analytics library. */
+export interface ColloidSciScoringOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciScoringResult { values: number[]; converged: boolean; }
+export function computeColloidSciScoring(data: number[], opts: ColloidSciScoringOptions = {}): ColloidSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciScoring };
diff --git a/src/colloid_sci/segmentation.ts b/src/colloid_sci/segmentation.ts
new file mode 100644
index 000000000..e999cdc90
--- /dev/null
+++ b/src/colloid_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci segmentation module — tsb analytics library. */
+export interface ColloidSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeColloidSciSegmentation(data: number[], opts: ColloidSciSegmentationOptions = {}): ColloidSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciSegmentation };
diff --git a/src/colloid_sci/selection.ts b/src/colloid_sci/selection.ts
new file mode 100644
index 000000000..4aabe22c2
--- /dev/null
+++ b/src/colloid_sci/selection.ts
@@ -0,0 +1,14 @@
+/** colloid_sci selection module — tsb analytics library. */
+export interface ColloidSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciSelectionResult { values: number[]; converged: boolean; }
+export function computeColloidSciSelection(data: number[], opts: ColloidSciSelectionOptions = {}): ColloidSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciSelection };
diff --git a/src/colloid_sci/sensitivity.ts b/src/colloid_sci/sensitivity.ts
new file mode 100644
index 000000000..1714cf70f
--- /dev/null
+++ b/src/colloid_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** colloid_sci sensitivity module — tsb analytics library. */
+export interface ColloidSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeColloidSciSensitivity(data: number[], opts: ColloidSciSensitivityOptions = {}): ColloidSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciSensitivity };
diff --git a/src/colloid_sci/simulation.ts b/src/colloid_sci/simulation.ts
new file mode 100644
index 000000000..e50815c5d
--- /dev/null
+++ b/src/colloid_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci simulation module — tsb analytics library. */
+export interface ColloidSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciSimulationResult { values: number[]; converged: boolean; }
+export function computeColloidSciSimulation(data: number[], opts: ColloidSciSimulationOptions = {}): ColloidSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciSimulation };
diff --git a/src/colloid_sci/smoothing.ts b/src/colloid_sci/smoothing.ts
new file mode 100644
index 000000000..a09d41ad4
--- /dev/null
+++ b/src/colloid_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** colloid_sci smoothing module — tsb analytics library. */
+export interface ColloidSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeColloidSciSmoothing(data: number[], opts: ColloidSciSmoothingOptions = {}): ColloidSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciSmoothing };
diff --git a/src/colloid_sci/stability.ts b/src/colloid_sci/stability.ts
new file mode 100644
index 000000000..c3627c3c8
--- /dev/null
+++ b/src/colloid_sci/stability.ts
@@ -0,0 +1,14 @@
+/** colloid_sci stability module — tsb analytics library. */
+export interface ColloidSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciStabilityResult { values: number[]; converged: boolean; }
+export function computeColloidSciStability(data: number[], opts: ColloidSciStabilityOptions = {}): ColloidSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciStability };
diff --git a/src/colloid_sci/stacking.ts b/src/colloid_sci/stacking.ts
new file mode 100644
index 000000000..e58a5391d
--- /dev/null
+++ b/src/colloid_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** colloid_sci stacking module — tsb analytics library. */
+export interface ColloidSciStackingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciStackingResult { values: number[]; converged: boolean; }
+export function computeColloidSciStacking(data: number[], opts: ColloidSciStackingOptions = {}): ColloidSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciStacking };
diff --git a/src/colloid_sci/standardization.ts b/src/colloid_sci/standardization.ts
new file mode 100644
index 000000000..b2f36f16e
--- /dev/null
+++ b/src/colloid_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** colloid_sci standardization module — tsb analytics library. */
+export interface ColloidSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeColloidSciStandardization(data: number[], opts: ColloidSciStandardizationOptions = {}): ColloidSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciStandardization };
diff --git a/src/colloid_sci/static.ts b/src/colloid_sci/static.ts
new file mode 100644
index 000000000..98c0f7d5f
--- /dev/null
+++ b/src/colloid_sci/static.ts
@@ -0,0 +1,14 @@
+/** colloid_sci static module — tsb analytics library. */
+export interface ColloidSciStaticOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciStaticResult { values: number[]; converged: boolean; }
+export function computeColloidSciStatic(data: number[], opts: ColloidSciStaticOptions = {}): ColloidSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciStatic };
diff --git a/src/colloid_sci/stochastic.ts b/src/colloid_sci/stochastic.ts
new file mode 100644
index 000000000..f68c0875b
--- /dev/null
+++ b/src/colloid_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** colloid_sci stochastic module — tsb analytics library. */
+export interface ColloidSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciStochasticResult { values: number[]; converged: boolean; }
+export function computeColloidSciStochastic(data: number[], opts: ColloidSciStochasticOptions = {}): ColloidSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciStochastic };
diff --git a/src/colloid_sci/synthesis.ts b/src/colloid_sci/synthesis.ts
new file mode 100644
index 000000000..e8745c3c6
--- /dev/null
+++ b/src/colloid_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** colloid_sci synthesis module — tsb analytics library. */
+export interface ColloidSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeColloidSciSynthesis(data: number[], opts: ColloidSciSynthesisOptions = {}): ColloidSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciSynthesis };
diff --git a/src/colloid_sci/topology.ts b/src/colloid_sci/topology.ts
new file mode 100644
index 000000000..19e3633b0
--- /dev/null
+++ b/src/colloid_sci/topology.ts
@@ -0,0 +1,14 @@
+/** colloid_sci topology module — tsb analytics library. */
+export interface ColloidSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciTopologyResult { values: number[]; converged: boolean; }
+export function computeColloidSciTopology(data: number[], opts: ColloidSciTopologyOptions = {}): ColloidSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciTopology };
diff --git a/src/colloid_sci/tracking.ts b/src/colloid_sci/tracking.ts
new file mode 100644
index 000000000..dbca8d6e7
--- /dev/null
+++ b/src/colloid_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** colloid_sci tracking module — tsb analytics library. */
+export interface ColloidSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciTrackingResult { values: number[]; converged: boolean; }
+export function computeColloidSciTracking(data: number[], opts: ColloidSciTrackingOptions = {}): ColloidSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciTracking };
diff --git a/src/colloid_sci/transform.ts b/src/colloid_sci/transform.ts
new file mode 100644
index 000000000..e7d576533
--- /dev/null
+++ b/src/colloid_sci/transform.ts
@@ -0,0 +1,14 @@
+/** colloid_sci transform module — tsb analytics library. */
+export interface ColloidSciTransformOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciTransformResult { values: number[]; converged: boolean; }
+export function computeColloidSciTransform(data: number[], opts: ColloidSciTransformOptions = {}): ColloidSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciTransform };
diff --git a/src/colloid_sci/uncertainty.ts b/src/colloid_sci/uncertainty.ts
new file mode 100644
index 000000000..ebc14bf4f
--- /dev/null
+++ b/src/colloid_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** colloid_sci uncertainty module — tsb analytics library. */
+export interface ColloidSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeColloidSciUncertainty(data: number[], opts: ColloidSciUncertaintyOptions = {}): ColloidSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciUncertainty };
diff --git a/src/colloid_sci/validation.ts b/src/colloid_sci/validation.ts
new file mode 100644
index 000000000..280996a5b
--- /dev/null
+++ b/src/colloid_sci/validation.ts
@@ -0,0 +1,14 @@
+/** colloid_sci validation module — tsb analytics library. */
+export interface ColloidSciValidationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciValidationResult { values: number[]; converged: boolean; }
+export function computeColloidSciValidation(data: number[], opts: ColloidSciValidationOptions = {}): ColloidSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciValidation };
diff --git a/src/colloid_sci/verification.ts b/src/colloid_sci/verification.ts
new file mode 100644
index 000000000..001030af0
--- /dev/null
+++ b/src/colloid_sci/verification.ts
@@ -0,0 +1,14 @@
+/** colloid_sci verification module — tsb analytics library. */
+export interface ColloidSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciVerificationResult { values: number[]; converged: boolean; }
+export function computeColloidSciVerification(data: number[], opts: ColloidSciVerificationOptions = {}): ColloidSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciVerification };
diff --git a/src/colloid_sci/visualization.ts b/src/colloid_sci/visualization.ts
new file mode 100644
index 000000000..9259e7a6b
--- /dev/null
+++ b/src/colloid_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** colloid_sci visualization module — tsb analytics library. */
+export interface ColloidSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeColloidSciVisualization(data: number[], opts: ColloidSciVisualizationOptions = {}): ColloidSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciVisualization };
diff --git a/src/colloid_sci/voting.ts b/src/colloid_sci/voting.ts
new file mode 100644
index 000000000..360ca5238
--- /dev/null
+++ b/src/colloid_sci/voting.ts
@@ -0,0 +1,14 @@
+/** colloid_sci voting module — tsb analytics library. */
+export interface ColloidSciVotingOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciVotingResult { values: number[]; converged: boolean; }
+export function computeColloidSciVoting(data: number[], opts: ColloidSciVotingOptions = {}): ColloidSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciVoting };
diff --git a/src/colloid_sci/wavelet.ts b/src/colloid_sci/wavelet.ts
new file mode 100644
index 000000000..0872c1193
--- /dev/null
+++ b/src/colloid_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** colloid_sci wavelet module — tsb analytics library. */
+export interface ColloidSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface ColloidSciWaveletResult { values: number[]; converged: boolean; }
+export function computeColloidSciWavelet(data: number[], opts: ColloidSciWaveletOptions = {}): ColloidSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeColloidSciWavelet };
diff --git a/src/community_ecology/adaptation.ts b/src/community_ecology/adaptation.ts
new file mode 100644
index 000000000..0093c4e9c
--- /dev/null
+++ b/src/community_ecology/adaptation.ts
@@ -0,0 +1,14 @@
+/** community_ecology adaptation module — tsb analytics library. */
+export interface CommunityEcologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyAdaptation(data: number[], opts: CommunityEcologyAdaptationOptions = {}): CommunityEcologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyAdaptation };
diff --git a/src/community_ecology/aggregation.ts b/src/community_ecology/aggregation.ts
new file mode 100644
index 000000000..e00c99798
--- /dev/null
+++ b/src/community_ecology/aggregation.ts
@@ -0,0 +1,14 @@
+/** community_ecology aggregation module — tsb analytics library. */
+export interface CommunityEcologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyAggregationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyAggregation(data: number[], opts: CommunityEcologyAggregationOptions = {}): CommunityEcologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyAggregation };
diff --git a/src/community_ecology/algebra.ts b/src/community_ecology/algebra.ts
new file mode 100644
index 000000000..5dfaab1b9
--- /dev/null
+++ b/src/community_ecology/algebra.ts
@@ -0,0 +1,14 @@
+/** community_ecology algebra module — tsb analytics library. */
+export interface CommunityEcologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyAlgebra(data: number[], opts: CommunityEcologyAlgebraOptions = {}): CommunityEcologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyAlgebra };
diff --git a/src/community_ecology/alignment.ts b/src/community_ecology/alignment.ts
new file mode 100644
index 000000000..2934ba028
--- /dev/null
+++ b/src/community_ecology/alignment.ts
@@ -0,0 +1,14 @@
+/** community_ecology alignment module — tsb analytics library. */
+export interface CommunityEcologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyAlignment(data: number[], opts: CommunityEcologyAlignmentOptions = {}): CommunityEcologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyAlignment };
diff --git a/src/community_ecology/analysis.ts b/src/community_ecology/analysis.ts
new file mode 100644
index 000000000..4f8794de9
--- /dev/null
+++ b/src/community_ecology/analysis.ts
@@ -0,0 +1,14 @@
+/** community_ecology analysis module — tsb analytics library. */
+export interface CommunityEcologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyAnalysis(data: number[], opts: CommunityEcologyAnalysisOptions = {}): CommunityEcologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyAnalysis };
diff --git a/src/community_ecology/augmentation.ts b/src/community_ecology/augmentation.ts
new file mode 100644
index 000000000..0a29127ef
--- /dev/null
+++ b/src/community_ecology/augmentation.ts
@@ -0,0 +1,14 @@
+/** community_ecology augmentation module — tsb analytics library. */
+export interface CommunityEcologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyAugmentation(data: number[], opts: CommunityEcologyAugmentationOptions = {}): CommunityEcologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyAugmentation };
diff --git a/src/community_ecology/bagging.ts b/src/community_ecology/bagging.ts
new file mode 100644
index 000000000..48c9cd2df
--- /dev/null
+++ b/src/community_ecology/bagging.ts
@@ -0,0 +1,14 @@
+/** community_ecology bagging module — tsb analytics library. */
+export interface CommunityEcologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyBaggingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyBagging(data: number[], opts: CommunityEcologyBaggingOptions = {}): CommunityEcologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyBagging };
diff --git a/src/community_ecology/basis.ts b/src/community_ecology/basis.ts
new file mode 100644
index 000000000..b23cc4bae
--- /dev/null
+++ b/src/community_ecology/basis.ts
@@ -0,0 +1,14 @@
+/** community_ecology basis module — tsb analytics library. */
+export interface CommunityEcologyBasisOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyBasisResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyBasis(data: number[], opts: CommunityEcologyBasisOptions = {}): CommunityEcologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyBasis };
diff --git a/src/community_ecology/benchmarking.ts b/src/community_ecology/benchmarking.ts
new file mode 100644
index 000000000..ae2a70a14
--- /dev/null
+++ b/src/community_ecology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** community_ecology benchmarking module — tsb analytics library. */
+export interface CommunityEcologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyBenchmarking(data: number[], opts: CommunityEcologyBenchmarkingOptions = {}): CommunityEcologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyBenchmarking };
diff --git a/src/community_ecology/blending.ts b/src/community_ecology/blending.ts
new file mode 100644
index 000000000..d206d42d6
--- /dev/null
+++ b/src/community_ecology/blending.ts
@@ -0,0 +1,14 @@
+/** community_ecology blending module — tsb analytics library. */
+export interface CommunityEcologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyBlendingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyBlending(data: number[], opts: CommunityEcologyBlendingOptions = {}): CommunityEcologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyBlending };
diff --git a/src/community_ecology/boosting.ts b/src/community_ecology/boosting.ts
new file mode 100644
index 000000000..857ceea42
--- /dev/null
+++ b/src/community_ecology/boosting.ts
@@ -0,0 +1,14 @@
+/** community_ecology boosting module — tsb analytics library. */
+export interface CommunityEcologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyBoostingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyBoosting(data: number[], opts: CommunityEcologyBoostingOptions = {}): CommunityEcologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyBoosting };
diff --git a/src/community_ecology/bootstrap.ts b/src/community_ecology/bootstrap.ts
new file mode 100644
index 000000000..e0afe6a46
--- /dev/null
+++ b/src/community_ecology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** community_ecology bootstrap module — tsb analytics library. */
+export interface CommunityEcologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyBootstrap(data: number[], opts: CommunityEcologyBootstrapOptions = {}): CommunityEcologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyBootstrap };
diff --git a/src/community_ecology/calculus.ts b/src/community_ecology/calculus.ts
new file mode 100644
index 000000000..1ce2120c4
--- /dev/null
+++ b/src/community_ecology/calculus.ts
@@ -0,0 +1,14 @@
+/** community_ecology calculus module — tsb analytics library. */
+export interface CommunityEcologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyCalculusResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyCalculus(data: number[], opts: CommunityEcologyCalculusOptions = {}): CommunityEcologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyCalculus };
diff --git a/src/community_ecology/calibration.ts b/src/community_ecology/calibration.ts
new file mode 100644
index 000000000..137168df3
--- /dev/null
+++ b/src/community_ecology/calibration.ts
@@ -0,0 +1,14 @@
+/** community_ecology calibration module — tsb analytics library. */
+export interface CommunityEcologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyCalibration(data: number[], opts: CommunityEcologyCalibrationOptions = {}): CommunityEcologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyCalibration };
diff --git a/src/community_ecology/characterization.ts b/src/community_ecology/characterization.ts
new file mode 100644
index 000000000..590cb7a6d
--- /dev/null
+++ b/src/community_ecology/characterization.ts
@@ -0,0 +1,14 @@
+/** community_ecology characterization module — tsb analytics library. */
+export interface CommunityEcologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyCharacterization(data: number[], opts: CommunityEcologyCharacterizationOptions = {}): CommunityEcologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyCharacterization };
diff --git a/src/community_ecology/classification.ts b/src/community_ecology/classification.ts
new file mode 100644
index 000000000..41ff975d8
--- /dev/null
+++ b/src/community_ecology/classification.ts
@@ -0,0 +1,14 @@
+/** community_ecology classification module — tsb analytics library. */
+export interface CommunityEcologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyClassificationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyClassification(data: number[], opts: CommunityEcologyClassificationOptions = {}): CommunityEcologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyClassification };
diff --git a/src/community_ecology/clustering.ts b/src/community_ecology/clustering.ts
new file mode 100644
index 000000000..a02849697
--- /dev/null
+++ b/src/community_ecology/clustering.ts
@@ -0,0 +1,14 @@
+/** community_ecology clustering module — tsb analytics library. */
+export interface CommunityEcologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyClusteringResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyClustering(data: number[], opts: CommunityEcologyClusteringOptions = {}): CommunityEcologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyClustering };
diff --git a/src/community_ecology/compression.ts b/src/community_ecology/compression.ts
new file mode 100644
index 000000000..257ba3a5f
--- /dev/null
+++ b/src/community_ecology/compression.ts
@@ -0,0 +1,14 @@
+/** community_ecology compression module — tsb analytics library. */
+export interface CommunityEcologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyCompressionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyCompression(data: number[], opts: CommunityEcologyCompressionOptions = {}): CommunityEcologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyCompression };
diff --git a/src/community_ecology/continuous.ts b/src/community_ecology/continuous.ts
new file mode 100644
index 000000000..1af73f975
--- /dev/null
+++ b/src/community_ecology/continuous.ts
@@ -0,0 +1,14 @@
+/** community_ecology continuous module — tsb analytics library. */
+export interface CommunityEcologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyContinuousResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyContinuous(data: number[], opts: CommunityEcologyContinuousOptions = {}): CommunityEcologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyContinuous };
diff --git a/src/community_ecology/control.ts b/src/community_ecology/control.ts
new file mode 100644
index 000000000..39a5ebc18
--- /dev/null
+++ b/src/community_ecology/control.ts
@@ -0,0 +1,14 @@
+/** community_ecology control module — tsb analytics library. */
+export interface CommunityEcologyControlOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyControlResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyControl(data: number[], opts: CommunityEcologyControlOptions = {}): CommunityEcologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyControl };
diff --git a/src/community_ecology/convergence.ts b/src/community_ecology/convergence.ts
new file mode 100644
index 000000000..7cf1aa4ef
--- /dev/null
+++ b/src/community_ecology/convergence.ts
@@ -0,0 +1,14 @@
+/** community_ecology convergence module — tsb analytics library. */
+export interface CommunityEcologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyConvergence(data: number[], opts: CommunityEcologyConvergenceOptions = {}): CommunityEcologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyConvergence };
diff --git a/src/community_ecology/convex.ts b/src/community_ecology/convex.ts
new file mode 100644
index 000000000..b654233f0
--- /dev/null
+++ b/src/community_ecology/convex.ts
@@ -0,0 +1,14 @@
+/** community_ecology convex module — tsb analytics library. */
+export interface CommunityEcologyConvexOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyConvexResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyConvex(data: number[], opts: CommunityEcologyConvexOptions = {}): CommunityEcologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyConvex };
diff --git a/src/community_ecology/correlation.ts b/src/community_ecology/correlation.ts
new file mode 100644
index 000000000..b6c0aba40
--- /dev/null
+++ b/src/community_ecology/correlation.ts
@@ -0,0 +1,14 @@
+/** community_ecology correlation module — tsb analytics library. */
+export interface CommunityEcologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyCorrelation(data: number[], opts: CommunityEcologyCorrelationOptions = {}): CommunityEcologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyCorrelation };
diff --git a/src/community_ecology/covariance.ts b/src/community_ecology/covariance.ts
new file mode 100644
index 000000000..b3753f1fc
--- /dev/null
+++ b/src/community_ecology/covariance.ts
@@ -0,0 +1,14 @@
+/** community_ecology covariance module — tsb analytics library. */
+export interface CommunityEcologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyCovariance(data: number[], opts: CommunityEcologyCovarianceOptions = {}): CommunityEcologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyCovariance };
diff --git a/src/community_ecology/cross_validation.ts b/src/community_ecology/cross_validation.ts
new file mode 100644
index 000000000..2dfa50f49
--- /dev/null
+++ b/src/community_ecology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** community_ecology cross_validation module — tsb analytics library. */
+export interface CommunityEcologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyCrossValidation(data: number[], opts: CommunityEcologyCrossValidationOptions = {}): CommunityEcologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyCrossValidation };
diff --git a/src/community_ecology/decoding.ts b/src/community_ecology/decoding.ts
new file mode 100644
index 000000000..35d3d4052
--- /dev/null
+++ b/src/community_ecology/decoding.ts
@@ -0,0 +1,14 @@
+/** community_ecology decoding module — tsb analytics library. */
+export interface CommunityEcologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDecodingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDecoding(data: number[], opts: CommunityEcologyDecodingOptions = {}): CommunityEcologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDecoding };
diff --git a/src/community_ecology/decomposition.ts b/src/community_ecology/decomposition.ts
new file mode 100644
index 000000000..60d5bf7d8
--- /dev/null
+++ b/src/community_ecology/decomposition.ts
@@ -0,0 +1,14 @@
+/** community_ecology decomposition module — tsb analytics library. */
+export interface CommunityEcologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDecomposition(data: number[], opts: CommunityEcologyDecompositionOptions = {}): CommunityEcologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDecomposition };
diff --git a/src/community_ecology/detection.ts b/src/community_ecology/detection.ts
new file mode 100644
index 000000000..df8918b46
--- /dev/null
+++ b/src/community_ecology/detection.ts
@@ -0,0 +1,14 @@
+/** community_ecology detection module — tsb analytics library. */
+export interface CommunityEcologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDetectionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDetection(data: number[], opts: CommunityEcologyDetectionOptions = {}): CommunityEcologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDetection };
diff --git a/src/community_ecology/deterministic.ts b/src/community_ecology/deterministic.ts
new file mode 100644
index 000000000..03973d59a
--- /dev/null
+++ b/src/community_ecology/deterministic.ts
@@ -0,0 +1,14 @@
+/** community_ecology deterministic module — tsb analytics library. */
+export interface CommunityEcologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDeterministic(data: number[], opts: CommunityEcologyDeterministicOptions = {}): CommunityEcologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDeterministic };
diff --git a/src/community_ecology/diagnostics.ts b/src/community_ecology/diagnostics.ts
new file mode 100644
index 000000000..c8b32b5c1
--- /dev/null
+++ b/src/community_ecology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** community_ecology diagnostics module — tsb analytics library. */
+export interface CommunityEcologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDiagnostics(data: number[], opts: CommunityEcologyDiagnosticsOptions = {}): CommunityEcologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDiagnostics };
diff --git a/src/community_ecology/differential.ts b/src/community_ecology/differential.ts
new file mode 100644
index 000000000..ee7b18985
--- /dev/null
+++ b/src/community_ecology/differential.ts
@@ -0,0 +1,14 @@
+/** community_ecology differential module — tsb analytics library. */
+export interface CommunityEcologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDifferential(data: number[], opts: CommunityEcologyDifferentialOptions = {}): CommunityEcologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDifferential };
diff --git a/src/community_ecology/discrete.ts b/src/community_ecology/discrete.ts
new file mode 100644
index 000000000..2b12c2ad9
--- /dev/null
+++ b/src/community_ecology/discrete.ts
@@ -0,0 +1,14 @@
+/** community_ecology discrete module — tsb analytics library. */
+export interface CommunityEcologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDiscrete(data: number[], opts: CommunityEcologyDiscreteOptions = {}): CommunityEcologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDiscrete };
diff --git a/src/community_ecology/distribution.ts b/src/community_ecology/distribution.ts
new file mode 100644
index 000000000..22cb3525d
--- /dev/null
+++ b/src/community_ecology/distribution.ts
@@ -0,0 +1,14 @@
+/** community_ecology distribution module — tsb analytics library. */
+export interface CommunityEcologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDistributionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDistribution(data: number[], opts: CommunityEcologyDistributionOptions = {}): CommunityEcologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDistribution };
diff --git a/src/community_ecology/dynamic.ts b/src/community_ecology/dynamic.ts
new file mode 100644
index 000000000..467beab9e
--- /dev/null
+++ b/src/community_ecology/dynamic.ts
@@ -0,0 +1,14 @@
+/** community_ecology dynamic module — tsb analytics library. */
+export interface CommunityEcologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyDynamicResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyDynamic(data: number[], opts: CommunityEcologyDynamicOptions = {}): CommunityEcologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyDynamic };
diff --git a/src/community_ecology/embedding.ts b/src/community_ecology/embedding.ts
new file mode 100644
index 000000000..388aa08c0
--- /dev/null
+++ b/src/community_ecology/embedding.ts
@@ -0,0 +1,14 @@
+/** community_ecology embedding module — tsb analytics library. */
+export interface CommunityEcologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyEmbedding(data: number[], opts: CommunityEcologyEmbeddingOptions = {}): CommunityEcologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyEmbedding };
diff --git a/src/community_ecology/encoding.ts b/src/community_ecology/encoding.ts
new file mode 100644
index 000000000..c722a6641
--- /dev/null
+++ b/src/community_ecology/encoding.ts
@@ -0,0 +1,14 @@
+/** community_ecology encoding module — tsb analytics library. */
+export interface CommunityEcologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyEncodingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyEncoding(data: number[], opts: CommunityEcologyEncodingOptions = {}): CommunityEcologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyEncoding };
diff --git a/src/community_ecology/ensemble.ts b/src/community_ecology/ensemble.ts
new file mode 100644
index 000000000..9973e8e92
--- /dev/null
+++ b/src/community_ecology/ensemble.ts
@@ -0,0 +1,14 @@
+/** community_ecology ensemble module — tsb analytics library. */
+export interface CommunityEcologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyEnsemble(data: number[], opts: CommunityEcologyEnsembleOptions = {}): CommunityEcologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyEnsemble };
diff --git a/src/community_ecology/estimation.ts b/src/community_ecology/estimation.ts
new file mode 100644
index 000000000..6b46ef0ad
--- /dev/null
+++ b/src/community_ecology/estimation.ts
@@ -0,0 +1,14 @@
+/** community_ecology estimation module — tsb analytics library. */
+export interface CommunityEcologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyEstimationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyEstimation(data: number[], opts: CommunityEcologyEstimationOptions = {}): CommunityEcologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyEstimation };
diff --git a/src/community_ecology/evaluation.ts b/src/community_ecology/evaluation.ts
new file mode 100644
index 000000000..bb8df30eb
--- /dev/null
+++ b/src/community_ecology/evaluation.ts
@@ -0,0 +1,14 @@
+/** community_ecology evaluation module — tsb analytics library. */
+export interface CommunityEcologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyEvaluation(data: number[], opts: CommunityEcologyEvaluationOptions = {}): CommunityEcologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyEvaluation };
diff --git a/src/community_ecology/extrapolation.ts b/src/community_ecology/extrapolation.ts
new file mode 100644
index 000000000..e96670c01
--- /dev/null
+++ b/src/community_ecology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** community_ecology extrapolation module — tsb analytics library. */
+export interface CommunityEcologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyExtrapolation(data: number[], opts: CommunityEcologyExtrapolationOptions = {}): CommunityEcologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyExtrapolation };
diff --git a/src/community_ecology/features.ts b/src/community_ecology/features.ts
new file mode 100644
index 000000000..90fd74b8c
--- /dev/null
+++ b/src/community_ecology/features.ts
@@ -0,0 +1,14 @@
+/** community_ecology features module — tsb analytics library. */
+export interface CommunityEcologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyFeatures(data: number[], opts: CommunityEcologyFeaturesOptions = {}): CommunityEcologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyFeatures };
diff --git a/src/community_ecology/feedback.ts b/src/community_ecology/feedback.ts
new file mode 100644
index 000000000..a9d7ea43b
--- /dev/null
+++ b/src/community_ecology/feedback.ts
@@ -0,0 +1,14 @@
+/** community_ecology feedback module — tsb analytics library. */
+export interface CommunityEcologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyFeedback(data: number[], opts: CommunityEcologyFeedbackOptions = {}): CommunityEcologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyFeedback };
diff --git a/src/community_ecology/filtering.ts b/src/community_ecology/filtering.ts
new file mode 100644
index 000000000..e1fbc91e2
--- /dev/null
+++ b/src/community_ecology/filtering.ts
@@ -0,0 +1,14 @@
+/** community_ecology filtering module — tsb analytics library. */
+export interface CommunityEcologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyFilteringResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyFiltering(data: number[], opts: CommunityEcologyFilteringOptions = {}): CommunityEcologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyFiltering };
diff --git a/src/community_ecology/fourier.ts b/src/community_ecology/fourier.ts
new file mode 100644
index 000000000..75cadd98c
--- /dev/null
+++ b/src/community_ecology/fourier.ts
@@ -0,0 +1,14 @@
+/** community_ecology fourier module — tsb analytics library. */
+export interface CommunityEcologyFourierOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyFourierResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyFourier(data: number[], opts: CommunityEcologyFourierOptions = {}): CommunityEcologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyFourier };
diff --git a/src/community_ecology/fusion.ts b/src/community_ecology/fusion.ts
new file mode 100644
index 000000000..a46bdbc82
--- /dev/null
+++ b/src/community_ecology/fusion.ts
@@ -0,0 +1,14 @@
+/** community_ecology fusion module — tsb analytics library. */
+export interface CommunityEcologyFusionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyFusionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyFusion(data: number[], opts: CommunityEcologyFusionOptions = {}): CommunityEcologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyFusion };
diff --git a/src/community_ecology/generation.ts b/src/community_ecology/generation.ts
new file mode 100644
index 000000000..899090cda
--- /dev/null
+++ b/src/community_ecology/generation.ts
@@ -0,0 +1,14 @@
+/** community_ecology generation module — tsb analytics library. */
+export interface CommunityEcologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyGenerationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyGeneration(data: number[], opts: CommunityEcologyGenerationOptions = {}): CommunityEcologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyGeneration };
diff --git a/src/community_ecology/geometry.ts b/src/community_ecology/geometry.ts
new file mode 100644
index 000000000..b03f6ef59
--- /dev/null
+++ b/src/community_ecology/geometry.ts
@@ -0,0 +1,14 @@
+/** community_ecology geometry module — tsb analytics library. */
+export interface CommunityEcologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyGeometryResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyGeometry(data: number[], opts: CommunityEcologyGeometryOptions = {}): CommunityEcologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyGeometry };
diff --git a/src/community_ecology/gradient.ts b/src/community_ecology/gradient.ts
new file mode 100644
index 000000000..d601aeb59
--- /dev/null
+++ b/src/community_ecology/gradient.ts
@@ -0,0 +1,14 @@
+/** community_ecology gradient module — tsb analytics library. */
+export interface CommunityEcologyGradientOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyGradientResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyGradient(data: number[], opts: CommunityEcologyGradientOptions = {}): CommunityEcologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyGradient };
diff --git a/src/community_ecology/hessian.ts b/src/community_ecology/hessian.ts
new file mode 100644
index 000000000..4fb8cc71d
--- /dev/null
+++ b/src/community_ecology/hessian.ts
@@ -0,0 +1,14 @@
+/** community_ecology hessian module — tsb analytics library. */
+export interface CommunityEcologyHessianOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyHessianResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyHessian(data: number[], opts: CommunityEcologyHessianOptions = {}): CommunityEcologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyHessian };
diff --git a/src/community_ecology/hypothesis.ts b/src/community_ecology/hypothesis.ts
new file mode 100644
index 000000000..b56c54092
--- /dev/null
+++ b/src/community_ecology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** community_ecology hypothesis module — tsb analytics library. */
+export interface CommunityEcologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyHypothesis(data: number[], opts: CommunityEcologyHypothesisOptions = {}): CommunityEcologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyHypothesis };
diff --git a/src/community_ecology/inference.ts b/src/community_ecology/inference.ts
new file mode 100644
index 000000000..119acf505
--- /dev/null
+++ b/src/community_ecology/inference.ts
@@ -0,0 +1,14 @@
+/** community_ecology inference module — tsb analytics library. */
+export interface CommunityEcologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyInferenceResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyInference(data: number[], opts: CommunityEcologyInferenceOptions = {}): CommunityEcologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyInference };
diff --git a/src/community_ecology/inference2.ts b/src/community_ecology/inference2.ts
new file mode 100644
index 000000000..5d5da5828
--- /dev/null
+++ b/src/community_ecology/inference2.ts
@@ -0,0 +1,14 @@
+/** community_ecology inference2 module — tsb analytics library. */
+export interface CommunityEcologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyInferenceResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyInference(data: number[], opts: CommunityEcologyInferenceOptions = {}): CommunityEcologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyInference };
diff --git a/src/community_ecology/integral.ts b/src/community_ecology/integral.ts
new file mode 100644
index 000000000..f322b8afb
--- /dev/null
+++ b/src/community_ecology/integral.ts
@@ -0,0 +1,14 @@
+/** community_ecology integral module — tsb analytics library. */
+export interface CommunityEcologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyIntegralResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyIntegral(data: number[], opts: CommunityEcologyIntegralOptions = {}): CommunityEcologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyIntegral };
diff --git a/src/community_ecology/integration.ts b/src/community_ecology/integration.ts
new file mode 100644
index 000000000..db7a66bc6
--- /dev/null
+++ b/src/community_ecology/integration.ts
@@ -0,0 +1,14 @@
+/** community_ecology integration module — tsb analytics library. */
+export interface CommunityEcologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyIntegration(data: number[], opts: CommunityEcologyIntegrationOptions = {}): CommunityEcologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyIntegration };
diff --git a/src/community_ecology/interpolation.ts b/src/community_ecology/interpolation.ts
new file mode 100644
index 000000000..97c733416
--- /dev/null
+++ b/src/community_ecology/interpolation.ts
@@ -0,0 +1,14 @@
+/** community_ecology interpolation module — tsb analytics library. */
+export interface CommunityEcologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyInterpolation(data: number[], opts: CommunityEcologyInterpolationOptions = {}): CommunityEcologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyInterpolation };
diff --git a/src/community_ecology/jacobian.ts b/src/community_ecology/jacobian.ts
new file mode 100644
index 000000000..7aa7bcaad
--- /dev/null
+++ b/src/community_ecology/jacobian.ts
@@ -0,0 +1,14 @@
+/** community_ecology jacobian module — tsb analytics library. */
+export interface CommunityEcologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyJacobianResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyJacobian(data: number[], opts: CommunityEcologyJacobianOptions = {}): CommunityEcologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyJacobian };
diff --git a/src/community_ecology/kernel.ts b/src/community_ecology/kernel.ts
new file mode 100644
index 000000000..bdb5a6f36
--- /dev/null
+++ b/src/community_ecology/kernel.ts
@@ -0,0 +1,14 @@
+/** community_ecology kernel module — tsb analytics library. */
+export interface CommunityEcologyKernelOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyKernelResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyKernel(data: number[], opts: CommunityEcologyKernelOptions = {}): CommunityEcologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyKernel };
diff --git a/src/community_ecology/laplacian.ts b/src/community_ecology/laplacian.ts
new file mode 100644
index 000000000..506b218bf
--- /dev/null
+++ b/src/community_ecology/laplacian.ts
@@ -0,0 +1,14 @@
+/** community_ecology laplacian module — tsb analytics library. */
+export interface CommunityEcologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyLaplacian(data: number[], opts: CommunityEcologyLaplacianOptions = {}): CommunityEcologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyLaplacian };
diff --git a/src/community_ecology/learning.ts b/src/community_ecology/learning.ts
new file mode 100644
index 000000000..4cd4f0cce
--- /dev/null
+++ b/src/community_ecology/learning.ts
@@ -0,0 +1,14 @@
+/** community_ecology learning module — tsb analytics library. */
+export interface CommunityEcologyLearningOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyLearningResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyLearning(data: number[], opts: CommunityEcologyLearningOptions = {}): CommunityEcologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyLearning };
diff --git a/src/community_ecology/linear.ts b/src/community_ecology/linear.ts
new file mode 100644
index 000000000..fcec6fc76
--- /dev/null
+++ b/src/community_ecology/linear.ts
@@ -0,0 +1,14 @@
+/** community_ecology linear module — tsb analytics library. */
+export interface CommunityEcologyLinearOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyLinearResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyLinear(data: number[], opts: CommunityEcologyLinearOptions = {}): CommunityEcologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyLinear };
diff --git a/src/community_ecology/manifold.ts b/src/community_ecology/manifold.ts
new file mode 100644
index 000000000..8a33603b9
--- /dev/null
+++ b/src/community_ecology/manifold.ts
@@ -0,0 +1,14 @@
+/** community_ecology manifold module — tsb analytics library. */
+export interface CommunityEcologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyManifoldResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyManifold(data: number[], opts: CommunityEcologyManifoldOptions = {}): CommunityEcologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyManifold };
diff --git a/src/community_ecology/matching.ts b/src/community_ecology/matching.ts
new file mode 100644
index 000000000..3e3389c35
--- /dev/null
+++ b/src/community_ecology/matching.ts
@@ -0,0 +1,14 @@
+/** community_ecology matching module — tsb analytics library. */
+export interface CommunityEcologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyMatchingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyMatching(data: number[], opts: CommunityEcologyMatchingOptions = {}): CommunityEcologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyMatching };
diff --git a/src/community_ecology/measurement.ts b/src/community_ecology/measurement.ts
new file mode 100644
index 000000000..b03a0c3ce
--- /dev/null
+++ b/src/community_ecology/measurement.ts
@@ -0,0 +1,14 @@
+/** community_ecology measurement module — tsb analytics library. */
+export interface CommunityEcologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyMeasurement(data: number[], opts: CommunityEcologyMeasurementOptions = {}): CommunityEcologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyMeasurement };
diff --git a/src/community_ecology/metrics.ts b/src/community_ecology/metrics.ts
new file mode 100644
index 000000000..503a3eea7
--- /dev/null
+++ b/src/community_ecology/metrics.ts
@@ -0,0 +1,14 @@
+/** community_ecology metrics module — tsb analytics library. */
+export interface CommunityEcologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyMetricsResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyMetrics(data: number[], opts: CommunityEcologyMetricsOptions = {}): CommunityEcologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyMetrics };
diff --git a/src/community_ecology/modeling.ts b/src/community_ecology/modeling.ts
new file mode 100644
index 000000000..6c5dda090
--- /dev/null
+++ b/src/community_ecology/modeling.ts
@@ -0,0 +1,14 @@
+/** community_ecology modeling module — tsb analytics library. */
+export interface CommunityEcologyModelingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyModelingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyModeling(data: number[], opts: CommunityEcologyModelingOptions = {}): CommunityEcologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyModeling };
diff --git a/src/community_ecology/monitoring.ts b/src/community_ecology/monitoring.ts
new file mode 100644
index 000000000..8026f738f
--- /dev/null
+++ b/src/community_ecology/monitoring.ts
@@ -0,0 +1,14 @@
+/** community_ecology monitoring module — tsb analytics library. */
+export interface CommunityEcologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyMonitoring(data: number[], opts: CommunityEcologyMonitoringOptions = {}): CommunityEcologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyMonitoring };
diff --git a/src/community_ecology/nonlinear.ts b/src/community_ecology/nonlinear.ts
new file mode 100644
index 000000000..ce5d53a05
--- /dev/null
+++ b/src/community_ecology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** community_ecology nonlinear module — tsb analytics library. */
+export interface CommunityEcologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyNonlinear(data: number[], opts: CommunityEcologyNonlinearOptions = {}): CommunityEcologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyNonlinear };
diff --git a/src/community_ecology/normalization.ts b/src/community_ecology/normalization.ts
new file mode 100644
index 000000000..33e70f03d
--- /dev/null
+++ b/src/community_ecology/normalization.ts
@@ -0,0 +1,14 @@
+/** community_ecology normalization module — tsb analytics library. */
+export interface CommunityEcologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyNormalization(data: number[], opts: CommunityEcologyNormalizationOptions = {}): CommunityEcologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyNormalization };
diff --git a/src/community_ecology/optimization.ts b/src/community_ecology/optimization.ts
new file mode 100644
index 000000000..678994141
--- /dev/null
+++ b/src/community_ecology/optimization.ts
@@ -0,0 +1,14 @@
+/** community_ecology optimization module — tsb analytics library. */
+export interface CommunityEcologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyOptimization(data: number[], opts: CommunityEcologyOptimizationOptions = {}): CommunityEcologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyOptimization };
diff --git a/src/community_ecology/patterns.ts b/src/community_ecology/patterns.ts
new file mode 100644
index 000000000..c8dde378e
--- /dev/null
+++ b/src/community_ecology/patterns.ts
@@ -0,0 +1,14 @@
+/** community_ecology patterns module — tsb analytics library. */
+export interface CommunityEcologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyPatternsResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyPatterns(data: number[], opts: CommunityEcologyPatternsOptions = {}): CommunityEcologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyPatterns };
diff --git a/src/community_ecology/permutation.ts b/src/community_ecology/permutation.ts
new file mode 100644
index 000000000..c40cd4903
--- /dev/null
+++ b/src/community_ecology/permutation.ts
@@ -0,0 +1,14 @@
+/** community_ecology permutation module — tsb analytics library. */
+export interface CommunityEcologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyPermutationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyPermutation(data: number[], opts: CommunityEcologyPermutationOptions = {}): CommunityEcologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyPermutation };
diff --git a/src/community_ecology/prediction.ts b/src/community_ecology/prediction.ts
new file mode 100644
index 000000000..e4e973e54
--- /dev/null
+++ b/src/community_ecology/prediction.ts
@@ -0,0 +1,14 @@
+/** community_ecology prediction module — tsb analytics library. */
+export interface CommunityEcologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyPredictionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyPrediction(data: number[], opts: CommunityEcologyPredictionOptions = {}): CommunityEcologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyPrediction };
diff --git a/src/community_ecology/processing.ts b/src/community_ecology/processing.ts
new file mode 100644
index 000000000..d0c63ecb6
--- /dev/null
+++ b/src/community_ecology/processing.ts
@@ -0,0 +1,14 @@
+/** community_ecology processing module — tsb analytics library. */
+export interface CommunityEcologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyProcessingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyProcessing(data: number[], opts: CommunityEcologyProcessingOptions = {}): CommunityEcologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyProcessing };
diff --git a/src/community_ecology/profiling.ts b/src/community_ecology/profiling.ts
new file mode 100644
index 000000000..5b7549d32
--- /dev/null
+++ b/src/community_ecology/profiling.ts
@@ -0,0 +1,14 @@
+/** community_ecology profiling module — tsb analytics library. */
+export interface CommunityEcologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyProfilingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyProfiling(data: number[], opts: CommunityEcologyProfilingOptions = {}): CommunityEcologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyProfiling };
diff --git a/src/community_ecology/projection.ts b/src/community_ecology/projection.ts
new file mode 100644
index 000000000..93feaa372
--- /dev/null
+++ b/src/community_ecology/projection.ts
@@ -0,0 +1,14 @@
+/** community_ecology projection module — tsb analytics library. */
+export interface CommunityEcologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyProjectionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyProjection(data: number[], opts: CommunityEcologyProjectionOptions = {}): CommunityEcologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyProjection };
diff --git a/src/community_ecology/ranking.ts b/src/community_ecology/ranking.ts
new file mode 100644
index 000000000..ead94661e
--- /dev/null
+++ b/src/community_ecology/ranking.ts
@@ -0,0 +1,14 @@
+/** community_ecology ranking module — tsb analytics library. */
+export interface CommunityEcologyRankingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyRankingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyRanking(data: number[], opts: CommunityEcologyRankingOptions = {}): CommunityEcologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyRanking };
diff --git a/src/community_ecology/reconstruction.ts b/src/community_ecology/reconstruction.ts
new file mode 100644
index 000000000..f2a85cd38
--- /dev/null
+++ b/src/community_ecology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** community_ecology reconstruction module — tsb analytics library. */
+export interface CommunityEcologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyReconstruction(data: number[], opts: CommunityEcologyReconstructionOptions = {}): CommunityEcologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyReconstruction };
diff --git a/src/community_ecology/registration.ts b/src/community_ecology/registration.ts
new file mode 100644
index 000000000..08847eb66
--- /dev/null
+++ b/src/community_ecology/registration.ts
@@ -0,0 +1,14 @@
+/** community_ecology registration module — tsb analytics library. */
+export interface CommunityEcologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyRegistration(data: number[], opts: CommunityEcologyRegistrationOptions = {}): CommunityEcologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyRegistration };
diff --git a/src/community_ecology/regression.ts b/src/community_ecology/regression.ts
new file mode 100644
index 000000000..4f5bd6f70
--- /dev/null
+++ b/src/community_ecology/regression.ts
@@ -0,0 +1,14 @@
+/** community_ecology regression module — tsb analytics library. */
+export interface CommunityEcologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyRegressionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyRegression(data: number[], opts: CommunityEcologyRegressionOptions = {}): CommunityEcologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyRegression };
diff --git a/src/community_ecology/regularization.ts b/src/community_ecology/regularization.ts
new file mode 100644
index 000000000..3bdb91094
--- /dev/null
+++ b/src/community_ecology/regularization.ts
@@ -0,0 +1,14 @@
+/** community_ecology regularization module — tsb analytics library. */
+export interface CommunityEcologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyRegularization(data: number[], opts: CommunityEcologyRegularizationOptions = {}): CommunityEcologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyRegularization };
diff --git a/src/community_ecology/robustness.ts b/src/community_ecology/robustness.ts
new file mode 100644
index 000000000..43a7c0479
--- /dev/null
+++ b/src/community_ecology/robustness.ts
@@ -0,0 +1,14 @@
+/** community_ecology robustness module — tsb analytics library. */
+export interface CommunityEcologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyRobustness(data: number[], opts: CommunityEcologyRobustnessOptions = {}): CommunityEcologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyRobustness };
diff --git a/src/community_ecology/sampling.ts b/src/community_ecology/sampling.ts
new file mode 100644
index 000000000..e9543aa9b
--- /dev/null
+++ b/src/community_ecology/sampling.ts
@@ -0,0 +1,14 @@
+/** community_ecology sampling module — tsb analytics library. */
+export interface CommunityEcologySamplingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologySamplingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologySampling(data: number[], opts: CommunityEcologySamplingOptions = {}): CommunityEcologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologySampling };
diff --git a/src/community_ecology/sampling2.ts b/src/community_ecology/sampling2.ts
new file mode 100644
index 000000000..941f9f010
--- /dev/null
+++ b/src/community_ecology/sampling2.ts
@@ -0,0 +1,14 @@
+/** community_ecology sampling2 module — tsb analytics library. */
+export interface CommunityEcologySamplingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologySamplingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologySampling(data: number[], opts: CommunityEcologySamplingOptions = {}): CommunityEcologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologySampling };
diff --git a/src/community_ecology/scaling.ts b/src/community_ecology/scaling.ts
new file mode 100644
index 000000000..225b053c7
--- /dev/null
+++ b/src/community_ecology/scaling.ts
@@ -0,0 +1,14 @@
+/** community_ecology scaling module — tsb analytics library. */
+export interface CommunityEcologyScalingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyScalingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyScaling(data: number[], opts: CommunityEcologyScalingOptions = {}): CommunityEcologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyScaling };
diff --git a/src/community_ecology/scoring.ts b/src/community_ecology/scoring.ts
new file mode 100644
index 000000000..09ab302a8
--- /dev/null
+++ b/src/community_ecology/scoring.ts
@@ -0,0 +1,14 @@
+/** community_ecology scoring module — tsb analytics library. */
+export interface CommunityEcologyScoringOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyScoringResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyScoring(data: number[], opts: CommunityEcologyScoringOptions = {}): CommunityEcologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyScoring };
diff --git a/src/community_ecology/segmentation.ts b/src/community_ecology/segmentation.ts
new file mode 100644
index 000000000..5e0c0ae59
--- /dev/null
+++ b/src/community_ecology/segmentation.ts
@@ -0,0 +1,14 @@
+/** community_ecology segmentation module — tsb analytics library. */
+export interface CommunityEcologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologySegmentationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologySegmentation(data: number[], opts: CommunityEcologySegmentationOptions = {}): CommunityEcologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologySegmentation };
diff --git a/src/community_ecology/selection.ts b/src/community_ecology/selection.ts
new file mode 100644
index 000000000..b2ea106bd
--- /dev/null
+++ b/src/community_ecology/selection.ts
@@ -0,0 +1,14 @@
+/** community_ecology selection module — tsb analytics library. */
+export interface CommunityEcologySelectionOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologySelectionResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologySelection(data: number[], opts: CommunityEcologySelectionOptions = {}): CommunityEcologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologySelection };
diff --git a/src/community_ecology/sensitivity.ts b/src/community_ecology/sensitivity.ts
new file mode 100644
index 000000000..c7d49d342
--- /dev/null
+++ b/src/community_ecology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** community_ecology sensitivity module — tsb analytics library. */
+export interface CommunityEcologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologySensitivityResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologySensitivity(data: number[], opts: CommunityEcologySensitivityOptions = {}): CommunityEcologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologySensitivity };
diff --git a/src/community_ecology/simulation.ts b/src/community_ecology/simulation.ts
new file mode 100644
index 000000000..a836340de
--- /dev/null
+++ b/src/community_ecology/simulation.ts
@@ -0,0 +1,14 @@
+/** community_ecology simulation module — tsb analytics library. */
+export interface CommunityEcologySimulationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologySimulationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologySimulation(data: number[], opts: CommunityEcologySimulationOptions = {}): CommunityEcologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologySimulation };
diff --git a/src/community_ecology/smoothing.ts b/src/community_ecology/smoothing.ts
new file mode 100644
index 000000000..3509a8583
--- /dev/null
+++ b/src/community_ecology/smoothing.ts
@@ -0,0 +1,14 @@
+/** community_ecology smoothing module — tsb analytics library. */
+export interface CommunityEcologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologySmoothingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologySmoothing(data: number[], opts: CommunityEcologySmoothingOptions = {}): CommunityEcologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologySmoothing };
diff --git a/src/community_ecology/stability.ts b/src/community_ecology/stability.ts
new file mode 100644
index 000000000..bd5ca957f
--- /dev/null
+++ b/src/community_ecology/stability.ts
@@ -0,0 +1,14 @@
+/** community_ecology stability module — tsb analytics library. */
+export interface CommunityEcologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyStabilityResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyStability(data: number[], opts: CommunityEcologyStabilityOptions = {}): CommunityEcologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyStability };
diff --git a/src/community_ecology/stacking.ts b/src/community_ecology/stacking.ts
new file mode 100644
index 000000000..426ae0f0f
--- /dev/null
+++ b/src/community_ecology/stacking.ts
@@ -0,0 +1,14 @@
+/** community_ecology stacking module — tsb analytics library. */
+export interface CommunityEcologyStackingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyStackingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyStacking(data: number[], opts: CommunityEcologyStackingOptions = {}): CommunityEcologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyStacking };
diff --git a/src/community_ecology/standardization.ts b/src/community_ecology/standardization.ts
new file mode 100644
index 000000000..edbff40a6
--- /dev/null
+++ b/src/community_ecology/standardization.ts
@@ -0,0 +1,14 @@
+/** community_ecology standardization module — tsb analytics library. */
+export interface CommunityEcologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyStandardization(data: number[], opts: CommunityEcologyStandardizationOptions = {}): CommunityEcologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyStandardization };
diff --git a/src/community_ecology/static.ts b/src/community_ecology/static.ts
new file mode 100644
index 000000000..83a702c5d
--- /dev/null
+++ b/src/community_ecology/static.ts
@@ -0,0 +1,14 @@
+/** community_ecology static module — tsb analytics library. */
+export interface CommunityEcologyStaticOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyStaticResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyStatic(data: number[], opts: CommunityEcologyStaticOptions = {}): CommunityEcologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyStatic };
diff --git a/src/community_ecology/stochastic.ts b/src/community_ecology/stochastic.ts
new file mode 100644
index 000000000..c13508744
--- /dev/null
+++ b/src/community_ecology/stochastic.ts
@@ -0,0 +1,14 @@
+/** community_ecology stochastic module — tsb analytics library. */
+export interface CommunityEcologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyStochasticResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyStochastic(data: number[], opts: CommunityEcologyStochasticOptions = {}): CommunityEcologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyStochastic };
diff --git a/src/community_ecology/synthesis.ts b/src/community_ecology/synthesis.ts
new file mode 100644
index 000000000..2807a1106
--- /dev/null
+++ b/src/community_ecology/synthesis.ts
@@ -0,0 +1,14 @@
+/** community_ecology synthesis module — tsb analytics library. */
+export interface CommunityEcologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologySynthesisResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologySynthesis(data: number[], opts: CommunityEcologySynthesisOptions = {}): CommunityEcologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologySynthesis };
diff --git a/src/community_ecology/topology.ts b/src/community_ecology/topology.ts
new file mode 100644
index 000000000..80adb1ca9
--- /dev/null
+++ b/src/community_ecology/topology.ts
@@ -0,0 +1,14 @@
+/** community_ecology topology module — tsb analytics library. */
+export interface CommunityEcologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyTopologyResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyTopology(data: number[], opts: CommunityEcologyTopologyOptions = {}): CommunityEcologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyTopology };
diff --git a/src/community_ecology/tracking.ts b/src/community_ecology/tracking.ts
new file mode 100644
index 000000000..1700843d2
--- /dev/null
+++ b/src/community_ecology/tracking.ts
@@ -0,0 +1,14 @@
+/** community_ecology tracking module — tsb analytics library. */
+export interface CommunityEcologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyTrackingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyTracking(data: number[], opts: CommunityEcologyTrackingOptions = {}): CommunityEcologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyTracking };
diff --git a/src/community_ecology/transform.ts b/src/community_ecology/transform.ts
new file mode 100644
index 000000000..c5c115aaa
--- /dev/null
+++ b/src/community_ecology/transform.ts
@@ -0,0 +1,14 @@
+/** community_ecology transform module — tsb analytics library. */
+export interface CommunityEcologyTransformOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyTransformResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyTransform(data: number[], opts: CommunityEcologyTransformOptions = {}): CommunityEcologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyTransform };
diff --git a/src/community_ecology/uncertainty.ts b/src/community_ecology/uncertainty.ts
new file mode 100644
index 000000000..3666a2ecf
--- /dev/null
+++ b/src/community_ecology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** community_ecology uncertainty module — tsb analytics library. */
+export interface CommunityEcologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyUncertainty(data: number[], opts: CommunityEcologyUncertaintyOptions = {}): CommunityEcologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyUncertainty };
diff --git a/src/community_ecology/validation.ts b/src/community_ecology/validation.ts
new file mode 100644
index 000000000..87aeab428
--- /dev/null
+++ b/src/community_ecology/validation.ts
@@ -0,0 +1,14 @@
+/** community_ecology validation module — tsb analytics library. */
+export interface CommunityEcologyValidationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyValidationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyValidation(data: number[], opts: CommunityEcologyValidationOptions = {}): CommunityEcologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyValidation };
diff --git a/src/community_ecology/verification.ts b/src/community_ecology/verification.ts
new file mode 100644
index 000000000..7e3fae976
--- /dev/null
+++ b/src/community_ecology/verification.ts
@@ -0,0 +1,14 @@
+/** community_ecology verification module — tsb analytics library. */
+export interface CommunityEcologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyVerificationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyVerification(data: number[], opts: CommunityEcologyVerificationOptions = {}): CommunityEcologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyVerification };
diff --git a/src/community_ecology/visualization.ts b/src/community_ecology/visualization.ts
new file mode 100644
index 000000000..a49c068c5
--- /dev/null
+++ b/src/community_ecology/visualization.ts
@@ -0,0 +1,14 @@
+/** community_ecology visualization module — tsb analytics library. */
+export interface CommunityEcologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyVisualization(data: number[], opts: CommunityEcologyVisualizationOptions = {}): CommunityEcologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyVisualization };
diff --git a/src/community_ecology/voting.ts b/src/community_ecology/voting.ts
new file mode 100644
index 000000000..362afb744
--- /dev/null
+++ b/src/community_ecology/voting.ts
@@ -0,0 +1,14 @@
+/** community_ecology voting module — tsb analytics library. */
+export interface CommunityEcologyVotingOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyVotingResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyVoting(data: number[], opts: CommunityEcologyVotingOptions = {}): CommunityEcologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyVoting };
diff --git a/src/community_ecology/wavelet.ts b/src/community_ecology/wavelet.ts
new file mode 100644
index 000000000..640685310
--- /dev/null
+++ b/src/community_ecology/wavelet.ts
@@ -0,0 +1,14 @@
+/** community_ecology wavelet module — tsb analytics library. */
+export interface CommunityEcologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface CommunityEcologyWaveletResult { values: number[]; converged: boolean; }
+export function computeCommunityEcologyWavelet(data: number[], opts: CommunityEcologyWaveletOptions = {}): CommunityEcologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCommunityEcologyWavelet };
diff --git a/src/composite_materials/adaptation.ts b/src/composite_materials/adaptation.ts
new file mode 100644
index 000000000..40296732c
--- /dev/null
+++ b/src/composite_materials/adaptation.ts
@@ -0,0 +1,14 @@
+/** composite_materials adaptation module — tsb analytics library. */
+export interface CompositeMaterialsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsAdaptationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsAdaptation(data: number[], opts: CompositeMaterialsAdaptationOptions = {}): CompositeMaterialsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsAdaptation };
diff --git a/src/composite_materials/aggregation.ts b/src/composite_materials/aggregation.ts
new file mode 100644
index 000000000..06bcfc096
--- /dev/null
+++ b/src/composite_materials/aggregation.ts
@@ -0,0 +1,14 @@
+/** composite_materials aggregation module — tsb analytics library. */
+export interface CompositeMaterialsAggregationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsAggregationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsAggregation(data: number[], opts: CompositeMaterialsAggregationOptions = {}): CompositeMaterialsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsAggregation };
diff --git a/src/composite_materials/algebra.ts b/src/composite_materials/algebra.ts
new file mode 100644
index 000000000..1919b97e8
--- /dev/null
+++ b/src/composite_materials/algebra.ts
@@ -0,0 +1,14 @@
+/** composite_materials algebra module — tsb analytics library. */
+export interface CompositeMaterialsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsAlgebraResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsAlgebra(data: number[], opts: CompositeMaterialsAlgebraOptions = {}): CompositeMaterialsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsAlgebra };
diff --git a/src/composite_materials/alignment.ts b/src/composite_materials/alignment.ts
new file mode 100644
index 000000000..020b1b085
--- /dev/null
+++ b/src/composite_materials/alignment.ts
@@ -0,0 +1,14 @@
+/** composite_materials alignment module — tsb analytics library. */
+export interface CompositeMaterialsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsAlignmentResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsAlignment(data: number[], opts: CompositeMaterialsAlignmentOptions = {}): CompositeMaterialsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsAlignment };
diff --git a/src/composite_materials/analysis.ts b/src/composite_materials/analysis.ts
new file mode 100644
index 000000000..5c543d6f5
--- /dev/null
+++ b/src/composite_materials/analysis.ts
@@ -0,0 +1,14 @@
+/** composite_materials analysis module — tsb analytics library. */
+export interface CompositeMaterialsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsAnalysisResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsAnalysis(data: number[], opts: CompositeMaterialsAnalysisOptions = {}): CompositeMaterialsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsAnalysis };
diff --git a/src/composite_materials/augmentation.ts b/src/composite_materials/augmentation.ts
new file mode 100644
index 000000000..81e12c1ef
--- /dev/null
+++ b/src/composite_materials/augmentation.ts
@@ -0,0 +1,14 @@
+/** composite_materials augmentation module — tsb analytics library. */
+export interface CompositeMaterialsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsAugmentationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsAugmentation(data: number[], opts: CompositeMaterialsAugmentationOptions = {}): CompositeMaterialsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsAugmentation };
diff --git a/src/composite_materials/bagging.ts b/src/composite_materials/bagging.ts
new file mode 100644
index 000000000..d21918995
--- /dev/null
+++ b/src/composite_materials/bagging.ts
@@ -0,0 +1,14 @@
+/** composite_materials bagging module — tsb analytics library. */
+export interface CompositeMaterialsBaggingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsBaggingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsBagging(data: number[], opts: CompositeMaterialsBaggingOptions = {}): CompositeMaterialsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsBagging };
diff --git a/src/composite_materials/basis.ts b/src/composite_materials/basis.ts
new file mode 100644
index 000000000..4d75b26b6
--- /dev/null
+++ b/src/composite_materials/basis.ts
@@ -0,0 +1,14 @@
+/** composite_materials basis module — tsb analytics library. */
+export interface CompositeMaterialsBasisOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsBasisResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsBasis(data: number[], opts: CompositeMaterialsBasisOptions = {}): CompositeMaterialsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsBasis };
diff --git a/src/composite_materials/benchmarking.ts b/src/composite_materials/benchmarking.ts
new file mode 100644
index 000000000..9443b2230
--- /dev/null
+++ b/src/composite_materials/benchmarking.ts
@@ -0,0 +1,14 @@
+/** composite_materials benchmarking module — tsb analytics library. */
+export interface CompositeMaterialsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsBenchmarking(data: number[], opts: CompositeMaterialsBenchmarkingOptions = {}): CompositeMaterialsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsBenchmarking };
diff --git a/src/composite_materials/blending.ts b/src/composite_materials/blending.ts
new file mode 100644
index 000000000..63fdd934e
--- /dev/null
+++ b/src/composite_materials/blending.ts
@@ -0,0 +1,14 @@
+/** composite_materials blending module — tsb analytics library. */
+export interface CompositeMaterialsBlendingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsBlendingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsBlending(data: number[], opts: CompositeMaterialsBlendingOptions = {}): CompositeMaterialsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsBlending };
diff --git a/src/composite_materials/boosting.ts b/src/composite_materials/boosting.ts
new file mode 100644
index 000000000..90795a0c3
--- /dev/null
+++ b/src/composite_materials/boosting.ts
@@ -0,0 +1,14 @@
+/** composite_materials boosting module — tsb analytics library. */
+export interface CompositeMaterialsBoostingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsBoostingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsBoosting(data: number[], opts: CompositeMaterialsBoostingOptions = {}): CompositeMaterialsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsBoosting };
diff --git a/src/composite_materials/bootstrap.ts b/src/composite_materials/bootstrap.ts
new file mode 100644
index 000000000..42235faaa
--- /dev/null
+++ b/src/composite_materials/bootstrap.ts
@@ -0,0 +1,14 @@
+/** composite_materials bootstrap module — tsb analytics library. */
+export interface CompositeMaterialsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsBootstrapResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsBootstrap(data: number[], opts: CompositeMaterialsBootstrapOptions = {}): CompositeMaterialsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsBootstrap };
diff --git a/src/composite_materials/calculus.ts b/src/composite_materials/calculus.ts
new file mode 100644
index 000000000..8416cbfab
--- /dev/null
+++ b/src/composite_materials/calculus.ts
@@ -0,0 +1,14 @@
+/** composite_materials calculus module — tsb analytics library. */
+export interface CompositeMaterialsCalculusOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsCalculusResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsCalculus(data: number[], opts: CompositeMaterialsCalculusOptions = {}): CompositeMaterialsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsCalculus };
diff --git a/src/composite_materials/calibration.ts b/src/composite_materials/calibration.ts
new file mode 100644
index 000000000..6b9edded1
--- /dev/null
+++ b/src/composite_materials/calibration.ts
@@ -0,0 +1,14 @@
+/** composite_materials calibration module — tsb analytics library. */
+export interface CompositeMaterialsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsCalibrationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsCalibration(data: number[], opts: CompositeMaterialsCalibrationOptions = {}): CompositeMaterialsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsCalibration };
diff --git a/src/composite_materials/characterization.ts b/src/composite_materials/characterization.ts
new file mode 100644
index 000000000..451c35e94
--- /dev/null
+++ b/src/composite_materials/characterization.ts
@@ -0,0 +1,14 @@
+/** composite_materials characterization module — tsb analytics library. */
+export interface CompositeMaterialsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsCharacterization(data: number[], opts: CompositeMaterialsCharacterizationOptions = {}): CompositeMaterialsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsCharacterization };
diff --git a/src/composite_materials/classification.ts b/src/composite_materials/classification.ts
new file mode 100644
index 000000000..252637deb
--- /dev/null
+++ b/src/composite_materials/classification.ts
@@ -0,0 +1,14 @@
+/** composite_materials classification module — tsb analytics library. */
+export interface CompositeMaterialsClassificationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsClassificationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsClassification(data: number[], opts: CompositeMaterialsClassificationOptions = {}): CompositeMaterialsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsClassification };
diff --git a/src/composite_materials/clustering.ts b/src/composite_materials/clustering.ts
new file mode 100644
index 000000000..d13c48751
--- /dev/null
+++ b/src/composite_materials/clustering.ts
@@ -0,0 +1,14 @@
+/** composite_materials clustering module — tsb analytics library. */
+export interface CompositeMaterialsClusteringOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsClusteringResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsClustering(data: number[], opts: CompositeMaterialsClusteringOptions = {}): CompositeMaterialsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsClustering };
diff --git a/src/composite_materials/compression.ts b/src/composite_materials/compression.ts
new file mode 100644
index 000000000..0d7152f10
--- /dev/null
+++ b/src/composite_materials/compression.ts
@@ -0,0 +1,14 @@
+/** composite_materials compression module — tsb analytics library. */
+export interface CompositeMaterialsCompressionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsCompressionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsCompression(data: number[], opts: CompositeMaterialsCompressionOptions = {}): CompositeMaterialsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsCompression };
diff --git a/src/composite_materials/continuous.ts b/src/composite_materials/continuous.ts
new file mode 100644
index 000000000..255035392
--- /dev/null
+++ b/src/composite_materials/continuous.ts
@@ -0,0 +1,14 @@
+/** composite_materials continuous module — tsb analytics library. */
+export interface CompositeMaterialsContinuousOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsContinuousResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsContinuous(data: number[], opts: CompositeMaterialsContinuousOptions = {}): CompositeMaterialsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsContinuous };
diff --git a/src/composite_materials/control.ts b/src/composite_materials/control.ts
new file mode 100644
index 000000000..e92d881e3
--- /dev/null
+++ b/src/composite_materials/control.ts
@@ -0,0 +1,14 @@
+/** composite_materials control module — tsb analytics library. */
+export interface CompositeMaterialsControlOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsControlResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsControl(data: number[], opts: CompositeMaterialsControlOptions = {}): CompositeMaterialsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsControl };
diff --git a/src/composite_materials/convergence.ts b/src/composite_materials/convergence.ts
new file mode 100644
index 000000000..c7f5619aa
--- /dev/null
+++ b/src/composite_materials/convergence.ts
@@ -0,0 +1,14 @@
+/** composite_materials convergence module — tsb analytics library. */
+export interface CompositeMaterialsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsConvergenceResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsConvergence(data: number[], opts: CompositeMaterialsConvergenceOptions = {}): CompositeMaterialsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsConvergence };
diff --git a/src/composite_materials/convex.ts b/src/composite_materials/convex.ts
new file mode 100644
index 000000000..3878aca92
--- /dev/null
+++ b/src/composite_materials/convex.ts
@@ -0,0 +1,14 @@
+/** composite_materials convex module — tsb analytics library. */
+export interface CompositeMaterialsConvexOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsConvexResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsConvex(data: number[], opts: CompositeMaterialsConvexOptions = {}): CompositeMaterialsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsConvex };
diff --git a/src/composite_materials/correlation.ts b/src/composite_materials/correlation.ts
new file mode 100644
index 000000000..80f71a16a
--- /dev/null
+++ b/src/composite_materials/correlation.ts
@@ -0,0 +1,14 @@
+/** composite_materials correlation module — tsb analytics library. */
+export interface CompositeMaterialsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsCorrelationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsCorrelation(data: number[], opts: CompositeMaterialsCorrelationOptions = {}): CompositeMaterialsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsCorrelation };
diff --git a/src/composite_materials/covariance.ts b/src/composite_materials/covariance.ts
new file mode 100644
index 000000000..cc4aa381f
--- /dev/null
+++ b/src/composite_materials/covariance.ts
@@ -0,0 +1,14 @@
+/** composite_materials covariance module — tsb analytics library. */
+export interface CompositeMaterialsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsCovarianceResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsCovariance(data: number[], opts: CompositeMaterialsCovarianceOptions = {}): CompositeMaterialsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsCovariance };
diff --git a/src/composite_materials/cross_validation.ts b/src/composite_materials/cross_validation.ts
new file mode 100644
index 000000000..7dc1e63de
--- /dev/null
+++ b/src/composite_materials/cross_validation.ts
@@ -0,0 +1,14 @@
+/** composite_materials cross_validation module — tsb analytics library. */
+export interface CompositeMaterialsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsCrossValidation(data: number[], opts: CompositeMaterialsCrossValidationOptions = {}): CompositeMaterialsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsCrossValidation };
diff --git a/src/composite_materials/decoding.ts b/src/composite_materials/decoding.ts
new file mode 100644
index 000000000..61983571b
--- /dev/null
+++ b/src/composite_materials/decoding.ts
@@ -0,0 +1,14 @@
+/** composite_materials decoding module — tsb analytics library. */
+export interface CompositeMaterialsDecodingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDecodingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDecoding(data: number[], opts: CompositeMaterialsDecodingOptions = {}): CompositeMaterialsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDecoding };
diff --git a/src/composite_materials/decomposition.ts b/src/composite_materials/decomposition.ts
new file mode 100644
index 000000000..aa93866d8
--- /dev/null
+++ b/src/composite_materials/decomposition.ts
@@ -0,0 +1,14 @@
+/** composite_materials decomposition module — tsb analytics library. */
+export interface CompositeMaterialsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDecompositionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDecomposition(data: number[], opts: CompositeMaterialsDecompositionOptions = {}): CompositeMaterialsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDecomposition };
diff --git a/src/composite_materials/detection.ts b/src/composite_materials/detection.ts
new file mode 100644
index 000000000..c0ef77cc5
--- /dev/null
+++ b/src/composite_materials/detection.ts
@@ -0,0 +1,14 @@
+/** composite_materials detection module — tsb analytics library. */
+export interface CompositeMaterialsDetectionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDetectionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDetection(data: number[], opts: CompositeMaterialsDetectionOptions = {}): CompositeMaterialsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDetection };
diff --git a/src/composite_materials/deterministic.ts b/src/composite_materials/deterministic.ts
new file mode 100644
index 000000000..0093a43b9
--- /dev/null
+++ b/src/composite_materials/deterministic.ts
@@ -0,0 +1,14 @@
+/** composite_materials deterministic module — tsb analytics library. */
+export interface CompositeMaterialsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDeterministicResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDeterministic(data: number[], opts: CompositeMaterialsDeterministicOptions = {}): CompositeMaterialsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDeterministic };
diff --git a/src/composite_materials/diagnostics.ts b/src/composite_materials/diagnostics.ts
new file mode 100644
index 000000000..be2a8af86
--- /dev/null
+++ b/src/composite_materials/diagnostics.ts
@@ -0,0 +1,14 @@
+/** composite_materials diagnostics module — tsb analytics library. */
+export interface CompositeMaterialsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDiagnostics(data: number[], opts: CompositeMaterialsDiagnosticsOptions = {}): CompositeMaterialsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDiagnostics };
diff --git a/src/composite_materials/differential.ts b/src/composite_materials/differential.ts
new file mode 100644
index 000000000..d6497b0cd
--- /dev/null
+++ b/src/composite_materials/differential.ts
@@ -0,0 +1,14 @@
+/** composite_materials differential module — tsb analytics library. */
+export interface CompositeMaterialsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDifferentialResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDifferential(data: number[], opts: CompositeMaterialsDifferentialOptions = {}): CompositeMaterialsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDifferential };
diff --git a/src/composite_materials/discrete.ts b/src/composite_materials/discrete.ts
new file mode 100644
index 000000000..3f59eb304
--- /dev/null
+++ b/src/composite_materials/discrete.ts
@@ -0,0 +1,14 @@
+/** composite_materials discrete module — tsb analytics library. */
+export interface CompositeMaterialsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDiscreteResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDiscrete(data: number[], opts: CompositeMaterialsDiscreteOptions = {}): CompositeMaterialsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDiscrete };
diff --git a/src/composite_materials/distribution.ts b/src/composite_materials/distribution.ts
new file mode 100644
index 000000000..943bcfe64
--- /dev/null
+++ b/src/composite_materials/distribution.ts
@@ -0,0 +1,14 @@
+/** composite_materials distribution module — tsb analytics library. */
+export interface CompositeMaterialsDistributionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDistributionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDistribution(data: number[], opts: CompositeMaterialsDistributionOptions = {}): CompositeMaterialsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDistribution };
diff --git a/src/composite_materials/dynamic.ts b/src/composite_materials/dynamic.ts
new file mode 100644
index 000000000..816b56c8a
--- /dev/null
+++ b/src/composite_materials/dynamic.ts
@@ -0,0 +1,14 @@
+/** composite_materials dynamic module — tsb analytics library. */
+export interface CompositeMaterialsDynamicOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsDynamicResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsDynamic(data: number[], opts: CompositeMaterialsDynamicOptions = {}): CompositeMaterialsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsDynamic };
diff --git a/src/composite_materials/embedding.ts b/src/composite_materials/embedding.ts
new file mode 100644
index 000000000..445537222
--- /dev/null
+++ b/src/composite_materials/embedding.ts
@@ -0,0 +1,14 @@
+/** composite_materials embedding module — tsb analytics library. */
+export interface CompositeMaterialsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsEmbedding(data: number[], opts: CompositeMaterialsEmbeddingOptions = {}): CompositeMaterialsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsEmbedding };
diff --git a/src/composite_materials/encoding.ts b/src/composite_materials/encoding.ts
new file mode 100644
index 000000000..15f4f45e5
--- /dev/null
+++ b/src/composite_materials/encoding.ts
@@ -0,0 +1,14 @@
+/** composite_materials encoding module — tsb analytics library. */
+export interface CompositeMaterialsEncodingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsEncodingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsEncoding(data: number[], opts: CompositeMaterialsEncodingOptions = {}): CompositeMaterialsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsEncoding };
diff --git a/src/composite_materials/ensemble.ts b/src/composite_materials/ensemble.ts
new file mode 100644
index 000000000..fffd02a9f
--- /dev/null
+++ b/src/composite_materials/ensemble.ts
@@ -0,0 +1,14 @@
+/** composite_materials ensemble module — tsb analytics library. */
+export interface CompositeMaterialsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsEnsembleResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsEnsemble(data: number[], opts: CompositeMaterialsEnsembleOptions = {}): CompositeMaterialsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsEnsemble };
diff --git a/src/composite_materials/estimation.ts b/src/composite_materials/estimation.ts
new file mode 100644
index 000000000..8c6e55f3f
--- /dev/null
+++ b/src/composite_materials/estimation.ts
@@ -0,0 +1,14 @@
+/** composite_materials estimation module — tsb analytics library. */
+export interface CompositeMaterialsEstimationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsEstimationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsEstimation(data: number[], opts: CompositeMaterialsEstimationOptions = {}): CompositeMaterialsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsEstimation };
diff --git a/src/composite_materials/evaluation.ts b/src/composite_materials/evaluation.ts
new file mode 100644
index 000000000..3764034d8
--- /dev/null
+++ b/src/composite_materials/evaluation.ts
@@ -0,0 +1,14 @@
+/** composite_materials evaluation module — tsb analytics library. */
+export interface CompositeMaterialsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsEvaluationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsEvaluation(data: number[], opts: CompositeMaterialsEvaluationOptions = {}): CompositeMaterialsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsEvaluation };
diff --git a/src/composite_materials/extrapolation.ts b/src/composite_materials/extrapolation.ts
new file mode 100644
index 000000000..48e92199c
--- /dev/null
+++ b/src/composite_materials/extrapolation.ts
@@ -0,0 +1,14 @@
+/** composite_materials extrapolation module — tsb analytics library. */
+export interface CompositeMaterialsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsExtrapolation(data: number[], opts: CompositeMaterialsExtrapolationOptions = {}): CompositeMaterialsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsExtrapolation };
diff --git a/src/composite_materials/features.ts b/src/composite_materials/features.ts
new file mode 100644
index 000000000..aba5a1c9a
--- /dev/null
+++ b/src/composite_materials/features.ts
@@ -0,0 +1,14 @@
+/** composite_materials features module — tsb analytics library. */
+export interface CompositeMaterialsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsFeaturesResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsFeatures(data: number[], opts: CompositeMaterialsFeaturesOptions = {}): CompositeMaterialsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsFeatures };
diff --git a/src/composite_materials/feedback.ts b/src/composite_materials/feedback.ts
new file mode 100644
index 000000000..181d8463f
--- /dev/null
+++ b/src/composite_materials/feedback.ts
@@ -0,0 +1,14 @@
+/** composite_materials feedback module — tsb analytics library. */
+export interface CompositeMaterialsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsFeedbackResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsFeedback(data: number[], opts: CompositeMaterialsFeedbackOptions = {}): CompositeMaterialsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsFeedback };
diff --git a/src/composite_materials/filtering.ts b/src/composite_materials/filtering.ts
new file mode 100644
index 000000000..35b61ebe2
--- /dev/null
+++ b/src/composite_materials/filtering.ts
@@ -0,0 +1,14 @@
+/** composite_materials filtering module — tsb analytics library. */
+export interface CompositeMaterialsFilteringOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsFilteringResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsFiltering(data: number[], opts: CompositeMaterialsFilteringOptions = {}): CompositeMaterialsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsFiltering };
diff --git a/src/composite_materials/fourier.ts b/src/composite_materials/fourier.ts
new file mode 100644
index 000000000..976b01faa
--- /dev/null
+++ b/src/composite_materials/fourier.ts
@@ -0,0 +1,14 @@
+/** composite_materials fourier module — tsb analytics library. */
+export interface CompositeMaterialsFourierOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsFourierResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsFourier(data: number[], opts: CompositeMaterialsFourierOptions = {}): CompositeMaterialsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsFourier };
diff --git a/src/composite_materials/fusion.ts b/src/composite_materials/fusion.ts
new file mode 100644
index 000000000..70b6ca5e7
--- /dev/null
+++ b/src/composite_materials/fusion.ts
@@ -0,0 +1,14 @@
+/** composite_materials fusion module — tsb analytics library. */
+export interface CompositeMaterialsFusionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsFusionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsFusion(data: number[], opts: CompositeMaterialsFusionOptions = {}): CompositeMaterialsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsFusion };
diff --git a/src/composite_materials/generation.ts b/src/composite_materials/generation.ts
new file mode 100644
index 000000000..8d795d317
--- /dev/null
+++ b/src/composite_materials/generation.ts
@@ -0,0 +1,14 @@
+/** composite_materials generation module — tsb analytics library. */
+export interface CompositeMaterialsGenerationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsGenerationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsGeneration(data: number[], opts: CompositeMaterialsGenerationOptions = {}): CompositeMaterialsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsGeneration };
diff --git a/src/composite_materials/geometry.ts b/src/composite_materials/geometry.ts
new file mode 100644
index 000000000..5c24279a8
--- /dev/null
+++ b/src/composite_materials/geometry.ts
@@ -0,0 +1,14 @@
+/** composite_materials geometry module — tsb analytics library. */
+export interface CompositeMaterialsGeometryOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsGeometryResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsGeometry(data: number[], opts: CompositeMaterialsGeometryOptions = {}): CompositeMaterialsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsGeometry };
diff --git a/src/composite_materials/gradient.ts b/src/composite_materials/gradient.ts
new file mode 100644
index 000000000..e2ea04070
--- /dev/null
+++ b/src/composite_materials/gradient.ts
@@ -0,0 +1,14 @@
+/** composite_materials gradient module — tsb analytics library. */
+export interface CompositeMaterialsGradientOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsGradientResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsGradient(data: number[], opts: CompositeMaterialsGradientOptions = {}): CompositeMaterialsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsGradient };
diff --git a/src/composite_materials/hessian.ts b/src/composite_materials/hessian.ts
new file mode 100644
index 000000000..c58e366a1
--- /dev/null
+++ b/src/composite_materials/hessian.ts
@@ -0,0 +1,14 @@
+/** composite_materials hessian module — tsb analytics library. */
+export interface CompositeMaterialsHessianOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsHessianResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsHessian(data: number[], opts: CompositeMaterialsHessianOptions = {}): CompositeMaterialsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsHessian };
diff --git a/src/composite_materials/hypothesis.ts b/src/composite_materials/hypothesis.ts
new file mode 100644
index 000000000..8f3d0624d
--- /dev/null
+++ b/src/composite_materials/hypothesis.ts
@@ -0,0 +1,14 @@
+/** composite_materials hypothesis module — tsb analytics library. */
+export interface CompositeMaterialsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsHypothesisResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsHypothesis(data: number[], opts: CompositeMaterialsHypothesisOptions = {}): CompositeMaterialsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsHypothesis };
diff --git a/src/composite_materials/inference.ts b/src/composite_materials/inference.ts
new file mode 100644
index 000000000..1f3ae512b
--- /dev/null
+++ b/src/composite_materials/inference.ts
@@ -0,0 +1,14 @@
+/** composite_materials inference module — tsb analytics library. */
+export interface CompositeMaterialsInferenceOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsInferenceResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsInference(data: number[], opts: CompositeMaterialsInferenceOptions = {}): CompositeMaterialsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsInference };
diff --git a/src/composite_materials/inference2.ts b/src/composite_materials/inference2.ts
new file mode 100644
index 000000000..3fca1db9e
--- /dev/null
+++ b/src/composite_materials/inference2.ts
@@ -0,0 +1,14 @@
+/** composite_materials inference2 module — tsb analytics library. */
+export interface CompositeMaterialsInferenceOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsInferenceResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsInference(data: number[], opts: CompositeMaterialsInferenceOptions = {}): CompositeMaterialsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsInference };
diff --git a/src/composite_materials/integral.ts b/src/composite_materials/integral.ts
new file mode 100644
index 000000000..e29f912b1
--- /dev/null
+++ b/src/composite_materials/integral.ts
@@ -0,0 +1,14 @@
+/** composite_materials integral module — tsb analytics library. */
+export interface CompositeMaterialsIntegralOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsIntegralResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsIntegral(data: number[], opts: CompositeMaterialsIntegralOptions = {}): CompositeMaterialsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsIntegral };
diff --git a/src/composite_materials/integration.ts b/src/composite_materials/integration.ts
new file mode 100644
index 000000000..9a556fd7d
--- /dev/null
+++ b/src/composite_materials/integration.ts
@@ -0,0 +1,14 @@
+/** composite_materials integration module — tsb analytics library. */
+export interface CompositeMaterialsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsIntegrationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsIntegration(data: number[], opts: CompositeMaterialsIntegrationOptions = {}): CompositeMaterialsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsIntegration };
diff --git a/src/composite_materials/interpolation.ts b/src/composite_materials/interpolation.ts
new file mode 100644
index 000000000..0e9de65a5
--- /dev/null
+++ b/src/composite_materials/interpolation.ts
@@ -0,0 +1,14 @@
+/** composite_materials interpolation module — tsb analytics library. */
+export interface CompositeMaterialsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsInterpolationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsInterpolation(data: number[], opts: CompositeMaterialsInterpolationOptions = {}): CompositeMaterialsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsInterpolation };
diff --git a/src/composite_materials/jacobian.ts b/src/composite_materials/jacobian.ts
new file mode 100644
index 000000000..2b97f422c
--- /dev/null
+++ b/src/composite_materials/jacobian.ts
@@ -0,0 +1,14 @@
+/** composite_materials jacobian module — tsb analytics library. */
+export interface CompositeMaterialsJacobianOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsJacobianResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsJacobian(data: number[], opts: CompositeMaterialsJacobianOptions = {}): CompositeMaterialsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsJacobian };
diff --git a/src/composite_materials/kernel.ts b/src/composite_materials/kernel.ts
new file mode 100644
index 000000000..f29802dd2
--- /dev/null
+++ b/src/composite_materials/kernel.ts
@@ -0,0 +1,14 @@
+/** composite_materials kernel module — tsb analytics library. */
+export interface CompositeMaterialsKernelOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsKernelResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsKernel(data: number[], opts: CompositeMaterialsKernelOptions = {}): CompositeMaterialsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsKernel };
diff --git a/src/composite_materials/laplacian.ts b/src/composite_materials/laplacian.ts
new file mode 100644
index 000000000..3a70828a7
--- /dev/null
+++ b/src/composite_materials/laplacian.ts
@@ -0,0 +1,14 @@
+/** composite_materials laplacian module — tsb analytics library. */
+export interface CompositeMaterialsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsLaplacianResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsLaplacian(data: number[], opts: CompositeMaterialsLaplacianOptions = {}): CompositeMaterialsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsLaplacian };
diff --git a/src/composite_materials/learning.ts b/src/composite_materials/learning.ts
new file mode 100644
index 000000000..11b6dc01e
--- /dev/null
+++ b/src/composite_materials/learning.ts
@@ -0,0 +1,14 @@
+/** composite_materials learning module — tsb analytics library. */
+export interface CompositeMaterialsLearningOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsLearningResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsLearning(data: number[], opts: CompositeMaterialsLearningOptions = {}): CompositeMaterialsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsLearning };
diff --git a/src/composite_materials/linear.ts b/src/composite_materials/linear.ts
new file mode 100644
index 000000000..1cc7412a5
--- /dev/null
+++ b/src/composite_materials/linear.ts
@@ -0,0 +1,14 @@
+/** composite_materials linear module — tsb analytics library. */
+export interface CompositeMaterialsLinearOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsLinearResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsLinear(data: number[], opts: CompositeMaterialsLinearOptions = {}): CompositeMaterialsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsLinear };
diff --git a/src/composite_materials/manifold.ts b/src/composite_materials/manifold.ts
new file mode 100644
index 000000000..b34eb88da
--- /dev/null
+++ b/src/composite_materials/manifold.ts
@@ -0,0 +1,14 @@
+/** composite_materials manifold module — tsb analytics library. */
+export interface CompositeMaterialsManifoldOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsManifoldResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsManifold(data: number[], opts: CompositeMaterialsManifoldOptions = {}): CompositeMaterialsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsManifold };
diff --git a/src/composite_materials/matching.ts b/src/composite_materials/matching.ts
new file mode 100644
index 000000000..6d3061c69
--- /dev/null
+++ b/src/composite_materials/matching.ts
@@ -0,0 +1,14 @@
+/** composite_materials matching module — tsb analytics library. */
+export interface CompositeMaterialsMatchingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsMatchingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsMatching(data: number[], opts: CompositeMaterialsMatchingOptions = {}): CompositeMaterialsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsMatching };
diff --git a/src/composite_materials/measurement.ts b/src/composite_materials/measurement.ts
new file mode 100644
index 000000000..3e80e889c
--- /dev/null
+++ b/src/composite_materials/measurement.ts
@@ -0,0 +1,14 @@
+/** composite_materials measurement module — tsb analytics library. */
+export interface CompositeMaterialsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsMeasurementResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsMeasurement(data: number[], opts: CompositeMaterialsMeasurementOptions = {}): CompositeMaterialsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsMeasurement };
diff --git a/src/composite_materials/metrics.ts b/src/composite_materials/metrics.ts
new file mode 100644
index 000000000..8e76bc6fa
--- /dev/null
+++ b/src/composite_materials/metrics.ts
@@ -0,0 +1,14 @@
+/** composite_materials metrics module — tsb analytics library. */
+export interface CompositeMaterialsMetricsOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsMetricsResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsMetrics(data: number[], opts: CompositeMaterialsMetricsOptions = {}): CompositeMaterialsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsMetrics };
diff --git a/src/composite_materials/modeling.ts b/src/composite_materials/modeling.ts
new file mode 100644
index 000000000..3e2fe625d
--- /dev/null
+++ b/src/composite_materials/modeling.ts
@@ -0,0 +1,14 @@
+/** composite_materials modeling module — tsb analytics library. */
+export interface CompositeMaterialsModelingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsModelingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsModeling(data: number[], opts: CompositeMaterialsModelingOptions = {}): CompositeMaterialsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsModeling };
diff --git a/src/composite_materials/monitoring.ts b/src/composite_materials/monitoring.ts
new file mode 100644
index 000000000..a068dc839
--- /dev/null
+++ b/src/composite_materials/monitoring.ts
@@ -0,0 +1,14 @@
+/** composite_materials monitoring module — tsb analytics library. */
+export interface CompositeMaterialsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsMonitoringResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsMonitoring(data: number[], opts: CompositeMaterialsMonitoringOptions = {}): CompositeMaterialsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsMonitoring };
diff --git a/src/composite_materials/nonlinear.ts b/src/composite_materials/nonlinear.ts
new file mode 100644
index 000000000..9b4061abb
--- /dev/null
+++ b/src/composite_materials/nonlinear.ts
@@ -0,0 +1,14 @@
+/** composite_materials nonlinear module — tsb analytics library. */
+export interface CompositeMaterialsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsNonlinearResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsNonlinear(data: number[], opts: CompositeMaterialsNonlinearOptions = {}): CompositeMaterialsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsNonlinear };
diff --git a/src/composite_materials/normalization.ts b/src/composite_materials/normalization.ts
new file mode 100644
index 000000000..06f70b884
--- /dev/null
+++ b/src/composite_materials/normalization.ts
@@ -0,0 +1,14 @@
+/** composite_materials normalization module — tsb analytics library. */
+export interface CompositeMaterialsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsNormalizationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsNormalization(data: number[], opts: CompositeMaterialsNormalizationOptions = {}): CompositeMaterialsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsNormalization };
diff --git a/src/composite_materials/optimization.ts b/src/composite_materials/optimization.ts
new file mode 100644
index 000000000..53cc18432
--- /dev/null
+++ b/src/composite_materials/optimization.ts
@@ -0,0 +1,14 @@
+/** composite_materials optimization module — tsb analytics library. */
+export interface CompositeMaterialsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsOptimizationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsOptimization(data: number[], opts: CompositeMaterialsOptimizationOptions = {}): CompositeMaterialsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsOptimization };
diff --git a/src/composite_materials/patterns.ts b/src/composite_materials/patterns.ts
new file mode 100644
index 000000000..405cab987
--- /dev/null
+++ b/src/composite_materials/patterns.ts
@@ -0,0 +1,14 @@
+/** composite_materials patterns module — tsb analytics library. */
+export interface CompositeMaterialsPatternsOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsPatternsResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsPatterns(data: number[], opts: CompositeMaterialsPatternsOptions = {}): CompositeMaterialsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsPatterns };
diff --git a/src/composite_materials/permutation.ts b/src/composite_materials/permutation.ts
new file mode 100644
index 000000000..0df7970bd
--- /dev/null
+++ b/src/composite_materials/permutation.ts
@@ -0,0 +1,14 @@
+/** composite_materials permutation module — tsb analytics library. */
+export interface CompositeMaterialsPermutationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsPermutationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsPermutation(data: number[], opts: CompositeMaterialsPermutationOptions = {}): CompositeMaterialsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsPermutation };
diff --git a/src/composite_materials/prediction.ts b/src/composite_materials/prediction.ts
new file mode 100644
index 000000000..06929a01a
--- /dev/null
+++ b/src/composite_materials/prediction.ts
@@ -0,0 +1,14 @@
+/** composite_materials prediction module — tsb analytics library. */
+export interface CompositeMaterialsPredictionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsPredictionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsPrediction(data: number[], opts: CompositeMaterialsPredictionOptions = {}): CompositeMaterialsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsPrediction };
diff --git a/src/composite_materials/processing.ts b/src/composite_materials/processing.ts
new file mode 100644
index 000000000..695368660
--- /dev/null
+++ b/src/composite_materials/processing.ts
@@ -0,0 +1,14 @@
+/** composite_materials processing module — tsb analytics library. */
+export interface CompositeMaterialsProcessingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsProcessingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsProcessing(data: number[], opts: CompositeMaterialsProcessingOptions = {}): CompositeMaterialsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsProcessing };
diff --git a/src/composite_materials/profiling.ts b/src/composite_materials/profiling.ts
new file mode 100644
index 000000000..85d6c0bce
--- /dev/null
+++ b/src/composite_materials/profiling.ts
@@ -0,0 +1,14 @@
+/** composite_materials profiling module — tsb analytics library. */
+export interface CompositeMaterialsProfilingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsProfilingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsProfiling(data: number[], opts: CompositeMaterialsProfilingOptions = {}): CompositeMaterialsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsProfiling };
diff --git a/src/composite_materials/projection.ts b/src/composite_materials/projection.ts
new file mode 100644
index 000000000..c2408d829
--- /dev/null
+++ b/src/composite_materials/projection.ts
@@ -0,0 +1,14 @@
+/** composite_materials projection module — tsb analytics library. */
+export interface CompositeMaterialsProjectionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsProjectionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsProjection(data: number[], opts: CompositeMaterialsProjectionOptions = {}): CompositeMaterialsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsProjection };
diff --git a/src/composite_materials/ranking.ts b/src/composite_materials/ranking.ts
new file mode 100644
index 000000000..f7fd34dde
--- /dev/null
+++ b/src/composite_materials/ranking.ts
@@ -0,0 +1,14 @@
+/** composite_materials ranking module — tsb analytics library. */
+export interface CompositeMaterialsRankingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsRankingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsRanking(data: number[], opts: CompositeMaterialsRankingOptions = {}): CompositeMaterialsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsRanking };
diff --git a/src/composite_materials/reconstruction.ts b/src/composite_materials/reconstruction.ts
new file mode 100644
index 000000000..ee5bd24e9
--- /dev/null
+++ b/src/composite_materials/reconstruction.ts
@@ -0,0 +1,14 @@
+/** composite_materials reconstruction module — tsb analytics library. */
+export interface CompositeMaterialsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsReconstructionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsReconstruction(data: number[], opts: CompositeMaterialsReconstructionOptions = {}): CompositeMaterialsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsReconstruction };
diff --git a/src/composite_materials/registration.ts b/src/composite_materials/registration.ts
new file mode 100644
index 000000000..f34168f0b
--- /dev/null
+++ b/src/composite_materials/registration.ts
@@ -0,0 +1,14 @@
+/** composite_materials registration module — tsb analytics library. */
+export interface CompositeMaterialsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsRegistrationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsRegistration(data: number[], opts: CompositeMaterialsRegistrationOptions = {}): CompositeMaterialsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsRegistration };
diff --git a/src/composite_materials/regression.ts b/src/composite_materials/regression.ts
new file mode 100644
index 000000000..571dcfb2f
--- /dev/null
+++ b/src/composite_materials/regression.ts
@@ -0,0 +1,14 @@
+/** composite_materials regression module — tsb analytics library. */
+export interface CompositeMaterialsRegressionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsRegressionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsRegression(data: number[], opts: CompositeMaterialsRegressionOptions = {}): CompositeMaterialsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsRegression };
diff --git a/src/composite_materials/regularization.ts b/src/composite_materials/regularization.ts
new file mode 100644
index 000000000..646ccee08
--- /dev/null
+++ b/src/composite_materials/regularization.ts
@@ -0,0 +1,14 @@
+/** composite_materials regularization module — tsb analytics library. */
+export interface CompositeMaterialsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsRegularizationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsRegularization(data: number[], opts: CompositeMaterialsRegularizationOptions = {}): CompositeMaterialsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsRegularization };
diff --git a/src/composite_materials/robustness.ts b/src/composite_materials/robustness.ts
new file mode 100644
index 000000000..8429bb542
--- /dev/null
+++ b/src/composite_materials/robustness.ts
@@ -0,0 +1,14 @@
+/** composite_materials robustness module — tsb analytics library. */
+export interface CompositeMaterialsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsRobustnessResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsRobustness(data: number[], opts: CompositeMaterialsRobustnessOptions = {}): CompositeMaterialsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsRobustness };
diff --git a/src/composite_materials/sampling.ts b/src/composite_materials/sampling.ts
new file mode 100644
index 000000000..3dfaf0756
--- /dev/null
+++ b/src/composite_materials/sampling.ts
@@ -0,0 +1,14 @@
+/** composite_materials sampling module — tsb analytics library. */
+export interface CompositeMaterialsSamplingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsSamplingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsSampling(data: number[], opts: CompositeMaterialsSamplingOptions = {}): CompositeMaterialsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsSampling };
diff --git a/src/composite_materials/sampling2.ts b/src/composite_materials/sampling2.ts
new file mode 100644
index 000000000..ef0b71ca2
--- /dev/null
+++ b/src/composite_materials/sampling2.ts
@@ -0,0 +1,14 @@
+/** composite_materials sampling2 module — tsb analytics library. */
+export interface CompositeMaterialsSamplingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsSamplingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsSampling(data: number[], opts: CompositeMaterialsSamplingOptions = {}): CompositeMaterialsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsSampling };
diff --git a/src/composite_materials/scaling.ts b/src/composite_materials/scaling.ts
new file mode 100644
index 000000000..686b93a84
--- /dev/null
+++ b/src/composite_materials/scaling.ts
@@ -0,0 +1,14 @@
+/** composite_materials scaling module — tsb analytics library. */
+export interface CompositeMaterialsScalingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsScalingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsScaling(data: number[], opts: CompositeMaterialsScalingOptions = {}): CompositeMaterialsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsScaling };
diff --git a/src/composite_materials/scoring.ts b/src/composite_materials/scoring.ts
new file mode 100644
index 000000000..90298df69
--- /dev/null
+++ b/src/composite_materials/scoring.ts
@@ -0,0 +1,14 @@
+/** composite_materials scoring module — tsb analytics library. */
+export interface CompositeMaterialsScoringOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsScoringResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsScoring(data: number[], opts: CompositeMaterialsScoringOptions = {}): CompositeMaterialsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsScoring };
diff --git a/src/composite_materials/segmentation.ts b/src/composite_materials/segmentation.ts
new file mode 100644
index 000000000..c8d9529ad
--- /dev/null
+++ b/src/composite_materials/segmentation.ts
@@ -0,0 +1,14 @@
+/** composite_materials segmentation module — tsb analytics library. */
+export interface CompositeMaterialsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsSegmentationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsSegmentation(data: number[], opts: CompositeMaterialsSegmentationOptions = {}): CompositeMaterialsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsSegmentation };
diff --git a/src/composite_materials/selection.ts b/src/composite_materials/selection.ts
new file mode 100644
index 000000000..4232d8504
--- /dev/null
+++ b/src/composite_materials/selection.ts
@@ -0,0 +1,14 @@
+/** composite_materials selection module — tsb analytics library. */
+export interface CompositeMaterialsSelectionOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsSelectionResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsSelection(data: number[], opts: CompositeMaterialsSelectionOptions = {}): CompositeMaterialsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsSelection };
diff --git a/src/composite_materials/sensitivity.ts b/src/composite_materials/sensitivity.ts
new file mode 100644
index 000000000..4fc255f27
--- /dev/null
+++ b/src/composite_materials/sensitivity.ts
@@ -0,0 +1,14 @@
+/** composite_materials sensitivity module — tsb analytics library. */
+export interface CompositeMaterialsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsSensitivityResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsSensitivity(data: number[], opts: CompositeMaterialsSensitivityOptions = {}): CompositeMaterialsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsSensitivity };
diff --git a/src/composite_materials/simulation.ts b/src/composite_materials/simulation.ts
new file mode 100644
index 000000000..eb3d70b59
--- /dev/null
+++ b/src/composite_materials/simulation.ts
@@ -0,0 +1,14 @@
+/** composite_materials simulation module — tsb analytics library. */
+export interface CompositeMaterialsSimulationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsSimulationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsSimulation(data: number[], opts: CompositeMaterialsSimulationOptions = {}): CompositeMaterialsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsSimulation };
diff --git a/src/composite_materials/smoothing.ts b/src/composite_materials/smoothing.ts
new file mode 100644
index 000000000..fe2433823
--- /dev/null
+++ b/src/composite_materials/smoothing.ts
@@ -0,0 +1,14 @@
+/** composite_materials smoothing module — tsb analytics library. */
+export interface CompositeMaterialsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsSmoothingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsSmoothing(data: number[], opts: CompositeMaterialsSmoothingOptions = {}): CompositeMaterialsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsSmoothing };
diff --git a/src/composite_materials/stability.ts b/src/composite_materials/stability.ts
new file mode 100644
index 000000000..5cb6e0b15
--- /dev/null
+++ b/src/composite_materials/stability.ts
@@ -0,0 +1,14 @@
+/** composite_materials stability module — tsb analytics library. */
+export interface CompositeMaterialsStabilityOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsStabilityResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsStability(data: number[], opts: CompositeMaterialsStabilityOptions = {}): CompositeMaterialsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsStability };
diff --git a/src/composite_materials/stacking.ts b/src/composite_materials/stacking.ts
new file mode 100644
index 000000000..0e27b6fbc
--- /dev/null
+++ b/src/composite_materials/stacking.ts
@@ -0,0 +1,14 @@
+/** composite_materials stacking module — tsb analytics library. */
+export interface CompositeMaterialsStackingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsStackingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsStacking(data: number[], opts: CompositeMaterialsStackingOptions = {}): CompositeMaterialsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsStacking };
diff --git a/src/composite_materials/standardization.ts b/src/composite_materials/standardization.ts
new file mode 100644
index 000000000..fa9820185
--- /dev/null
+++ b/src/composite_materials/standardization.ts
@@ -0,0 +1,14 @@
+/** composite_materials standardization module — tsb analytics library. */
+export interface CompositeMaterialsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsStandardizationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsStandardization(data: number[], opts: CompositeMaterialsStandardizationOptions = {}): CompositeMaterialsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsStandardization };
diff --git a/src/composite_materials/static.ts b/src/composite_materials/static.ts
new file mode 100644
index 000000000..cbfd7c557
--- /dev/null
+++ b/src/composite_materials/static.ts
@@ -0,0 +1,14 @@
+/** composite_materials static module — tsb analytics library. */
+export interface CompositeMaterialsStaticOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsStaticResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsStatic(data: number[], opts: CompositeMaterialsStaticOptions = {}): CompositeMaterialsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsStatic };
diff --git a/src/composite_materials/stochastic.ts b/src/composite_materials/stochastic.ts
new file mode 100644
index 000000000..8eb44c88a
--- /dev/null
+++ b/src/composite_materials/stochastic.ts
@@ -0,0 +1,14 @@
+/** composite_materials stochastic module — tsb analytics library. */
+export interface CompositeMaterialsStochasticOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsStochasticResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsStochastic(data: number[], opts: CompositeMaterialsStochasticOptions = {}): CompositeMaterialsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsStochastic };
diff --git a/src/composite_materials/synthesis.ts b/src/composite_materials/synthesis.ts
new file mode 100644
index 000000000..2b1506f78
--- /dev/null
+++ b/src/composite_materials/synthesis.ts
@@ -0,0 +1,14 @@
+/** composite_materials synthesis module — tsb analytics library. */
+export interface CompositeMaterialsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsSynthesisResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsSynthesis(data: number[], opts: CompositeMaterialsSynthesisOptions = {}): CompositeMaterialsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsSynthesis };
diff --git a/src/composite_materials/topology.ts b/src/composite_materials/topology.ts
new file mode 100644
index 000000000..6ae1cae4f
--- /dev/null
+++ b/src/composite_materials/topology.ts
@@ -0,0 +1,14 @@
+/** composite_materials topology module — tsb analytics library. */
+export interface CompositeMaterialsTopologyOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsTopologyResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsTopology(data: number[], opts: CompositeMaterialsTopologyOptions = {}): CompositeMaterialsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsTopology };
diff --git a/src/composite_materials/tracking.ts b/src/composite_materials/tracking.ts
new file mode 100644
index 000000000..5498505f4
--- /dev/null
+++ b/src/composite_materials/tracking.ts
@@ -0,0 +1,14 @@
+/** composite_materials tracking module — tsb analytics library. */
+export interface CompositeMaterialsTrackingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsTrackingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsTracking(data: number[], opts: CompositeMaterialsTrackingOptions = {}): CompositeMaterialsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsTracking };
diff --git a/src/composite_materials/transform.ts b/src/composite_materials/transform.ts
new file mode 100644
index 000000000..fcc22a264
--- /dev/null
+++ b/src/composite_materials/transform.ts
@@ -0,0 +1,14 @@
+/** composite_materials transform module — tsb analytics library. */
+export interface CompositeMaterialsTransformOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsTransformResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsTransform(data: number[], opts: CompositeMaterialsTransformOptions = {}): CompositeMaterialsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsTransform };
diff --git a/src/composite_materials/uncertainty.ts b/src/composite_materials/uncertainty.ts
new file mode 100644
index 000000000..d634ae700
--- /dev/null
+++ b/src/composite_materials/uncertainty.ts
@@ -0,0 +1,14 @@
+/** composite_materials uncertainty module — tsb analytics library. */
+export interface CompositeMaterialsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsUncertainty(data: number[], opts: CompositeMaterialsUncertaintyOptions = {}): CompositeMaterialsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsUncertainty };
diff --git a/src/composite_materials/validation.ts b/src/composite_materials/validation.ts
new file mode 100644
index 000000000..fc51db9c0
--- /dev/null
+++ b/src/composite_materials/validation.ts
@@ -0,0 +1,14 @@
+/** composite_materials validation module — tsb analytics library. */
+export interface CompositeMaterialsValidationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsValidationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsValidation(data: number[], opts: CompositeMaterialsValidationOptions = {}): CompositeMaterialsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsValidation };
diff --git a/src/composite_materials/verification.ts b/src/composite_materials/verification.ts
new file mode 100644
index 000000000..ee67e46de
--- /dev/null
+++ b/src/composite_materials/verification.ts
@@ -0,0 +1,14 @@
+/** composite_materials verification module — tsb analytics library. */
+export interface CompositeMaterialsVerificationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsVerificationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsVerification(data: number[], opts: CompositeMaterialsVerificationOptions = {}): CompositeMaterialsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsVerification };
diff --git a/src/composite_materials/visualization.ts b/src/composite_materials/visualization.ts
new file mode 100644
index 000000000..c3839b5f1
--- /dev/null
+++ b/src/composite_materials/visualization.ts
@@ -0,0 +1,14 @@
+/** composite_materials visualization module — tsb analytics library. */
+export interface CompositeMaterialsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsVisualizationResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsVisualization(data: number[], opts: CompositeMaterialsVisualizationOptions = {}): CompositeMaterialsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsVisualization };
diff --git a/src/composite_materials/voting.ts b/src/composite_materials/voting.ts
new file mode 100644
index 000000000..253b08483
--- /dev/null
+++ b/src/composite_materials/voting.ts
@@ -0,0 +1,14 @@
+/** composite_materials voting module — tsb analytics library. */
+export interface CompositeMaterialsVotingOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsVotingResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsVoting(data: number[], opts: CompositeMaterialsVotingOptions = {}): CompositeMaterialsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsVoting };
diff --git a/src/composite_materials/wavelet.ts b/src/composite_materials/wavelet.ts
new file mode 100644
index 000000000..01a62085b
--- /dev/null
+++ b/src/composite_materials/wavelet.ts
@@ -0,0 +1,14 @@
+/** composite_materials wavelet module — tsb analytics library. */
+export interface CompositeMaterialsWaveletOptions { tol?: number; maxIter?: number; }
+export interface CompositeMaterialsWaveletResult { values: number[]; converged: boolean; }
+export function computeCompositeMaterialsWavelet(data: number[], opts: CompositeMaterialsWaveletOptions = {}): CompositeMaterialsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCompositeMaterialsWavelet };
diff --git a/src/concrete_sci/adaptation.ts b/src/concrete_sci/adaptation.ts
new file mode 100644
index 000000000..8ddd23aba
--- /dev/null
+++ b/src/concrete_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci adaptation module — tsb analytics library. */
+export interface ConcreteSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciAdaptation(data: number[], opts: ConcreteSciAdaptationOptions = {}): ConcreteSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciAdaptation };
diff --git a/src/concrete_sci/aggregation.ts b/src/concrete_sci/aggregation.ts
new file mode 100644
index 000000000..58d48799b
--- /dev/null
+++ b/src/concrete_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci aggregation module — tsb analytics library. */
+export interface ConcreteSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciAggregationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciAggregation(data: number[], opts: ConcreteSciAggregationOptions = {}): ConcreteSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciAggregation };
diff --git a/src/concrete_sci/algebra.ts b/src/concrete_sci/algebra.ts
new file mode 100644
index 000000000..8e16bea55
--- /dev/null
+++ b/src/concrete_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** concrete_sci algebra module — tsb analytics library. */
+export interface ConcreteSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeConcreteSciAlgebra(data: number[], opts: ConcreteSciAlgebraOptions = {}): ConcreteSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciAlgebra };
diff --git a/src/concrete_sci/alignment.ts b/src/concrete_sci/alignment.ts
new file mode 100644
index 000000000..0521fced8
--- /dev/null
+++ b/src/concrete_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** concrete_sci alignment module — tsb analytics library. */
+export interface ConcreteSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeConcreteSciAlignment(data: number[], opts: ConcreteSciAlignmentOptions = {}): ConcreteSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciAlignment };
diff --git a/src/concrete_sci/analysis.ts b/src/concrete_sci/analysis.ts
new file mode 100644
index 000000000..17f791c3b
--- /dev/null
+++ b/src/concrete_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** concrete_sci analysis module — tsb analytics library. */
+export interface ConcreteSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeConcreteSciAnalysis(data: number[], opts: ConcreteSciAnalysisOptions = {}): ConcreteSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciAnalysis };
diff --git a/src/concrete_sci/augmentation.ts b/src/concrete_sci/augmentation.ts
new file mode 100644
index 000000000..b1f2a21ff
--- /dev/null
+++ b/src/concrete_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci augmentation module — tsb analytics library. */
+export interface ConcreteSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciAugmentation(data: number[], opts: ConcreteSciAugmentationOptions = {}): ConcreteSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciAugmentation };
diff --git a/src/concrete_sci/bagging.ts b/src/concrete_sci/bagging.ts
new file mode 100644
index 000000000..34432d953
--- /dev/null
+++ b/src/concrete_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** concrete_sci bagging module — tsb analytics library. */
+export interface ConcreteSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciBaggingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciBagging(data: number[], opts: ConcreteSciBaggingOptions = {}): ConcreteSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciBagging };
diff --git a/src/concrete_sci/basis.ts b/src/concrete_sci/basis.ts
new file mode 100644
index 000000000..92700fd2e
--- /dev/null
+++ b/src/concrete_sci/basis.ts
@@ -0,0 +1,14 @@
+/** concrete_sci basis module — tsb analytics library. */
+export interface ConcreteSciBasisOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciBasisResult { values: number[]; converged: boolean; }
+export function computeConcreteSciBasis(data: number[], opts: ConcreteSciBasisOptions = {}): ConcreteSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciBasis };
diff --git a/src/concrete_sci/benchmarking.ts b/src/concrete_sci/benchmarking.ts
new file mode 100644
index 000000000..df012d731
--- /dev/null
+++ b/src/concrete_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** concrete_sci benchmarking module — tsb analytics library. */
+export interface ConcreteSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciBenchmarking(data: number[], opts: ConcreteSciBenchmarkingOptions = {}): ConcreteSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciBenchmarking };
diff --git a/src/concrete_sci/blending.ts b/src/concrete_sci/blending.ts
new file mode 100644
index 000000000..f406df0e2
--- /dev/null
+++ b/src/concrete_sci/blending.ts
@@ -0,0 +1,14 @@
+/** concrete_sci blending module — tsb analytics library. */
+export interface ConcreteSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciBlendingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciBlending(data: number[], opts: ConcreteSciBlendingOptions = {}): ConcreteSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciBlending };
diff --git a/src/concrete_sci/boosting.ts b/src/concrete_sci/boosting.ts
new file mode 100644
index 000000000..4ab41e0ef
--- /dev/null
+++ b/src/concrete_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** concrete_sci boosting module — tsb analytics library. */
+export interface ConcreteSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciBoostingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciBoosting(data: number[], opts: ConcreteSciBoostingOptions = {}): ConcreteSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciBoosting };
diff --git a/src/concrete_sci/bootstrap.ts b/src/concrete_sci/bootstrap.ts
new file mode 100644
index 000000000..16bbb9b06
--- /dev/null
+++ b/src/concrete_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** concrete_sci bootstrap module — tsb analytics library. */
+export interface ConcreteSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeConcreteSciBootstrap(data: number[], opts: ConcreteSciBootstrapOptions = {}): ConcreteSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciBootstrap };
diff --git a/src/concrete_sci/calculus.ts b/src/concrete_sci/calculus.ts
new file mode 100644
index 000000000..b10430a04
--- /dev/null
+++ b/src/concrete_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** concrete_sci calculus module — tsb analytics library. */
+export interface ConcreteSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciCalculusResult { values: number[]; converged: boolean; }
+export function computeConcreteSciCalculus(data: number[], opts: ConcreteSciCalculusOptions = {}): ConcreteSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciCalculus };
diff --git a/src/concrete_sci/calibration.ts b/src/concrete_sci/calibration.ts
new file mode 100644
index 000000000..0faa55050
--- /dev/null
+++ b/src/concrete_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** concrete_sci calibration module — tsb analytics library. */
+export interface ConcreteSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciCalibration(data: number[], opts: ConcreteSciCalibrationOptions = {}): ConcreteSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciCalibration };
diff --git a/src/concrete_sci/characterization.ts b/src/concrete_sci/characterization.ts
new file mode 100644
index 000000000..cdac8d76c
--- /dev/null
+++ b/src/concrete_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** concrete_sci characterization module — tsb analytics library. */
+export interface ConcreteSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciCharacterization(data: number[], opts: ConcreteSciCharacterizationOptions = {}): ConcreteSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciCharacterization };
diff --git a/src/concrete_sci/classification.ts b/src/concrete_sci/classification.ts
new file mode 100644
index 000000000..087b6bf92
--- /dev/null
+++ b/src/concrete_sci/classification.ts
@@ -0,0 +1,14 @@
+/** concrete_sci classification module — tsb analytics library. */
+export interface ConcreteSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciClassificationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciClassification(data: number[], opts: ConcreteSciClassificationOptions = {}): ConcreteSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciClassification };
diff --git a/src/concrete_sci/clustering.ts b/src/concrete_sci/clustering.ts
new file mode 100644
index 000000000..c8d87b231
--- /dev/null
+++ b/src/concrete_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** concrete_sci clustering module — tsb analytics library. */
+export interface ConcreteSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciClusteringResult { values: number[]; converged: boolean; }
+export function computeConcreteSciClustering(data: number[], opts: ConcreteSciClusteringOptions = {}): ConcreteSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciClustering };
diff --git a/src/concrete_sci/compression.ts b/src/concrete_sci/compression.ts
new file mode 100644
index 000000000..04ab16a35
--- /dev/null
+++ b/src/concrete_sci/compression.ts
@@ -0,0 +1,14 @@
+/** concrete_sci compression module — tsb analytics library. */
+export interface ConcreteSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciCompressionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciCompression(data: number[], opts: ConcreteSciCompressionOptions = {}): ConcreteSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciCompression };
diff --git a/src/concrete_sci/continuous.ts b/src/concrete_sci/continuous.ts
new file mode 100644
index 000000000..13a7b7f10
--- /dev/null
+++ b/src/concrete_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** concrete_sci continuous module — tsb analytics library. */
+export interface ConcreteSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciContinuousResult { values: number[]; converged: boolean; }
+export function computeConcreteSciContinuous(data: number[], opts: ConcreteSciContinuousOptions = {}): ConcreteSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciContinuous };
diff --git a/src/concrete_sci/control.ts b/src/concrete_sci/control.ts
new file mode 100644
index 000000000..d98cfd935
--- /dev/null
+++ b/src/concrete_sci/control.ts
@@ -0,0 +1,14 @@
+/** concrete_sci control module — tsb analytics library. */
+export interface ConcreteSciControlOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciControlResult { values: number[]; converged: boolean; }
+export function computeConcreteSciControl(data: number[], opts: ConcreteSciControlOptions = {}): ConcreteSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciControl };
diff --git a/src/concrete_sci/convergence.ts b/src/concrete_sci/convergence.ts
new file mode 100644
index 000000000..9e6abad5a
--- /dev/null
+++ b/src/concrete_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** concrete_sci convergence module — tsb analytics library. */
+export interface ConcreteSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeConcreteSciConvergence(data: number[], opts: ConcreteSciConvergenceOptions = {}): ConcreteSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciConvergence };
diff --git a/src/concrete_sci/convex.ts b/src/concrete_sci/convex.ts
new file mode 100644
index 000000000..4073753b9
--- /dev/null
+++ b/src/concrete_sci/convex.ts
@@ -0,0 +1,14 @@
+/** concrete_sci convex module — tsb analytics library. */
+export interface ConcreteSciConvexOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciConvexResult { values: number[]; converged: boolean; }
+export function computeConcreteSciConvex(data: number[], opts: ConcreteSciConvexOptions = {}): ConcreteSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciConvex };
diff --git a/src/concrete_sci/correlation.ts b/src/concrete_sci/correlation.ts
new file mode 100644
index 000000000..f1c5fa99e
--- /dev/null
+++ b/src/concrete_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci correlation module — tsb analytics library. */
+export interface ConcreteSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciCorrelation(data: number[], opts: ConcreteSciCorrelationOptions = {}): ConcreteSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciCorrelation };
diff --git a/src/concrete_sci/covariance.ts b/src/concrete_sci/covariance.ts
new file mode 100644
index 000000000..f5f10c6f2
--- /dev/null
+++ b/src/concrete_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** concrete_sci covariance module — tsb analytics library. */
+export interface ConcreteSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeConcreteSciCovariance(data: number[], opts: ConcreteSciCovarianceOptions = {}): ConcreteSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciCovariance };
diff --git a/src/concrete_sci/cross_validation.ts b/src/concrete_sci/cross_validation.ts
new file mode 100644
index 000000000..b79ab2a89
--- /dev/null
+++ b/src/concrete_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci cross_validation module — tsb analytics library. */
+export interface ConcreteSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciCrossValidation(data: number[], opts: ConcreteSciCrossValidationOptions = {}): ConcreteSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciCrossValidation };
diff --git a/src/concrete_sci/decoding.ts b/src/concrete_sci/decoding.ts
new file mode 100644
index 000000000..2848af0bc
--- /dev/null
+++ b/src/concrete_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** concrete_sci decoding module — tsb analytics library. */
+export interface ConcreteSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDecodingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDecoding(data: number[], opts: ConcreteSciDecodingOptions = {}): ConcreteSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDecoding };
diff --git a/src/concrete_sci/decomposition.ts b/src/concrete_sci/decomposition.ts
new file mode 100644
index 000000000..6a83ad182
--- /dev/null
+++ b/src/concrete_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** concrete_sci decomposition module — tsb analytics library. */
+export interface ConcreteSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDecomposition(data: number[], opts: ConcreteSciDecompositionOptions = {}): ConcreteSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDecomposition };
diff --git a/src/concrete_sci/detection.ts b/src/concrete_sci/detection.ts
new file mode 100644
index 000000000..80ac4dc1e
--- /dev/null
+++ b/src/concrete_sci/detection.ts
@@ -0,0 +1,14 @@
+/** concrete_sci detection module — tsb analytics library. */
+export interface ConcreteSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDetectionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDetection(data: number[], opts: ConcreteSciDetectionOptions = {}): ConcreteSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDetection };
diff --git a/src/concrete_sci/deterministic.ts b/src/concrete_sci/deterministic.ts
new file mode 100644
index 000000000..4bea48456
--- /dev/null
+++ b/src/concrete_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** concrete_sci deterministic module — tsb analytics library. */
+export interface ConcreteSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDeterministic(data: number[], opts: ConcreteSciDeterministicOptions = {}): ConcreteSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDeterministic };
diff --git a/src/concrete_sci/diagnostics.ts b/src/concrete_sci/diagnostics.ts
new file mode 100644
index 000000000..ef18901d4
--- /dev/null
+++ b/src/concrete_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** concrete_sci diagnostics module — tsb analytics library. */
+export interface ConcreteSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDiagnostics(data: number[], opts: ConcreteSciDiagnosticsOptions = {}): ConcreteSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDiagnostics };
diff --git a/src/concrete_sci/differential.ts b/src/concrete_sci/differential.ts
new file mode 100644
index 000000000..270ff5ade
--- /dev/null
+++ b/src/concrete_sci/differential.ts
@@ -0,0 +1,14 @@
+/** concrete_sci differential module — tsb analytics library. */
+export interface ConcreteSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDifferential(data: number[], opts: ConcreteSciDifferentialOptions = {}): ConcreteSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDifferential };
diff --git a/src/concrete_sci/discrete.ts b/src/concrete_sci/discrete.ts
new file mode 100644
index 000000000..65e10ab26
--- /dev/null
+++ b/src/concrete_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** concrete_sci discrete module — tsb analytics library. */
+export interface ConcreteSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDiscrete(data: number[], opts: ConcreteSciDiscreteOptions = {}): ConcreteSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDiscrete };
diff --git a/src/concrete_sci/distribution.ts b/src/concrete_sci/distribution.ts
new file mode 100644
index 000000000..c7f1847a7
--- /dev/null
+++ b/src/concrete_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** concrete_sci distribution module — tsb analytics library. */
+export interface ConcreteSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDistributionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDistribution(data: number[], opts: ConcreteSciDistributionOptions = {}): ConcreteSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDistribution };
diff --git a/src/concrete_sci/dynamic.ts b/src/concrete_sci/dynamic.ts
new file mode 100644
index 000000000..a0046863e
--- /dev/null
+++ b/src/concrete_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** concrete_sci dynamic module — tsb analytics library. */
+export interface ConcreteSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciDynamicResult { values: number[]; converged: boolean; }
+export function computeConcreteSciDynamic(data: number[], opts: ConcreteSciDynamicOptions = {}): ConcreteSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciDynamic };
diff --git a/src/concrete_sci/embedding.ts b/src/concrete_sci/embedding.ts
new file mode 100644
index 000000000..0f5e4db99
--- /dev/null
+++ b/src/concrete_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** concrete_sci embedding module — tsb analytics library. */
+export interface ConcreteSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciEmbedding(data: number[], opts: ConcreteSciEmbeddingOptions = {}): ConcreteSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciEmbedding };
diff --git a/src/concrete_sci/encoding.ts b/src/concrete_sci/encoding.ts
new file mode 100644
index 000000000..abe4565bc
--- /dev/null
+++ b/src/concrete_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** concrete_sci encoding module — tsb analytics library. */
+export interface ConcreteSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciEncodingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciEncoding(data: number[], opts: ConcreteSciEncodingOptions = {}): ConcreteSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciEncoding };
diff --git a/src/concrete_sci/ensemble.ts b/src/concrete_sci/ensemble.ts
new file mode 100644
index 000000000..d6eaf7fdc
--- /dev/null
+++ b/src/concrete_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** concrete_sci ensemble module — tsb analytics library. */
+export interface ConcreteSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeConcreteSciEnsemble(data: number[], opts: ConcreteSciEnsembleOptions = {}): ConcreteSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciEnsemble };
diff --git a/src/concrete_sci/estimation.ts b/src/concrete_sci/estimation.ts
new file mode 100644
index 000000000..5a275cbe0
--- /dev/null
+++ b/src/concrete_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci estimation module — tsb analytics library. */
+export interface ConcreteSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciEstimationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciEstimation(data: number[], opts: ConcreteSciEstimationOptions = {}): ConcreteSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciEstimation };
diff --git a/src/concrete_sci/evaluation.ts b/src/concrete_sci/evaluation.ts
new file mode 100644
index 000000000..429f100a1
--- /dev/null
+++ b/src/concrete_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci evaluation module — tsb analytics library. */
+export interface ConcreteSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciEvaluation(data: number[], opts: ConcreteSciEvaluationOptions = {}): ConcreteSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciEvaluation };
diff --git a/src/concrete_sci/extrapolation.ts b/src/concrete_sci/extrapolation.ts
new file mode 100644
index 000000000..7b3a4d162
--- /dev/null
+++ b/src/concrete_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci extrapolation module — tsb analytics library. */
+export interface ConcreteSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciExtrapolation(data: number[], opts: ConcreteSciExtrapolationOptions = {}): ConcreteSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciExtrapolation };
diff --git a/src/concrete_sci/features.ts b/src/concrete_sci/features.ts
new file mode 100644
index 000000000..8a52eb0a8
--- /dev/null
+++ b/src/concrete_sci/features.ts
@@ -0,0 +1,14 @@
+/** concrete_sci features module — tsb analytics library. */
+export interface ConcreteSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeConcreteSciFeatures(data: number[], opts: ConcreteSciFeaturesOptions = {}): ConcreteSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciFeatures };
diff --git a/src/concrete_sci/feedback.ts b/src/concrete_sci/feedback.ts
new file mode 100644
index 000000000..fba0467ca
--- /dev/null
+++ b/src/concrete_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** concrete_sci feedback module — tsb analytics library. */
+export interface ConcreteSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeConcreteSciFeedback(data: number[], opts: ConcreteSciFeedbackOptions = {}): ConcreteSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciFeedback };
diff --git a/src/concrete_sci/filtering.ts b/src/concrete_sci/filtering.ts
new file mode 100644
index 000000000..39de0457a
--- /dev/null
+++ b/src/concrete_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** concrete_sci filtering module — tsb analytics library. */
+export interface ConcreteSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciFilteringResult { values: number[]; converged: boolean; }
+export function computeConcreteSciFiltering(data: number[], opts: ConcreteSciFilteringOptions = {}): ConcreteSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciFiltering };
diff --git a/src/concrete_sci/fourier.ts b/src/concrete_sci/fourier.ts
new file mode 100644
index 000000000..279216a13
--- /dev/null
+++ b/src/concrete_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** concrete_sci fourier module — tsb analytics library. */
+export interface ConcreteSciFourierOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciFourierResult { values: number[]; converged: boolean; }
+export function computeConcreteSciFourier(data: number[], opts: ConcreteSciFourierOptions = {}): ConcreteSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciFourier };
diff --git a/src/concrete_sci/fusion.ts b/src/concrete_sci/fusion.ts
new file mode 100644
index 000000000..f88a59de0
--- /dev/null
+++ b/src/concrete_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** concrete_sci fusion module — tsb analytics library. */
+export interface ConcreteSciFusionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciFusionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciFusion(data: number[], opts: ConcreteSciFusionOptions = {}): ConcreteSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciFusion };
diff --git a/src/concrete_sci/generation.ts b/src/concrete_sci/generation.ts
new file mode 100644
index 000000000..d7dd5ebd6
--- /dev/null
+++ b/src/concrete_sci/generation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci generation module — tsb analytics library. */
+export interface ConcreteSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciGenerationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciGeneration(data: number[], opts: ConcreteSciGenerationOptions = {}): ConcreteSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciGeneration };
diff --git a/src/concrete_sci/geometry.ts b/src/concrete_sci/geometry.ts
new file mode 100644
index 000000000..406999ead
--- /dev/null
+++ b/src/concrete_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** concrete_sci geometry module — tsb analytics library. */
+export interface ConcreteSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciGeometryResult { values: number[]; converged: boolean; }
+export function computeConcreteSciGeometry(data: number[], opts: ConcreteSciGeometryOptions = {}): ConcreteSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciGeometry };
diff --git a/src/concrete_sci/gradient.ts b/src/concrete_sci/gradient.ts
new file mode 100644
index 000000000..9ffe94de8
--- /dev/null
+++ b/src/concrete_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** concrete_sci gradient module — tsb analytics library. */
+export interface ConcreteSciGradientOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciGradientResult { values: number[]; converged: boolean; }
+export function computeConcreteSciGradient(data: number[], opts: ConcreteSciGradientOptions = {}): ConcreteSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciGradient };
diff --git a/src/concrete_sci/hessian.ts b/src/concrete_sci/hessian.ts
new file mode 100644
index 000000000..1d6042552
--- /dev/null
+++ b/src/concrete_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** concrete_sci hessian module — tsb analytics library. */
+export interface ConcreteSciHessianOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciHessianResult { values: number[]; converged: boolean; }
+export function computeConcreteSciHessian(data: number[], opts: ConcreteSciHessianOptions = {}): ConcreteSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciHessian };
diff --git a/src/concrete_sci/hypothesis.ts b/src/concrete_sci/hypothesis.ts
new file mode 100644
index 000000000..c2c91ed01
--- /dev/null
+++ b/src/concrete_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** concrete_sci hypothesis module — tsb analytics library. */
+export interface ConcreteSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeConcreteSciHypothesis(data: number[], opts: ConcreteSciHypothesisOptions = {}): ConcreteSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciHypothesis };
diff --git a/src/concrete_sci/inference.ts b/src/concrete_sci/inference.ts
new file mode 100644
index 000000000..6780d1fe1
--- /dev/null
+++ b/src/concrete_sci/inference.ts
@@ -0,0 +1,14 @@
+/** concrete_sci inference module — tsb analytics library. */
+export interface ConcreteSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciInferenceResult { values: number[]; converged: boolean; }
+export function computeConcreteSciInference(data: number[], opts: ConcreteSciInferenceOptions = {}): ConcreteSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciInference };
diff --git a/src/concrete_sci/inference2.ts b/src/concrete_sci/inference2.ts
new file mode 100644
index 000000000..b33328316
--- /dev/null
+++ b/src/concrete_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** concrete_sci inference2 module — tsb analytics library. */
+export interface ConcreteSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciInferenceResult { values: number[]; converged: boolean; }
+export function computeConcreteSciInference(data: number[], opts: ConcreteSciInferenceOptions = {}): ConcreteSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciInference };
diff --git a/src/concrete_sci/integral.ts b/src/concrete_sci/integral.ts
new file mode 100644
index 000000000..75430b70e
--- /dev/null
+++ b/src/concrete_sci/integral.ts
@@ -0,0 +1,14 @@
+/** concrete_sci integral module — tsb analytics library. */
+export interface ConcreteSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciIntegralResult { values: number[]; converged: boolean; }
+export function computeConcreteSciIntegral(data: number[], opts: ConcreteSciIntegralOptions = {}): ConcreteSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciIntegral };
diff --git a/src/concrete_sci/integration.ts b/src/concrete_sci/integration.ts
new file mode 100644
index 000000000..40df632cc
--- /dev/null
+++ b/src/concrete_sci/integration.ts
@@ -0,0 +1,14 @@
+/** concrete_sci integration module — tsb analytics library. */
+export interface ConcreteSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciIntegration(data: number[], opts: ConcreteSciIntegrationOptions = {}): ConcreteSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciIntegration };
diff --git a/src/concrete_sci/interpolation.ts b/src/concrete_sci/interpolation.ts
new file mode 100644
index 000000000..8e46a49df
--- /dev/null
+++ b/src/concrete_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci interpolation module — tsb analytics library. */
+export interface ConcreteSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciInterpolation(data: number[], opts: ConcreteSciInterpolationOptions = {}): ConcreteSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciInterpolation };
diff --git a/src/concrete_sci/jacobian.ts b/src/concrete_sci/jacobian.ts
new file mode 100644
index 000000000..e5d69ec3c
--- /dev/null
+++ b/src/concrete_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** concrete_sci jacobian module — tsb analytics library. */
+export interface ConcreteSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciJacobianResult { values: number[]; converged: boolean; }
+export function computeConcreteSciJacobian(data: number[], opts: ConcreteSciJacobianOptions = {}): ConcreteSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciJacobian };
diff --git a/src/concrete_sci/kernel.ts b/src/concrete_sci/kernel.ts
new file mode 100644
index 000000000..9247242c5
--- /dev/null
+++ b/src/concrete_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** concrete_sci kernel module — tsb analytics library. */
+export interface ConcreteSciKernelOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciKernelResult { values: number[]; converged: boolean; }
+export function computeConcreteSciKernel(data: number[], opts: ConcreteSciKernelOptions = {}): ConcreteSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciKernel };
diff --git a/src/concrete_sci/laplacian.ts b/src/concrete_sci/laplacian.ts
new file mode 100644
index 000000000..fe1c29b9c
--- /dev/null
+++ b/src/concrete_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** concrete_sci laplacian module — tsb analytics library. */
+export interface ConcreteSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeConcreteSciLaplacian(data: number[], opts: ConcreteSciLaplacianOptions = {}): ConcreteSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciLaplacian };
diff --git a/src/concrete_sci/learning.ts b/src/concrete_sci/learning.ts
new file mode 100644
index 000000000..8a0ddbf53
--- /dev/null
+++ b/src/concrete_sci/learning.ts
@@ -0,0 +1,14 @@
+/** concrete_sci learning module — tsb analytics library. */
+export interface ConcreteSciLearningOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciLearningResult { values: number[]; converged: boolean; }
+export function computeConcreteSciLearning(data: number[], opts: ConcreteSciLearningOptions = {}): ConcreteSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciLearning };
diff --git a/src/concrete_sci/linear.ts b/src/concrete_sci/linear.ts
new file mode 100644
index 000000000..e57511a62
--- /dev/null
+++ b/src/concrete_sci/linear.ts
@@ -0,0 +1,14 @@
+/** concrete_sci linear module — tsb analytics library. */
+export interface ConcreteSciLinearOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciLinearResult { values: number[]; converged: boolean; }
+export function computeConcreteSciLinear(data: number[], opts: ConcreteSciLinearOptions = {}): ConcreteSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciLinear };
diff --git a/src/concrete_sci/manifold.ts b/src/concrete_sci/manifold.ts
new file mode 100644
index 000000000..a1e439254
--- /dev/null
+++ b/src/concrete_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** concrete_sci manifold module — tsb analytics library. */
+export interface ConcreteSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciManifoldResult { values: number[]; converged: boolean; }
+export function computeConcreteSciManifold(data: number[], opts: ConcreteSciManifoldOptions = {}): ConcreteSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciManifold };
diff --git a/src/concrete_sci/matching.ts b/src/concrete_sci/matching.ts
new file mode 100644
index 000000000..aa9476984
--- /dev/null
+++ b/src/concrete_sci/matching.ts
@@ -0,0 +1,14 @@
+/** concrete_sci matching module — tsb analytics library. */
+export interface ConcreteSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciMatchingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciMatching(data: number[], opts: ConcreteSciMatchingOptions = {}): ConcreteSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciMatching };
diff --git a/src/concrete_sci/measurement.ts b/src/concrete_sci/measurement.ts
new file mode 100644
index 000000000..5b208026a
--- /dev/null
+++ b/src/concrete_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** concrete_sci measurement module — tsb analytics library. */
+export interface ConcreteSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeConcreteSciMeasurement(data: number[], opts: ConcreteSciMeasurementOptions = {}): ConcreteSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciMeasurement };
diff --git a/src/concrete_sci/metrics.ts b/src/concrete_sci/metrics.ts
new file mode 100644
index 000000000..e4a386a2e
--- /dev/null
+++ b/src/concrete_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** concrete_sci metrics module — tsb analytics library. */
+export interface ConcreteSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciMetricsResult { values: number[]; converged: boolean; }
+export function computeConcreteSciMetrics(data: number[], opts: ConcreteSciMetricsOptions = {}): ConcreteSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciMetrics };
diff --git a/src/concrete_sci/modeling.ts b/src/concrete_sci/modeling.ts
new file mode 100644
index 000000000..c86ef45ce
--- /dev/null
+++ b/src/concrete_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** concrete_sci modeling module — tsb analytics library. */
+export interface ConcreteSciModelingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciModelingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciModeling(data: number[], opts: ConcreteSciModelingOptions = {}): ConcreteSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciModeling };
diff --git a/src/concrete_sci/monitoring.ts b/src/concrete_sci/monitoring.ts
new file mode 100644
index 000000000..c151ad79d
--- /dev/null
+++ b/src/concrete_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** concrete_sci monitoring module — tsb analytics library. */
+export interface ConcreteSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeConcreteSciMonitoring(data: number[], opts: ConcreteSciMonitoringOptions = {}): ConcreteSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciMonitoring };
diff --git a/src/concrete_sci/nonlinear.ts b/src/concrete_sci/nonlinear.ts
new file mode 100644
index 000000000..76888fc51
--- /dev/null
+++ b/src/concrete_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** concrete_sci nonlinear module — tsb analytics library. */
+export interface ConcreteSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeConcreteSciNonlinear(data: number[], opts: ConcreteSciNonlinearOptions = {}): ConcreteSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciNonlinear };
diff --git a/src/concrete_sci/normalization.ts b/src/concrete_sci/normalization.ts
new file mode 100644
index 000000000..2a2ee6f27
--- /dev/null
+++ b/src/concrete_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** concrete_sci normalization module — tsb analytics library. */
+export interface ConcreteSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciNormalization(data: number[], opts: ConcreteSciNormalizationOptions = {}): ConcreteSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciNormalization };
diff --git a/src/concrete_sci/optimization.ts b/src/concrete_sci/optimization.ts
new file mode 100644
index 000000000..3994ebefd
--- /dev/null
+++ b/src/concrete_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** concrete_sci optimization module — tsb analytics library. */
+export interface ConcreteSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciOptimization(data: number[], opts: ConcreteSciOptimizationOptions = {}): ConcreteSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciOptimization };
diff --git a/src/concrete_sci/patterns.ts b/src/concrete_sci/patterns.ts
new file mode 100644
index 000000000..9c0b87343
--- /dev/null
+++ b/src/concrete_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** concrete_sci patterns module — tsb analytics library. */
+export interface ConcreteSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciPatternsResult { values: number[]; converged: boolean; }
+export function computeConcreteSciPatterns(data: number[], opts: ConcreteSciPatternsOptions = {}): ConcreteSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciPatterns };
diff --git a/src/concrete_sci/permutation.ts b/src/concrete_sci/permutation.ts
new file mode 100644
index 000000000..0e2a8de51
--- /dev/null
+++ b/src/concrete_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci permutation module — tsb analytics library. */
+export interface ConcreteSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciPermutationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciPermutation(data: number[], opts: ConcreteSciPermutationOptions = {}): ConcreteSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciPermutation };
diff --git a/src/concrete_sci/prediction.ts b/src/concrete_sci/prediction.ts
new file mode 100644
index 000000000..8e315deff
--- /dev/null
+++ b/src/concrete_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** concrete_sci prediction module — tsb analytics library. */
+export interface ConcreteSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciPredictionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciPrediction(data: number[], opts: ConcreteSciPredictionOptions = {}): ConcreteSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciPrediction };
diff --git a/src/concrete_sci/processing.ts b/src/concrete_sci/processing.ts
new file mode 100644
index 000000000..387bf8af3
--- /dev/null
+++ b/src/concrete_sci/processing.ts
@@ -0,0 +1,14 @@
+/** concrete_sci processing module — tsb analytics library. */
+export interface ConcreteSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciProcessingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciProcessing(data: number[], opts: ConcreteSciProcessingOptions = {}): ConcreteSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciProcessing };
diff --git a/src/concrete_sci/profiling.ts b/src/concrete_sci/profiling.ts
new file mode 100644
index 000000000..b0ae2ba62
--- /dev/null
+++ b/src/concrete_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** concrete_sci profiling module — tsb analytics library. */
+export interface ConcreteSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciProfilingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciProfiling(data: number[], opts: ConcreteSciProfilingOptions = {}): ConcreteSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciProfiling };
diff --git a/src/concrete_sci/projection.ts b/src/concrete_sci/projection.ts
new file mode 100644
index 000000000..eb5bb6858
--- /dev/null
+++ b/src/concrete_sci/projection.ts
@@ -0,0 +1,14 @@
+/** concrete_sci projection module — tsb analytics library. */
+export interface ConcreteSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciProjectionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciProjection(data: number[], opts: ConcreteSciProjectionOptions = {}): ConcreteSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciProjection };
diff --git a/src/concrete_sci/ranking.ts b/src/concrete_sci/ranking.ts
new file mode 100644
index 000000000..8ad7cb57e
--- /dev/null
+++ b/src/concrete_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** concrete_sci ranking module — tsb analytics library. */
+export interface ConcreteSciRankingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciRankingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciRanking(data: number[], opts: ConcreteSciRankingOptions = {}): ConcreteSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciRanking };
diff --git a/src/concrete_sci/reconstruction.ts b/src/concrete_sci/reconstruction.ts
new file mode 100644
index 000000000..6bc94ca90
--- /dev/null
+++ b/src/concrete_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** concrete_sci reconstruction module — tsb analytics library. */
+export interface ConcreteSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciReconstruction(data: number[], opts: ConcreteSciReconstructionOptions = {}): ConcreteSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciReconstruction };
diff --git a/src/concrete_sci/registration.ts b/src/concrete_sci/registration.ts
new file mode 100644
index 000000000..fdaa98375
--- /dev/null
+++ b/src/concrete_sci/registration.ts
@@ -0,0 +1,14 @@
+/** concrete_sci registration module — tsb analytics library. */
+export interface ConcreteSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciRegistration(data: number[], opts: ConcreteSciRegistrationOptions = {}): ConcreteSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciRegistration };
diff --git a/src/concrete_sci/regression.ts b/src/concrete_sci/regression.ts
new file mode 100644
index 000000000..1a5d38799
--- /dev/null
+++ b/src/concrete_sci/regression.ts
@@ -0,0 +1,14 @@
+/** concrete_sci regression module — tsb analytics library. */
+export interface ConcreteSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciRegressionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciRegression(data: number[], opts: ConcreteSciRegressionOptions = {}): ConcreteSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciRegression };
diff --git a/src/concrete_sci/regularization.ts b/src/concrete_sci/regularization.ts
new file mode 100644
index 000000000..b428acee7
--- /dev/null
+++ b/src/concrete_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** concrete_sci regularization module — tsb analytics library. */
+export interface ConcreteSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciRegularization(data: number[], opts: ConcreteSciRegularizationOptions = {}): ConcreteSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciRegularization };
diff --git a/src/concrete_sci/robustness.ts b/src/concrete_sci/robustness.ts
new file mode 100644
index 000000000..b22557670
--- /dev/null
+++ b/src/concrete_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** concrete_sci robustness module — tsb analytics library. */
+export interface ConcreteSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeConcreteSciRobustness(data: number[], opts: ConcreteSciRobustnessOptions = {}): ConcreteSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciRobustness };
diff --git a/src/concrete_sci/sampling.ts b/src/concrete_sci/sampling.ts
new file mode 100644
index 000000000..e4a156cfe
--- /dev/null
+++ b/src/concrete_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** concrete_sci sampling module — tsb analytics library. */
+export interface ConcreteSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciSamplingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciSampling(data: number[], opts: ConcreteSciSamplingOptions = {}): ConcreteSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciSampling };
diff --git a/src/concrete_sci/sampling2.ts b/src/concrete_sci/sampling2.ts
new file mode 100644
index 000000000..08c27cead
--- /dev/null
+++ b/src/concrete_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** concrete_sci sampling2 module — tsb analytics library. */
+export interface ConcreteSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciSamplingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciSampling(data: number[], opts: ConcreteSciSamplingOptions = {}): ConcreteSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciSampling };
diff --git a/src/concrete_sci/scaling.ts b/src/concrete_sci/scaling.ts
new file mode 100644
index 000000000..256356f4b
--- /dev/null
+++ b/src/concrete_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** concrete_sci scaling module — tsb analytics library. */
+export interface ConcreteSciScalingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciScalingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciScaling(data: number[], opts: ConcreteSciScalingOptions = {}): ConcreteSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciScaling };
diff --git a/src/concrete_sci/scoring.ts b/src/concrete_sci/scoring.ts
new file mode 100644
index 000000000..653638bff
--- /dev/null
+++ b/src/concrete_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** concrete_sci scoring module — tsb analytics library. */
+export interface ConcreteSciScoringOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciScoringResult { values: number[]; converged: boolean; }
+export function computeConcreteSciScoring(data: number[], opts: ConcreteSciScoringOptions = {}): ConcreteSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciScoring };
diff --git a/src/concrete_sci/segmentation.ts b/src/concrete_sci/segmentation.ts
new file mode 100644
index 000000000..cdf6061cc
--- /dev/null
+++ b/src/concrete_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci segmentation module — tsb analytics library. */
+export interface ConcreteSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciSegmentation(data: number[], opts: ConcreteSciSegmentationOptions = {}): ConcreteSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciSegmentation };
diff --git a/src/concrete_sci/selection.ts b/src/concrete_sci/selection.ts
new file mode 100644
index 000000000..d4a32a213
--- /dev/null
+++ b/src/concrete_sci/selection.ts
@@ -0,0 +1,14 @@
+/** concrete_sci selection module — tsb analytics library. */
+export interface ConcreteSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciSelectionResult { values: number[]; converged: boolean; }
+export function computeConcreteSciSelection(data: number[], opts: ConcreteSciSelectionOptions = {}): ConcreteSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciSelection };
diff --git a/src/concrete_sci/sensitivity.ts b/src/concrete_sci/sensitivity.ts
new file mode 100644
index 000000000..ee27d25a4
--- /dev/null
+++ b/src/concrete_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** concrete_sci sensitivity module — tsb analytics library. */
+export interface ConcreteSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeConcreteSciSensitivity(data: number[], opts: ConcreteSciSensitivityOptions = {}): ConcreteSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciSensitivity };
diff --git a/src/concrete_sci/simulation.ts b/src/concrete_sci/simulation.ts
new file mode 100644
index 000000000..16119c09b
--- /dev/null
+++ b/src/concrete_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci simulation module — tsb analytics library. */
+export interface ConcreteSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciSimulationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciSimulation(data: number[], opts: ConcreteSciSimulationOptions = {}): ConcreteSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciSimulation };
diff --git a/src/concrete_sci/smoothing.ts b/src/concrete_sci/smoothing.ts
new file mode 100644
index 000000000..8cf2548ca
--- /dev/null
+++ b/src/concrete_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** concrete_sci smoothing module — tsb analytics library. */
+export interface ConcreteSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciSmoothing(data: number[], opts: ConcreteSciSmoothingOptions = {}): ConcreteSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciSmoothing };
diff --git a/src/concrete_sci/stability.ts b/src/concrete_sci/stability.ts
new file mode 100644
index 000000000..64cfe6340
--- /dev/null
+++ b/src/concrete_sci/stability.ts
@@ -0,0 +1,14 @@
+/** concrete_sci stability module — tsb analytics library. */
+export interface ConcreteSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciStabilityResult { values: number[]; converged: boolean; }
+export function computeConcreteSciStability(data: number[], opts: ConcreteSciStabilityOptions = {}): ConcreteSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciStability };
diff --git a/src/concrete_sci/stacking.ts b/src/concrete_sci/stacking.ts
new file mode 100644
index 000000000..e00ee2eb9
--- /dev/null
+++ b/src/concrete_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** concrete_sci stacking module — tsb analytics library. */
+export interface ConcreteSciStackingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciStackingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciStacking(data: number[], opts: ConcreteSciStackingOptions = {}): ConcreteSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciStacking };
diff --git a/src/concrete_sci/standardization.ts b/src/concrete_sci/standardization.ts
new file mode 100644
index 000000000..62dba9fac
--- /dev/null
+++ b/src/concrete_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** concrete_sci standardization module — tsb analytics library. */
+export interface ConcreteSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciStandardization(data: number[], opts: ConcreteSciStandardizationOptions = {}): ConcreteSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciStandardization };
diff --git a/src/concrete_sci/static.ts b/src/concrete_sci/static.ts
new file mode 100644
index 000000000..74a2e45f4
--- /dev/null
+++ b/src/concrete_sci/static.ts
@@ -0,0 +1,14 @@
+/** concrete_sci static module — tsb analytics library. */
+export interface ConcreteSciStaticOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciStaticResult { values: number[]; converged: boolean; }
+export function computeConcreteSciStatic(data: number[], opts: ConcreteSciStaticOptions = {}): ConcreteSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciStatic };
diff --git a/src/concrete_sci/stochastic.ts b/src/concrete_sci/stochastic.ts
new file mode 100644
index 000000000..f63235593
--- /dev/null
+++ b/src/concrete_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** concrete_sci stochastic module — tsb analytics library. */
+export interface ConcreteSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciStochasticResult { values: number[]; converged: boolean; }
+export function computeConcreteSciStochastic(data: number[], opts: ConcreteSciStochasticOptions = {}): ConcreteSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciStochastic };
diff --git a/src/concrete_sci/synthesis.ts b/src/concrete_sci/synthesis.ts
new file mode 100644
index 000000000..b62eacecd
--- /dev/null
+++ b/src/concrete_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** concrete_sci synthesis module — tsb analytics library. */
+export interface ConcreteSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeConcreteSciSynthesis(data: number[], opts: ConcreteSciSynthesisOptions = {}): ConcreteSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciSynthesis };
diff --git a/src/concrete_sci/topology.ts b/src/concrete_sci/topology.ts
new file mode 100644
index 000000000..3c3b90a7a
--- /dev/null
+++ b/src/concrete_sci/topology.ts
@@ -0,0 +1,14 @@
+/** concrete_sci topology module — tsb analytics library. */
+export interface ConcreteSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciTopologyResult { values: number[]; converged: boolean; }
+export function computeConcreteSciTopology(data: number[], opts: ConcreteSciTopologyOptions = {}): ConcreteSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciTopology };
diff --git a/src/concrete_sci/tracking.ts b/src/concrete_sci/tracking.ts
new file mode 100644
index 000000000..f8eca00a7
--- /dev/null
+++ b/src/concrete_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** concrete_sci tracking module — tsb analytics library. */
+export interface ConcreteSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciTrackingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciTracking(data: number[], opts: ConcreteSciTrackingOptions = {}): ConcreteSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciTracking };
diff --git a/src/concrete_sci/transform.ts b/src/concrete_sci/transform.ts
new file mode 100644
index 000000000..4b559b1c0
--- /dev/null
+++ b/src/concrete_sci/transform.ts
@@ -0,0 +1,14 @@
+/** concrete_sci transform module — tsb analytics library. */
+export interface ConcreteSciTransformOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciTransformResult { values: number[]; converged: boolean; }
+export function computeConcreteSciTransform(data: number[], opts: ConcreteSciTransformOptions = {}): ConcreteSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciTransform };
diff --git a/src/concrete_sci/uncertainty.ts b/src/concrete_sci/uncertainty.ts
new file mode 100644
index 000000000..f235a2c8b
--- /dev/null
+++ b/src/concrete_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** concrete_sci uncertainty module — tsb analytics library. */
+export interface ConcreteSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeConcreteSciUncertainty(data: number[], opts: ConcreteSciUncertaintyOptions = {}): ConcreteSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciUncertainty };
diff --git a/src/concrete_sci/validation.ts b/src/concrete_sci/validation.ts
new file mode 100644
index 000000000..5b30edd32
--- /dev/null
+++ b/src/concrete_sci/validation.ts
@@ -0,0 +1,14 @@
+/** concrete_sci validation module — tsb analytics library. */
+export interface ConcreteSciValidationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciValidationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciValidation(data: number[], opts: ConcreteSciValidationOptions = {}): ConcreteSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciValidation };
diff --git a/src/concrete_sci/verification.ts b/src/concrete_sci/verification.ts
new file mode 100644
index 000000000..13ed20950
--- /dev/null
+++ b/src/concrete_sci/verification.ts
@@ -0,0 +1,14 @@
+/** concrete_sci verification module — tsb analytics library. */
+export interface ConcreteSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciVerificationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciVerification(data: number[], opts: ConcreteSciVerificationOptions = {}): ConcreteSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciVerification };
diff --git a/src/concrete_sci/visualization.ts b/src/concrete_sci/visualization.ts
new file mode 100644
index 000000000..c7237f820
--- /dev/null
+++ b/src/concrete_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** concrete_sci visualization module — tsb analytics library. */
+export interface ConcreteSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeConcreteSciVisualization(data: number[], opts: ConcreteSciVisualizationOptions = {}): ConcreteSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciVisualization };
diff --git a/src/concrete_sci/voting.ts b/src/concrete_sci/voting.ts
new file mode 100644
index 000000000..4180d7fe5
--- /dev/null
+++ b/src/concrete_sci/voting.ts
@@ -0,0 +1,14 @@
+/** concrete_sci voting module — tsb analytics library. */
+export interface ConcreteSciVotingOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciVotingResult { values: number[]; converged: boolean; }
+export function computeConcreteSciVoting(data: number[], opts: ConcreteSciVotingOptions = {}): ConcreteSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciVoting };
diff --git a/src/concrete_sci/wavelet.ts b/src/concrete_sci/wavelet.ts
new file mode 100644
index 000000000..a026201ca
--- /dev/null
+++ b/src/concrete_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** concrete_sci wavelet module — tsb analytics library. */
+export interface ConcreteSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface ConcreteSciWaveletResult { values: number[]; converged: boolean; }
+export function computeConcreteSciWavelet(data: number[], opts: ConcreteSciWaveletOptions = {}): ConcreteSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeConcreteSciWavelet };
diff --git a/src/continuum_mech/adaptation.ts b/src/continuum_mech/adaptation.ts
new file mode 100644
index 000000000..64a5974db
--- /dev/null
+++ b/src/continuum_mech/adaptation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech adaptation module — tsb analytics library. */
+export interface ContinuumMechAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechAdaptationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechAdaptation(data: number[], opts: ContinuumMechAdaptationOptions = {}): ContinuumMechAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechAdaptation };
diff --git a/src/continuum_mech/aggregation.ts b/src/continuum_mech/aggregation.ts
new file mode 100644
index 000000000..9b8062011
--- /dev/null
+++ b/src/continuum_mech/aggregation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech aggregation module — tsb analytics library. */
+export interface ContinuumMechAggregationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechAggregationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechAggregation(data: number[], opts: ContinuumMechAggregationOptions = {}): ContinuumMechAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechAggregation };
diff --git a/src/continuum_mech/algebra.ts b/src/continuum_mech/algebra.ts
new file mode 100644
index 000000000..ba395320f
--- /dev/null
+++ b/src/continuum_mech/algebra.ts
@@ -0,0 +1,14 @@
+/** continuum_mech algebra module — tsb analytics library. */
+export interface ContinuumMechAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechAlgebraResult { values: number[]; converged: boolean; }
+export function computeContinuumMechAlgebra(data: number[], opts: ContinuumMechAlgebraOptions = {}): ContinuumMechAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechAlgebra };
diff --git a/src/continuum_mech/alignment.ts b/src/continuum_mech/alignment.ts
new file mode 100644
index 000000000..99fb14a07
--- /dev/null
+++ b/src/continuum_mech/alignment.ts
@@ -0,0 +1,14 @@
+/** continuum_mech alignment module — tsb analytics library. */
+export interface ContinuumMechAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechAlignmentResult { values: number[]; converged: boolean; }
+export function computeContinuumMechAlignment(data: number[], opts: ContinuumMechAlignmentOptions = {}): ContinuumMechAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechAlignment };
diff --git a/src/continuum_mech/analysis.ts b/src/continuum_mech/analysis.ts
new file mode 100644
index 000000000..ba10d4fb8
--- /dev/null
+++ b/src/continuum_mech/analysis.ts
@@ -0,0 +1,14 @@
+/** continuum_mech analysis module — tsb analytics library. */
+export interface ContinuumMechAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechAnalysisResult { values: number[]; converged: boolean; }
+export function computeContinuumMechAnalysis(data: number[], opts: ContinuumMechAnalysisOptions = {}): ContinuumMechAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechAnalysis };
diff --git a/src/continuum_mech/augmentation.ts b/src/continuum_mech/augmentation.ts
new file mode 100644
index 000000000..886c62053
--- /dev/null
+++ b/src/continuum_mech/augmentation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech augmentation module — tsb analytics library. */
+export interface ContinuumMechAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechAugmentationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechAugmentation(data: number[], opts: ContinuumMechAugmentationOptions = {}): ContinuumMechAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechAugmentation };
diff --git a/src/continuum_mech/bagging.ts b/src/continuum_mech/bagging.ts
new file mode 100644
index 000000000..677942731
--- /dev/null
+++ b/src/continuum_mech/bagging.ts
@@ -0,0 +1,14 @@
+/** continuum_mech bagging module — tsb analytics library. */
+export interface ContinuumMechBaggingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechBaggingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechBagging(data: number[], opts: ContinuumMechBaggingOptions = {}): ContinuumMechBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechBagging };
diff --git a/src/continuum_mech/basis.ts b/src/continuum_mech/basis.ts
new file mode 100644
index 000000000..4301769a3
--- /dev/null
+++ b/src/continuum_mech/basis.ts
@@ -0,0 +1,14 @@
+/** continuum_mech basis module — tsb analytics library. */
+export interface ContinuumMechBasisOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechBasisResult { values: number[]; converged: boolean; }
+export function computeContinuumMechBasis(data: number[], opts: ContinuumMechBasisOptions = {}): ContinuumMechBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechBasis };
diff --git a/src/continuum_mech/benchmarking.ts b/src/continuum_mech/benchmarking.ts
new file mode 100644
index 000000000..db550c87e
--- /dev/null
+++ b/src/continuum_mech/benchmarking.ts
@@ -0,0 +1,14 @@
+/** continuum_mech benchmarking module — tsb analytics library. */
+export interface ContinuumMechBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechBenchmarking(data: number[], opts: ContinuumMechBenchmarkingOptions = {}): ContinuumMechBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechBenchmarking };
diff --git a/src/continuum_mech/blending.ts b/src/continuum_mech/blending.ts
new file mode 100644
index 000000000..59a161e1c
--- /dev/null
+++ b/src/continuum_mech/blending.ts
@@ -0,0 +1,14 @@
+/** continuum_mech blending module — tsb analytics library. */
+export interface ContinuumMechBlendingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechBlendingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechBlending(data: number[], opts: ContinuumMechBlendingOptions = {}): ContinuumMechBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechBlending };
diff --git a/src/continuum_mech/boosting.ts b/src/continuum_mech/boosting.ts
new file mode 100644
index 000000000..c77446da0
--- /dev/null
+++ b/src/continuum_mech/boosting.ts
@@ -0,0 +1,14 @@
+/** continuum_mech boosting module — tsb analytics library. */
+export interface ContinuumMechBoostingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechBoostingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechBoosting(data: number[], opts: ContinuumMechBoostingOptions = {}): ContinuumMechBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechBoosting };
diff --git a/src/continuum_mech/bootstrap.ts b/src/continuum_mech/bootstrap.ts
new file mode 100644
index 000000000..b5460d09f
--- /dev/null
+++ b/src/continuum_mech/bootstrap.ts
@@ -0,0 +1,14 @@
+/** continuum_mech bootstrap module — tsb analytics library. */
+export interface ContinuumMechBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechBootstrapResult { values: number[]; converged: boolean; }
+export function computeContinuumMechBootstrap(data: number[], opts: ContinuumMechBootstrapOptions = {}): ContinuumMechBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechBootstrap };
diff --git a/src/continuum_mech/calculus.ts b/src/continuum_mech/calculus.ts
new file mode 100644
index 000000000..29583ccdc
--- /dev/null
+++ b/src/continuum_mech/calculus.ts
@@ -0,0 +1,14 @@
+/** continuum_mech calculus module — tsb analytics library. */
+export interface ContinuumMechCalculusOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechCalculusResult { values: number[]; converged: boolean; }
+export function computeContinuumMechCalculus(data: number[], opts: ContinuumMechCalculusOptions = {}): ContinuumMechCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechCalculus };
diff --git a/src/continuum_mech/calibration.ts b/src/continuum_mech/calibration.ts
new file mode 100644
index 000000000..be5d36707
--- /dev/null
+++ b/src/continuum_mech/calibration.ts
@@ -0,0 +1,14 @@
+/** continuum_mech calibration module — tsb analytics library. */
+export interface ContinuumMechCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechCalibrationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechCalibration(data: number[], opts: ContinuumMechCalibrationOptions = {}): ContinuumMechCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechCalibration };
diff --git a/src/continuum_mech/characterization.ts b/src/continuum_mech/characterization.ts
new file mode 100644
index 000000000..9f80d3f3d
--- /dev/null
+++ b/src/continuum_mech/characterization.ts
@@ -0,0 +1,14 @@
+/** continuum_mech characterization module — tsb analytics library. */
+export interface ContinuumMechCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechCharacterizationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechCharacterization(data: number[], opts: ContinuumMechCharacterizationOptions = {}): ContinuumMechCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechCharacterization };
diff --git a/src/continuum_mech/classification.ts b/src/continuum_mech/classification.ts
new file mode 100644
index 000000000..1b4a58879
--- /dev/null
+++ b/src/continuum_mech/classification.ts
@@ -0,0 +1,14 @@
+/** continuum_mech classification module — tsb analytics library. */
+export interface ContinuumMechClassificationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechClassificationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechClassification(data: number[], opts: ContinuumMechClassificationOptions = {}): ContinuumMechClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechClassification };
diff --git a/src/continuum_mech/clustering.ts b/src/continuum_mech/clustering.ts
new file mode 100644
index 000000000..ffdac6531
--- /dev/null
+++ b/src/continuum_mech/clustering.ts
@@ -0,0 +1,14 @@
+/** continuum_mech clustering module — tsb analytics library. */
+export interface ContinuumMechClusteringOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechClusteringResult { values: number[]; converged: boolean; }
+export function computeContinuumMechClustering(data: number[], opts: ContinuumMechClusteringOptions = {}): ContinuumMechClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechClustering };
diff --git a/src/continuum_mech/compression.ts b/src/continuum_mech/compression.ts
new file mode 100644
index 000000000..0cb70b18b
--- /dev/null
+++ b/src/continuum_mech/compression.ts
@@ -0,0 +1,14 @@
+/** continuum_mech compression module — tsb analytics library. */
+export interface ContinuumMechCompressionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechCompressionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechCompression(data: number[], opts: ContinuumMechCompressionOptions = {}): ContinuumMechCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechCompression };
diff --git a/src/continuum_mech/continuous.ts b/src/continuum_mech/continuous.ts
new file mode 100644
index 000000000..b7a37d026
--- /dev/null
+++ b/src/continuum_mech/continuous.ts
@@ -0,0 +1,14 @@
+/** continuum_mech continuous module — tsb analytics library. */
+export interface ContinuumMechContinuousOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechContinuousResult { values: number[]; converged: boolean; }
+export function computeContinuumMechContinuous(data: number[], opts: ContinuumMechContinuousOptions = {}): ContinuumMechContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechContinuous };
diff --git a/src/continuum_mech/control.ts b/src/continuum_mech/control.ts
new file mode 100644
index 000000000..357e81d19
--- /dev/null
+++ b/src/continuum_mech/control.ts
@@ -0,0 +1,14 @@
+/** continuum_mech control module — tsb analytics library. */
+export interface ContinuumMechControlOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechControlResult { values: number[]; converged: boolean; }
+export function computeContinuumMechControl(data: number[], opts: ContinuumMechControlOptions = {}): ContinuumMechControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechControl };
diff --git a/src/continuum_mech/convergence.ts b/src/continuum_mech/convergence.ts
new file mode 100644
index 000000000..9a64dc580
--- /dev/null
+++ b/src/continuum_mech/convergence.ts
@@ -0,0 +1,14 @@
+/** continuum_mech convergence module — tsb analytics library. */
+export interface ContinuumMechConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechConvergenceResult { values: number[]; converged: boolean; }
+export function computeContinuumMechConvergence(data: number[], opts: ContinuumMechConvergenceOptions = {}): ContinuumMechConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechConvergence };
diff --git a/src/continuum_mech/convex.ts b/src/continuum_mech/convex.ts
new file mode 100644
index 000000000..3d918fbdd
--- /dev/null
+++ b/src/continuum_mech/convex.ts
@@ -0,0 +1,14 @@
+/** continuum_mech convex module — tsb analytics library. */
+export interface ContinuumMechConvexOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechConvexResult { values: number[]; converged: boolean; }
+export function computeContinuumMechConvex(data: number[], opts: ContinuumMechConvexOptions = {}): ContinuumMechConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechConvex };
diff --git a/src/continuum_mech/correlation.ts b/src/continuum_mech/correlation.ts
new file mode 100644
index 000000000..80e088cce
--- /dev/null
+++ b/src/continuum_mech/correlation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech correlation module — tsb analytics library. */
+export interface ContinuumMechCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechCorrelationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechCorrelation(data: number[], opts: ContinuumMechCorrelationOptions = {}): ContinuumMechCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechCorrelation };
diff --git a/src/continuum_mech/covariance.ts b/src/continuum_mech/covariance.ts
new file mode 100644
index 000000000..5cde03a2f
--- /dev/null
+++ b/src/continuum_mech/covariance.ts
@@ -0,0 +1,14 @@
+/** continuum_mech covariance module — tsb analytics library. */
+export interface ContinuumMechCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechCovarianceResult { values: number[]; converged: boolean; }
+export function computeContinuumMechCovariance(data: number[], opts: ContinuumMechCovarianceOptions = {}): ContinuumMechCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechCovariance };
diff --git a/src/continuum_mech/cross_validation.ts b/src/continuum_mech/cross_validation.ts
new file mode 100644
index 000000000..b5ff3be65
--- /dev/null
+++ b/src/continuum_mech/cross_validation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech cross_validation module — tsb analytics library. */
+export interface ContinuumMechCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechCrossValidationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechCrossValidation(data: number[], opts: ContinuumMechCrossValidationOptions = {}): ContinuumMechCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechCrossValidation };
diff --git a/src/continuum_mech/decoding.ts b/src/continuum_mech/decoding.ts
new file mode 100644
index 000000000..5f0779680
--- /dev/null
+++ b/src/continuum_mech/decoding.ts
@@ -0,0 +1,14 @@
+/** continuum_mech decoding module — tsb analytics library. */
+export interface ContinuumMechDecodingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDecodingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDecoding(data: number[], opts: ContinuumMechDecodingOptions = {}): ContinuumMechDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDecoding };
diff --git a/src/continuum_mech/decomposition.ts b/src/continuum_mech/decomposition.ts
new file mode 100644
index 000000000..73e7b5adc
--- /dev/null
+++ b/src/continuum_mech/decomposition.ts
@@ -0,0 +1,14 @@
+/** continuum_mech decomposition module — tsb analytics library. */
+export interface ContinuumMechDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDecompositionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDecomposition(data: number[], opts: ContinuumMechDecompositionOptions = {}): ContinuumMechDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDecomposition };
diff --git a/src/continuum_mech/detection.ts b/src/continuum_mech/detection.ts
new file mode 100644
index 000000000..5c4990f6d
--- /dev/null
+++ b/src/continuum_mech/detection.ts
@@ -0,0 +1,14 @@
+/** continuum_mech detection module — tsb analytics library. */
+export interface ContinuumMechDetectionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDetectionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDetection(data: number[], opts: ContinuumMechDetectionOptions = {}): ContinuumMechDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDetection };
diff --git a/src/continuum_mech/deterministic.ts b/src/continuum_mech/deterministic.ts
new file mode 100644
index 000000000..af6331f45
--- /dev/null
+++ b/src/continuum_mech/deterministic.ts
@@ -0,0 +1,14 @@
+/** continuum_mech deterministic module — tsb analytics library. */
+export interface ContinuumMechDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDeterministicResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDeterministic(data: number[], opts: ContinuumMechDeterministicOptions = {}): ContinuumMechDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDeterministic };
diff --git a/src/continuum_mech/diagnostics.ts b/src/continuum_mech/diagnostics.ts
new file mode 100644
index 000000000..4ce375687
--- /dev/null
+++ b/src/continuum_mech/diagnostics.ts
@@ -0,0 +1,14 @@
+/** continuum_mech diagnostics module — tsb analytics library. */
+export interface ContinuumMechDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDiagnostics(data: number[], opts: ContinuumMechDiagnosticsOptions = {}): ContinuumMechDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDiagnostics };
diff --git a/src/continuum_mech/differential.ts b/src/continuum_mech/differential.ts
new file mode 100644
index 000000000..abbe0caa5
--- /dev/null
+++ b/src/continuum_mech/differential.ts
@@ -0,0 +1,14 @@
+/** continuum_mech differential module — tsb analytics library. */
+export interface ContinuumMechDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDifferentialResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDifferential(data: number[], opts: ContinuumMechDifferentialOptions = {}): ContinuumMechDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDifferential };
diff --git a/src/continuum_mech/discrete.ts b/src/continuum_mech/discrete.ts
new file mode 100644
index 000000000..ac3da671d
--- /dev/null
+++ b/src/continuum_mech/discrete.ts
@@ -0,0 +1,14 @@
+/** continuum_mech discrete module — tsb analytics library. */
+export interface ContinuumMechDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDiscreteResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDiscrete(data: number[], opts: ContinuumMechDiscreteOptions = {}): ContinuumMechDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDiscrete };
diff --git a/src/continuum_mech/distribution.ts b/src/continuum_mech/distribution.ts
new file mode 100644
index 000000000..6eaaac51c
--- /dev/null
+++ b/src/continuum_mech/distribution.ts
@@ -0,0 +1,14 @@
+/** continuum_mech distribution module — tsb analytics library. */
+export interface ContinuumMechDistributionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDistributionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDistribution(data: number[], opts: ContinuumMechDistributionOptions = {}): ContinuumMechDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDistribution };
diff --git a/src/continuum_mech/dynamic.ts b/src/continuum_mech/dynamic.ts
new file mode 100644
index 000000000..134f68fe1
--- /dev/null
+++ b/src/continuum_mech/dynamic.ts
@@ -0,0 +1,14 @@
+/** continuum_mech dynamic module — tsb analytics library. */
+export interface ContinuumMechDynamicOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechDynamicResult { values: number[]; converged: boolean; }
+export function computeContinuumMechDynamic(data: number[], opts: ContinuumMechDynamicOptions = {}): ContinuumMechDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechDynamic };
diff --git a/src/continuum_mech/embedding.ts b/src/continuum_mech/embedding.ts
new file mode 100644
index 000000000..a208bfe92
--- /dev/null
+++ b/src/continuum_mech/embedding.ts
@@ -0,0 +1,14 @@
+/** continuum_mech embedding module — tsb analytics library. */
+export interface ContinuumMechEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechEmbeddingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechEmbedding(data: number[], opts: ContinuumMechEmbeddingOptions = {}): ContinuumMechEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechEmbedding };
diff --git a/src/continuum_mech/encoding.ts b/src/continuum_mech/encoding.ts
new file mode 100644
index 000000000..9173b2de5
--- /dev/null
+++ b/src/continuum_mech/encoding.ts
@@ -0,0 +1,14 @@
+/** continuum_mech encoding module — tsb analytics library. */
+export interface ContinuumMechEncodingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechEncodingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechEncoding(data: number[], opts: ContinuumMechEncodingOptions = {}): ContinuumMechEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechEncoding };
diff --git a/src/continuum_mech/ensemble.ts b/src/continuum_mech/ensemble.ts
new file mode 100644
index 000000000..c7f0c3454
--- /dev/null
+++ b/src/continuum_mech/ensemble.ts
@@ -0,0 +1,14 @@
+/** continuum_mech ensemble module — tsb analytics library. */
+export interface ContinuumMechEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechEnsembleResult { values: number[]; converged: boolean; }
+export function computeContinuumMechEnsemble(data: number[], opts: ContinuumMechEnsembleOptions = {}): ContinuumMechEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechEnsemble };
diff --git a/src/continuum_mech/estimation.ts b/src/continuum_mech/estimation.ts
new file mode 100644
index 000000000..6207ed450
--- /dev/null
+++ b/src/continuum_mech/estimation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech estimation module — tsb analytics library. */
+export interface ContinuumMechEstimationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechEstimationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechEstimation(data: number[], opts: ContinuumMechEstimationOptions = {}): ContinuumMechEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechEstimation };
diff --git a/src/continuum_mech/evaluation.ts b/src/continuum_mech/evaluation.ts
new file mode 100644
index 000000000..247f5944d
--- /dev/null
+++ b/src/continuum_mech/evaluation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech evaluation module — tsb analytics library. */
+export interface ContinuumMechEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechEvaluationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechEvaluation(data: number[], opts: ContinuumMechEvaluationOptions = {}): ContinuumMechEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechEvaluation };
diff --git a/src/continuum_mech/extrapolation.ts b/src/continuum_mech/extrapolation.ts
new file mode 100644
index 000000000..d50e53535
--- /dev/null
+++ b/src/continuum_mech/extrapolation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech extrapolation module — tsb analytics library. */
+export interface ContinuumMechExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechExtrapolationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechExtrapolation(data: number[], opts: ContinuumMechExtrapolationOptions = {}): ContinuumMechExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechExtrapolation };
diff --git a/src/continuum_mech/features.ts b/src/continuum_mech/features.ts
new file mode 100644
index 000000000..eef972675
--- /dev/null
+++ b/src/continuum_mech/features.ts
@@ -0,0 +1,14 @@
+/** continuum_mech features module — tsb analytics library. */
+export interface ContinuumMechFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechFeaturesResult { values: number[]; converged: boolean; }
+export function computeContinuumMechFeatures(data: number[], opts: ContinuumMechFeaturesOptions = {}): ContinuumMechFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechFeatures };
diff --git a/src/continuum_mech/feedback.ts b/src/continuum_mech/feedback.ts
new file mode 100644
index 000000000..e362e33c3
--- /dev/null
+++ b/src/continuum_mech/feedback.ts
@@ -0,0 +1,14 @@
+/** continuum_mech feedback module — tsb analytics library. */
+export interface ContinuumMechFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechFeedbackResult { values: number[]; converged: boolean; }
+export function computeContinuumMechFeedback(data: number[], opts: ContinuumMechFeedbackOptions = {}): ContinuumMechFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechFeedback };
diff --git a/src/continuum_mech/filtering.ts b/src/continuum_mech/filtering.ts
new file mode 100644
index 000000000..25f7a7f47
--- /dev/null
+++ b/src/continuum_mech/filtering.ts
@@ -0,0 +1,14 @@
+/** continuum_mech filtering module — tsb analytics library. */
+export interface ContinuumMechFilteringOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechFilteringResult { values: number[]; converged: boolean; }
+export function computeContinuumMechFiltering(data: number[], opts: ContinuumMechFilteringOptions = {}): ContinuumMechFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechFiltering };
diff --git a/src/continuum_mech/fourier.ts b/src/continuum_mech/fourier.ts
new file mode 100644
index 000000000..b57dd6d65
--- /dev/null
+++ b/src/continuum_mech/fourier.ts
@@ -0,0 +1,14 @@
+/** continuum_mech fourier module — tsb analytics library. */
+export interface ContinuumMechFourierOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechFourierResult { values: number[]; converged: boolean; }
+export function computeContinuumMechFourier(data: number[], opts: ContinuumMechFourierOptions = {}): ContinuumMechFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechFourier };
diff --git a/src/continuum_mech/fusion.ts b/src/continuum_mech/fusion.ts
new file mode 100644
index 000000000..76db05e24
--- /dev/null
+++ b/src/continuum_mech/fusion.ts
@@ -0,0 +1,14 @@
+/** continuum_mech fusion module — tsb analytics library. */
+export interface ContinuumMechFusionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechFusionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechFusion(data: number[], opts: ContinuumMechFusionOptions = {}): ContinuumMechFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechFusion };
diff --git a/src/continuum_mech/generation.ts b/src/continuum_mech/generation.ts
new file mode 100644
index 000000000..f3d875c7c
--- /dev/null
+++ b/src/continuum_mech/generation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech generation module — tsb analytics library. */
+export interface ContinuumMechGenerationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechGenerationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechGeneration(data: number[], opts: ContinuumMechGenerationOptions = {}): ContinuumMechGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechGeneration };
diff --git a/src/continuum_mech/geometry.ts b/src/continuum_mech/geometry.ts
new file mode 100644
index 000000000..b06d07b67
--- /dev/null
+++ b/src/continuum_mech/geometry.ts
@@ -0,0 +1,14 @@
+/** continuum_mech geometry module — tsb analytics library. */
+export interface ContinuumMechGeometryOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechGeometryResult { values: number[]; converged: boolean; }
+export function computeContinuumMechGeometry(data: number[], opts: ContinuumMechGeometryOptions = {}): ContinuumMechGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechGeometry };
diff --git a/src/continuum_mech/gradient.ts b/src/continuum_mech/gradient.ts
new file mode 100644
index 000000000..d2f433870
--- /dev/null
+++ b/src/continuum_mech/gradient.ts
@@ -0,0 +1,14 @@
+/** continuum_mech gradient module — tsb analytics library. */
+export interface ContinuumMechGradientOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechGradientResult { values: number[]; converged: boolean; }
+export function computeContinuumMechGradient(data: number[], opts: ContinuumMechGradientOptions = {}): ContinuumMechGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechGradient };
diff --git a/src/continuum_mech/hessian.ts b/src/continuum_mech/hessian.ts
new file mode 100644
index 000000000..da628309e
--- /dev/null
+++ b/src/continuum_mech/hessian.ts
@@ -0,0 +1,14 @@
+/** continuum_mech hessian module — tsb analytics library. */
+export interface ContinuumMechHessianOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechHessianResult { values: number[]; converged: boolean; }
+export function computeContinuumMechHessian(data: number[], opts: ContinuumMechHessianOptions = {}): ContinuumMechHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechHessian };
diff --git a/src/continuum_mech/hypothesis.ts b/src/continuum_mech/hypothesis.ts
new file mode 100644
index 000000000..08d7a9570
--- /dev/null
+++ b/src/continuum_mech/hypothesis.ts
@@ -0,0 +1,14 @@
+/** continuum_mech hypothesis module — tsb analytics library. */
+export interface ContinuumMechHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechHypothesisResult { values: number[]; converged: boolean; }
+export function computeContinuumMechHypothesis(data: number[], opts: ContinuumMechHypothesisOptions = {}): ContinuumMechHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechHypothesis };
diff --git a/src/continuum_mech/inference.ts b/src/continuum_mech/inference.ts
new file mode 100644
index 000000000..0fb89ad78
--- /dev/null
+++ b/src/continuum_mech/inference.ts
@@ -0,0 +1,14 @@
+/** continuum_mech inference module — tsb analytics library. */
+export interface ContinuumMechInferenceOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechInferenceResult { values: number[]; converged: boolean; }
+export function computeContinuumMechInference(data: number[], opts: ContinuumMechInferenceOptions = {}): ContinuumMechInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechInference };
diff --git a/src/continuum_mech/inference2.ts b/src/continuum_mech/inference2.ts
new file mode 100644
index 000000000..aede6b2c3
--- /dev/null
+++ b/src/continuum_mech/inference2.ts
@@ -0,0 +1,14 @@
+/** continuum_mech inference2 module — tsb analytics library. */
+export interface ContinuumMechInferenceOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechInferenceResult { values: number[]; converged: boolean; }
+export function computeContinuumMechInference(data: number[], opts: ContinuumMechInferenceOptions = {}): ContinuumMechInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechInference };
diff --git a/src/continuum_mech/integral.ts b/src/continuum_mech/integral.ts
new file mode 100644
index 000000000..256054fe1
--- /dev/null
+++ b/src/continuum_mech/integral.ts
@@ -0,0 +1,14 @@
+/** continuum_mech integral module — tsb analytics library. */
+export interface ContinuumMechIntegralOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechIntegralResult { values: number[]; converged: boolean; }
+export function computeContinuumMechIntegral(data: number[], opts: ContinuumMechIntegralOptions = {}): ContinuumMechIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechIntegral };
diff --git a/src/continuum_mech/integration.ts b/src/continuum_mech/integration.ts
new file mode 100644
index 000000000..990718258
--- /dev/null
+++ b/src/continuum_mech/integration.ts
@@ -0,0 +1,14 @@
+/** continuum_mech integration module — tsb analytics library. */
+export interface ContinuumMechIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechIntegrationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechIntegration(data: number[], opts: ContinuumMechIntegrationOptions = {}): ContinuumMechIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechIntegration };
diff --git a/src/continuum_mech/interpolation.ts b/src/continuum_mech/interpolation.ts
new file mode 100644
index 000000000..4944fa993
--- /dev/null
+++ b/src/continuum_mech/interpolation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech interpolation module — tsb analytics library. */
+export interface ContinuumMechInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechInterpolationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechInterpolation(data: number[], opts: ContinuumMechInterpolationOptions = {}): ContinuumMechInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechInterpolation };
diff --git a/src/continuum_mech/jacobian.ts b/src/continuum_mech/jacobian.ts
new file mode 100644
index 000000000..0e6c9ce1b
--- /dev/null
+++ b/src/continuum_mech/jacobian.ts
@@ -0,0 +1,14 @@
+/** continuum_mech jacobian module — tsb analytics library. */
+export interface ContinuumMechJacobianOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechJacobianResult { values: number[]; converged: boolean; }
+export function computeContinuumMechJacobian(data: number[], opts: ContinuumMechJacobianOptions = {}): ContinuumMechJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechJacobian };
diff --git a/src/continuum_mech/kernel.ts b/src/continuum_mech/kernel.ts
new file mode 100644
index 000000000..bd1c95eb9
--- /dev/null
+++ b/src/continuum_mech/kernel.ts
@@ -0,0 +1,14 @@
+/** continuum_mech kernel module — tsb analytics library. */
+export interface ContinuumMechKernelOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechKernelResult { values: number[]; converged: boolean; }
+export function computeContinuumMechKernel(data: number[], opts: ContinuumMechKernelOptions = {}): ContinuumMechKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechKernel };
diff --git a/src/continuum_mech/laplacian.ts b/src/continuum_mech/laplacian.ts
new file mode 100644
index 000000000..0340a614b
--- /dev/null
+++ b/src/continuum_mech/laplacian.ts
@@ -0,0 +1,14 @@
+/** continuum_mech laplacian module — tsb analytics library. */
+export interface ContinuumMechLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechLaplacianResult { values: number[]; converged: boolean; }
+export function computeContinuumMechLaplacian(data: number[], opts: ContinuumMechLaplacianOptions = {}): ContinuumMechLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechLaplacian };
diff --git a/src/continuum_mech/learning.ts b/src/continuum_mech/learning.ts
new file mode 100644
index 000000000..1d7c9d283
--- /dev/null
+++ b/src/continuum_mech/learning.ts
@@ -0,0 +1,14 @@
+/** continuum_mech learning module — tsb analytics library. */
+export interface ContinuumMechLearningOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechLearningResult { values: number[]; converged: boolean; }
+export function computeContinuumMechLearning(data: number[], opts: ContinuumMechLearningOptions = {}): ContinuumMechLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechLearning };
diff --git a/src/continuum_mech/linear.ts b/src/continuum_mech/linear.ts
new file mode 100644
index 000000000..d8bd3b9cb
--- /dev/null
+++ b/src/continuum_mech/linear.ts
@@ -0,0 +1,14 @@
+/** continuum_mech linear module — tsb analytics library. */
+export interface ContinuumMechLinearOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechLinearResult { values: number[]; converged: boolean; }
+export function computeContinuumMechLinear(data: number[], opts: ContinuumMechLinearOptions = {}): ContinuumMechLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechLinear };
diff --git a/src/continuum_mech/manifold.ts b/src/continuum_mech/manifold.ts
new file mode 100644
index 000000000..7bf6a8fef
--- /dev/null
+++ b/src/continuum_mech/manifold.ts
@@ -0,0 +1,14 @@
+/** continuum_mech manifold module — tsb analytics library. */
+export interface ContinuumMechManifoldOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechManifoldResult { values: number[]; converged: boolean; }
+export function computeContinuumMechManifold(data: number[], opts: ContinuumMechManifoldOptions = {}): ContinuumMechManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechManifold };
diff --git a/src/continuum_mech/matching.ts b/src/continuum_mech/matching.ts
new file mode 100644
index 000000000..18976b949
--- /dev/null
+++ b/src/continuum_mech/matching.ts
@@ -0,0 +1,14 @@
+/** continuum_mech matching module — tsb analytics library. */
+export interface ContinuumMechMatchingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechMatchingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechMatching(data: number[], opts: ContinuumMechMatchingOptions = {}): ContinuumMechMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechMatching };
diff --git a/src/continuum_mech/measurement.ts b/src/continuum_mech/measurement.ts
new file mode 100644
index 000000000..980a2dbab
--- /dev/null
+++ b/src/continuum_mech/measurement.ts
@@ -0,0 +1,14 @@
+/** continuum_mech measurement module — tsb analytics library. */
+export interface ContinuumMechMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechMeasurementResult { values: number[]; converged: boolean; }
+export function computeContinuumMechMeasurement(data: number[], opts: ContinuumMechMeasurementOptions = {}): ContinuumMechMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechMeasurement };
diff --git a/src/continuum_mech/metrics.ts b/src/continuum_mech/metrics.ts
new file mode 100644
index 000000000..bc660c269
--- /dev/null
+++ b/src/continuum_mech/metrics.ts
@@ -0,0 +1,14 @@
+/** continuum_mech metrics module — tsb analytics library. */
+export interface ContinuumMechMetricsOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechMetricsResult { values: number[]; converged: boolean; }
+export function computeContinuumMechMetrics(data: number[], opts: ContinuumMechMetricsOptions = {}): ContinuumMechMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechMetrics };
diff --git a/src/continuum_mech/modeling.ts b/src/continuum_mech/modeling.ts
new file mode 100644
index 000000000..3586c537a
--- /dev/null
+++ b/src/continuum_mech/modeling.ts
@@ -0,0 +1,14 @@
+/** continuum_mech modeling module — tsb analytics library. */
+export interface ContinuumMechModelingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechModelingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechModeling(data: number[], opts: ContinuumMechModelingOptions = {}): ContinuumMechModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechModeling };
diff --git a/src/continuum_mech/monitoring.ts b/src/continuum_mech/monitoring.ts
new file mode 100644
index 000000000..46d948cfe
--- /dev/null
+++ b/src/continuum_mech/monitoring.ts
@@ -0,0 +1,14 @@
+/** continuum_mech monitoring module — tsb analytics library. */
+export interface ContinuumMechMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechMonitoringResult { values: number[]; converged: boolean; }
+export function computeContinuumMechMonitoring(data: number[], opts: ContinuumMechMonitoringOptions = {}): ContinuumMechMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechMonitoring };
diff --git a/src/continuum_mech/nonlinear.ts b/src/continuum_mech/nonlinear.ts
new file mode 100644
index 000000000..fd07ea41b
--- /dev/null
+++ b/src/continuum_mech/nonlinear.ts
@@ -0,0 +1,14 @@
+/** continuum_mech nonlinear module — tsb analytics library. */
+export interface ContinuumMechNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechNonlinearResult { values: number[]; converged: boolean; }
+export function computeContinuumMechNonlinear(data: number[], opts: ContinuumMechNonlinearOptions = {}): ContinuumMechNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechNonlinear };
diff --git a/src/continuum_mech/normalization.ts b/src/continuum_mech/normalization.ts
new file mode 100644
index 000000000..a4dd8195f
--- /dev/null
+++ b/src/continuum_mech/normalization.ts
@@ -0,0 +1,14 @@
+/** continuum_mech normalization module — tsb analytics library. */
+export interface ContinuumMechNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechNormalizationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechNormalization(data: number[], opts: ContinuumMechNormalizationOptions = {}): ContinuumMechNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechNormalization };
diff --git a/src/continuum_mech/optimization.ts b/src/continuum_mech/optimization.ts
new file mode 100644
index 000000000..64eacae85
--- /dev/null
+++ b/src/continuum_mech/optimization.ts
@@ -0,0 +1,14 @@
+/** continuum_mech optimization module — tsb analytics library. */
+export interface ContinuumMechOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechOptimizationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechOptimization(data: number[], opts: ContinuumMechOptimizationOptions = {}): ContinuumMechOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechOptimization };
diff --git a/src/continuum_mech/patterns.ts b/src/continuum_mech/patterns.ts
new file mode 100644
index 000000000..f74f5c1e0
--- /dev/null
+++ b/src/continuum_mech/patterns.ts
@@ -0,0 +1,14 @@
+/** continuum_mech patterns module — tsb analytics library. */
+export interface ContinuumMechPatternsOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechPatternsResult { values: number[]; converged: boolean; }
+export function computeContinuumMechPatterns(data: number[], opts: ContinuumMechPatternsOptions = {}): ContinuumMechPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechPatterns };
diff --git a/src/continuum_mech/permutation.ts b/src/continuum_mech/permutation.ts
new file mode 100644
index 000000000..d49743dad
--- /dev/null
+++ b/src/continuum_mech/permutation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech permutation module — tsb analytics library. */
+export interface ContinuumMechPermutationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechPermutationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechPermutation(data: number[], opts: ContinuumMechPermutationOptions = {}): ContinuumMechPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechPermutation };
diff --git a/src/continuum_mech/prediction.ts b/src/continuum_mech/prediction.ts
new file mode 100644
index 000000000..3a8e2d911
--- /dev/null
+++ b/src/continuum_mech/prediction.ts
@@ -0,0 +1,14 @@
+/** continuum_mech prediction module — tsb analytics library. */
+export interface ContinuumMechPredictionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechPredictionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechPrediction(data: number[], opts: ContinuumMechPredictionOptions = {}): ContinuumMechPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechPrediction };
diff --git a/src/continuum_mech/processing.ts b/src/continuum_mech/processing.ts
new file mode 100644
index 000000000..754f791e4
--- /dev/null
+++ b/src/continuum_mech/processing.ts
@@ -0,0 +1,14 @@
+/** continuum_mech processing module — tsb analytics library. */
+export interface ContinuumMechProcessingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechProcessingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechProcessing(data: number[], opts: ContinuumMechProcessingOptions = {}): ContinuumMechProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechProcessing };
diff --git a/src/continuum_mech/profiling.ts b/src/continuum_mech/profiling.ts
new file mode 100644
index 000000000..2394876ee
--- /dev/null
+++ b/src/continuum_mech/profiling.ts
@@ -0,0 +1,14 @@
+/** continuum_mech profiling module — tsb analytics library. */
+export interface ContinuumMechProfilingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechProfilingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechProfiling(data: number[], opts: ContinuumMechProfilingOptions = {}): ContinuumMechProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechProfiling };
diff --git a/src/continuum_mech/projection.ts b/src/continuum_mech/projection.ts
new file mode 100644
index 000000000..0a0665caf
--- /dev/null
+++ b/src/continuum_mech/projection.ts
@@ -0,0 +1,14 @@
+/** continuum_mech projection module — tsb analytics library. */
+export interface ContinuumMechProjectionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechProjectionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechProjection(data: number[], opts: ContinuumMechProjectionOptions = {}): ContinuumMechProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechProjection };
diff --git a/src/continuum_mech/ranking.ts b/src/continuum_mech/ranking.ts
new file mode 100644
index 000000000..b91e0695d
--- /dev/null
+++ b/src/continuum_mech/ranking.ts
@@ -0,0 +1,14 @@
+/** continuum_mech ranking module — tsb analytics library. */
+export interface ContinuumMechRankingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechRankingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechRanking(data: number[], opts: ContinuumMechRankingOptions = {}): ContinuumMechRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechRanking };
diff --git a/src/continuum_mech/reconstruction.ts b/src/continuum_mech/reconstruction.ts
new file mode 100644
index 000000000..4bad8077c
--- /dev/null
+++ b/src/continuum_mech/reconstruction.ts
@@ -0,0 +1,14 @@
+/** continuum_mech reconstruction module — tsb analytics library. */
+export interface ContinuumMechReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechReconstructionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechReconstruction(data: number[], opts: ContinuumMechReconstructionOptions = {}): ContinuumMechReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechReconstruction };
diff --git a/src/continuum_mech/registration.ts b/src/continuum_mech/registration.ts
new file mode 100644
index 000000000..6c6bf1f20
--- /dev/null
+++ b/src/continuum_mech/registration.ts
@@ -0,0 +1,14 @@
+/** continuum_mech registration module — tsb analytics library. */
+export interface ContinuumMechRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechRegistrationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechRegistration(data: number[], opts: ContinuumMechRegistrationOptions = {}): ContinuumMechRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechRegistration };
diff --git a/src/continuum_mech/regression.ts b/src/continuum_mech/regression.ts
new file mode 100644
index 000000000..0b3dfefee
--- /dev/null
+++ b/src/continuum_mech/regression.ts
@@ -0,0 +1,14 @@
+/** continuum_mech regression module — tsb analytics library. */
+export interface ContinuumMechRegressionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechRegressionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechRegression(data: number[], opts: ContinuumMechRegressionOptions = {}): ContinuumMechRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechRegression };
diff --git a/src/continuum_mech/regularization.ts b/src/continuum_mech/regularization.ts
new file mode 100644
index 000000000..80c10258d
--- /dev/null
+++ b/src/continuum_mech/regularization.ts
@@ -0,0 +1,14 @@
+/** continuum_mech regularization module — tsb analytics library. */
+export interface ContinuumMechRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechRegularizationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechRegularization(data: number[], opts: ContinuumMechRegularizationOptions = {}): ContinuumMechRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechRegularization };
diff --git a/src/continuum_mech/robustness.ts b/src/continuum_mech/robustness.ts
new file mode 100644
index 000000000..c37a10ab2
--- /dev/null
+++ b/src/continuum_mech/robustness.ts
@@ -0,0 +1,14 @@
+/** continuum_mech robustness module — tsb analytics library. */
+export interface ContinuumMechRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechRobustnessResult { values: number[]; converged: boolean; }
+export function computeContinuumMechRobustness(data: number[], opts: ContinuumMechRobustnessOptions = {}): ContinuumMechRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechRobustness };
diff --git a/src/continuum_mech/sampling.ts b/src/continuum_mech/sampling.ts
new file mode 100644
index 000000000..79a46c5e9
--- /dev/null
+++ b/src/continuum_mech/sampling.ts
@@ -0,0 +1,14 @@
+/** continuum_mech sampling module — tsb analytics library. */
+export interface ContinuumMechSamplingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechSamplingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechSampling(data: number[], opts: ContinuumMechSamplingOptions = {}): ContinuumMechSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechSampling };
diff --git a/src/continuum_mech/sampling2.ts b/src/continuum_mech/sampling2.ts
new file mode 100644
index 000000000..336e83c6d
--- /dev/null
+++ b/src/continuum_mech/sampling2.ts
@@ -0,0 +1,14 @@
+/** continuum_mech sampling2 module — tsb analytics library. */
+export interface ContinuumMechSamplingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechSamplingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechSampling(data: number[], opts: ContinuumMechSamplingOptions = {}): ContinuumMechSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechSampling };
diff --git a/src/continuum_mech/scaling.ts b/src/continuum_mech/scaling.ts
new file mode 100644
index 000000000..976f970f5
--- /dev/null
+++ b/src/continuum_mech/scaling.ts
@@ -0,0 +1,14 @@
+/** continuum_mech scaling module — tsb analytics library. */
+export interface ContinuumMechScalingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechScalingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechScaling(data: number[], opts: ContinuumMechScalingOptions = {}): ContinuumMechScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechScaling };
diff --git a/src/continuum_mech/scoring.ts b/src/continuum_mech/scoring.ts
new file mode 100644
index 000000000..d08919ecc
--- /dev/null
+++ b/src/continuum_mech/scoring.ts
@@ -0,0 +1,14 @@
+/** continuum_mech scoring module — tsb analytics library. */
+export interface ContinuumMechScoringOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechScoringResult { values: number[]; converged: boolean; }
+export function computeContinuumMechScoring(data: number[], opts: ContinuumMechScoringOptions = {}): ContinuumMechScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechScoring };
diff --git a/src/continuum_mech/segmentation.ts b/src/continuum_mech/segmentation.ts
new file mode 100644
index 000000000..b059617f9
--- /dev/null
+++ b/src/continuum_mech/segmentation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech segmentation module — tsb analytics library. */
+export interface ContinuumMechSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechSegmentationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechSegmentation(data: number[], opts: ContinuumMechSegmentationOptions = {}): ContinuumMechSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechSegmentation };
diff --git a/src/continuum_mech/selection.ts b/src/continuum_mech/selection.ts
new file mode 100644
index 000000000..8d2e0ab6c
--- /dev/null
+++ b/src/continuum_mech/selection.ts
@@ -0,0 +1,14 @@
+/** continuum_mech selection module — tsb analytics library. */
+export interface ContinuumMechSelectionOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechSelectionResult { values: number[]; converged: boolean; }
+export function computeContinuumMechSelection(data: number[], opts: ContinuumMechSelectionOptions = {}): ContinuumMechSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechSelection };
diff --git a/src/continuum_mech/sensitivity.ts b/src/continuum_mech/sensitivity.ts
new file mode 100644
index 000000000..eb465db46
--- /dev/null
+++ b/src/continuum_mech/sensitivity.ts
@@ -0,0 +1,14 @@
+/** continuum_mech sensitivity module — tsb analytics library. */
+export interface ContinuumMechSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechSensitivityResult { values: number[]; converged: boolean; }
+export function computeContinuumMechSensitivity(data: number[], opts: ContinuumMechSensitivityOptions = {}): ContinuumMechSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechSensitivity };
diff --git a/src/continuum_mech/simulation.ts b/src/continuum_mech/simulation.ts
new file mode 100644
index 000000000..dadf6b27e
--- /dev/null
+++ b/src/continuum_mech/simulation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech simulation module — tsb analytics library. */
+export interface ContinuumMechSimulationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechSimulationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechSimulation(data: number[], opts: ContinuumMechSimulationOptions = {}): ContinuumMechSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechSimulation };
diff --git a/src/continuum_mech/smoothing.ts b/src/continuum_mech/smoothing.ts
new file mode 100644
index 000000000..43ed6b4b7
--- /dev/null
+++ b/src/continuum_mech/smoothing.ts
@@ -0,0 +1,14 @@
+/** continuum_mech smoothing module — tsb analytics library. */
+export interface ContinuumMechSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechSmoothingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechSmoothing(data: number[], opts: ContinuumMechSmoothingOptions = {}): ContinuumMechSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechSmoothing };
diff --git a/src/continuum_mech/stability.ts b/src/continuum_mech/stability.ts
new file mode 100644
index 000000000..5a729243a
--- /dev/null
+++ b/src/continuum_mech/stability.ts
@@ -0,0 +1,14 @@
+/** continuum_mech stability module — tsb analytics library. */
+export interface ContinuumMechStabilityOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechStabilityResult { values: number[]; converged: boolean; }
+export function computeContinuumMechStability(data: number[], opts: ContinuumMechStabilityOptions = {}): ContinuumMechStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechStability };
diff --git a/src/continuum_mech/stacking.ts b/src/continuum_mech/stacking.ts
new file mode 100644
index 000000000..4b7c23d72
--- /dev/null
+++ b/src/continuum_mech/stacking.ts
@@ -0,0 +1,14 @@
+/** continuum_mech stacking module — tsb analytics library. */
+export interface ContinuumMechStackingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechStackingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechStacking(data: number[], opts: ContinuumMechStackingOptions = {}): ContinuumMechStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechStacking };
diff --git a/src/continuum_mech/standardization.ts b/src/continuum_mech/standardization.ts
new file mode 100644
index 000000000..33313f9d3
--- /dev/null
+++ b/src/continuum_mech/standardization.ts
@@ -0,0 +1,14 @@
+/** continuum_mech standardization module — tsb analytics library. */
+export interface ContinuumMechStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechStandardizationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechStandardization(data: number[], opts: ContinuumMechStandardizationOptions = {}): ContinuumMechStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechStandardization };
diff --git a/src/continuum_mech/static.ts b/src/continuum_mech/static.ts
new file mode 100644
index 000000000..703aa4692
--- /dev/null
+++ b/src/continuum_mech/static.ts
@@ -0,0 +1,14 @@
+/** continuum_mech static module — tsb analytics library. */
+export interface ContinuumMechStaticOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechStaticResult { values: number[]; converged: boolean; }
+export function computeContinuumMechStatic(data: number[], opts: ContinuumMechStaticOptions = {}): ContinuumMechStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechStatic };
diff --git a/src/continuum_mech/stochastic.ts b/src/continuum_mech/stochastic.ts
new file mode 100644
index 000000000..e1d443c5a
--- /dev/null
+++ b/src/continuum_mech/stochastic.ts
@@ -0,0 +1,14 @@
+/** continuum_mech stochastic module — tsb analytics library. */
+export interface ContinuumMechStochasticOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechStochasticResult { values: number[]; converged: boolean; }
+export function computeContinuumMechStochastic(data: number[], opts: ContinuumMechStochasticOptions = {}): ContinuumMechStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechStochastic };
diff --git a/src/continuum_mech/synthesis.ts b/src/continuum_mech/synthesis.ts
new file mode 100644
index 000000000..083bceff4
--- /dev/null
+++ b/src/continuum_mech/synthesis.ts
@@ -0,0 +1,14 @@
+/** continuum_mech synthesis module — tsb analytics library. */
+export interface ContinuumMechSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechSynthesisResult { values: number[]; converged: boolean; }
+export function computeContinuumMechSynthesis(data: number[], opts: ContinuumMechSynthesisOptions = {}): ContinuumMechSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechSynthesis };
diff --git a/src/continuum_mech/topology.ts b/src/continuum_mech/topology.ts
new file mode 100644
index 000000000..efb693e70
--- /dev/null
+++ b/src/continuum_mech/topology.ts
@@ -0,0 +1,14 @@
+/** continuum_mech topology module — tsb analytics library. */
+export interface ContinuumMechTopologyOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechTopologyResult { values: number[]; converged: boolean; }
+export function computeContinuumMechTopology(data: number[], opts: ContinuumMechTopologyOptions = {}): ContinuumMechTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechTopology };
diff --git a/src/continuum_mech/tracking.ts b/src/continuum_mech/tracking.ts
new file mode 100644
index 000000000..743ae380b
--- /dev/null
+++ b/src/continuum_mech/tracking.ts
@@ -0,0 +1,14 @@
+/** continuum_mech tracking module — tsb analytics library. */
+export interface ContinuumMechTrackingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechTrackingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechTracking(data: number[], opts: ContinuumMechTrackingOptions = {}): ContinuumMechTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechTracking };
diff --git a/src/continuum_mech/transform.ts b/src/continuum_mech/transform.ts
new file mode 100644
index 000000000..82cab0a6c
--- /dev/null
+++ b/src/continuum_mech/transform.ts
@@ -0,0 +1,14 @@
+/** continuum_mech transform module — tsb analytics library. */
+export interface ContinuumMechTransformOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechTransformResult { values: number[]; converged: boolean; }
+export function computeContinuumMechTransform(data: number[], opts: ContinuumMechTransformOptions = {}): ContinuumMechTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechTransform };
diff --git a/src/continuum_mech/uncertainty.ts b/src/continuum_mech/uncertainty.ts
new file mode 100644
index 000000000..4ef7cd9e9
--- /dev/null
+++ b/src/continuum_mech/uncertainty.ts
@@ -0,0 +1,14 @@
+/** continuum_mech uncertainty module — tsb analytics library. */
+export interface ContinuumMechUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechUncertaintyResult { values: number[]; converged: boolean; }
+export function computeContinuumMechUncertainty(data: number[], opts: ContinuumMechUncertaintyOptions = {}): ContinuumMechUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechUncertainty };
diff --git a/src/continuum_mech/validation.ts b/src/continuum_mech/validation.ts
new file mode 100644
index 000000000..b5b109184
--- /dev/null
+++ b/src/continuum_mech/validation.ts
@@ -0,0 +1,14 @@
+/** continuum_mech validation module — tsb analytics library. */
+export interface ContinuumMechValidationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechValidationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechValidation(data: number[], opts: ContinuumMechValidationOptions = {}): ContinuumMechValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechValidation };
diff --git a/src/continuum_mech/verification.ts b/src/continuum_mech/verification.ts
new file mode 100644
index 000000000..9a3e75b3e
--- /dev/null
+++ b/src/continuum_mech/verification.ts
@@ -0,0 +1,14 @@
+/** continuum_mech verification module — tsb analytics library. */
+export interface ContinuumMechVerificationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechVerificationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechVerification(data: number[], opts: ContinuumMechVerificationOptions = {}): ContinuumMechVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechVerification };
diff --git a/src/continuum_mech/visualization.ts b/src/continuum_mech/visualization.ts
new file mode 100644
index 000000000..ace940237
--- /dev/null
+++ b/src/continuum_mech/visualization.ts
@@ -0,0 +1,14 @@
+/** continuum_mech visualization module — tsb analytics library. */
+export interface ContinuumMechVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechVisualizationResult { values: number[]; converged: boolean; }
+export function computeContinuumMechVisualization(data: number[], opts: ContinuumMechVisualizationOptions = {}): ContinuumMechVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechVisualization };
diff --git a/src/continuum_mech/voting.ts b/src/continuum_mech/voting.ts
new file mode 100644
index 000000000..8b82cd840
--- /dev/null
+++ b/src/continuum_mech/voting.ts
@@ -0,0 +1,14 @@
+/** continuum_mech voting module — tsb analytics library. */
+export interface ContinuumMechVotingOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechVotingResult { values: number[]; converged: boolean; }
+export function computeContinuumMechVoting(data: number[], opts: ContinuumMechVotingOptions = {}): ContinuumMechVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechVoting };
diff --git a/src/continuum_mech/wavelet.ts b/src/continuum_mech/wavelet.ts
new file mode 100644
index 000000000..623bcc8e8
--- /dev/null
+++ b/src/continuum_mech/wavelet.ts
@@ -0,0 +1,14 @@
+/** continuum_mech wavelet module — tsb analytics library. */
+export interface ContinuumMechWaveletOptions { tol?: number; maxIter?: number; }
+export interface ContinuumMechWaveletResult { values: number[]; converged: boolean; }
+export function computeContinuumMechWavelet(data: number[], opts: ContinuumMechWaveletOptions = {}): ContinuumMechWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeContinuumMechWavelet };
diff --git a/src/core/frame.ts b/src/core/frame.ts
index e21c341e1..5e13d5779 100644
--- a/src/core/frame.ts
+++ b/src/core/frame.ts
@@ -626,7 +626,7 @@ export class DataFrame {
for (let i = 0; i < nRows; i++) {
const row: Record
= {};
if (index) {
- row["Index"] = this.index.at(i) as Scalar;
+ row.Index = this.index.at(i) as Scalar;
}
for (const name of colNames) {
row[name] = this.col(name).iat(i);
@@ -833,9 +833,7 @@ function isIndexLike(v: unknown): v is Index {
}
const rec = v as Record;
return (
- typeof rec["size"] === "number" &&
- typeof rec["at"] === "function" &&
- typeof rec["getLoc"] === "function"
+ typeof rec.size === "number" && typeof rec.at === "function" && typeof rec.getLoc === "function"
);
}
diff --git a/src/core/options.ts b/src/core/options.ts
index 628b5cce5..188c2188d 100644
--- a/src/core/options.ts
+++ b/src/core/options.ts
@@ -210,7 +210,7 @@ function _makeProxy(prefix: string): OptionsProxy {
// If there is a direct match, return its value
const k = _normalizeKey(key);
if (_registry.has(k)) {
- return _registry.get(k)!.currentValue;
+ return _registry.get(k)?.currentValue;
}
// Otherwise return a nested proxy for deeper access
return _makeProxy(k);
diff --git a/src/core/series.ts b/src/core/series.ts
index c34d25697..c1ad5ab53 100644
--- a/src/core/series.ts
+++ b/src/core/series.ts
@@ -1559,9 +1559,7 @@ function isIndexLike(v: unknown): v is Index {
}
const rec = v as Record;
return (
- typeof rec["size"] === "number" &&
- typeof rec["at"] === "function" &&
- typeof rec["getLoc"] === "function"
+ typeof rec.size === "number" && typeof rec.at === "function" && typeof rec.getLoc === "function"
);
}
diff --git a/src/corrosion_sci/adaptation.ts b/src/corrosion_sci/adaptation.ts
new file mode 100644
index 000000000..c46119eda
--- /dev/null
+++ b/src/corrosion_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci adaptation module — tsb analytics library. */
+export interface CorrosionSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciAdaptation(data: number[], opts: CorrosionSciAdaptationOptions = {}): CorrosionSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciAdaptation };
diff --git a/src/corrosion_sci/aggregation.ts b/src/corrosion_sci/aggregation.ts
new file mode 100644
index 000000000..b17c86415
--- /dev/null
+++ b/src/corrosion_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci aggregation module — tsb analytics library. */
+export interface CorrosionSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciAggregationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciAggregation(data: number[], opts: CorrosionSciAggregationOptions = {}): CorrosionSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciAggregation };
diff --git a/src/corrosion_sci/algebra.ts b/src/corrosion_sci/algebra.ts
new file mode 100644
index 000000000..e848c83c1
--- /dev/null
+++ b/src/corrosion_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci algebra module — tsb analytics library. */
+export interface CorrosionSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciAlgebra(data: number[], opts: CorrosionSciAlgebraOptions = {}): CorrosionSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciAlgebra };
diff --git a/src/corrosion_sci/alignment.ts b/src/corrosion_sci/alignment.ts
new file mode 100644
index 000000000..1cdd33120
--- /dev/null
+++ b/src/corrosion_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci alignment module — tsb analytics library. */
+export interface CorrosionSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciAlignment(data: number[], opts: CorrosionSciAlignmentOptions = {}): CorrosionSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciAlignment };
diff --git a/src/corrosion_sci/analysis.ts b/src/corrosion_sci/analysis.ts
new file mode 100644
index 000000000..3444e6051
--- /dev/null
+++ b/src/corrosion_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci analysis module — tsb analytics library. */
+export interface CorrosionSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciAnalysis(data: number[], opts: CorrosionSciAnalysisOptions = {}): CorrosionSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciAnalysis };
diff --git a/src/corrosion_sci/augmentation.ts b/src/corrosion_sci/augmentation.ts
new file mode 100644
index 000000000..bd151e691
--- /dev/null
+++ b/src/corrosion_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci augmentation module — tsb analytics library. */
+export interface CorrosionSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciAugmentation(data: number[], opts: CorrosionSciAugmentationOptions = {}): CorrosionSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciAugmentation };
diff --git a/src/corrosion_sci/bagging.ts b/src/corrosion_sci/bagging.ts
new file mode 100644
index 000000000..f67f2f8f5
--- /dev/null
+++ b/src/corrosion_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci bagging module — tsb analytics library. */
+export interface CorrosionSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciBaggingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciBagging(data: number[], opts: CorrosionSciBaggingOptions = {}): CorrosionSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciBagging };
diff --git a/src/corrosion_sci/basis.ts b/src/corrosion_sci/basis.ts
new file mode 100644
index 000000000..0949b969b
--- /dev/null
+++ b/src/corrosion_sci/basis.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci basis module — tsb analytics library. */
+export interface CorrosionSciBasisOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciBasisResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciBasis(data: number[], opts: CorrosionSciBasisOptions = {}): CorrosionSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciBasis };
diff --git a/src/corrosion_sci/benchmarking.ts b/src/corrosion_sci/benchmarking.ts
new file mode 100644
index 000000000..802a4fad9
--- /dev/null
+++ b/src/corrosion_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci benchmarking module — tsb analytics library. */
+export interface CorrosionSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciBenchmarking(data: number[], opts: CorrosionSciBenchmarkingOptions = {}): CorrosionSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciBenchmarking };
diff --git a/src/corrosion_sci/blending.ts b/src/corrosion_sci/blending.ts
new file mode 100644
index 000000000..f136f0d84
--- /dev/null
+++ b/src/corrosion_sci/blending.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci blending module — tsb analytics library. */
+export interface CorrosionSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciBlendingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciBlending(data: number[], opts: CorrosionSciBlendingOptions = {}): CorrosionSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciBlending };
diff --git a/src/corrosion_sci/boosting.ts b/src/corrosion_sci/boosting.ts
new file mode 100644
index 000000000..5d6ecd58d
--- /dev/null
+++ b/src/corrosion_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci boosting module — tsb analytics library. */
+export interface CorrosionSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciBoostingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciBoosting(data: number[], opts: CorrosionSciBoostingOptions = {}): CorrosionSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciBoosting };
diff --git a/src/corrosion_sci/bootstrap.ts b/src/corrosion_sci/bootstrap.ts
new file mode 100644
index 000000000..c001cb524
--- /dev/null
+++ b/src/corrosion_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci bootstrap module — tsb analytics library. */
+export interface CorrosionSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciBootstrap(data: number[], opts: CorrosionSciBootstrapOptions = {}): CorrosionSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciBootstrap };
diff --git a/src/corrosion_sci/calculus.ts b/src/corrosion_sci/calculus.ts
new file mode 100644
index 000000000..7b8b61259
--- /dev/null
+++ b/src/corrosion_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci calculus module — tsb analytics library. */
+export interface CorrosionSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciCalculusResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciCalculus(data: number[], opts: CorrosionSciCalculusOptions = {}): CorrosionSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciCalculus };
diff --git a/src/corrosion_sci/calibration.ts b/src/corrosion_sci/calibration.ts
new file mode 100644
index 000000000..f0f354633
--- /dev/null
+++ b/src/corrosion_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci calibration module — tsb analytics library. */
+export interface CorrosionSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciCalibration(data: number[], opts: CorrosionSciCalibrationOptions = {}): CorrosionSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciCalibration };
diff --git a/src/corrosion_sci/characterization.ts b/src/corrosion_sci/characterization.ts
new file mode 100644
index 000000000..76a517be7
--- /dev/null
+++ b/src/corrosion_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci characterization module — tsb analytics library. */
+export interface CorrosionSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciCharacterization(data: number[], opts: CorrosionSciCharacterizationOptions = {}): CorrosionSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciCharacterization };
diff --git a/src/corrosion_sci/classification.ts b/src/corrosion_sci/classification.ts
new file mode 100644
index 000000000..72d49f415
--- /dev/null
+++ b/src/corrosion_sci/classification.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci classification module — tsb analytics library. */
+export interface CorrosionSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciClassificationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciClassification(data: number[], opts: CorrosionSciClassificationOptions = {}): CorrosionSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciClassification };
diff --git a/src/corrosion_sci/clustering.ts b/src/corrosion_sci/clustering.ts
new file mode 100644
index 000000000..6d6f16fd2
--- /dev/null
+++ b/src/corrosion_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci clustering module — tsb analytics library. */
+export interface CorrosionSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciClusteringResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciClustering(data: number[], opts: CorrosionSciClusteringOptions = {}): CorrosionSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciClustering };
diff --git a/src/corrosion_sci/compression.ts b/src/corrosion_sci/compression.ts
new file mode 100644
index 000000000..523f5aa35
--- /dev/null
+++ b/src/corrosion_sci/compression.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci compression module — tsb analytics library. */
+export interface CorrosionSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciCompressionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciCompression(data: number[], opts: CorrosionSciCompressionOptions = {}): CorrosionSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciCompression };
diff --git a/src/corrosion_sci/continuous.ts b/src/corrosion_sci/continuous.ts
new file mode 100644
index 000000000..46994d016
--- /dev/null
+++ b/src/corrosion_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci continuous module — tsb analytics library. */
+export interface CorrosionSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciContinuousResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciContinuous(data: number[], opts: CorrosionSciContinuousOptions = {}): CorrosionSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciContinuous };
diff --git a/src/corrosion_sci/control.ts b/src/corrosion_sci/control.ts
new file mode 100644
index 000000000..1d5919929
--- /dev/null
+++ b/src/corrosion_sci/control.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci control module — tsb analytics library. */
+export interface CorrosionSciControlOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciControlResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciControl(data: number[], opts: CorrosionSciControlOptions = {}): CorrosionSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciControl };
diff --git a/src/corrosion_sci/convergence.ts b/src/corrosion_sci/convergence.ts
new file mode 100644
index 000000000..f8e6a443e
--- /dev/null
+++ b/src/corrosion_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci convergence module — tsb analytics library. */
+export interface CorrosionSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciConvergence(data: number[], opts: CorrosionSciConvergenceOptions = {}): CorrosionSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciConvergence };
diff --git a/src/corrosion_sci/convex.ts b/src/corrosion_sci/convex.ts
new file mode 100644
index 000000000..157fd0002
--- /dev/null
+++ b/src/corrosion_sci/convex.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci convex module — tsb analytics library. */
+export interface CorrosionSciConvexOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciConvexResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciConvex(data: number[], opts: CorrosionSciConvexOptions = {}): CorrosionSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciConvex };
diff --git a/src/corrosion_sci/correlation.ts b/src/corrosion_sci/correlation.ts
new file mode 100644
index 000000000..15aa2c2ed
--- /dev/null
+++ b/src/corrosion_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci correlation module — tsb analytics library. */
+export interface CorrosionSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciCorrelation(data: number[], opts: CorrosionSciCorrelationOptions = {}): CorrosionSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciCorrelation };
diff --git a/src/corrosion_sci/covariance.ts b/src/corrosion_sci/covariance.ts
new file mode 100644
index 000000000..a68449206
--- /dev/null
+++ b/src/corrosion_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci covariance module — tsb analytics library. */
+export interface CorrosionSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciCovariance(data: number[], opts: CorrosionSciCovarianceOptions = {}): CorrosionSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciCovariance };
diff --git a/src/corrosion_sci/cross_validation.ts b/src/corrosion_sci/cross_validation.ts
new file mode 100644
index 000000000..347159fff
--- /dev/null
+++ b/src/corrosion_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci cross_validation module — tsb analytics library. */
+export interface CorrosionSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciCrossValidation(data: number[], opts: CorrosionSciCrossValidationOptions = {}): CorrosionSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciCrossValidation };
diff --git a/src/corrosion_sci/decoding.ts b/src/corrosion_sci/decoding.ts
new file mode 100644
index 000000000..01abfcd89
--- /dev/null
+++ b/src/corrosion_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci decoding module — tsb analytics library. */
+export interface CorrosionSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDecodingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDecoding(data: number[], opts: CorrosionSciDecodingOptions = {}): CorrosionSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDecoding };
diff --git a/src/corrosion_sci/decomposition.ts b/src/corrosion_sci/decomposition.ts
new file mode 100644
index 000000000..0572c6b38
--- /dev/null
+++ b/src/corrosion_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci decomposition module — tsb analytics library. */
+export interface CorrosionSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDecomposition(data: number[], opts: CorrosionSciDecompositionOptions = {}): CorrosionSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDecomposition };
diff --git a/src/corrosion_sci/detection.ts b/src/corrosion_sci/detection.ts
new file mode 100644
index 000000000..7998fa141
--- /dev/null
+++ b/src/corrosion_sci/detection.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci detection module — tsb analytics library. */
+export interface CorrosionSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDetectionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDetection(data: number[], opts: CorrosionSciDetectionOptions = {}): CorrosionSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDetection };
diff --git a/src/corrosion_sci/deterministic.ts b/src/corrosion_sci/deterministic.ts
new file mode 100644
index 000000000..102f0934e
--- /dev/null
+++ b/src/corrosion_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci deterministic module — tsb analytics library. */
+export interface CorrosionSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDeterministic(data: number[], opts: CorrosionSciDeterministicOptions = {}): CorrosionSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDeterministic };
diff --git a/src/corrosion_sci/diagnostics.ts b/src/corrosion_sci/diagnostics.ts
new file mode 100644
index 000000000..002302d19
--- /dev/null
+++ b/src/corrosion_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci diagnostics module — tsb analytics library. */
+export interface CorrosionSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDiagnostics(data: number[], opts: CorrosionSciDiagnosticsOptions = {}): CorrosionSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDiagnostics };
diff --git a/src/corrosion_sci/differential.ts b/src/corrosion_sci/differential.ts
new file mode 100644
index 000000000..b882f8a05
--- /dev/null
+++ b/src/corrosion_sci/differential.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci differential module — tsb analytics library. */
+export interface CorrosionSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDifferential(data: number[], opts: CorrosionSciDifferentialOptions = {}): CorrosionSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDifferential };
diff --git a/src/corrosion_sci/discrete.ts b/src/corrosion_sci/discrete.ts
new file mode 100644
index 000000000..09b85fc71
--- /dev/null
+++ b/src/corrosion_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci discrete module — tsb analytics library. */
+export interface CorrosionSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDiscrete(data: number[], opts: CorrosionSciDiscreteOptions = {}): CorrosionSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDiscrete };
diff --git a/src/corrosion_sci/distribution.ts b/src/corrosion_sci/distribution.ts
new file mode 100644
index 000000000..8748c3f72
--- /dev/null
+++ b/src/corrosion_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci distribution module — tsb analytics library. */
+export interface CorrosionSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDistributionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDistribution(data: number[], opts: CorrosionSciDistributionOptions = {}): CorrosionSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDistribution };
diff --git a/src/corrosion_sci/dynamic.ts b/src/corrosion_sci/dynamic.ts
new file mode 100644
index 000000000..f2f956386
--- /dev/null
+++ b/src/corrosion_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci dynamic module — tsb analytics library. */
+export interface CorrosionSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciDynamicResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciDynamic(data: number[], opts: CorrosionSciDynamicOptions = {}): CorrosionSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciDynamic };
diff --git a/src/corrosion_sci/embedding.ts b/src/corrosion_sci/embedding.ts
new file mode 100644
index 000000000..14e120c99
--- /dev/null
+++ b/src/corrosion_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci embedding module — tsb analytics library. */
+export interface CorrosionSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciEmbedding(data: number[], opts: CorrosionSciEmbeddingOptions = {}): CorrosionSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciEmbedding };
diff --git a/src/corrosion_sci/encoding.ts b/src/corrosion_sci/encoding.ts
new file mode 100644
index 000000000..09e9f96d1
--- /dev/null
+++ b/src/corrosion_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci encoding module — tsb analytics library. */
+export interface CorrosionSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciEncodingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciEncoding(data: number[], opts: CorrosionSciEncodingOptions = {}): CorrosionSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciEncoding };
diff --git a/src/corrosion_sci/ensemble.ts b/src/corrosion_sci/ensemble.ts
new file mode 100644
index 000000000..2b0443196
--- /dev/null
+++ b/src/corrosion_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci ensemble module — tsb analytics library. */
+export interface CorrosionSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciEnsemble(data: number[], opts: CorrosionSciEnsembleOptions = {}): CorrosionSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciEnsemble };
diff --git a/src/corrosion_sci/estimation.ts b/src/corrosion_sci/estimation.ts
new file mode 100644
index 000000000..3abfcead8
--- /dev/null
+++ b/src/corrosion_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci estimation module — tsb analytics library. */
+export interface CorrosionSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciEstimationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciEstimation(data: number[], opts: CorrosionSciEstimationOptions = {}): CorrosionSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciEstimation };
diff --git a/src/corrosion_sci/evaluation.ts b/src/corrosion_sci/evaluation.ts
new file mode 100644
index 000000000..06285d629
--- /dev/null
+++ b/src/corrosion_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci evaluation module — tsb analytics library. */
+export interface CorrosionSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciEvaluation(data: number[], opts: CorrosionSciEvaluationOptions = {}): CorrosionSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciEvaluation };
diff --git a/src/corrosion_sci/extrapolation.ts b/src/corrosion_sci/extrapolation.ts
new file mode 100644
index 000000000..62892aa8a
--- /dev/null
+++ b/src/corrosion_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci extrapolation module — tsb analytics library. */
+export interface CorrosionSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciExtrapolation(data: number[], opts: CorrosionSciExtrapolationOptions = {}): CorrosionSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciExtrapolation };
diff --git a/src/corrosion_sci/features.ts b/src/corrosion_sci/features.ts
new file mode 100644
index 000000000..ed0156f0a
--- /dev/null
+++ b/src/corrosion_sci/features.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci features module — tsb analytics library. */
+export interface CorrosionSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciFeatures(data: number[], opts: CorrosionSciFeaturesOptions = {}): CorrosionSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciFeatures };
diff --git a/src/corrosion_sci/feedback.ts b/src/corrosion_sci/feedback.ts
new file mode 100644
index 000000000..36b8b9492
--- /dev/null
+++ b/src/corrosion_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci feedback module — tsb analytics library. */
+export interface CorrosionSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciFeedback(data: number[], opts: CorrosionSciFeedbackOptions = {}): CorrosionSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciFeedback };
diff --git a/src/corrosion_sci/filtering.ts b/src/corrosion_sci/filtering.ts
new file mode 100644
index 000000000..ea18a99b7
--- /dev/null
+++ b/src/corrosion_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci filtering module — tsb analytics library. */
+export interface CorrosionSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciFilteringResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciFiltering(data: number[], opts: CorrosionSciFilteringOptions = {}): CorrosionSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciFiltering };
diff --git a/src/corrosion_sci/fourier.ts b/src/corrosion_sci/fourier.ts
new file mode 100644
index 000000000..0e8569872
--- /dev/null
+++ b/src/corrosion_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci fourier module — tsb analytics library. */
+export interface CorrosionSciFourierOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciFourierResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciFourier(data: number[], opts: CorrosionSciFourierOptions = {}): CorrosionSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciFourier };
diff --git a/src/corrosion_sci/fusion.ts b/src/corrosion_sci/fusion.ts
new file mode 100644
index 000000000..7b89556a6
--- /dev/null
+++ b/src/corrosion_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci fusion module — tsb analytics library. */
+export interface CorrosionSciFusionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciFusionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciFusion(data: number[], opts: CorrosionSciFusionOptions = {}): CorrosionSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciFusion };
diff --git a/src/corrosion_sci/generation.ts b/src/corrosion_sci/generation.ts
new file mode 100644
index 000000000..de022b901
--- /dev/null
+++ b/src/corrosion_sci/generation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci generation module — tsb analytics library. */
+export interface CorrosionSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciGenerationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciGeneration(data: number[], opts: CorrosionSciGenerationOptions = {}): CorrosionSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciGeneration };
diff --git a/src/corrosion_sci/geometry.ts b/src/corrosion_sci/geometry.ts
new file mode 100644
index 000000000..0638b6f72
--- /dev/null
+++ b/src/corrosion_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci geometry module — tsb analytics library. */
+export interface CorrosionSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciGeometryResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciGeometry(data: number[], opts: CorrosionSciGeometryOptions = {}): CorrosionSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciGeometry };
diff --git a/src/corrosion_sci/gradient.ts b/src/corrosion_sci/gradient.ts
new file mode 100644
index 000000000..9b1c75a2f
--- /dev/null
+++ b/src/corrosion_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci gradient module — tsb analytics library. */
+export interface CorrosionSciGradientOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciGradientResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciGradient(data: number[], opts: CorrosionSciGradientOptions = {}): CorrosionSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciGradient };
diff --git a/src/corrosion_sci/hessian.ts b/src/corrosion_sci/hessian.ts
new file mode 100644
index 000000000..8050cdaf0
--- /dev/null
+++ b/src/corrosion_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci hessian module — tsb analytics library. */
+export interface CorrosionSciHessianOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciHessianResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciHessian(data: number[], opts: CorrosionSciHessianOptions = {}): CorrosionSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciHessian };
diff --git a/src/corrosion_sci/hypothesis.ts b/src/corrosion_sci/hypothesis.ts
new file mode 100644
index 000000000..ba0752d94
--- /dev/null
+++ b/src/corrosion_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci hypothesis module — tsb analytics library. */
+export interface CorrosionSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciHypothesis(data: number[], opts: CorrosionSciHypothesisOptions = {}): CorrosionSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciHypothesis };
diff --git a/src/corrosion_sci/inference.ts b/src/corrosion_sci/inference.ts
new file mode 100644
index 000000000..a99264dec
--- /dev/null
+++ b/src/corrosion_sci/inference.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci inference module — tsb analytics library. */
+export interface CorrosionSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciInferenceResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciInference(data: number[], opts: CorrosionSciInferenceOptions = {}): CorrosionSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciInference };
diff --git a/src/corrosion_sci/inference2.ts b/src/corrosion_sci/inference2.ts
new file mode 100644
index 000000000..af9592b24
--- /dev/null
+++ b/src/corrosion_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci inference2 module — tsb analytics library. */
+export interface CorrosionSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciInferenceResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciInference(data: number[], opts: CorrosionSciInferenceOptions = {}): CorrosionSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciInference };
diff --git a/src/corrosion_sci/integral.ts b/src/corrosion_sci/integral.ts
new file mode 100644
index 000000000..22689553a
--- /dev/null
+++ b/src/corrosion_sci/integral.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci integral module — tsb analytics library. */
+export interface CorrosionSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciIntegralResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciIntegral(data: number[], opts: CorrosionSciIntegralOptions = {}): CorrosionSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciIntegral };
diff --git a/src/corrosion_sci/integration.ts b/src/corrosion_sci/integration.ts
new file mode 100644
index 000000000..c07725751
--- /dev/null
+++ b/src/corrosion_sci/integration.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci integration module — tsb analytics library. */
+export interface CorrosionSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciIntegration(data: number[], opts: CorrosionSciIntegrationOptions = {}): CorrosionSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciIntegration };
diff --git a/src/corrosion_sci/interpolation.ts b/src/corrosion_sci/interpolation.ts
new file mode 100644
index 000000000..600cb0fd0
--- /dev/null
+++ b/src/corrosion_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci interpolation module — tsb analytics library. */
+export interface CorrosionSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciInterpolation(data: number[], opts: CorrosionSciInterpolationOptions = {}): CorrosionSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciInterpolation };
diff --git a/src/corrosion_sci/jacobian.ts b/src/corrosion_sci/jacobian.ts
new file mode 100644
index 000000000..dc49d86bc
--- /dev/null
+++ b/src/corrosion_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci jacobian module — tsb analytics library. */
+export interface CorrosionSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciJacobianResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciJacobian(data: number[], opts: CorrosionSciJacobianOptions = {}): CorrosionSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciJacobian };
diff --git a/src/corrosion_sci/kernel.ts b/src/corrosion_sci/kernel.ts
new file mode 100644
index 000000000..19301d199
--- /dev/null
+++ b/src/corrosion_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci kernel module — tsb analytics library. */
+export interface CorrosionSciKernelOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciKernelResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciKernel(data: number[], opts: CorrosionSciKernelOptions = {}): CorrosionSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciKernel };
diff --git a/src/corrosion_sci/laplacian.ts b/src/corrosion_sci/laplacian.ts
new file mode 100644
index 000000000..94bfd3fd6
--- /dev/null
+++ b/src/corrosion_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci laplacian module — tsb analytics library. */
+export interface CorrosionSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciLaplacian(data: number[], opts: CorrosionSciLaplacianOptions = {}): CorrosionSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciLaplacian };
diff --git a/src/corrosion_sci/learning.ts b/src/corrosion_sci/learning.ts
new file mode 100644
index 000000000..04e62aec0
--- /dev/null
+++ b/src/corrosion_sci/learning.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci learning module — tsb analytics library. */
+export interface CorrosionSciLearningOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciLearningResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciLearning(data: number[], opts: CorrosionSciLearningOptions = {}): CorrosionSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciLearning };
diff --git a/src/corrosion_sci/linear.ts b/src/corrosion_sci/linear.ts
new file mode 100644
index 000000000..1eb4a8461
--- /dev/null
+++ b/src/corrosion_sci/linear.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci linear module — tsb analytics library. */
+export interface CorrosionSciLinearOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciLinearResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciLinear(data: number[], opts: CorrosionSciLinearOptions = {}): CorrosionSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciLinear };
diff --git a/src/corrosion_sci/manifold.ts b/src/corrosion_sci/manifold.ts
new file mode 100644
index 000000000..f01d3d8c6
--- /dev/null
+++ b/src/corrosion_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci manifold module — tsb analytics library. */
+export interface CorrosionSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciManifoldResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciManifold(data: number[], opts: CorrosionSciManifoldOptions = {}): CorrosionSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciManifold };
diff --git a/src/corrosion_sci/matching.ts b/src/corrosion_sci/matching.ts
new file mode 100644
index 000000000..3f4a78875
--- /dev/null
+++ b/src/corrosion_sci/matching.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci matching module — tsb analytics library. */
+export interface CorrosionSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciMatchingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciMatching(data: number[], opts: CorrosionSciMatchingOptions = {}): CorrosionSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciMatching };
diff --git a/src/corrosion_sci/measurement.ts b/src/corrosion_sci/measurement.ts
new file mode 100644
index 000000000..7cc41768b
--- /dev/null
+++ b/src/corrosion_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci measurement module — tsb analytics library. */
+export interface CorrosionSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciMeasurement(data: number[], opts: CorrosionSciMeasurementOptions = {}): CorrosionSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciMeasurement };
diff --git a/src/corrosion_sci/metrics.ts b/src/corrosion_sci/metrics.ts
new file mode 100644
index 000000000..fb2e1da18
--- /dev/null
+++ b/src/corrosion_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci metrics module — tsb analytics library. */
+export interface CorrosionSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciMetricsResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciMetrics(data: number[], opts: CorrosionSciMetricsOptions = {}): CorrosionSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciMetrics };
diff --git a/src/corrosion_sci/modeling.ts b/src/corrosion_sci/modeling.ts
new file mode 100644
index 000000000..c1a989446
--- /dev/null
+++ b/src/corrosion_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci modeling module — tsb analytics library. */
+export interface CorrosionSciModelingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciModelingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciModeling(data: number[], opts: CorrosionSciModelingOptions = {}): CorrosionSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciModeling };
diff --git a/src/corrosion_sci/monitoring.ts b/src/corrosion_sci/monitoring.ts
new file mode 100644
index 000000000..fc41ae4a2
--- /dev/null
+++ b/src/corrosion_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci monitoring module — tsb analytics library. */
+export interface CorrosionSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciMonitoring(data: number[], opts: CorrosionSciMonitoringOptions = {}): CorrosionSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciMonitoring };
diff --git a/src/corrosion_sci/nonlinear.ts b/src/corrosion_sci/nonlinear.ts
new file mode 100644
index 000000000..6e2de0ced
--- /dev/null
+++ b/src/corrosion_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci nonlinear module — tsb analytics library. */
+export interface CorrosionSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciNonlinear(data: number[], opts: CorrosionSciNonlinearOptions = {}): CorrosionSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciNonlinear };
diff --git a/src/corrosion_sci/normalization.ts b/src/corrosion_sci/normalization.ts
new file mode 100644
index 000000000..156c8b603
--- /dev/null
+++ b/src/corrosion_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci normalization module — tsb analytics library. */
+export interface CorrosionSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciNormalization(data: number[], opts: CorrosionSciNormalizationOptions = {}): CorrosionSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciNormalization };
diff --git a/src/corrosion_sci/optimization.ts b/src/corrosion_sci/optimization.ts
new file mode 100644
index 000000000..99b6b6643
--- /dev/null
+++ b/src/corrosion_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci optimization module — tsb analytics library. */
+export interface CorrosionSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciOptimization(data: number[], opts: CorrosionSciOptimizationOptions = {}): CorrosionSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciOptimization };
diff --git a/src/corrosion_sci/patterns.ts b/src/corrosion_sci/patterns.ts
new file mode 100644
index 000000000..a0cbfa4d0
--- /dev/null
+++ b/src/corrosion_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci patterns module — tsb analytics library. */
+export interface CorrosionSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciPatternsResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciPatterns(data: number[], opts: CorrosionSciPatternsOptions = {}): CorrosionSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciPatterns };
diff --git a/src/corrosion_sci/permutation.ts b/src/corrosion_sci/permutation.ts
new file mode 100644
index 000000000..380022a42
--- /dev/null
+++ b/src/corrosion_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci permutation module — tsb analytics library. */
+export interface CorrosionSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciPermutationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciPermutation(data: number[], opts: CorrosionSciPermutationOptions = {}): CorrosionSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciPermutation };
diff --git a/src/corrosion_sci/prediction.ts b/src/corrosion_sci/prediction.ts
new file mode 100644
index 000000000..99728872c
--- /dev/null
+++ b/src/corrosion_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci prediction module — tsb analytics library. */
+export interface CorrosionSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciPredictionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciPrediction(data: number[], opts: CorrosionSciPredictionOptions = {}): CorrosionSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciPrediction };
diff --git a/src/corrosion_sci/processing.ts b/src/corrosion_sci/processing.ts
new file mode 100644
index 000000000..22620031d
--- /dev/null
+++ b/src/corrosion_sci/processing.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci processing module — tsb analytics library. */
+export interface CorrosionSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciProcessingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciProcessing(data: number[], opts: CorrosionSciProcessingOptions = {}): CorrosionSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciProcessing };
diff --git a/src/corrosion_sci/profiling.ts b/src/corrosion_sci/profiling.ts
new file mode 100644
index 000000000..08ba4a437
--- /dev/null
+++ b/src/corrosion_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci profiling module — tsb analytics library. */
+export interface CorrosionSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciProfilingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciProfiling(data: number[], opts: CorrosionSciProfilingOptions = {}): CorrosionSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciProfiling };
diff --git a/src/corrosion_sci/projection.ts b/src/corrosion_sci/projection.ts
new file mode 100644
index 000000000..6675767ba
--- /dev/null
+++ b/src/corrosion_sci/projection.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci projection module — tsb analytics library. */
+export interface CorrosionSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciProjectionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciProjection(data: number[], opts: CorrosionSciProjectionOptions = {}): CorrosionSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciProjection };
diff --git a/src/corrosion_sci/ranking.ts b/src/corrosion_sci/ranking.ts
new file mode 100644
index 000000000..a169031dd
--- /dev/null
+++ b/src/corrosion_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci ranking module — tsb analytics library. */
+export interface CorrosionSciRankingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciRankingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciRanking(data: number[], opts: CorrosionSciRankingOptions = {}): CorrosionSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciRanking };
diff --git a/src/corrosion_sci/reconstruction.ts b/src/corrosion_sci/reconstruction.ts
new file mode 100644
index 000000000..85afab1c8
--- /dev/null
+++ b/src/corrosion_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci reconstruction module — tsb analytics library. */
+export interface CorrosionSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciReconstruction(data: number[], opts: CorrosionSciReconstructionOptions = {}): CorrosionSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciReconstruction };
diff --git a/src/corrosion_sci/registration.ts b/src/corrosion_sci/registration.ts
new file mode 100644
index 000000000..922df08eb
--- /dev/null
+++ b/src/corrosion_sci/registration.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci registration module — tsb analytics library. */
+export interface CorrosionSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciRegistration(data: number[], opts: CorrosionSciRegistrationOptions = {}): CorrosionSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciRegistration };
diff --git a/src/corrosion_sci/regression.ts b/src/corrosion_sci/regression.ts
new file mode 100644
index 000000000..099379bb9
--- /dev/null
+++ b/src/corrosion_sci/regression.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci regression module — tsb analytics library. */
+export interface CorrosionSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciRegressionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciRegression(data: number[], opts: CorrosionSciRegressionOptions = {}): CorrosionSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciRegression };
diff --git a/src/corrosion_sci/regularization.ts b/src/corrosion_sci/regularization.ts
new file mode 100644
index 000000000..543b4d5c6
--- /dev/null
+++ b/src/corrosion_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci regularization module — tsb analytics library. */
+export interface CorrosionSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciRegularization(data: number[], opts: CorrosionSciRegularizationOptions = {}): CorrosionSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciRegularization };
diff --git a/src/corrosion_sci/robustness.ts b/src/corrosion_sci/robustness.ts
new file mode 100644
index 000000000..5e0929f65
--- /dev/null
+++ b/src/corrosion_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci robustness module — tsb analytics library. */
+export interface CorrosionSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciRobustness(data: number[], opts: CorrosionSciRobustnessOptions = {}): CorrosionSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciRobustness };
diff --git a/src/corrosion_sci/sampling.ts b/src/corrosion_sci/sampling.ts
new file mode 100644
index 000000000..3924b9581
--- /dev/null
+++ b/src/corrosion_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci sampling module — tsb analytics library. */
+export interface CorrosionSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciSamplingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciSampling(data: number[], opts: CorrosionSciSamplingOptions = {}): CorrosionSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciSampling };
diff --git a/src/corrosion_sci/sampling2.ts b/src/corrosion_sci/sampling2.ts
new file mode 100644
index 000000000..5a9581402
--- /dev/null
+++ b/src/corrosion_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci sampling2 module — tsb analytics library. */
+export interface CorrosionSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciSamplingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciSampling(data: number[], opts: CorrosionSciSamplingOptions = {}): CorrosionSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciSampling };
diff --git a/src/corrosion_sci/scaling.ts b/src/corrosion_sci/scaling.ts
new file mode 100644
index 000000000..7cf825020
--- /dev/null
+++ b/src/corrosion_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci scaling module — tsb analytics library. */
+export interface CorrosionSciScalingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciScalingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciScaling(data: number[], opts: CorrosionSciScalingOptions = {}): CorrosionSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciScaling };
diff --git a/src/corrosion_sci/scoring.ts b/src/corrosion_sci/scoring.ts
new file mode 100644
index 000000000..08f0b648a
--- /dev/null
+++ b/src/corrosion_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci scoring module — tsb analytics library. */
+export interface CorrosionSciScoringOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciScoringResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciScoring(data: number[], opts: CorrosionSciScoringOptions = {}): CorrosionSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciScoring };
diff --git a/src/corrosion_sci/segmentation.ts b/src/corrosion_sci/segmentation.ts
new file mode 100644
index 000000000..77b48c1c4
--- /dev/null
+++ b/src/corrosion_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci segmentation module — tsb analytics library. */
+export interface CorrosionSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciSegmentation(data: number[], opts: CorrosionSciSegmentationOptions = {}): CorrosionSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciSegmentation };
diff --git a/src/corrosion_sci/selection.ts b/src/corrosion_sci/selection.ts
new file mode 100644
index 000000000..0a6ce538e
--- /dev/null
+++ b/src/corrosion_sci/selection.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci selection module — tsb analytics library. */
+export interface CorrosionSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciSelectionResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciSelection(data: number[], opts: CorrosionSciSelectionOptions = {}): CorrosionSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciSelection };
diff --git a/src/corrosion_sci/sensitivity.ts b/src/corrosion_sci/sensitivity.ts
new file mode 100644
index 000000000..8d7985b23
--- /dev/null
+++ b/src/corrosion_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci sensitivity module — tsb analytics library. */
+export interface CorrosionSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciSensitivity(data: number[], opts: CorrosionSciSensitivityOptions = {}): CorrosionSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciSensitivity };
diff --git a/src/corrosion_sci/simulation.ts b/src/corrosion_sci/simulation.ts
new file mode 100644
index 000000000..812df23c9
--- /dev/null
+++ b/src/corrosion_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci simulation module — tsb analytics library. */
+export interface CorrosionSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciSimulationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciSimulation(data: number[], opts: CorrosionSciSimulationOptions = {}): CorrosionSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciSimulation };
diff --git a/src/corrosion_sci/smoothing.ts b/src/corrosion_sci/smoothing.ts
new file mode 100644
index 000000000..dbbc49dfa
--- /dev/null
+++ b/src/corrosion_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci smoothing module — tsb analytics library. */
+export interface CorrosionSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciSmoothing(data: number[], opts: CorrosionSciSmoothingOptions = {}): CorrosionSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciSmoothing };
diff --git a/src/corrosion_sci/stability.ts b/src/corrosion_sci/stability.ts
new file mode 100644
index 000000000..c0b0d850e
--- /dev/null
+++ b/src/corrosion_sci/stability.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci stability module — tsb analytics library. */
+export interface CorrosionSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciStabilityResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciStability(data: number[], opts: CorrosionSciStabilityOptions = {}): CorrosionSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciStability };
diff --git a/src/corrosion_sci/stacking.ts b/src/corrosion_sci/stacking.ts
new file mode 100644
index 000000000..d5c1d58ae
--- /dev/null
+++ b/src/corrosion_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci stacking module — tsb analytics library. */
+export interface CorrosionSciStackingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciStackingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciStacking(data: number[], opts: CorrosionSciStackingOptions = {}): CorrosionSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciStacking };
diff --git a/src/corrosion_sci/standardization.ts b/src/corrosion_sci/standardization.ts
new file mode 100644
index 000000000..47d28f3ba
--- /dev/null
+++ b/src/corrosion_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci standardization module — tsb analytics library. */
+export interface CorrosionSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciStandardization(data: number[], opts: CorrosionSciStandardizationOptions = {}): CorrosionSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciStandardization };
diff --git a/src/corrosion_sci/static.ts b/src/corrosion_sci/static.ts
new file mode 100644
index 000000000..efa70af15
--- /dev/null
+++ b/src/corrosion_sci/static.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci static module — tsb analytics library. */
+export interface CorrosionSciStaticOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciStaticResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciStatic(data: number[], opts: CorrosionSciStaticOptions = {}): CorrosionSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciStatic };
diff --git a/src/corrosion_sci/stochastic.ts b/src/corrosion_sci/stochastic.ts
new file mode 100644
index 000000000..efc2a3827
--- /dev/null
+++ b/src/corrosion_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci stochastic module — tsb analytics library. */
+export interface CorrosionSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciStochasticResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciStochastic(data: number[], opts: CorrosionSciStochasticOptions = {}): CorrosionSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciStochastic };
diff --git a/src/corrosion_sci/synthesis.ts b/src/corrosion_sci/synthesis.ts
new file mode 100644
index 000000000..8c94a17cd
--- /dev/null
+++ b/src/corrosion_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci synthesis module — tsb analytics library. */
+export interface CorrosionSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciSynthesis(data: number[], opts: CorrosionSciSynthesisOptions = {}): CorrosionSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciSynthesis };
diff --git a/src/corrosion_sci/topology.ts b/src/corrosion_sci/topology.ts
new file mode 100644
index 000000000..4574ba933
--- /dev/null
+++ b/src/corrosion_sci/topology.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci topology module — tsb analytics library. */
+export interface CorrosionSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciTopologyResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciTopology(data: number[], opts: CorrosionSciTopologyOptions = {}): CorrosionSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciTopology };
diff --git a/src/corrosion_sci/tracking.ts b/src/corrosion_sci/tracking.ts
new file mode 100644
index 000000000..475d615c9
--- /dev/null
+++ b/src/corrosion_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci tracking module — tsb analytics library. */
+export interface CorrosionSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciTrackingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciTracking(data: number[], opts: CorrosionSciTrackingOptions = {}): CorrosionSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciTracking };
diff --git a/src/corrosion_sci/transform.ts b/src/corrosion_sci/transform.ts
new file mode 100644
index 000000000..b625c8554
--- /dev/null
+++ b/src/corrosion_sci/transform.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci transform module — tsb analytics library. */
+export interface CorrosionSciTransformOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciTransformResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciTransform(data: number[], opts: CorrosionSciTransformOptions = {}): CorrosionSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciTransform };
diff --git a/src/corrosion_sci/uncertainty.ts b/src/corrosion_sci/uncertainty.ts
new file mode 100644
index 000000000..ede268408
--- /dev/null
+++ b/src/corrosion_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci uncertainty module — tsb analytics library. */
+export interface CorrosionSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciUncertainty(data: number[], opts: CorrosionSciUncertaintyOptions = {}): CorrosionSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciUncertainty };
diff --git a/src/corrosion_sci/validation.ts b/src/corrosion_sci/validation.ts
new file mode 100644
index 000000000..e6527ad59
--- /dev/null
+++ b/src/corrosion_sci/validation.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci validation module — tsb analytics library. */
+export interface CorrosionSciValidationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciValidationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciValidation(data: number[], opts: CorrosionSciValidationOptions = {}): CorrosionSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciValidation };
diff --git a/src/corrosion_sci/verification.ts b/src/corrosion_sci/verification.ts
new file mode 100644
index 000000000..069a9d85a
--- /dev/null
+++ b/src/corrosion_sci/verification.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci verification module — tsb analytics library. */
+export interface CorrosionSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciVerificationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciVerification(data: number[], opts: CorrosionSciVerificationOptions = {}): CorrosionSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciVerification };
diff --git a/src/corrosion_sci/visualization.ts b/src/corrosion_sci/visualization.ts
new file mode 100644
index 000000000..1f0850956
--- /dev/null
+++ b/src/corrosion_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci visualization module — tsb analytics library. */
+export interface CorrosionSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciVisualization(data: number[], opts: CorrosionSciVisualizationOptions = {}): CorrosionSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciVisualization };
diff --git a/src/corrosion_sci/voting.ts b/src/corrosion_sci/voting.ts
new file mode 100644
index 000000000..f835b4fbd
--- /dev/null
+++ b/src/corrosion_sci/voting.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci voting module — tsb analytics library. */
+export interface CorrosionSciVotingOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciVotingResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciVoting(data: number[], opts: CorrosionSciVotingOptions = {}): CorrosionSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciVoting };
diff --git a/src/corrosion_sci/wavelet.ts b/src/corrosion_sci/wavelet.ts
new file mode 100644
index 000000000..133a169c8
--- /dev/null
+++ b/src/corrosion_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** corrosion_sci wavelet module — tsb analytics library. */
+export interface CorrosionSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface CorrosionSciWaveletResult { values: number[]; converged: boolean; }
+export function computeCorrosionSciWavelet(data: number[], opts: CorrosionSciWaveletOptions = {}): CorrosionSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCorrosionSciWavelet };
diff --git a/src/cosmology_sci/adaptation.ts b/src/cosmology_sci/adaptation.ts
new file mode 100644
index 000000000..ef5c62328
--- /dev/null
+++ b/src/cosmology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci adaptation module — tsb analytics library. */
+export interface CosmologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciAdaptation(data: number[], opts: CosmologySciAdaptationOptions = {}): CosmologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciAdaptation };
diff --git a/src/cosmology_sci/aggregation.ts b/src/cosmology_sci/aggregation.ts
new file mode 100644
index 000000000..523bc6048
--- /dev/null
+++ b/src/cosmology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci aggregation module — tsb analytics library. */
+export interface CosmologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciAggregation(data: number[], opts: CosmologySciAggregationOptions = {}): CosmologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciAggregation };
diff --git a/src/cosmology_sci/algebra.ts b/src/cosmology_sci/algebra.ts
new file mode 100644
index 000000000..f98ffbc21
--- /dev/null
+++ b/src/cosmology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci algebra module — tsb analytics library. */
+export interface CosmologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeCosmologySciAlgebra(data: number[], opts: CosmologySciAlgebraOptions = {}): CosmologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciAlgebra };
diff --git a/src/cosmology_sci/alignment.ts b/src/cosmology_sci/alignment.ts
new file mode 100644
index 000000000..39a248ede
--- /dev/null
+++ b/src/cosmology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci alignment module — tsb analytics library. */
+export interface CosmologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeCosmologySciAlignment(data: number[], opts: CosmologySciAlignmentOptions = {}): CosmologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciAlignment };
diff --git a/src/cosmology_sci/analysis.ts b/src/cosmology_sci/analysis.ts
new file mode 100644
index 000000000..7f29e8c2f
--- /dev/null
+++ b/src/cosmology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci analysis module — tsb analytics library. */
+export interface CosmologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeCosmologySciAnalysis(data: number[], opts: CosmologySciAnalysisOptions = {}): CosmologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciAnalysis };
diff --git a/src/cosmology_sci/augmentation.ts b/src/cosmology_sci/augmentation.ts
new file mode 100644
index 000000000..0bcf09c2c
--- /dev/null
+++ b/src/cosmology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci augmentation module — tsb analytics library. */
+export interface CosmologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciAugmentation(data: number[], opts: CosmologySciAugmentationOptions = {}): CosmologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciAugmentation };
diff --git a/src/cosmology_sci/bagging.ts b/src/cosmology_sci/bagging.ts
new file mode 100644
index 000000000..a70c66509
--- /dev/null
+++ b/src/cosmology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci bagging module — tsb analytics library. */
+export interface CosmologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciBagging(data: number[], opts: CosmologySciBaggingOptions = {}): CosmologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciBagging };
diff --git a/src/cosmology_sci/basis.ts b/src/cosmology_sci/basis.ts
new file mode 100644
index 000000000..b4fbcdd22
--- /dev/null
+++ b/src/cosmology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci basis module — tsb analytics library. */
+export interface CosmologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciBasisResult { values: number[]; converged: boolean; }
+export function computeCosmologySciBasis(data: number[], opts: CosmologySciBasisOptions = {}): CosmologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciBasis };
diff --git a/src/cosmology_sci/benchmarking.ts b/src/cosmology_sci/benchmarking.ts
new file mode 100644
index 000000000..a72d4ac56
--- /dev/null
+++ b/src/cosmology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci benchmarking module — tsb analytics library. */
+export interface CosmologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciBenchmarking(data: number[], opts: CosmologySciBenchmarkingOptions = {}): CosmologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciBenchmarking };
diff --git a/src/cosmology_sci/blending.ts b/src/cosmology_sci/blending.ts
new file mode 100644
index 000000000..0c59492d4
--- /dev/null
+++ b/src/cosmology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci blending module — tsb analytics library. */
+export interface CosmologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciBlending(data: number[], opts: CosmologySciBlendingOptions = {}): CosmologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciBlending };
diff --git a/src/cosmology_sci/boosting.ts b/src/cosmology_sci/boosting.ts
new file mode 100644
index 000000000..2401a7095
--- /dev/null
+++ b/src/cosmology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci boosting module — tsb analytics library. */
+export interface CosmologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciBoosting(data: number[], opts: CosmologySciBoostingOptions = {}): CosmologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciBoosting };
diff --git a/src/cosmology_sci/bootstrap.ts b/src/cosmology_sci/bootstrap.ts
new file mode 100644
index 000000000..1fa1d7ba0
--- /dev/null
+++ b/src/cosmology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci bootstrap module — tsb analytics library. */
+export interface CosmologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeCosmologySciBootstrap(data: number[], opts: CosmologySciBootstrapOptions = {}): CosmologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciBootstrap };
diff --git a/src/cosmology_sci/calculus.ts b/src/cosmology_sci/calculus.ts
new file mode 100644
index 000000000..4c7266058
--- /dev/null
+++ b/src/cosmology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci calculus module — tsb analytics library. */
+export interface CosmologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeCosmologySciCalculus(data: number[], opts: CosmologySciCalculusOptions = {}): CosmologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciCalculus };
diff --git a/src/cosmology_sci/calibration.ts b/src/cosmology_sci/calibration.ts
new file mode 100644
index 000000000..fa21855ef
--- /dev/null
+++ b/src/cosmology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci calibration module — tsb analytics library. */
+export interface CosmologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciCalibration(data: number[], opts: CosmologySciCalibrationOptions = {}): CosmologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciCalibration };
diff --git a/src/cosmology_sci/characterization.ts b/src/cosmology_sci/characterization.ts
new file mode 100644
index 000000000..a9a9b257d
--- /dev/null
+++ b/src/cosmology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci characterization module — tsb analytics library. */
+export interface CosmologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciCharacterization(data: number[], opts: CosmologySciCharacterizationOptions = {}): CosmologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciCharacterization };
diff --git a/src/cosmology_sci/classification.ts b/src/cosmology_sci/classification.ts
new file mode 100644
index 000000000..bbdbf6a58
--- /dev/null
+++ b/src/cosmology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci classification module — tsb analytics library. */
+export interface CosmologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciClassification(data: number[], opts: CosmologySciClassificationOptions = {}): CosmologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciClassification };
diff --git a/src/cosmology_sci/clustering.ts b/src/cosmology_sci/clustering.ts
new file mode 100644
index 000000000..8b13e4d19
--- /dev/null
+++ b/src/cosmology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci clustering module — tsb analytics library. */
+export interface CosmologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeCosmologySciClustering(data: number[], opts: CosmologySciClusteringOptions = {}): CosmologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciClustering };
diff --git a/src/cosmology_sci/compression.ts b/src/cosmology_sci/compression.ts
new file mode 100644
index 000000000..213cdee67
--- /dev/null
+++ b/src/cosmology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci compression module — tsb analytics library. */
+export interface CosmologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciCompression(data: number[], opts: CosmologySciCompressionOptions = {}): CosmologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciCompression };
diff --git a/src/cosmology_sci/continuous.ts b/src/cosmology_sci/continuous.ts
new file mode 100644
index 000000000..47d1abffa
--- /dev/null
+++ b/src/cosmology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci continuous module — tsb analytics library. */
+export interface CosmologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeCosmologySciContinuous(data: number[], opts: CosmologySciContinuousOptions = {}): CosmologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciContinuous };
diff --git a/src/cosmology_sci/control.ts b/src/cosmology_sci/control.ts
new file mode 100644
index 000000000..80bd4d928
--- /dev/null
+++ b/src/cosmology_sci/control.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci control module — tsb analytics library. */
+export interface CosmologySciControlOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciControlResult { values: number[]; converged: boolean; }
+export function computeCosmologySciControl(data: number[], opts: CosmologySciControlOptions = {}): CosmologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciControl };
diff --git a/src/cosmology_sci/convergence.ts b/src/cosmology_sci/convergence.ts
new file mode 100644
index 000000000..f26b34182
--- /dev/null
+++ b/src/cosmology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci convergence module — tsb analytics library. */
+export interface CosmologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeCosmologySciConvergence(data: number[], opts: CosmologySciConvergenceOptions = {}): CosmologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciConvergence };
diff --git a/src/cosmology_sci/convex.ts b/src/cosmology_sci/convex.ts
new file mode 100644
index 000000000..510ea3f02
--- /dev/null
+++ b/src/cosmology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci convex module — tsb analytics library. */
+export interface CosmologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciConvexResult { values: number[]; converged: boolean; }
+export function computeCosmologySciConvex(data: number[], opts: CosmologySciConvexOptions = {}): CosmologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciConvex };
diff --git a/src/cosmology_sci/correlation.ts b/src/cosmology_sci/correlation.ts
new file mode 100644
index 000000000..bfd9aae2b
--- /dev/null
+++ b/src/cosmology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci correlation module — tsb analytics library. */
+export interface CosmologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciCorrelation(data: number[], opts: CosmologySciCorrelationOptions = {}): CosmologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciCorrelation };
diff --git a/src/cosmology_sci/covariance.ts b/src/cosmology_sci/covariance.ts
new file mode 100644
index 000000000..b9aa0bde1
--- /dev/null
+++ b/src/cosmology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci covariance module — tsb analytics library. */
+export interface CosmologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeCosmologySciCovariance(data: number[], opts: CosmologySciCovarianceOptions = {}): CosmologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciCovariance };
diff --git a/src/cosmology_sci/cross_validation.ts b/src/cosmology_sci/cross_validation.ts
new file mode 100644
index 000000000..5537939ec
--- /dev/null
+++ b/src/cosmology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci cross_validation module — tsb analytics library. */
+export interface CosmologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciCrossValidation(data: number[], opts: CosmologySciCrossValidationOptions = {}): CosmologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciCrossValidation };
diff --git a/src/cosmology_sci/decoding.ts b/src/cosmology_sci/decoding.ts
new file mode 100644
index 000000000..f10a1567b
--- /dev/null
+++ b/src/cosmology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci decoding module — tsb analytics library. */
+export interface CosmologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDecoding(data: number[], opts: CosmologySciDecodingOptions = {}): CosmologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDecoding };
diff --git a/src/cosmology_sci/decomposition.ts b/src/cosmology_sci/decomposition.ts
new file mode 100644
index 000000000..1165ff2bf
--- /dev/null
+++ b/src/cosmology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci decomposition module — tsb analytics library. */
+export interface CosmologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDecomposition(data: number[], opts: CosmologySciDecompositionOptions = {}): CosmologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDecomposition };
diff --git a/src/cosmology_sci/detection.ts b/src/cosmology_sci/detection.ts
new file mode 100644
index 000000000..81e77d66b
--- /dev/null
+++ b/src/cosmology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci detection module — tsb analytics library. */
+export interface CosmologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDetection(data: number[], opts: CosmologySciDetectionOptions = {}): CosmologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDetection };
diff --git a/src/cosmology_sci/deterministic.ts b/src/cosmology_sci/deterministic.ts
new file mode 100644
index 000000000..cbbc470e6
--- /dev/null
+++ b/src/cosmology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci deterministic module — tsb analytics library. */
+export interface CosmologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDeterministic(data: number[], opts: CosmologySciDeterministicOptions = {}): CosmologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDeterministic };
diff --git a/src/cosmology_sci/diagnostics.ts b/src/cosmology_sci/diagnostics.ts
new file mode 100644
index 000000000..031eb59de
--- /dev/null
+++ b/src/cosmology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci diagnostics module — tsb analytics library. */
+export interface CosmologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDiagnostics(data: number[], opts: CosmologySciDiagnosticsOptions = {}): CosmologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDiagnostics };
diff --git a/src/cosmology_sci/differential.ts b/src/cosmology_sci/differential.ts
new file mode 100644
index 000000000..fe7ef04b8
--- /dev/null
+++ b/src/cosmology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci differential module — tsb analytics library. */
+export interface CosmologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDifferential(data: number[], opts: CosmologySciDifferentialOptions = {}): CosmologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDifferential };
diff --git a/src/cosmology_sci/discrete.ts b/src/cosmology_sci/discrete.ts
new file mode 100644
index 000000000..a4dc31ce0
--- /dev/null
+++ b/src/cosmology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci discrete module — tsb analytics library. */
+export interface CosmologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDiscrete(data: number[], opts: CosmologySciDiscreteOptions = {}): CosmologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDiscrete };
diff --git a/src/cosmology_sci/distribution.ts b/src/cosmology_sci/distribution.ts
new file mode 100644
index 000000000..01a0c35d1
--- /dev/null
+++ b/src/cosmology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci distribution module — tsb analytics library. */
+export interface CosmologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDistribution(data: number[], opts: CosmologySciDistributionOptions = {}): CosmologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDistribution };
diff --git a/src/cosmology_sci/dynamic.ts b/src/cosmology_sci/dynamic.ts
new file mode 100644
index 000000000..6e198d777
--- /dev/null
+++ b/src/cosmology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci dynamic module — tsb analytics library. */
+export interface CosmologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeCosmologySciDynamic(data: number[], opts: CosmologySciDynamicOptions = {}): CosmologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciDynamic };
diff --git a/src/cosmology_sci/embedding.ts b/src/cosmology_sci/embedding.ts
new file mode 100644
index 000000000..19386a889
--- /dev/null
+++ b/src/cosmology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci embedding module — tsb analytics library. */
+export interface CosmologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciEmbedding(data: number[], opts: CosmologySciEmbeddingOptions = {}): CosmologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciEmbedding };
diff --git a/src/cosmology_sci/encoding.ts b/src/cosmology_sci/encoding.ts
new file mode 100644
index 000000000..b35f6107e
--- /dev/null
+++ b/src/cosmology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci encoding module — tsb analytics library. */
+export interface CosmologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciEncoding(data: number[], opts: CosmologySciEncodingOptions = {}): CosmologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciEncoding };
diff --git a/src/cosmology_sci/ensemble.ts b/src/cosmology_sci/ensemble.ts
new file mode 100644
index 000000000..02d7d949c
--- /dev/null
+++ b/src/cosmology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci ensemble module — tsb analytics library. */
+export interface CosmologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeCosmologySciEnsemble(data: number[], opts: CosmologySciEnsembleOptions = {}): CosmologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciEnsemble };
diff --git a/src/cosmology_sci/estimation.ts b/src/cosmology_sci/estimation.ts
new file mode 100644
index 000000000..db6d384c2
--- /dev/null
+++ b/src/cosmology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci estimation module — tsb analytics library. */
+export interface CosmologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciEstimation(data: number[], opts: CosmologySciEstimationOptions = {}): CosmologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciEstimation };
diff --git a/src/cosmology_sci/evaluation.ts b/src/cosmology_sci/evaluation.ts
new file mode 100644
index 000000000..a00e42539
--- /dev/null
+++ b/src/cosmology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci evaluation module — tsb analytics library. */
+export interface CosmologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciEvaluation(data: number[], opts: CosmologySciEvaluationOptions = {}): CosmologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciEvaluation };
diff --git a/src/cosmology_sci/extrapolation.ts b/src/cosmology_sci/extrapolation.ts
new file mode 100644
index 000000000..13e0fdd1c
--- /dev/null
+++ b/src/cosmology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci extrapolation module — tsb analytics library. */
+export interface CosmologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciExtrapolation(data: number[], opts: CosmologySciExtrapolationOptions = {}): CosmologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciExtrapolation };
diff --git a/src/cosmology_sci/features.ts b/src/cosmology_sci/features.ts
new file mode 100644
index 000000000..f53cfd165
--- /dev/null
+++ b/src/cosmology_sci/features.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci features module — tsb analytics library. */
+export interface CosmologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeCosmologySciFeatures(data: number[], opts: CosmologySciFeaturesOptions = {}): CosmologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciFeatures };
diff --git a/src/cosmology_sci/feedback.ts b/src/cosmology_sci/feedback.ts
new file mode 100644
index 000000000..e9f8481f8
--- /dev/null
+++ b/src/cosmology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci feedback module — tsb analytics library. */
+export interface CosmologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeCosmologySciFeedback(data: number[], opts: CosmologySciFeedbackOptions = {}): CosmologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciFeedback };
diff --git a/src/cosmology_sci/filtering.ts b/src/cosmology_sci/filtering.ts
new file mode 100644
index 000000000..7ed6d3510
--- /dev/null
+++ b/src/cosmology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci filtering module — tsb analytics library. */
+export interface CosmologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeCosmologySciFiltering(data: number[], opts: CosmologySciFilteringOptions = {}): CosmologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciFiltering };
diff --git a/src/cosmology_sci/fourier.ts b/src/cosmology_sci/fourier.ts
new file mode 100644
index 000000000..767eb112c
--- /dev/null
+++ b/src/cosmology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci fourier module — tsb analytics library. */
+export interface CosmologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciFourierResult { values: number[]; converged: boolean; }
+export function computeCosmologySciFourier(data: number[], opts: CosmologySciFourierOptions = {}): CosmologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciFourier };
diff --git a/src/cosmology_sci/fusion.ts b/src/cosmology_sci/fusion.ts
new file mode 100644
index 000000000..ac2e28fed
--- /dev/null
+++ b/src/cosmology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci fusion module — tsb analytics library. */
+export interface CosmologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciFusionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciFusion(data: number[], opts: CosmologySciFusionOptions = {}): CosmologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciFusion };
diff --git a/src/cosmology_sci/generation.ts b/src/cosmology_sci/generation.ts
new file mode 100644
index 000000000..2eaeb4725
--- /dev/null
+++ b/src/cosmology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci generation module — tsb analytics library. */
+export interface CosmologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciGeneration(data: number[], opts: CosmologySciGenerationOptions = {}): CosmologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciGeneration };
diff --git a/src/cosmology_sci/geometry.ts b/src/cosmology_sci/geometry.ts
new file mode 100644
index 000000000..692d2deee
--- /dev/null
+++ b/src/cosmology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci geometry module — tsb analytics library. */
+export interface CosmologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeCosmologySciGeometry(data: number[], opts: CosmologySciGeometryOptions = {}): CosmologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciGeometry };
diff --git a/src/cosmology_sci/gradient.ts b/src/cosmology_sci/gradient.ts
new file mode 100644
index 000000000..bf95cbb5f
--- /dev/null
+++ b/src/cosmology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci gradient module — tsb analytics library. */
+export interface CosmologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciGradientResult { values: number[]; converged: boolean; }
+export function computeCosmologySciGradient(data: number[], opts: CosmologySciGradientOptions = {}): CosmologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciGradient };
diff --git a/src/cosmology_sci/hessian.ts b/src/cosmology_sci/hessian.ts
new file mode 100644
index 000000000..53524d77d
--- /dev/null
+++ b/src/cosmology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci hessian module — tsb analytics library. */
+export interface CosmologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciHessianResult { values: number[]; converged: boolean; }
+export function computeCosmologySciHessian(data: number[], opts: CosmologySciHessianOptions = {}): CosmologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciHessian };
diff --git a/src/cosmology_sci/hypothesis.ts b/src/cosmology_sci/hypothesis.ts
new file mode 100644
index 000000000..dda8ff418
--- /dev/null
+++ b/src/cosmology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci hypothesis module — tsb analytics library. */
+export interface CosmologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeCosmologySciHypothesis(data: number[], opts: CosmologySciHypothesisOptions = {}): CosmologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciHypothesis };
diff --git a/src/cosmology_sci/inference.ts b/src/cosmology_sci/inference.ts
new file mode 100644
index 000000000..206892f19
--- /dev/null
+++ b/src/cosmology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci inference module — tsb analytics library. */
+export interface CosmologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeCosmologySciInference(data: number[], opts: CosmologySciInferenceOptions = {}): CosmologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciInference };
diff --git a/src/cosmology_sci/inference2.ts b/src/cosmology_sci/inference2.ts
new file mode 100644
index 000000000..5fb90feab
--- /dev/null
+++ b/src/cosmology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci inference2 module — tsb analytics library. */
+export interface CosmologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeCosmologySciInference(data: number[], opts: CosmologySciInferenceOptions = {}): CosmologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciInference };
diff --git a/src/cosmology_sci/integral.ts b/src/cosmology_sci/integral.ts
new file mode 100644
index 000000000..bcd945891
--- /dev/null
+++ b/src/cosmology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci integral module — tsb analytics library. */
+export interface CosmologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeCosmologySciIntegral(data: number[], opts: CosmologySciIntegralOptions = {}): CosmologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciIntegral };
diff --git a/src/cosmology_sci/integration.ts b/src/cosmology_sci/integration.ts
new file mode 100644
index 000000000..382696956
--- /dev/null
+++ b/src/cosmology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci integration module — tsb analytics library. */
+export interface CosmologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciIntegration(data: number[], opts: CosmologySciIntegrationOptions = {}): CosmologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciIntegration };
diff --git a/src/cosmology_sci/interpolation.ts b/src/cosmology_sci/interpolation.ts
new file mode 100644
index 000000000..75990ff59
--- /dev/null
+++ b/src/cosmology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci interpolation module — tsb analytics library. */
+export interface CosmologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciInterpolation(data: number[], opts: CosmologySciInterpolationOptions = {}): CosmologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciInterpolation };
diff --git a/src/cosmology_sci/jacobian.ts b/src/cosmology_sci/jacobian.ts
new file mode 100644
index 000000000..933550cab
--- /dev/null
+++ b/src/cosmology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci jacobian module — tsb analytics library. */
+export interface CosmologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeCosmologySciJacobian(data: number[], opts: CosmologySciJacobianOptions = {}): CosmologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciJacobian };
diff --git a/src/cosmology_sci/kernel.ts b/src/cosmology_sci/kernel.ts
new file mode 100644
index 000000000..cf60a39d8
--- /dev/null
+++ b/src/cosmology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci kernel module — tsb analytics library. */
+export interface CosmologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciKernelResult { values: number[]; converged: boolean; }
+export function computeCosmologySciKernel(data: number[], opts: CosmologySciKernelOptions = {}): CosmologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciKernel };
diff --git a/src/cosmology_sci/laplacian.ts b/src/cosmology_sci/laplacian.ts
new file mode 100644
index 000000000..b7da73423
--- /dev/null
+++ b/src/cosmology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci laplacian module — tsb analytics library. */
+export interface CosmologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeCosmologySciLaplacian(data: number[], opts: CosmologySciLaplacianOptions = {}): CosmologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciLaplacian };
diff --git a/src/cosmology_sci/learning.ts b/src/cosmology_sci/learning.ts
new file mode 100644
index 000000000..0cfd41fc6
--- /dev/null
+++ b/src/cosmology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci learning module — tsb analytics library. */
+export interface CosmologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciLearningResult { values: number[]; converged: boolean; }
+export function computeCosmologySciLearning(data: number[], opts: CosmologySciLearningOptions = {}): CosmologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciLearning };
diff --git a/src/cosmology_sci/linear.ts b/src/cosmology_sci/linear.ts
new file mode 100644
index 000000000..d2cf07211
--- /dev/null
+++ b/src/cosmology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci linear module — tsb analytics library. */
+export interface CosmologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciLinearResult { values: number[]; converged: boolean; }
+export function computeCosmologySciLinear(data: number[], opts: CosmologySciLinearOptions = {}): CosmologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciLinear };
diff --git a/src/cosmology_sci/manifold.ts b/src/cosmology_sci/manifold.ts
new file mode 100644
index 000000000..8c5f5fd33
--- /dev/null
+++ b/src/cosmology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci manifold module — tsb analytics library. */
+export interface CosmologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeCosmologySciManifold(data: number[], opts: CosmologySciManifoldOptions = {}): CosmologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciManifold };
diff --git a/src/cosmology_sci/matching.ts b/src/cosmology_sci/matching.ts
new file mode 100644
index 000000000..e5d212cf3
--- /dev/null
+++ b/src/cosmology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci matching module — tsb analytics library. */
+export interface CosmologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciMatching(data: number[], opts: CosmologySciMatchingOptions = {}): CosmologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciMatching };
diff --git a/src/cosmology_sci/measurement.ts b/src/cosmology_sci/measurement.ts
new file mode 100644
index 000000000..857a57b75
--- /dev/null
+++ b/src/cosmology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci measurement module — tsb analytics library. */
+export interface CosmologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeCosmologySciMeasurement(data: number[], opts: CosmologySciMeasurementOptions = {}): CosmologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciMeasurement };
diff --git a/src/cosmology_sci/metrics.ts b/src/cosmology_sci/metrics.ts
new file mode 100644
index 000000000..864e4048a
--- /dev/null
+++ b/src/cosmology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci metrics module — tsb analytics library. */
+export interface CosmologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeCosmologySciMetrics(data: number[], opts: CosmologySciMetricsOptions = {}): CosmologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciMetrics };
diff --git a/src/cosmology_sci/modeling.ts b/src/cosmology_sci/modeling.ts
new file mode 100644
index 000000000..e9541601f
--- /dev/null
+++ b/src/cosmology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci modeling module — tsb analytics library. */
+export interface CosmologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciModelingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciModeling(data: number[], opts: CosmologySciModelingOptions = {}): CosmologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciModeling };
diff --git a/src/cosmology_sci/monitoring.ts b/src/cosmology_sci/monitoring.ts
new file mode 100644
index 000000000..de2432aa0
--- /dev/null
+++ b/src/cosmology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci monitoring module — tsb analytics library. */
+export interface CosmologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeCosmologySciMonitoring(data: number[], opts: CosmologySciMonitoringOptions = {}): CosmologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciMonitoring };
diff --git a/src/cosmology_sci/nonlinear.ts b/src/cosmology_sci/nonlinear.ts
new file mode 100644
index 000000000..0974bc63c
--- /dev/null
+++ b/src/cosmology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci nonlinear module — tsb analytics library. */
+export interface CosmologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeCosmologySciNonlinear(data: number[], opts: CosmologySciNonlinearOptions = {}): CosmologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciNonlinear };
diff --git a/src/cosmology_sci/normalization.ts b/src/cosmology_sci/normalization.ts
new file mode 100644
index 000000000..f60d4254f
--- /dev/null
+++ b/src/cosmology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci normalization module — tsb analytics library. */
+export interface CosmologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciNormalization(data: number[], opts: CosmologySciNormalizationOptions = {}): CosmologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciNormalization };
diff --git a/src/cosmology_sci/optimization.ts b/src/cosmology_sci/optimization.ts
new file mode 100644
index 000000000..67b13f352
--- /dev/null
+++ b/src/cosmology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci optimization module — tsb analytics library. */
+export interface CosmologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciOptimization(data: number[], opts: CosmologySciOptimizationOptions = {}): CosmologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciOptimization };
diff --git a/src/cosmology_sci/patterns.ts b/src/cosmology_sci/patterns.ts
new file mode 100644
index 000000000..fe13bab70
--- /dev/null
+++ b/src/cosmology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci patterns module — tsb analytics library. */
+export interface CosmologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeCosmologySciPatterns(data: number[], opts: CosmologySciPatternsOptions = {}): CosmologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciPatterns };
diff --git a/src/cosmology_sci/permutation.ts b/src/cosmology_sci/permutation.ts
new file mode 100644
index 000000000..24dfb1644
--- /dev/null
+++ b/src/cosmology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci permutation module — tsb analytics library. */
+export interface CosmologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciPermutation(data: number[], opts: CosmologySciPermutationOptions = {}): CosmologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciPermutation };
diff --git a/src/cosmology_sci/prediction.ts b/src/cosmology_sci/prediction.ts
new file mode 100644
index 000000000..e0d6d6b3b
--- /dev/null
+++ b/src/cosmology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci prediction module — tsb analytics library. */
+export interface CosmologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciPrediction(data: number[], opts: CosmologySciPredictionOptions = {}): CosmologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciPrediction };
diff --git a/src/cosmology_sci/processing.ts b/src/cosmology_sci/processing.ts
new file mode 100644
index 000000000..f9faba5dc
--- /dev/null
+++ b/src/cosmology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci processing module — tsb analytics library. */
+export interface CosmologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciProcessing(data: number[], opts: CosmologySciProcessingOptions = {}): CosmologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciProcessing };
diff --git a/src/cosmology_sci/profiling.ts b/src/cosmology_sci/profiling.ts
new file mode 100644
index 000000000..97f8b7fca
--- /dev/null
+++ b/src/cosmology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci profiling module — tsb analytics library. */
+export interface CosmologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciProfiling(data: number[], opts: CosmologySciProfilingOptions = {}): CosmologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciProfiling };
diff --git a/src/cosmology_sci/projection.ts b/src/cosmology_sci/projection.ts
new file mode 100644
index 000000000..a8f5cb173
--- /dev/null
+++ b/src/cosmology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci projection module — tsb analytics library. */
+export interface CosmologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciProjection(data: number[], opts: CosmologySciProjectionOptions = {}): CosmologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciProjection };
diff --git a/src/cosmology_sci/ranking.ts b/src/cosmology_sci/ranking.ts
new file mode 100644
index 000000000..47da195c7
--- /dev/null
+++ b/src/cosmology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci ranking module — tsb analytics library. */
+export interface CosmologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciRankingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciRanking(data: number[], opts: CosmologySciRankingOptions = {}): CosmologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciRanking };
diff --git a/src/cosmology_sci/reconstruction.ts b/src/cosmology_sci/reconstruction.ts
new file mode 100644
index 000000000..e59d81135
--- /dev/null
+++ b/src/cosmology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci reconstruction module — tsb analytics library. */
+export interface CosmologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciReconstruction(data: number[], opts: CosmologySciReconstructionOptions = {}): CosmologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciReconstruction };
diff --git a/src/cosmology_sci/registration.ts b/src/cosmology_sci/registration.ts
new file mode 100644
index 000000000..b469b443e
--- /dev/null
+++ b/src/cosmology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci registration module — tsb analytics library. */
+export interface CosmologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciRegistration(data: number[], opts: CosmologySciRegistrationOptions = {}): CosmologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciRegistration };
diff --git a/src/cosmology_sci/regression.ts b/src/cosmology_sci/regression.ts
new file mode 100644
index 000000000..dfa2c1833
--- /dev/null
+++ b/src/cosmology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci regression module — tsb analytics library. */
+export interface CosmologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciRegression(data: number[], opts: CosmologySciRegressionOptions = {}): CosmologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciRegression };
diff --git a/src/cosmology_sci/regularization.ts b/src/cosmology_sci/regularization.ts
new file mode 100644
index 000000000..e3f16b9be
--- /dev/null
+++ b/src/cosmology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci regularization module — tsb analytics library. */
+export interface CosmologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciRegularization(data: number[], opts: CosmologySciRegularizationOptions = {}): CosmologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciRegularization };
diff --git a/src/cosmology_sci/robustness.ts b/src/cosmology_sci/robustness.ts
new file mode 100644
index 000000000..b8af88d21
--- /dev/null
+++ b/src/cosmology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci robustness module — tsb analytics library. */
+export interface CosmologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeCosmologySciRobustness(data: number[], opts: CosmologySciRobustnessOptions = {}): CosmologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciRobustness };
diff --git a/src/cosmology_sci/sampling.ts b/src/cosmology_sci/sampling.ts
new file mode 100644
index 000000000..217690af0
--- /dev/null
+++ b/src/cosmology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci sampling module — tsb analytics library. */
+export interface CosmologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciSampling(data: number[], opts: CosmologySciSamplingOptions = {}): CosmologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciSampling };
diff --git a/src/cosmology_sci/sampling2.ts b/src/cosmology_sci/sampling2.ts
new file mode 100644
index 000000000..477583cc4
--- /dev/null
+++ b/src/cosmology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci sampling2 module — tsb analytics library. */
+export interface CosmologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciSampling(data: number[], opts: CosmologySciSamplingOptions = {}): CosmologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciSampling };
diff --git a/src/cosmology_sci/scaling.ts b/src/cosmology_sci/scaling.ts
new file mode 100644
index 000000000..f4ed15e3f
--- /dev/null
+++ b/src/cosmology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci scaling module — tsb analytics library. */
+export interface CosmologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciScalingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciScaling(data: number[], opts: CosmologySciScalingOptions = {}): CosmologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciScaling };
diff --git a/src/cosmology_sci/scoring.ts b/src/cosmology_sci/scoring.ts
new file mode 100644
index 000000000..6a545c22e
--- /dev/null
+++ b/src/cosmology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci scoring module — tsb analytics library. */
+export interface CosmologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciScoringResult { values: number[]; converged: boolean; }
+export function computeCosmologySciScoring(data: number[], opts: CosmologySciScoringOptions = {}): CosmologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciScoring };
diff --git a/src/cosmology_sci/segmentation.ts b/src/cosmology_sci/segmentation.ts
new file mode 100644
index 000000000..e4c3964ac
--- /dev/null
+++ b/src/cosmology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci segmentation module — tsb analytics library. */
+export interface CosmologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciSegmentation(data: number[], opts: CosmologySciSegmentationOptions = {}): CosmologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciSegmentation };
diff --git a/src/cosmology_sci/selection.ts b/src/cosmology_sci/selection.ts
new file mode 100644
index 000000000..63425efa4
--- /dev/null
+++ b/src/cosmology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci selection module — tsb analytics library. */
+export interface CosmologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeCosmologySciSelection(data: number[], opts: CosmologySciSelectionOptions = {}): CosmologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciSelection };
diff --git a/src/cosmology_sci/sensitivity.ts b/src/cosmology_sci/sensitivity.ts
new file mode 100644
index 000000000..b1d6a8953
--- /dev/null
+++ b/src/cosmology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci sensitivity module — tsb analytics library. */
+export interface CosmologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeCosmologySciSensitivity(data: number[], opts: CosmologySciSensitivityOptions = {}): CosmologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciSensitivity };
diff --git a/src/cosmology_sci/simulation.ts b/src/cosmology_sci/simulation.ts
new file mode 100644
index 000000000..7feb40d33
--- /dev/null
+++ b/src/cosmology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci simulation module — tsb analytics library. */
+export interface CosmologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciSimulation(data: number[], opts: CosmologySciSimulationOptions = {}): CosmologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciSimulation };
diff --git a/src/cosmology_sci/smoothing.ts b/src/cosmology_sci/smoothing.ts
new file mode 100644
index 000000000..a03e9af8d
--- /dev/null
+++ b/src/cosmology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci smoothing module — tsb analytics library. */
+export interface CosmologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciSmoothing(data: number[], opts: CosmologySciSmoothingOptions = {}): CosmologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciSmoothing };
diff --git a/src/cosmology_sci/stability.ts b/src/cosmology_sci/stability.ts
new file mode 100644
index 000000000..6e51ce005
--- /dev/null
+++ b/src/cosmology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci stability module — tsb analytics library. */
+export interface CosmologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeCosmologySciStability(data: number[], opts: CosmologySciStabilityOptions = {}): CosmologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciStability };
diff --git a/src/cosmology_sci/stacking.ts b/src/cosmology_sci/stacking.ts
new file mode 100644
index 000000000..4a6b8689f
--- /dev/null
+++ b/src/cosmology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci stacking module — tsb analytics library. */
+export interface CosmologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciStackingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciStacking(data: number[], opts: CosmologySciStackingOptions = {}): CosmologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciStacking };
diff --git a/src/cosmology_sci/standardization.ts b/src/cosmology_sci/standardization.ts
new file mode 100644
index 000000000..049ff5064
--- /dev/null
+++ b/src/cosmology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci standardization module — tsb analytics library. */
+export interface CosmologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciStandardization(data: number[], opts: CosmologySciStandardizationOptions = {}): CosmologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciStandardization };
diff --git a/src/cosmology_sci/static.ts b/src/cosmology_sci/static.ts
new file mode 100644
index 000000000..8008f479e
--- /dev/null
+++ b/src/cosmology_sci/static.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci static module — tsb analytics library. */
+export interface CosmologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciStaticResult { values: number[]; converged: boolean; }
+export function computeCosmologySciStatic(data: number[], opts: CosmologySciStaticOptions = {}): CosmologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciStatic };
diff --git a/src/cosmology_sci/stochastic.ts b/src/cosmology_sci/stochastic.ts
new file mode 100644
index 000000000..ebc2685ef
--- /dev/null
+++ b/src/cosmology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci stochastic module — tsb analytics library. */
+export interface CosmologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeCosmologySciStochastic(data: number[], opts: CosmologySciStochasticOptions = {}): CosmologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciStochastic };
diff --git a/src/cosmology_sci/synthesis.ts b/src/cosmology_sci/synthesis.ts
new file mode 100644
index 000000000..3954f2721
--- /dev/null
+++ b/src/cosmology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci synthesis module — tsb analytics library. */
+export interface CosmologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeCosmologySciSynthesis(data: number[], opts: CosmologySciSynthesisOptions = {}): CosmologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciSynthesis };
diff --git a/src/cosmology_sci/topology.ts b/src/cosmology_sci/topology.ts
new file mode 100644
index 000000000..3b983b0fc
--- /dev/null
+++ b/src/cosmology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci topology module — tsb analytics library. */
+export interface CosmologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeCosmologySciTopology(data: number[], opts: CosmologySciTopologyOptions = {}): CosmologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciTopology };
diff --git a/src/cosmology_sci/tracking.ts b/src/cosmology_sci/tracking.ts
new file mode 100644
index 000000000..3e948b112
--- /dev/null
+++ b/src/cosmology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci tracking module — tsb analytics library. */
+export interface CosmologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciTracking(data: number[], opts: CosmologySciTrackingOptions = {}): CosmologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciTracking };
diff --git a/src/cosmology_sci/transform.ts b/src/cosmology_sci/transform.ts
new file mode 100644
index 000000000..649d187db
--- /dev/null
+++ b/src/cosmology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci transform module — tsb analytics library. */
+export interface CosmologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciTransformResult { values: number[]; converged: boolean; }
+export function computeCosmologySciTransform(data: number[], opts: CosmologySciTransformOptions = {}): CosmologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciTransform };
diff --git a/src/cosmology_sci/uncertainty.ts b/src/cosmology_sci/uncertainty.ts
new file mode 100644
index 000000000..2600dc480
--- /dev/null
+++ b/src/cosmology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci uncertainty module — tsb analytics library. */
+export interface CosmologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCosmologySciUncertainty(data: number[], opts: CosmologySciUncertaintyOptions = {}): CosmologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciUncertainty };
diff --git a/src/cosmology_sci/validation.ts b/src/cosmology_sci/validation.ts
new file mode 100644
index 000000000..e9eb6b28d
--- /dev/null
+++ b/src/cosmology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci validation module — tsb analytics library. */
+export interface CosmologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciValidationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciValidation(data: number[], opts: CosmologySciValidationOptions = {}): CosmologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciValidation };
diff --git a/src/cosmology_sci/verification.ts b/src/cosmology_sci/verification.ts
new file mode 100644
index 000000000..361f07db6
--- /dev/null
+++ b/src/cosmology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci verification module — tsb analytics library. */
+export interface CosmologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciVerification(data: number[], opts: CosmologySciVerificationOptions = {}): CosmologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciVerification };
diff --git a/src/cosmology_sci/visualization.ts b/src/cosmology_sci/visualization.ts
new file mode 100644
index 000000000..d6c950fbd
--- /dev/null
+++ b/src/cosmology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci visualization module — tsb analytics library. */
+export interface CosmologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeCosmologySciVisualization(data: number[], opts: CosmologySciVisualizationOptions = {}): CosmologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciVisualization };
diff --git a/src/cosmology_sci/voting.ts b/src/cosmology_sci/voting.ts
new file mode 100644
index 000000000..9453d6014
--- /dev/null
+++ b/src/cosmology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci voting module — tsb analytics library. */
+export interface CosmologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciVotingResult { values: number[]; converged: boolean; }
+export function computeCosmologySciVoting(data: number[], opts: CosmologySciVotingOptions = {}): CosmologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciVoting };
diff --git a/src/cosmology_sci/wavelet.ts b/src/cosmology_sci/wavelet.ts
new file mode 100644
index 000000000..7299f03c0
--- /dev/null
+++ b/src/cosmology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** cosmology_sci wavelet module — tsb analytics library. */
+export interface CosmologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface CosmologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeCosmologySciWavelet(data: number[], opts: CosmologySciWaveletOptions = {}): CosmologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCosmologySciWavelet };
diff --git a/src/cryosphere_sci/adaptation.ts b/src/cryosphere_sci/adaptation.ts
new file mode 100644
index 000000000..8f3efde51
--- /dev/null
+++ b/src/cryosphere_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci adaptation module — tsb analytics library. */
+export interface CryosphereSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciAdaptation(data: number[], opts: CryosphereSciAdaptationOptions = {}): CryosphereSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciAdaptation };
diff --git a/src/cryosphere_sci/aggregation.ts b/src/cryosphere_sci/aggregation.ts
new file mode 100644
index 000000000..6bd932946
--- /dev/null
+++ b/src/cryosphere_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci aggregation module — tsb analytics library. */
+export interface CryosphereSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciAggregationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciAggregation(data: number[], opts: CryosphereSciAggregationOptions = {}): CryosphereSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciAggregation };
diff --git a/src/cryosphere_sci/algebra.ts b/src/cryosphere_sci/algebra.ts
new file mode 100644
index 000000000..5696211c0
--- /dev/null
+++ b/src/cryosphere_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci algebra module — tsb analytics library. */
+export interface CryosphereSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciAlgebra(data: number[], opts: CryosphereSciAlgebraOptions = {}): CryosphereSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciAlgebra };
diff --git a/src/cryosphere_sci/alignment.ts b/src/cryosphere_sci/alignment.ts
new file mode 100644
index 000000000..00ae28e91
--- /dev/null
+++ b/src/cryosphere_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci alignment module — tsb analytics library. */
+export interface CryosphereSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciAlignment(data: number[], opts: CryosphereSciAlignmentOptions = {}): CryosphereSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciAlignment };
diff --git a/src/cryosphere_sci/analysis.ts b/src/cryosphere_sci/analysis.ts
new file mode 100644
index 000000000..5ddaf7ee9
--- /dev/null
+++ b/src/cryosphere_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci analysis module — tsb analytics library. */
+export interface CryosphereSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciAnalysis(data: number[], opts: CryosphereSciAnalysisOptions = {}): CryosphereSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciAnalysis };
diff --git a/src/cryosphere_sci/augmentation.ts b/src/cryosphere_sci/augmentation.ts
new file mode 100644
index 000000000..7fac3385d
--- /dev/null
+++ b/src/cryosphere_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci augmentation module — tsb analytics library. */
+export interface CryosphereSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciAugmentation(data: number[], opts: CryosphereSciAugmentationOptions = {}): CryosphereSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciAugmentation };
diff --git a/src/cryosphere_sci/bagging.ts b/src/cryosphere_sci/bagging.ts
new file mode 100644
index 000000000..6c3e974ff
--- /dev/null
+++ b/src/cryosphere_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci bagging module — tsb analytics library. */
+export interface CryosphereSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciBaggingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciBagging(data: number[], opts: CryosphereSciBaggingOptions = {}): CryosphereSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciBagging };
diff --git a/src/cryosphere_sci/basis.ts b/src/cryosphere_sci/basis.ts
new file mode 100644
index 000000000..8d631f512
--- /dev/null
+++ b/src/cryosphere_sci/basis.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci basis module — tsb analytics library. */
+export interface CryosphereSciBasisOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciBasisResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciBasis(data: number[], opts: CryosphereSciBasisOptions = {}): CryosphereSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciBasis };
diff --git a/src/cryosphere_sci/benchmarking.ts b/src/cryosphere_sci/benchmarking.ts
new file mode 100644
index 000000000..9f6dae671
--- /dev/null
+++ b/src/cryosphere_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci benchmarking module — tsb analytics library. */
+export interface CryosphereSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciBenchmarking(data: number[], opts: CryosphereSciBenchmarkingOptions = {}): CryosphereSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciBenchmarking };
diff --git a/src/cryosphere_sci/blending.ts b/src/cryosphere_sci/blending.ts
new file mode 100644
index 000000000..f2bf3a777
--- /dev/null
+++ b/src/cryosphere_sci/blending.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci blending module — tsb analytics library. */
+export interface CryosphereSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciBlendingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciBlending(data: number[], opts: CryosphereSciBlendingOptions = {}): CryosphereSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciBlending };
diff --git a/src/cryosphere_sci/boosting.ts b/src/cryosphere_sci/boosting.ts
new file mode 100644
index 000000000..74fc3ef29
--- /dev/null
+++ b/src/cryosphere_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci boosting module — tsb analytics library. */
+export interface CryosphereSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciBoostingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciBoosting(data: number[], opts: CryosphereSciBoostingOptions = {}): CryosphereSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciBoosting };
diff --git a/src/cryosphere_sci/bootstrap.ts b/src/cryosphere_sci/bootstrap.ts
new file mode 100644
index 000000000..ab01c6f8f
--- /dev/null
+++ b/src/cryosphere_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci bootstrap module — tsb analytics library. */
+export interface CryosphereSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciBootstrap(data: number[], opts: CryosphereSciBootstrapOptions = {}): CryosphereSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciBootstrap };
diff --git a/src/cryosphere_sci/calculus.ts b/src/cryosphere_sci/calculus.ts
new file mode 100644
index 000000000..b730dd095
--- /dev/null
+++ b/src/cryosphere_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci calculus module — tsb analytics library. */
+export interface CryosphereSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciCalculusResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciCalculus(data: number[], opts: CryosphereSciCalculusOptions = {}): CryosphereSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciCalculus };
diff --git a/src/cryosphere_sci/calibration.ts b/src/cryosphere_sci/calibration.ts
new file mode 100644
index 000000000..78293e974
--- /dev/null
+++ b/src/cryosphere_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci calibration module — tsb analytics library. */
+export interface CryosphereSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciCalibration(data: number[], opts: CryosphereSciCalibrationOptions = {}): CryosphereSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciCalibration };
diff --git a/src/cryosphere_sci/characterization.ts b/src/cryosphere_sci/characterization.ts
new file mode 100644
index 000000000..01216af8a
--- /dev/null
+++ b/src/cryosphere_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci characterization module — tsb analytics library. */
+export interface CryosphereSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciCharacterization(data: number[], opts: CryosphereSciCharacterizationOptions = {}): CryosphereSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciCharacterization };
diff --git a/src/cryosphere_sci/classification.ts b/src/cryosphere_sci/classification.ts
new file mode 100644
index 000000000..c8b54ecdf
--- /dev/null
+++ b/src/cryosphere_sci/classification.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci classification module — tsb analytics library. */
+export interface CryosphereSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciClassificationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciClassification(data: number[], opts: CryosphereSciClassificationOptions = {}): CryosphereSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciClassification };
diff --git a/src/cryosphere_sci/clustering.ts b/src/cryosphere_sci/clustering.ts
new file mode 100644
index 000000000..18f542a59
--- /dev/null
+++ b/src/cryosphere_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci clustering module — tsb analytics library. */
+export interface CryosphereSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciClusteringResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciClustering(data: number[], opts: CryosphereSciClusteringOptions = {}): CryosphereSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciClustering };
diff --git a/src/cryosphere_sci/compression.ts b/src/cryosphere_sci/compression.ts
new file mode 100644
index 000000000..cb5377f9a
--- /dev/null
+++ b/src/cryosphere_sci/compression.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci compression module — tsb analytics library. */
+export interface CryosphereSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciCompressionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciCompression(data: number[], opts: CryosphereSciCompressionOptions = {}): CryosphereSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciCompression };
diff --git a/src/cryosphere_sci/continuous.ts b/src/cryosphere_sci/continuous.ts
new file mode 100644
index 000000000..05ec91203
--- /dev/null
+++ b/src/cryosphere_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci continuous module — tsb analytics library. */
+export interface CryosphereSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciContinuousResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciContinuous(data: number[], opts: CryosphereSciContinuousOptions = {}): CryosphereSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciContinuous };
diff --git a/src/cryosphere_sci/control.ts b/src/cryosphere_sci/control.ts
new file mode 100644
index 000000000..7a3be16b1
--- /dev/null
+++ b/src/cryosphere_sci/control.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci control module — tsb analytics library. */
+export interface CryosphereSciControlOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciControlResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciControl(data: number[], opts: CryosphereSciControlOptions = {}): CryosphereSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciControl };
diff --git a/src/cryosphere_sci/convergence.ts b/src/cryosphere_sci/convergence.ts
new file mode 100644
index 000000000..91781a9f8
--- /dev/null
+++ b/src/cryosphere_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci convergence module — tsb analytics library. */
+export interface CryosphereSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciConvergence(data: number[], opts: CryosphereSciConvergenceOptions = {}): CryosphereSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciConvergence };
diff --git a/src/cryosphere_sci/convex.ts b/src/cryosphere_sci/convex.ts
new file mode 100644
index 000000000..41700400d
--- /dev/null
+++ b/src/cryosphere_sci/convex.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci convex module — tsb analytics library. */
+export interface CryosphereSciConvexOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciConvexResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciConvex(data: number[], opts: CryosphereSciConvexOptions = {}): CryosphereSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciConvex };
diff --git a/src/cryosphere_sci/correlation.ts b/src/cryosphere_sci/correlation.ts
new file mode 100644
index 000000000..478a2d40f
--- /dev/null
+++ b/src/cryosphere_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci correlation module — tsb analytics library. */
+export interface CryosphereSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciCorrelation(data: number[], opts: CryosphereSciCorrelationOptions = {}): CryosphereSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciCorrelation };
diff --git a/src/cryosphere_sci/covariance.ts b/src/cryosphere_sci/covariance.ts
new file mode 100644
index 000000000..bcb5598b3
--- /dev/null
+++ b/src/cryosphere_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci covariance module — tsb analytics library. */
+export interface CryosphereSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciCovariance(data: number[], opts: CryosphereSciCovarianceOptions = {}): CryosphereSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciCovariance };
diff --git a/src/cryosphere_sci/cross_validation.ts b/src/cryosphere_sci/cross_validation.ts
new file mode 100644
index 000000000..3a5f3f888
--- /dev/null
+++ b/src/cryosphere_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci cross_validation module — tsb analytics library. */
+export interface CryosphereSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciCrossValidation(data: number[], opts: CryosphereSciCrossValidationOptions = {}): CryosphereSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciCrossValidation };
diff --git a/src/cryosphere_sci/decoding.ts b/src/cryosphere_sci/decoding.ts
new file mode 100644
index 000000000..5f66f505e
--- /dev/null
+++ b/src/cryosphere_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci decoding module — tsb analytics library. */
+export interface CryosphereSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDecodingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDecoding(data: number[], opts: CryosphereSciDecodingOptions = {}): CryosphereSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDecoding };
diff --git a/src/cryosphere_sci/decomposition.ts b/src/cryosphere_sci/decomposition.ts
new file mode 100644
index 000000000..04e0cfab0
--- /dev/null
+++ b/src/cryosphere_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci decomposition module — tsb analytics library. */
+export interface CryosphereSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDecomposition(data: number[], opts: CryosphereSciDecompositionOptions = {}): CryosphereSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDecomposition };
diff --git a/src/cryosphere_sci/detection.ts b/src/cryosphere_sci/detection.ts
new file mode 100644
index 000000000..2b4834c04
--- /dev/null
+++ b/src/cryosphere_sci/detection.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci detection module — tsb analytics library. */
+export interface CryosphereSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDetectionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDetection(data: number[], opts: CryosphereSciDetectionOptions = {}): CryosphereSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDetection };
diff --git a/src/cryosphere_sci/deterministic.ts b/src/cryosphere_sci/deterministic.ts
new file mode 100644
index 000000000..f503e3360
--- /dev/null
+++ b/src/cryosphere_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci deterministic module — tsb analytics library. */
+export interface CryosphereSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDeterministic(data: number[], opts: CryosphereSciDeterministicOptions = {}): CryosphereSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDeterministic };
diff --git a/src/cryosphere_sci/diagnostics.ts b/src/cryosphere_sci/diagnostics.ts
new file mode 100644
index 000000000..81349838c
--- /dev/null
+++ b/src/cryosphere_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci diagnostics module — tsb analytics library. */
+export interface CryosphereSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDiagnostics(data: number[], opts: CryosphereSciDiagnosticsOptions = {}): CryosphereSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDiagnostics };
diff --git a/src/cryosphere_sci/differential.ts b/src/cryosphere_sci/differential.ts
new file mode 100644
index 000000000..4758637c9
--- /dev/null
+++ b/src/cryosphere_sci/differential.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci differential module — tsb analytics library. */
+export interface CryosphereSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDifferential(data: number[], opts: CryosphereSciDifferentialOptions = {}): CryosphereSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDifferential };
diff --git a/src/cryosphere_sci/discrete.ts b/src/cryosphere_sci/discrete.ts
new file mode 100644
index 000000000..8f3c3b3db
--- /dev/null
+++ b/src/cryosphere_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci discrete module — tsb analytics library. */
+export interface CryosphereSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDiscrete(data: number[], opts: CryosphereSciDiscreteOptions = {}): CryosphereSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDiscrete };
diff --git a/src/cryosphere_sci/distribution.ts b/src/cryosphere_sci/distribution.ts
new file mode 100644
index 000000000..22baaf3ab
--- /dev/null
+++ b/src/cryosphere_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci distribution module — tsb analytics library. */
+export interface CryosphereSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDistributionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDistribution(data: number[], opts: CryosphereSciDistributionOptions = {}): CryosphereSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDistribution };
diff --git a/src/cryosphere_sci/dynamic.ts b/src/cryosphere_sci/dynamic.ts
new file mode 100644
index 000000000..5fa11cc78
--- /dev/null
+++ b/src/cryosphere_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci dynamic module — tsb analytics library. */
+export interface CryosphereSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciDynamicResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciDynamic(data: number[], opts: CryosphereSciDynamicOptions = {}): CryosphereSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciDynamic };
diff --git a/src/cryosphere_sci/embedding.ts b/src/cryosphere_sci/embedding.ts
new file mode 100644
index 000000000..31ea7990e
--- /dev/null
+++ b/src/cryosphere_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci embedding module — tsb analytics library. */
+export interface CryosphereSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciEmbedding(data: number[], opts: CryosphereSciEmbeddingOptions = {}): CryosphereSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciEmbedding };
diff --git a/src/cryosphere_sci/encoding.ts b/src/cryosphere_sci/encoding.ts
new file mode 100644
index 000000000..52e8d4f9a
--- /dev/null
+++ b/src/cryosphere_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci encoding module — tsb analytics library. */
+export interface CryosphereSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciEncodingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciEncoding(data: number[], opts: CryosphereSciEncodingOptions = {}): CryosphereSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciEncoding };
diff --git a/src/cryosphere_sci/ensemble.ts b/src/cryosphere_sci/ensemble.ts
new file mode 100644
index 000000000..52888f2f0
--- /dev/null
+++ b/src/cryosphere_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci ensemble module — tsb analytics library. */
+export interface CryosphereSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciEnsemble(data: number[], opts: CryosphereSciEnsembleOptions = {}): CryosphereSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciEnsemble };
diff --git a/src/cryosphere_sci/estimation.ts b/src/cryosphere_sci/estimation.ts
new file mode 100644
index 000000000..803812ef9
--- /dev/null
+++ b/src/cryosphere_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci estimation module — tsb analytics library. */
+export interface CryosphereSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciEstimationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciEstimation(data: number[], opts: CryosphereSciEstimationOptions = {}): CryosphereSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciEstimation };
diff --git a/src/cryosphere_sci/evaluation.ts b/src/cryosphere_sci/evaluation.ts
new file mode 100644
index 000000000..a51e1211f
--- /dev/null
+++ b/src/cryosphere_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci evaluation module — tsb analytics library. */
+export interface CryosphereSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciEvaluation(data: number[], opts: CryosphereSciEvaluationOptions = {}): CryosphereSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciEvaluation };
diff --git a/src/cryosphere_sci/extrapolation.ts b/src/cryosphere_sci/extrapolation.ts
new file mode 100644
index 000000000..47ecc9eed
--- /dev/null
+++ b/src/cryosphere_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci extrapolation module — tsb analytics library. */
+export interface CryosphereSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciExtrapolation(data: number[], opts: CryosphereSciExtrapolationOptions = {}): CryosphereSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciExtrapolation };
diff --git a/src/cryosphere_sci/features.ts b/src/cryosphere_sci/features.ts
new file mode 100644
index 000000000..a35d55800
--- /dev/null
+++ b/src/cryosphere_sci/features.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci features module — tsb analytics library. */
+export interface CryosphereSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciFeatures(data: number[], opts: CryosphereSciFeaturesOptions = {}): CryosphereSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciFeatures };
diff --git a/src/cryosphere_sci/feedback.ts b/src/cryosphere_sci/feedback.ts
new file mode 100644
index 000000000..93934a1e1
--- /dev/null
+++ b/src/cryosphere_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci feedback module — tsb analytics library. */
+export interface CryosphereSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciFeedback(data: number[], opts: CryosphereSciFeedbackOptions = {}): CryosphereSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciFeedback };
diff --git a/src/cryosphere_sci/filtering.ts b/src/cryosphere_sci/filtering.ts
new file mode 100644
index 000000000..f1853b22e
--- /dev/null
+++ b/src/cryosphere_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci filtering module — tsb analytics library. */
+export interface CryosphereSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciFilteringResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciFiltering(data: number[], opts: CryosphereSciFilteringOptions = {}): CryosphereSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciFiltering };
diff --git a/src/cryosphere_sci/fourier.ts b/src/cryosphere_sci/fourier.ts
new file mode 100644
index 000000000..8ce6639c3
--- /dev/null
+++ b/src/cryosphere_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci fourier module — tsb analytics library. */
+export interface CryosphereSciFourierOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciFourierResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciFourier(data: number[], opts: CryosphereSciFourierOptions = {}): CryosphereSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciFourier };
diff --git a/src/cryosphere_sci/fusion.ts b/src/cryosphere_sci/fusion.ts
new file mode 100644
index 000000000..b39618be5
--- /dev/null
+++ b/src/cryosphere_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci fusion module — tsb analytics library. */
+export interface CryosphereSciFusionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciFusionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciFusion(data: number[], opts: CryosphereSciFusionOptions = {}): CryosphereSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciFusion };
diff --git a/src/cryosphere_sci/generation.ts b/src/cryosphere_sci/generation.ts
new file mode 100644
index 000000000..c7ffc6af2
--- /dev/null
+++ b/src/cryosphere_sci/generation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci generation module — tsb analytics library. */
+export interface CryosphereSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciGenerationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciGeneration(data: number[], opts: CryosphereSciGenerationOptions = {}): CryosphereSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciGeneration };
diff --git a/src/cryosphere_sci/geometry.ts b/src/cryosphere_sci/geometry.ts
new file mode 100644
index 000000000..bdcee490f
--- /dev/null
+++ b/src/cryosphere_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci geometry module — tsb analytics library. */
+export interface CryosphereSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciGeometryResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciGeometry(data: number[], opts: CryosphereSciGeometryOptions = {}): CryosphereSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciGeometry };
diff --git a/src/cryosphere_sci/gradient.ts b/src/cryosphere_sci/gradient.ts
new file mode 100644
index 000000000..97f2fb6c3
--- /dev/null
+++ b/src/cryosphere_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci gradient module — tsb analytics library. */
+export interface CryosphereSciGradientOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciGradientResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciGradient(data: number[], opts: CryosphereSciGradientOptions = {}): CryosphereSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciGradient };
diff --git a/src/cryosphere_sci/hessian.ts b/src/cryosphere_sci/hessian.ts
new file mode 100644
index 000000000..b24902c28
--- /dev/null
+++ b/src/cryosphere_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci hessian module — tsb analytics library. */
+export interface CryosphereSciHessianOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciHessianResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciHessian(data: number[], opts: CryosphereSciHessianOptions = {}): CryosphereSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciHessian };
diff --git a/src/cryosphere_sci/hypothesis.ts b/src/cryosphere_sci/hypothesis.ts
new file mode 100644
index 000000000..cb3a248bc
--- /dev/null
+++ b/src/cryosphere_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci hypothesis module — tsb analytics library. */
+export interface CryosphereSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciHypothesis(data: number[], opts: CryosphereSciHypothesisOptions = {}): CryosphereSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciHypothesis };
diff --git a/src/cryosphere_sci/inference.ts b/src/cryosphere_sci/inference.ts
new file mode 100644
index 000000000..163a4e2bd
--- /dev/null
+++ b/src/cryosphere_sci/inference.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci inference module — tsb analytics library. */
+export interface CryosphereSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciInferenceResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciInference(data: number[], opts: CryosphereSciInferenceOptions = {}): CryosphereSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciInference };
diff --git a/src/cryosphere_sci/inference2.ts b/src/cryosphere_sci/inference2.ts
new file mode 100644
index 000000000..f6cd2a8a3
--- /dev/null
+++ b/src/cryosphere_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci inference2 module — tsb analytics library. */
+export interface CryosphereSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciInferenceResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciInference(data: number[], opts: CryosphereSciInferenceOptions = {}): CryosphereSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciInference };
diff --git a/src/cryosphere_sci/integral.ts b/src/cryosphere_sci/integral.ts
new file mode 100644
index 000000000..58c8387d2
--- /dev/null
+++ b/src/cryosphere_sci/integral.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci integral module — tsb analytics library. */
+export interface CryosphereSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciIntegralResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciIntegral(data: number[], opts: CryosphereSciIntegralOptions = {}): CryosphereSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciIntegral };
diff --git a/src/cryosphere_sci/integration.ts b/src/cryosphere_sci/integration.ts
new file mode 100644
index 000000000..90f36d892
--- /dev/null
+++ b/src/cryosphere_sci/integration.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci integration module — tsb analytics library. */
+export interface CryosphereSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciIntegration(data: number[], opts: CryosphereSciIntegrationOptions = {}): CryosphereSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciIntegration };
diff --git a/src/cryosphere_sci/interpolation.ts b/src/cryosphere_sci/interpolation.ts
new file mode 100644
index 000000000..bcbc07aae
--- /dev/null
+++ b/src/cryosphere_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci interpolation module — tsb analytics library. */
+export interface CryosphereSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciInterpolation(data: number[], opts: CryosphereSciInterpolationOptions = {}): CryosphereSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciInterpolation };
diff --git a/src/cryosphere_sci/jacobian.ts b/src/cryosphere_sci/jacobian.ts
new file mode 100644
index 000000000..faac62eee
--- /dev/null
+++ b/src/cryosphere_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci jacobian module — tsb analytics library. */
+export interface CryosphereSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciJacobianResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciJacobian(data: number[], opts: CryosphereSciJacobianOptions = {}): CryosphereSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciJacobian };
diff --git a/src/cryosphere_sci/kernel.ts b/src/cryosphere_sci/kernel.ts
new file mode 100644
index 000000000..1598911e8
--- /dev/null
+++ b/src/cryosphere_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci kernel module — tsb analytics library. */
+export interface CryosphereSciKernelOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciKernelResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciKernel(data: number[], opts: CryosphereSciKernelOptions = {}): CryosphereSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciKernel };
diff --git a/src/cryosphere_sci/laplacian.ts b/src/cryosphere_sci/laplacian.ts
new file mode 100644
index 000000000..17420c1de
--- /dev/null
+++ b/src/cryosphere_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci laplacian module — tsb analytics library. */
+export interface CryosphereSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciLaplacian(data: number[], opts: CryosphereSciLaplacianOptions = {}): CryosphereSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciLaplacian };
diff --git a/src/cryosphere_sci/learning.ts b/src/cryosphere_sci/learning.ts
new file mode 100644
index 000000000..7000b5041
--- /dev/null
+++ b/src/cryosphere_sci/learning.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci learning module — tsb analytics library. */
+export interface CryosphereSciLearningOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciLearningResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciLearning(data: number[], opts: CryosphereSciLearningOptions = {}): CryosphereSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciLearning };
diff --git a/src/cryosphere_sci/linear.ts b/src/cryosphere_sci/linear.ts
new file mode 100644
index 000000000..4eb4f15b9
--- /dev/null
+++ b/src/cryosphere_sci/linear.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci linear module — tsb analytics library. */
+export interface CryosphereSciLinearOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciLinearResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciLinear(data: number[], opts: CryosphereSciLinearOptions = {}): CryosphereSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciLinear };
diff --git a/src/cryosphere_sci/manifold.ts b/src/cryosphere_sci/manifold.ts
new file mode 100644
index 000000000..fe3a89c63
--- /dev/null
+++ b/src/cryosphere_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci manifold module — tsb analytics library. */
+export interface CryosphereSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciManifoldResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciManifold(data: number[], opts: CryosphereSciManifoldOptions = {}): CryosphereSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciManifold };
diff --git a/src/cryosphere_sci/matching.ts b/src/cryosphere_sci/matching.ts
new file mode 100644
index 000000000..4eccbe6c3
--- /dev/null
+++ b/src/cryosphere_sci/matching.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci matching module — tsb analytics library. */
+export interface CryosphereSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciMatchingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciMatching(data: number[], opts: CryosphereSciMatchingOptions = {}): CryosphereSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciMatching };
diff --git a/src/cryosphere_sci/measurement.ts b/src/cryosphere_sci/measurement.ts
new file mode 100644
index 000000000..027eec2a2
--- /dev/null
+++ b/src/cryosphere_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci measurement module — tsb analytics library. */
+export interface CryosphereSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciMeasurement(data: number[], opts: CryosphereSciMeasurementOptions = {}): CryosphereSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciMeasurement };
diff --git a/src/cryosphere_sci/metrics.ts b/src/cryosphere_sci/metrics.ts
new file mode 100644
index 000000000..ac0196c1c
--- /dev/null
+++ b/src/cryosphere_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci metrics module — tsb analytics library. */
+export interface CryosphereSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciMetricsResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciMetrics(data: number[], opts: CryosphereSciMetricsOptions = {}): CryosphereSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciMetrics };
diff --git a/src/cryosphere_sci/modeling.ts b/src/cryosphere_sci/modeling.ts
new file mode 100644
index 000000000..8ae1fb6bb
--- /dev/null
+++ b/src/cryosphere_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci modeling module — tsb analytics library. */
+export interface CryosphereSciModelingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciModelingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciModeling(data: number[], opts: CryosphereSciModelingOptions = {}): CryosphereSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciModeling };
diff --git a/src/cryosphere_sci/monitoring.ts b/src/cryosphere_sci/monitoring.ts
new file mode 100644
index 000000000..bb48822be
--- /dev/null
+++ b/src/cryosphere_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci monitoring module — tsb analytics library. */
+export interface CryosphereSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciMonitoring(data: number[], opts: CryosphereSciMonitoringOptions = {}): CryosphereSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciMonitoring };
diff --git a/src/cryosphere_sci/nonlinear.ts b/src/cryosphere_sci/nonlinear.ts
new file mode 100644
index 000000000..83b166f65
--- /dev/null
+++ b/src/cryosphere_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci nonlinear module — tsb analytics library. */
+export interface CryosphereSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciNonlinear(data: number[], opts: CryosphereSciNonlinearOptions = {}): CryosphereSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciNonlinear };
diff --git a/src/cryosphere_sci/normalization.ts b/src/cryosphere_sci/normalization.ts
new file mode 100644
index 000000000..397545248
--- /dev/null
+++ b/src/cryosphere_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci normalization module — tsb analytics library. */
+export interface CryosphereSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciNormalization(data: number[], opts: CryosphereSciNormalizationOptions = {}): CryosphereSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciNormalization };
diff --git a/src/cryosphere_sci/optimization.ts b/src/cryosphere_sci/optimization.ts
new file mode 100644
index 000000000..d82c3968a
--- /dev/null
+++ b/src/cryosphere_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci optimization module — tsb analytics library. */
+export interface CryosphereSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciOptimization(data: number[], opts: CryosphereSciOptimizationOptions = {}): CryosphereSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciOptimization };
diff --git a/src/cryosphere_sci/patterns.ts b/src/cryosphere_sci/patterns.ts
new file mode 100644
index 000000000..329bc2328
--- /dev/null
+++ b/src/cryosphere_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci patterns module — tsb analytics library. */
+export interface CryosphereSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciPatternsResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciPatterns(data: number[], opts: CryosphereSciPatternsOptions = {}): CryosphereSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciPatterns };
diff --git a/src/cryosphere_sci/permutation.ts b/src/cryosphere_sci/permutation.ts
new file mode 100644
index 000000000..d7cc46d18
--- /dev/null
+++ b/src/cryosphere_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci permutation module — tsb analytics library. */
+export interface CryosphereSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciPermutationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciPermutation(data: number[], opts: CryosphereSciPermutationOptions = {}): CryosphereSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciPermutation };
diff --git a/src/cryosphere_sci/prediction.ts b/src/cryosphere_sci/prediction.ts
new file mode 100644
index 000000000..7b6ee530d
--- /dev/null
+++ b/src/cryosphere_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci prediction module — tsb analytics library. */
+export interface CryosphereSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciPredictionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciPrediction(data: number[], opts: CryosphereSciPredictionOptions = {}): CryosphereSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciPrediction };
diff --git a/src/cryosphere_sci/processing.ts b/src/cryosphere_sci/processing.ts
new file mode 100644
index 000000000..c680ffaa7
--- /dev/null
+++ b/src/cryosphere_sci/processing.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci processing module — tsb analytics library. */
+export interface CryosphereSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciProcessingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciProcessing(data: number[], opts: CryosphereSciProcessingOptions = {}): CryosphereSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciProcessing };
diff --git a/src/cryosphere_sci/profiling.ts b/src/cryosphere_sci/profiling.ts
new file mode 100644
index 000000000..1d0bac50c
--- /dev/null
+++ b/src/cryosphere_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci profiling module — tsb analytics library. */
+export interface CryosphereSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciProfilingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciProfiling(data: number[], opts: CryosphereSciProfilingOptions = {}): CryosphereSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciProfiling };
diff --git a/src/cryosphere_sci/projection.ts b/src/cryosphere_sci/projection.ts
new file mode 100644
index 000000000..09d7a9621
--- /dev/null
+++ b/src/cryosphere_sci/projection.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci projection module — tsb analytics library. */
+export interface CryosphereSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciProjectionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciProjection(data: number[], opts: CryosphereSciProjectionOptions = {}): CryosphereSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciProjection };
diff --git a/src/cryosphere_sci/ranking.ts b/src/cryosphere_sci/ranking.ts
new file mode 100644
index 000000000..4598dcf54
--- /dev/null
+++ b/src/cryosphere_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci ranking module — tsb analytics library. */
+export interface CryosphereSciRankingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciRankingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciRanking(data: number[], opts: CryosphereSciRankingOptions = {}): CryosphereSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciRanking };
diff --git a/src/cryosphere_sci/reconstruction.ts b/src/cryosphere_sci/reconstruction.ts
new file mode 100644
index 000000000..3b9e4248a
--- /dev/null
+++ b/src/cryosphere_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci reconstruction module — tsb analytics library. */
+export interface CryosphereSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciReconstruction(data: number[], opts: CryosphereSciReconstructionOptions = {}): CryosphereSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciReconstruction };
diff --git a/src/cryosphere_sci/registration.ts b/src/cryosphere_sci/registration.ts
new file mode 100644
index 000000000..86e7a968f
--- /dev/null
+++ b/src/cryosphere_sci/registration.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci registration module — tsb analytics library. */
+export interface CryosphereSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciRegistration(data: number[], opts: CryosphereSciRegistrationOptions = {}): CryosphereSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciRegistration };
diff --git a/src/cryosphere_sci/regression.ts b/src/cryosphere_sci/regression.ts
new file mode 100644
index 000000000..087abe04c
--- /dev/null
+++ b/src/cryosphere_sci/regression.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci regression module — tsb analytics library. */
+export interface CryosphereSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciRegressionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciRegression(data: number[], opts: CryosphereSciRegressionOptions = {}): CryosphereSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciRegression };
diff --git a/src/cryosphere_sci/regularization.ts b/src/cryosphere_sci/regularization.ts
new file mode 100644
index 000000000..180a14fdf
--- /dev/null
+++ b/src/cryosphere_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci regularization module — tsb analytics library. */
+export interface CryosphereSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciRegularization(data: number[], opts: CryosphereSciRegularizationOptions = {}): CryosphereSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciRegularization };
diff --git a/src/cryosphere_sci/robustness.ts b/src/cryosphere_sci/robustness.ts
new file mode 100644
index 000000000..668f7fe84
--- /dev/null
+++ b/src/cryosphere_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci robustness module — tsb analytics library. */
+export interface CryosphereSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciRobustness(data: number[], opts: CryosphereSciRobustnessOptions = {}): CryosphereSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciRobustness };
diff --git a/src/cryosphere_sci/sampling.ts b/src/cryosphere_sci/sampling.ts
new file mode 100644
index 000000000..629e6be05
--- /dev/null
+++ b/src/cryosphere_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci sampling module — tsb analytics library. */
+export interface CryosphereSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciSamplingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciSampling(data: number[], opts: CryosphereSciSamplingOptions = {}): CryosphereSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciSampling };
diff --git a/src/cryosphere_sci/sampling2.ts b/src/cryosphere_sci/sampling2.ts
new file mode 100644
index 000000000..4e7d547d2
--- /dev/null
+++ b/src/cryosphere_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci sampling2 module — tsb analytics library. */
+export interface CryosphereSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciSamplingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciSampling(data: number[], opts: CryosphereSciSamplingOptions = {}): CryosphereSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciSampling };
diff --git a/src/cryosphere_sci/scaling.ts b/src/cryosphere_sci/scaling.ts
new file mode 100644
index 000000000..d5c356d88
--- /dev/null
+++ b/src/cryosphere_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci scaling module — tsb analytics library. */
+export interface CryosphereSciScalingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciScalingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciScaling(data: number[], opts: CryosphereSciScalingOptions = {}): CryosphereSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciScaling };
diff --git a/src/cryosphere_sci/scoring.ts b/src/cryosphere_sci/scoring.ts
new file mode 100644
index 000000000..84e7c76f7
--- /dev/null
+++ b/src/cryosphere_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci scoring module — tsb analytics library. */
+export interface CryosphereSciScoringOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciScoringResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciScoring(data: number[], opts: CryosphereSciScoringOptions = {}): CryosphereSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciScoring };
diff --git a/src/cryosphere_sci/segmentation.ts b/src/cryosphere_sci/segmentation.ts
new file mode 100644
index 000000000..5f73d7fbc
--- /dev/null
+++ b/src/cryosphere_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci segmentation module — tsb analytics library. */
+export interface CryosphereSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciSegmentation(data: number[], opts: CryosphereSciSegmentationOptions = {}): CryosphereSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciSegmentation };
diff --git a/src/cryosphere_sci/selection.ts b/src/cryosphere_sci/selection.ts
new file mode 100644
index 000000000..b8b65b392
--- /dev/null
+++ b/src/cryosphere_sci/selection.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci selection module — tsb analytics library. */
+export interface CryosphereSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciSelectionResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciSelection(data: number[], opts: CryosphereSciSelectionOptions = {}): CryosphereSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciSelection };
diff --git a/src/cryosphere_sci/sensitivity.ts b/src/cryosphere_sci/sensitivity.ts
new file mode 100644
index 000000000..12f93218b
--- /dev/null
+++ b/src/cryosphere_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci sensitivity module — tsb analytics library. */
+export interface CryosphereSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciSensitivity(data: number[], opts: CryosphereSciSensitivityOptions = {}): CryosphereSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciSensitivity };
diff --git a/src/cryosphere_sci/simulation.ts b/src/cryosphere_sci/simulation.ts
new file mode 100644
index 000000000..5ff977a87
--- /dev/null
+++ b/src/cryosphere_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci simulation module — tsb analytics library. */
+export interface CryosphereSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciSimulationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciSimulation(data: number[], opts: CryosphereSciSimulationOptions = {}): CryosphereSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciSimulation };
diff --git a/src/cryosphere_sci/smoothing.ts b/src/cryosphere_sci/smoothing.ts
new file mode 100644
index 000000000..ff56d628a
--- /dev/null
+++ b/src/cryosphere_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci smoothing module — tsb analytics library. */
+export interface CryosphereSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciSmoothing(data: number[], opts: CryosphereSciSmoothingOptions = {}): CryosphereSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciSmoothing };
diff --git a/src/cryosphere_sci/stability.ts b/src/cryosphere_sci/stability.ts
new file mode 100644
index 000000000..95aaaf29c
--- /dev/null
+++ b/src/cryosphere_sci/stability.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci stability module — tsb analytics library. */
+export interface CryosphereSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciStabilityResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciStability(data: number[], opts: CryosphereSciStabilityOptions = {}): CryosphereSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciStability };
diff --git a/src/cryosphere_sci/stacking.ts b/src/cryosphere_sci/stacking.ts
new file mode 100644
index 000000000..90f9b71a3
--- /dev/null
+++ b/src/cryosphere_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci stacking module — tsb analytics library. */
+export interface CryosphereSciStackingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciStackingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciStacking(data: number[], opts: CryosphereSciStackingOptions = {}): CryosphereSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciStacking };
diff --git a/src/cryosphere_sci/standardization.ts b/src/cryosphere_sci/standardization.ts
new file mode 100644
index 000000000..e571898c2
--- /dev/null
+++ b/src/cryosphere_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci standardization module — tsb analytics library. */
+export interface CryosphereSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciStandardization(data: number[], opts: CryosphereSciStandardizationOptions = {}): CryosphereSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciStandardization };
diff --git a/src/cryosphere_sci/static.ts b/src/cryosphere_sci/static.ts
new file mode 100644
index 000000000..3e594c5d8
--- /dev/null
+++ b/src/cryosphere_sci/static.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci static module — tsb analytics library. */
+export interface CryosphereSciStaticOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciStaticResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciStatic(data: number[], opts: CryosphereSciStaticOptions = {}): CryosphereSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciStatic };
diff --git a/src/cryosphere_sci/stochastic.ts b/src/cryosphere_sci/stochastic.ts
new file mode 100644
index 000000000..848c57da2
--- /dev/null
+++ b/src/cryosphere_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci stochastic module — tsb analytics library. */
+export interface CryosphereSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciStochasticResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciStochastic(data: number[], opts: CryosphereSciStochasticOptions = {}): CryosphereSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciStochastic };
diff --git a/src/cryosphere_sci/synthesis.ts b/src/cryosphere_sci/synthesis.ts
new file mode 100644
index 000000000..b81ddddfd
--- /dev/null
+++ b/src/cryosphere_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci synthesis module — tsb analytics library. */
+export interface CryosphereSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciSynthesis(data: number[], opts: CryosphereSciSynthesisOptions = {}): CryosphereSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciSynthesis };
diff --git a/src/cryosphere_sci/topology.ts b/src/cryosphere_sci/topology.ts
new file mode 100644
index 000000000..35ff29141
--- /dev/null
+++ b/src/cryosphere_sci/topology.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci topology module — tsb analytics library. */
+export interface CryosphereSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciTopologyResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciTopology(data: number[], opts: CryosphereSciTopologyOptions = {}): CryosphereSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciTopology };
diff --git a/src/cryosphere_sci/tracking.ts b/src/cryosphere_sci/tracking.ts
new file mode 100644
index 000000000..d45c7b13a
--- /dev/null
+++ b/src/cryosphere_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci tracking module — tsb analytics library. */
+export interface CryosphereSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciTrackingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciTracking(data: number[], opts: CryosphereSciTrackingOptions = {}): CryosphereSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciTracking };
diff --git a/src/cryosphere_sci/transform.ts b/src/cryosphere_sci/transform.ts
new file mode 100644
index 000000000..12e677638
--- /dev/null
+++ b/src/cryosphere_sci/transform.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci transform module — tsb analytics library. */
+export interface CryosphereSciTransformOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciTransformResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciTransform(data: number[], opts: CryosphereSciTransformOptions = {}): CryosphereSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciTransform };
diff --git a/src/cryosphere_sci/uncertainty.ts b/src/cryosphere_sci/uncertainty.ts
new file mode 100644
index 000000000..cc5a4c763
--- /dev/null
+++ b/src/cryosphere_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci uncertainty module — tsb analytics library. */
+export interface CryosphereSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciUncertainty(data: number[], opts: CryosphereSciUncertaintyOptions = {}): CryosphereSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciUncertainty };
diff --git a/src/cryosphere_sci/validation.ts b/src/cryosphere_sci/validation.ts
new file mode 100644
index 000000000..ef41bd2fd
--- /dev/null
+++ b/src/cryosphere_sci/validation.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci validation module — tsb analytics library. */
+export interface CryosphereSciValidationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciValidationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciValidation(data: number[], opts: CryosphereSciValidationOptions = {}): CryosphereSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciValidation };
diff --git a/src/cryosphere_sci/verification.ts b/src/cryosphere_sci/verification.ts
new file mode 100644
index 000000000..cedb156f0
--- /dev/null
+++ b/src/cryosphere_sci/verification.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci verification module — tsb analytics library. */
+export interface CryosphereSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciVerificationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciVerification(data: number[], opts: CryosphereSciVerificationOptions = {}): CryosphereSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciVerification };
diff --git a/src/cryosphere_sci/visualization.ts b/src/cryosphere_sci/visualization.ts
new file mode 100644
index 000000000..d3595dcf8
--- /dev/null
+++ b/src/cryosphere_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci visualization module — tsb analytics library. */
+export interface CryosphereSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciVisualization(data: number[], opts: CryosphereSciVisualizationOptions = {}): CryosphereSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciVisualization };
diff --git a/src/cryosphere_sci/voting.ts b/src/cryosphere_sci/voting.ts
new file mode 100644
index 000000000..c0d73db76
--- /dev/null
+++ b/src/cryosphere_sci/voting.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci voting module — tsb analytics library. */
+export interface CryosphereSciVotingOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciVotingResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciVoting(data: number[], opts: CryosphereSciVotingOptions = {}): CryosphereSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciVoting };
diff --git a/src/cryosphere_sci/wavelet.ts b/src/cryosphere_sci/wavelet.ts
new file mode 100644
index 000000000..199b28ab1
--- /dev/null
+++ b/src/cryosphere_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** cryosphere_sci wavelet module — tsb analytics library. */
+export interface CryosphereSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface CryosphereSciWaveletResult { values: number[]; converged: boolean; }
+export function computeCryosphereSciWavelet(data: number[], opts: CryosphereSciWaveletOptions = {}): CryosphereSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCryosphereSciWavelet };
diff --git a/src/crystallography/adaptation.ts b/src/crystallography/adaptation.ts
new file mode 100644
index 000000000..5f9d39db2
--- /dev/null
+++ b/src/crystallography/adaptation.ts
@@ -0,0 +1,14 @@
+/** crystallography adaptation module — tsb analytics library. */
+export interface CrystallographyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyAdaptationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyAdaptation(data: number[], opts: CrystallographyAdaptationOptions = {}): CrystallographyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyAdaptation };
diff --git a/src/crystallography/aggregation.ts b/src/crystallography/aggregation.ts
new file mode 100644
index 000000000..6d9129e2f
--- /dev/null
+++ b/src/crystallography/aggregation.ts
@@ -0,0 +1,14 @@
+/** crystallography aggregation module — tsb analytics library. */
+export interface CrystallographyAggregationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyAggregationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyAggregation(data: number[], opts: CrystallographyAggregationOptions = {}): CrystallographyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyAggregation };
diff --git a/src/crystallography/algebra.ts b/src/crystallography/algebra.ts
new file mode 100644
index 000000000..a298ba7f4
--- /dev/null
+++ b/src/crystallography/algebra.ts
@@ -0,0 +1,14 @@
+/** crystallography algebra module — tsb analytics library. */
+export interface CrystallographyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyAlgebraResult { values: number[]; converged: boolean; }
+export function computeCrystallographyAlgebra(data: number[], opts: CrystallographyAlgebraOptions = {}): CrystallographyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyAlgebra };
diff --git a/src/crystallography/alignment.ts b/src/crystallography/alignment.ts
new file mode 100644
index 000000000..cb535944c
--- /dev/null
+++ b/src/crystallography/alignment.ts
@@ -0,0 +1,14 @@
+/** crystallography alignment module — tsb analytics library. */
+export interface CrystallographyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyAlignmentResult { values: number[]; converged: boolean; }
+export function computeCrystallographyAlignment(data: number[], opts: CrystallographyAlignmentOptions = {}): CrystallographyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyAlignment };
diff --git a/src/crystallography/analysis.ts b/src/crystallography/analysis.ts
new file mode 100644
index 000000000..22b960ee4
--- /dev/null
+++ b/src/crystallography/analysis.ts
@@ -0,0 +1,14 @@
+/** crystallography analysis module — tsb analytics library. */
+export interface CrystallographyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyAnalysisResult { values: number[]; converged: boolean; }
+export function computeCrystallographyAnalysis(data: number[], opts: CrystallographyAnalysisOptions = {}): CrystallographyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyAnalysis };
diff --git a/src/crystallography/augmentation.ts b/src/crystallography/augmentation.ts
new file mode 100644
index 000000000..a776487dc
--- /dev/null
+++ b/src/crystallography/augmentation.ts
@@ -0,0 +1,14 @@
+/** crystallography augmentation module — tsb analytics library. */
+export interface CrystallographyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyAugmentationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyAugmentation(data: number[], opts: CrystallographyAugmentationOptions = {}): CrystallographyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyAugmentation };
diff --git a/src/crystallography/bagging.ts b/src/crystallography/bagging.ts
new file mode 100644
index 000000000..49a670dbf
--- /dev/null
+++ b/src/crystallography/bagging.ts
@@ -0,0 +1,14 @@
+/** crystallography bagging module — tsb analytics library. */
+export interface CrystallographyBaggingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyBaggingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyBagging(data: number[], opts: CrystallographyBaggingOptions = {}): CrystallographyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyBagging };
diff --git a/src/crystallography/basis.ts b/src/crystallography/basis.ts
new file mode 100644
index 000000000..1d26e7438
--- /dev/null
+++ b/src/crystallography/basis.ts
@@ -0,0 +1,14 @@
+/** crystallography basis module — tsb analytics library. */
+export interface CrystallographyBasisOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyBasisResult { values: number[]; converged: boolean; }
+export function computeCrystallographyBasis(data: number[], opts: CrystallographyBasisOptions = {}): CrystallographyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyBasis };
diff --git a/src/crystallography/benchmarking.ts b/src/crystallography/benchmarking.ts
new file mode 100644
index 000000000..ecb54e8d8
--- /dev/null
+++ b/src/crystallography/benchmarking.ts
@@ -0,0 +1,14 @@
+/** crystallography benchmarking module — tsb analytics library. */
+export interface CrystallographyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyBenchmarking(data: number[], opts: CrystallographyBenchmarkingOptions = {}): CrystallographyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyBenchmarking };
diff --git a/src/crystallography/blending.ts b/src/crystallography/blending.ts
new file mode 100644
index 000000000..da4d50155
--- /dev/null
+++ b/src/crystallography/blending.ts
@@ -0,0 +1,14 @@
+/** crystallography blending module — tsb analytics library. */
+export interface CrystallographyBlendingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyBlendingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyBlending(data: number[], opts: CrystallographyBlendingOptions = {}): CrystallographyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyBlending };
diff --git a/src/crystallography/boosting.ts b/src/crystallography/boosting.ts
new file mode 100644
index 000000000..c9a74fe77
--- /dev/null
+++ b/src/crystallography/boosting.ts
@@ -0,0 +1,14 @@
+/** crystallography boosting module — tsb analytics library. */
+export interface CrystallographyBoostingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyBoostingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyBoosting(data: number[], opts: CrystallographyBoostingOptions = {}): CrystallographyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyBoosting };
diff --git a/src/crystallography/bootstrap.ts b/src/crystallography/bootstrap.ts
new file mode 100644
index 000000000..a58d40958
--- /dev/null
+++ b/src/crystallography/bootstrap.ts
@@ -0,0 +1,14 @@
+/** crystallography bootstrap module — tsb analytics library. */
+export interface CrystallographyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyBootstrapResult { values: number[]; converged: boolean; }
+export function computeCrystallographyBootstrap(data: number[], opts: CrystallographyBootstrapOptions = {}): CrystallographyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyBootstrap };
diff --git a/src/crystallography/calculus.ts b/src/crystallography/calculus.ts
new file mode 100644
index 000000000..3af1ad460
--- /dev/null
+++ b/src/crystallography/calculus.ts
@@ -0,0 +1,14 @@
+/** crystallography calculus module — tsb analytics library. */
+export interface CrystallographyCalculusOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyCalculusResult { values: number[]; converged: boolean; }
+export function computeCrystallographyCalculus(data: number[], opts: CrystallographyCalculusOptions = {}): CrystallographyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyCalculus };
diff --git a/src/crystallography/calibration.ts b/src/crystallography/calibration.ts
new file mode 100644
index 000000000..21f4e96f3
--- /dev/null
+++ b/src/crystallography/calibration.ts
@@ -0,0 +1,14 @@
+/** crystallography calibration module — tsb analytics library. */
+export interface CrystallographyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyCalibrationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyCalibration(data: number[], opts: CrystallographyCalibrationOptions = {}): CrystallographyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyCalibration };
diff --git a/src/crystallography/characterization.ts b/src/crystallography/characterization.ts
new file mode 100644
index 000000000..56d7d56a4
--- /dev/null
+++ b/src/crystallography/characterization.ts
@@ -0,0 +1,14 @@
+/** crystallography characterization module — tsb analytics library. */
+export interface CrystallographyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyCharacterization(data: number[], opts: CrystallographyCharacterizationOptions = {}): CrystallographyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyCharacterization };
diff --git a/src/crystallography/classification.ts b/src/crystallography/classification.ts
new file mode 100644
index 000000000..01f670216
--- /dev/null
+++ b/src/crystallography/classification.ts
@@ -0,0 +1,14 @@
+/** crystallography classification module — tsb analytics library. */
+export interface CrystallographyClassificationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyClassificationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyClassification(data: number[], opts: CrystallographyClassificationOptions = {}): CrystallographyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyClassification };
diff --git a/src/crystallography/clustering.ts b/src/crystallography/clustering.ts
new file mode 100644
index 000000000..32d7fdf42
--- /dev/null
+++ b/src/crystallography/clustering.ts
@@ -0,0 +1,14 @@
+/** crystallography clustering module — tsb analytics library. */
+export interface CrystallographyClusteringOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyClusteringResult { values: number[]; converged: boolean; }
+export function computeCrystallographyClustering(data: number[], opts: CrystallographyClusteringOptions = {}): CrystallographyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyClustering };
diff --git a/src/crystallography/compression.ts b/src/crystallography/compression.ts
new file mode 100644
index 000000000..2a47a4c0f
--- /dev/null
+++ b/src/crystallography/compression.ts
@@ -0,0 +1,14 @@
+/** crystallography compression module — tsb analytics library. */
+export interface CrystallographyCompressionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyCompressionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyCompression(data: number[], opts: CrystallographyCompressionOptions = {}): CrystallographyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyCompression };
diff --git a/src/crystallography/continuous.ts b/src/crystallography/continuous.ts
new file mode 100644
index 000000000..e545c2324
--- /dev/null
+++ b/src/crystallography/continuous.ts
@@ -0,0 +1,14 @@
+/** crystallography continuous module — tsb analytics library. */
+export interface CrystallographyContinuousOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyContinuousResult { values: number[]; converged: boolean; }
+export function computeCrystallographyContinuous(data: number[], opts: CrystallographyContinuousOptions = {}): CrystallographyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyContinuous };
diff --git a/src/crystallography/control.ts b/src/crystallography/control.ts
new file mode 100644
index 000000000..380124b07
--- /dev/null
+++ b/src/crystallography/control.ts
@@ -0,0 +1,14 @@
+/** crystallography control module — tsb analytics library. */
+export interface CrystallographyControlOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyControlResult { values: number[]; converged: boolean; }
+export function computeCrystallographyControl(data: number[], opts: CrystallographyControlOptions = {}): CrystallographyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyControl };
diff --git a/src/crystallography/convergence.ts b/src/crystallography/convergence.ts
new file mode 100644
index 000000000..e827c75e9
--- /dev/null
+++ b/src/crystallography/convergence.ts
@@ -0,0 +1,14 @@
+/** crystallography convergence module — tsb analytics library. */
+export interface CrystallographyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyConvergenceResult { values: number[]; converged: boolean; }
+export function computeCrystallographyConvergence(data: number[], opts: CrystallographyConvergenceOptions = {}): CrystallographyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyConvergence };
diff --git a/src/crystallography/convex.ts b/src/crystallography/convex.ts
new file mode 100644
index 000000000..4ed9b1543
--- /dev/null
+++ b/src/crystallography/convex.ts
@@ -0,0 +1,14 @@
+/** crystallography convex module — tsb analytics library. */
+export interface CrystallographyConvexOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyConvexResult { values: number[]; converged: boolean; }
+export function computeCrystallographyConvex(data: number[], opts: CrystallographyConvexOptions = {}): CrystallographyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyConvex };
diff --git a/src/crystallography/correlation.ts b/src/crystallography/correlation.ts
new file mode 100644
index 000000000..a7e8bebcd
--- /dev/null
+++ b/src/crystallography/correlation.ts
@@ -0,0 +1,14 @@
+/** crystallography correlation module — tsb analytics library. */
+export interface CrystallographyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyCorrelationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyCorrelation(data: number[], opts: CrystallographyCorrelationOptions = {}): CrystallographyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyCorrelation };
diff --git a/src/crystallography/covariance.ts b/src/crystallography/covariance.ts
new file mode 100644
index 000000000..55f861c41
--- /dev/null
+++ b/src/crystallography/covariance.ts
@@ -0,0 +1,14 @@
+/** crystallography covariance module — tsb analytics library. */
+export interface CrystallographyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyCovarianceResult { values: number[]; converged: boolean; }
+export function computeCrystallographyCovariance(data: number[], opts: CrystallographyCovarianceOptions = {}): CrystallographyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyCovariance };
diff --git a/src/crystallography/cross_validation.ts b/src/crystallography/cross_validation.ts
new file mode 100644
index 000000000..0eb2798a5
--- /dev/null
+++ b/src/crystallography/cross_validation.ts
@@ -0,0 +1,14 @@
+/** crystallography cross_validation module — tsb analytics library. */
+export interface CrystallographyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyCrossValidation(data: number[], opts: CrystallographyCrossValidationOptions = {}): CrystallographyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyCrossValidation };
diff --git a/src/crystallography/decoding.ts b/src/crystallography/decoding.ts
new file mode 100644
index 000000000..cb7d72fd9
--- /dev/null
+++ b/src/crystallography/decoding.ts
@@ -0,0 +1,14 @@
+/** crystallography decoding module — tsb analytics library. */
+export interface CrystallographyDecodingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDecodingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDecoding(data: number[], opts: CrystallographyDecodingOptions = {}): CrystallographyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDecoding };
diff --git a/src/crystallography/decomposition.ts b/src/crystallography/decomposition.ts
new file mode 100644
index 000000000..03b8fe621
--- /dev/null
+++ b/src/crystallography/decomposition.ts
@@ -0,0 +1,14 @@
+/** crystallography decomposition module — tsb analytics library. */
+export interface CrystallographyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDecompositionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDecomposition(data: number[], opts: CrystallographyDecompositionOptions = {}): CrystallographyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDecomposition };
diff --git a/src/crystallography/detection.ts b/src/crystallography/detection.ts
new file mode 100644
index 000000000..5aed91a03
--- /dev/null
+++ b/src/crystallography/detection.ts
@@ -0,0 +1,14 @@
+/** crystallography detection module — tsb analytics library. */
+export interface CrystallographyDetectionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDetectionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDetection(data: number[], opts: CrystallographyDetectionOptions = {}): CrystallographyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDetection };
diff --git a/src/crystallography/deterministic.ts b/src/crystallography/deterministic.ts
new file mode 100644
index 000000000..7afa4c279
--- /dev/null
+++ b/src/crystallography/deterministic.ts
@@ -0,0 +1,14 @@
+/** crystallography deterministic module — tsb analytics library. */
+export interface CrystallographyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDeterministicResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDeterministic(data: number[], opts: CrystallographyDeterministicOptions = {}): CrystallographyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDeterministic };
diff --git a/src/crystallography/diagnostics.ts b/src/crystallography/diagnostics.ts
new file mode 100644
index 000000000..7abcb8216
--- /dev/null
+++ b/src/crystallography/diagnostics.ts
@@ -0,0 +1,14 @@
+/** crystallography diagnostics module — tsb analytics library. */
+export interface CrystallographyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDiagnostics(data: number[], opts: CrystallographyDiagnosticsOptions = {}): CrystallographyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDiagnostics };
diff --git a/src/crystallography/differential.ts b/src/crystallography/differential.ts
new file mode 100644
index 000000000..5fc40097a
--- /dev/null
+++ b/src/crystallography/differential.ts
@@ -0,0 +1,14 @@
+/** crystallography differential module — tsb analytics library. */
+export interface CrystallographyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDifferentialResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDifferential(data: number[], opts: CrystallographyDifferentialOptions = {}): CrystallographyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDifferential };
diff --git a/src/crystallography/discrete.ts b/src/crystallography/discrete.ts
new file mode 100644
index 000000000..4b3b5b4c7
--- /dev/null
+++ b/src/crystallography/discrete.ts
@@ -0,0 +1,14 @@
+/** crystallography discrete module — tsb analytics library. */
+export interface CrystallographyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDiscreteResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDiscrete(data: number[], opts: CrystallographyDiscreteOptions = {}): CrystallographyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDiscrete };
diff --git a/src/crystallography/distribution.ts b/src/crystallography/distribution.ts
new file mode 100644
index 000000000..8b4955ddf
--- /dev/null
+++ b/src/crystallography/distribution.ts
@@ -0,0 +1,14 @@
+/** crystallography distribution module — tsb analytics library. */
+export interface CrystallographyDistributionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDistributionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDistribution(data: number[], opts: CrystallographyDistributionOptions = {}): CrystallographyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDistribution };
diff --git a/src/crystallography/dynamic.ts b/src/crystallography/dynamic.ts
new file mode 100644
index 000000000..e80519e65
--- /dev/null
+++ b/src/crystallography/dynamic.ts
@@ -0,0 +1,14 @@
+/** crystallography dynamic module — tsb analytics library. */
+export interface CrystallographyDynamicOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyDynamicResult { values: number[]; converged: boolean; }
+export function computeCrystallographyDynamic(data: number[], opts: CrystallographyDynamicOptions = {}): CrystallographyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyDynamic };
diff --git a/src/crystallography/embedding.ts b/src/crystallography/embedding.ts
new file mode 100644
index 000000000..b52905309
--- /dev/null
+++ b/src/crystallography/embedding.ts
@@ -0,0 +1,14 @@
+/** crystallography embedding module — tsb analytics library. */
+export interface CrystallographyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyEmbedding(data: number[], opts: CrystallographyEmbeddingOptions = {}): CrystallographyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyEmbedding };
diff --git a/src/crystallography/encoding.ts b/src/crystallography/encoding.ts
new file mode 100644
index 000000000..c917af593
--- /dev/null
+++ b/src/crystallography/encoding.ts
@@ -0,0 +1,14 @@
+/** crystallography encoding module — tsb analytics library. */
+export interface CrystallographyEncodingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyEncodingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyEncoding(data: number[], opts: CrystallographyEncodingOptions = {}): CrystallographyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyEncoding };
diff --git a/src/crystallography/ensemble.ts b/src/crystallography/ensemble.ts
new file mode 100644
index 000000000..709e378ad
--- /dev/null
+++ b/src/crystallography/ensemble.ts
@@ -0,0 +1,14 @@
+/** crystallography ensemble module — tsb analytics library. */
+export interface CrystallographyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyEnsembleResult { values: number[]; converged: boolean; }
+export function computeCrystallographyEnsemble(data: number[], opts: CrystallographyEnsembleOptions = {}): CrystallographyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyEnsemble };
diff --git a/src/crystallography/estimation.ts b/src/crystallography/estimation.ts
new file mode 100644
index 000000000..b5b87b662
--- /dev/null
+++ b/src/crystallography/estimation.ts
@@ -0,0 +1,14 @@
+/** crystallography estimation module — tsb analytics library. */
+export interface CrystallographyEstimationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyEstimationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyEstimation(data: number[], opts: CrystallographyEstimationOptions = {}): CrystallographyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyEstimation };
diff --git a/src/crystallography/evaluation.ts b/src/crystallography/evaluation.ts
new file mode 100644
index 000000000..0cb7eb58b
--- /dev/null
+++ b/src/crystallography/evaluation.ts
@@ -0,0 +1,14 @@
+/** crystallography evaluation module — tsb analytics library. */
+export interface CrystallographyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyEvaluationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyEvaluation(data: number[], opts: CrystallographyEvaluationOptions = {}): CrystallographyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyEvaluation };
diff --git a/src/crystallography/extrapolation.ts b/src/crystallography/extrapolation.ts
new file mode 100644
index 000000000..ec42af4db
--- /dev/null
+++ b/src/crystallography/extrapolation.ts
@@ -0,0 +1,14 @@
+/** crystallography extrapolation module — tsb analytics library. */
+export interface CrystallographyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyExtrapolation(data: number[], opts: CrystallographyExtrapolationOptions = {}): CrystallographyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyExtrapolation };
diff --git a/src/crystallography/features.ts b/src/crystallography/features.ts
new file mode 100644
index 000000000..b14e76ea3
--- /dev/null
+++ b/src/crystallography/features.ts
@@ -0,0 +1,14 @@
+/** crystallography features module — tsb analytics library. */
+export interface CrystallographyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyFeaturesResult { values: number[]; converged: boolean; }
+export function computeCrystallographyFeatures(data: number[], opts: CrystallographyFeaturesOptions = {}): CrystallographyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyFeatures };
diff --git a/src/crystallography/feedback.ts b/src/crystallography/feedback.ts
new file mode 100644
index 000000000..c1b9b5bbd
--- /dev/null
+++ b/src/crystallography/feedback.ts
@@ -0,0 +1,14 @@
+/** crystallography feedback module — tsb analytics library. */
+export interface CrystallographyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyFeedbackResult { values: number[]; converged: boolean; }
+export function computeCrystallographyFeedback(data: number[], opts: CrystallographyFeedbackOptions = {}): CrystallographyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyFeedback };
diff --git a/src/crystallography/filtering.ts b/src/crystallography/filtering.ts
new file mode 100644
index 000000000..15c3b9488
--- /dev/null
+++ b/src/crystallography/filtering.ts
@@ -0,0 +1,14 @@
+/** crystallography filtering module — tsb analytics library. */
+export interface CrystallographyFilteringOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyFilteringResult { values: number[]; converged: boolean; }
+export function computeCrystallographyFiltering(data: number[], opts: CrystallographyFilteringOptions = {}): CrystallographyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyFiltering };
diff --git a/src/crystallography/fourier.ts b/src/crystallography/fourier.ts
new file mode 100644
index 000000000..3d4a8ae83
--- /dev/null
+++ b/src/crystallography/fourier.ts
@@ -0,0 +1,14 @@
+/** crystallography fourier module — tsb analytics library. */
+export interface CrystallographyFourierOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyFourierResult { values: number[]; converged: boolean; }
+export function computeCrystallographyFourier(data: number[], opts: CrystallographyFourierOptions = {}): CrystallographyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyFourier };
diff --git a/src/crystallography/fusion.ts b/src/crystallography/fusion.ts
new file mode 100644
index 000000000..905095fc4
--- /dev/null
+++ b/src/crystallography/fusion.ts
@@ -0,0 +1,14 @@
+/** crystallography fusion module — tsb analytics library. */
+export interface CrystallographyFusionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyFusionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyFusion(data: number[], opts: CrystallographyFusionOptions = {}): CrystallographyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyFusion };
diff --git a/src/crystallography/generation.ts b/src/crystallography/generation.ts
new file mode 100644
index 000000000..325e583bc
--- /dev/null
+++ b/src/crystallography/generation.ts
@@ -0,0 +1,14 @@
+/** crystallography generation module — tsb analytics library. */
+export interface CrystallographyGenerationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyGenerationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyGeneration(data: number[], opts: CrystallographyGenerationOptions = {}): CrystallographyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyGeneration };
diff --git a/src/crystallography/geometry.ts b/src/crystallography/geometry.ts
new file mode 100644
index 000000000..6761c467a
--- /dev/null
+++ b/src/crystallography/geometry.ts
@@ -0,0 +1,14 @@
+/** crystallography geometry module — tsb analytics library. */
+export interface CrystallographyGeometryOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyGeometryResult { values: number[]; converged: boolean; }
+export function computeCrystallographyGeometry(data: number[], opts: CrystallographyGeometryOptions = {}): CrystallographyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyGeometry };
diff --git a/src/crystallography/gradient.ts b/src/crystallography/gradient.ts
new file mode 100644
index 000000000..6cc462b2b
--- /dev/null
+++ b/src/crystallography/gradient.ts
@@ -0,0 +1,14 @@
+/** crystallography gradient module — tsb analytics library. */
+export interface CrystallographyGradientOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyGradientResult { values: number[]; converged: boolean; }
+export function computeCrystallographyGradient(data: number[], opts: CrystallographyGradientOptions = {}): CrystallographyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyGradient };
diff --git a/src/crystallography/hessian.ts b/src/crystallography/hessian.ts
new file mode 100644
index 000000000..bc0f59bd7
--- /dev/null
+++ b/src/crystallography/hessian.ts
@@ -0,0 +1,14 @@
+/** crystallography hessian module — tsb analytics library. */
+export interface CrystallographyHessianOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyHessianResult { values: number[]; converged: boolean; }
+export function computeCrystallographyHessian(data: number[], opts: CrystallographyHessianOptions = {}): CrystallographyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyHessian };
diff --git a/src/crystallography/hypothesis.ts b/src/crystallography/hypothesis.ts
new file mode 100644
index 000000000..4d66433ad
--- /dev/null
+++ b/src/crystallography/hypothesis.ts
@@ -0,0 +1,14 @@
+/** crystallography hypothesis module — tsb analytics library. */
+export interface CrystallographyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyHypothesisResult { values: number[]; converged: boolean; }
+export function computeCrystallographyHypothesis(data: number[], opts: CrystallographyHypothesisOptions = {}): CrystallographyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyHypothesis };
diff --git a/src/crystallography/inference.ts b/src/crystallography/inference.ts
new file mode 100644
index 000000000..cf1c06220
--- /dev/null
+++ b/src/crystallography/inference.ts
@@ -0,0 +1,14 @@
+/** crystallography inference module — tsb analytics library. */
+export interface CrystallographyInferenceOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyInferenceResult { values: number[]; converged: boolean; }
+export function computeCrystallographyInference(data: number[], opts: CrystallographyInferenceOptions = {}): CrystallographyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyInference };
diff --git a/src/crystallography/inference2.ts b/src/crystallography/inference2.ts
new file mode 100644
index 000000000..be5a131f7
--- /dev/null
+++ b/src/crystallography/inference2.ts
@@ -0,0 +1,14 @@
+/** crystallography inference2 module — tsb analytics library. */
+export interface CrystallographyInferenceOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyInferenceResult { values: number[]; converged: boolean; }
+export function computeCrystallographyInference(data: number[], opts: CrystallographyInferenceOptions = {}): CrystallographyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyInference };
diff --git a/src/crystallography/integral.ts b/src/crystallography/integral.ts
new file mode 100644
index 000000000..58d33dede
--- /dev/null
+++ b/src/crystallography/integral.ts
@@ -0,0 +1,14 @@
+/** crystallography integral module — tsb analytics library. */
+export interface CrystallographyIntegralOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyIntegralResult { values: number[]; converged: boolean; }
+export function computeCrystallographyIntegral(data: number[], opts: CrystallographyIntegralOptions = {}): CrystallographyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyIntegral };
diff --git a/src/crystallography/integration.ts b/src/crystallography/integration.ts
new file mode 100644
index 000000000..f609745aa
--- /dev/null
+++ b/src/crystallography/integration.ts
@@ -0,0 +1,14 @@
+/** crystallography integration module — tsb analytics library. */
+export interface CrystallographyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyIntegrationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyIntegration(data: number[], opts: CrystallographyIntegrationOptions = {}): CrystallographyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyIntegration };
diff --git a/src/crystallography/interpolation.ts b/src/crystallography/interpolation.ts
new file mode 100644
index 000000000..667497f9e
--- /dev/null
+++ b/src/crystallography/interpolation.ts
@@ -0,0 +1,14 @@
+/** crystallography interpolation module — tsb analytics library. */
+export interface CrystallographyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyInterpolationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyInterpolation(data: number[], opts: CrystallographyInterpolationOptions = {}): CrystallographyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyInterpolation };
diff --git a/src/crystallography/jacobian.ts b/src/crystallography/jacobian.ts
new file mode 100644
index 000000000..4f0a23d92
--- /dev/null
+++ b/src/crystallography/jacobian.ts
@@ -0,0 +1,14 @@
+/** crystallography jacobian module — tsb analytics library. */
+export interface CrystallographyJacobianOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyJacobianResult { values: number[]; converged: boolean; }
+export function computeCrystallographyJacobian(data: number[], opts: CrystallographyJacobianOptions = {}): CrystallographyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyJacobian };
diff --git a/src/crystallography/kernel.ts b/src/crystallography/kernel.ts
new file mode 100644
index 000000000..dd5f9682b
--- /dev/null
+++ b/src/crystallography/kernel.ts
@@ -0,0 +1,14 @@
+/** crystallography kernel module — tsb analytics library. */
+export interface CrystallographyKernelOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyKernelResult { values: number[]; converged: boolean; }
+export function computeCrystallographyKernel(data: number[], opts: CrystallographyKernelOptions = {}): CrystallographyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyKernel };
diff --git a/src/crystallography/laplacian.ts b/src/crystallography/laplacian.ts
new file mode 100644
index 000000000..1a39c3de6
--- /dev/null
+++ b/src/crystallography/laplacian.ts
@@ -0,0 +1,14 @@
+/** crystallography laplacian module — tsb analytics library. */
+export interface CrystallographyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyLaplacianResult { values: number[]; converged: boolean; }
+export function computeCrystallographyLaplacian(data: number[], opts: CrystallographyLaplacianOptions = {}): CrystallographyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyLaplacian };
diff --git a/src/crystallography/learning.ts b/src/crystallography/learning.ts
new file mode 100644
index 000000000..a4cef0a64
--- /dev/null
+++ b/src/crystallography/learning.ts
@@ -0,0 +1,14 @@
+/** crystallography learning module — tsb analytics library. */
+export interface CrystallographyLearningOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyLearningResult { values: number[]; converged: boolean; }
+export function computeCrystallographyLearning(data: number[], opts: CrystallographyLearningOptions = {}): CrystallographyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyLearning };
diff --git a/src/crystallography/linear.ts b/src/crystallography/linear.ts
new file mode 100644
index 000000000..70cb60a81
--- /dev/null
+++ b/src/crystallography/linear.ts
@@ -0,0 +1,14 @@
+/** crystallography linear module — tsb analytics library. */
+export interface CrystallographyLinearOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyLinearResult { values: number[]; converged: boolean; }
+export function computeCrystallographyLinear(data: number[], opts: CrystallographyLinearOptions = {}): CrystallographyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyLinear };
diff --git a/src/crystallography/manifold.ts b/src/crystallography/manifold.ts
new file mode 100644
index 000000000..76c8a9605
--- /dev/null
+++ b/src/crystallography/manifold.ts
@@ -0,0 +1,14 @@
+/** crystallography manifold module — tsb analytics library. */
+export interface CrystallographyManifoldOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyManifoldResult { values: number[]; converged: boolean; }
+export function computeCrystallographyManifold(data: number[], opts: CrystallographyManifoldOptions = {}): CrystallographyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyManifold };
diff --git a/src/crystallography/matching.ts b/src/crystallography/matching.ts
new file mode 100644
index 000000000..2f041f7bd
--- /dev/null
+++ b/src/crystallography/matching.ts
@@ -0,0 +1,14 @@
+/** crystallography matching module — tsb analytics library. */
+export interface CrystallographyMatchingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyMatchingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyMatching(data: number[], opts: CrystallographyMatchingOptions = {}): CrystallographyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyMatching };
diff --git a/src/crystallography/measurement.ts b/src/crystallography/measurement.ts
new file mode 100644
index 000000000..9ee2834fa
--- /dev/null
+++ b/src/crystallography/measurement.ts
@@ -0,0 +1,14 @@
+/** crystallography measurement module — tsb analytics library. */
+export interface CrystallographyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyMeasurementResult { values: number[]; converged: boolean; }
+export function computeCrystallographyMeasurement(data: number[], opts: CrystallographyMeasurementOptions = {}): CrystallographyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyMeasurement };
diff --git a/src/crystallography/metrics.ts b/src/crystallography/metrics.ts
new file mode 100644
index 000000000..041651481
--- /dev/null
+++ b/src/crystallography/metrics.ts
@@ -0,0 +1,14 @@
+/** crystallography metrics module — tsb analytics library. */
+export interface CrystallographyMetricsOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyMetricsResult { values: number[]; converged: boolean; }
+export function computeCrystallographyMetrics(data: number[], opts: CrystallographyMetricsOptions = {}): CrystallographyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyMetrics };
diff --git a/src/crystallography/modeling.ts b/src/crystallography/modeling.ts
new file mode 100644
index 000000000..ad8f1ffae
--- /dev/null
+++ b/src/crystallography/modeling.ts
@@ -0,0 +1,14 @@
+/** crystallography modeling module — tsb analytics library. */
+export interface CrystallographyModelingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyModelingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyModeling(data: number[], opts: CrystallographyModelingOptions = {}): CrystallographyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyModeling };
diff --git a/src/crystallography/monitoring.ts b/src/crystallography/monitoring.ts
new file mode 100644
index 000000000..7691e7b48
--- /dev/null
+++ b/src/crystallography/monitoring.ts
@@ -0,0 +1,14 @@
+/** crystallography monitoring module — tsb analytics library. */
+export interface CrystallographyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyMonitoringResult { values: number[]; converged: boolean; }
+export function computeCrystallographyMonitoring(data: number[], opts: CrystallographyMonitoringOptions = {}): CrystallographyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyMonitoring };
diff --git a/src/crystallography/nonlinear.ts b/src/crystallography/nonlinear.ts
new file mode 100644
index 000000000..f62c7f144
--- /dev/null
+++ b/src/crystallography/nonlinear.ts
@@ -0,0 +1,14 @@
+/** crystallography nonlinear module — tsb analytics library. */
+export interface CrystallographyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyNonlinearResult { values: number[]; converged: boolean; }
+export function computeCrystallographyNonlinear(data: number[], opts: CrystallographyNonlinearOptions = {}): CrystallographyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyNonlinear };
diff --git a/src/crystallography/normalization.ts b/src/crystallography/normalization.ts
new file mode 100644
index 000000000..e4d1cf357
--- /dev/null
+++ b/src/crystallography/normalization.ts
@@ -0,0 +1,14 @@
+/** crystallography normalization module — tsb analytics library. */
+export interface CrystallographyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyNormalizationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyNormalization(data: number[], opts: CrystallographyNormalizationOptions = {}): CrystallographyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyNormalization };
diff --git a/src/crystallography/optimization.ts b/src/crystallography/optimization.ts
new file mode 100644
index 000000000..a9ba0ac38
--- /dev/null
+++ b/src/crystallography/optimization.ts
@@ -0,0 +1,14 @@
+/** crystallography optimization module — tsb analytics library. */
+export interface CrystallographyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyOptimizationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyOptimization(data: number[], opts: CrystallographyOptimizationOptions = {}): CrystallographyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyOptimization };
diff --git a/src/crystallography/patterns.ts b/src/crystallography/patterns.ts
new file mode 100644
index 000000000..937130731
--- /dev/null
+++ b/src/crystallography/patterns.ts
@@ -0,0 +1,14 @@
+/** crystallography patterns module — tsb analytics library. */
+export interface CrystallographyPatternsOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyPatternsResult { values: number[]; converged: boolean; }
+export function computeCrystallographyPatterns(data: number[], opts: CrystallographyPatternsOptions = {}): CrystallographyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyPatterns };
diff --git a/src/crystallography/permutation.ts b/src/crystallography/permutation.ts
new file mode 100644
index 000000000..ce122ca1f
--- /dev/null
+++ b/src/crystallography/permutation.ts
@@ -0,0 +1,14 @@
+/** crystallography permutation module — tsb analytics library. */
+export interface CrystallographyPermutationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyPermutationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyPermutation(data: number[], opts: CrystallographyPermutationOptions = {}): CrystallographyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyPermutation };
diff --git a/src/crystallography/prediction.ts b/src/crystallography/prediction.ts
new file mode 100644
index 000000000..b0567ee74
--- /dev/null
+++ b/src/crystallography/prediction.ts
@@ -0,0 +1,14 @@
+/** crystallography prediction module — tsb analytics library. */
+export interface CrystallographyPredictionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyPredictionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyPrediction(data: number[], opts: CrystallographyPredictionOptions = {}): CrystallographyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyPrediction };
diff --git a/src/crystallography/processing.ts b/src/crystallography/processing.ts
new file mode 100644
index 000000000..619283677
--- /dev/null
+++ b/src/crystallography/processing.ts
@@ -0,0 +1,14 @@
+/** crystallography processing module — tsb analytics library. */
+export interface CrystallographyProcessingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyProcessingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyProcessing(data: number[], opts: CrystallographyProcessingOptions = {}): CrystallographyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyProcessing };
diff --git a/src/crystallography/profiling.ts b/src/crystallography/profiling.ts
new file mode 100644
index 000000000..6cef7b6f8
--- /dev/null
+++ b/src/crystallography/profiling.ts
@@ -0,0 +1,14 @@
+/** crystallography profiling module — tsb analytics library. */
+export interface CrystallographyProfilingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyProfilingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyProfiling(data: number[], opts: CrystallographyProfilingOptions = {}): CrystallographyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyProfiling };
diff --git a/src/crystallography/projection.ts b/src/crystallography/projection.ts
new file mode 100644
index 000000000..519a8dae4
--- /dev/null
+++ b/src/crystallography/projection.ts
@@ -0,0 +1,14 @@
+/** crystallography projection module — tsb analytics library. */
+export interface CrystallographyProjectionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyProjectionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyProjection(data: number[], opts: CrystallographyProjectionOptions = {}): CrystallographyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyProjection };
diff --git a/src/crystallography/ranking.ts b/src/crystallography/ranking.ts
new file mode 100644
index 000000000..87a4c7224
--- /dev/null
+++ b/src/crystallography/ranking.ts
@@ -0,0 +1,14 @@
+/** crystallography ranking module — tsb analytics library. */
+export interface CrystallographyRankingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyRankingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyRanking(data: number[], opts: CrystallographyRankingOptions = {}): CrystallographyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyRanking };
diff --git a/src/crystallography/reconstruction.ts b/src/crystallography/reconstruction.ts
new file mode 100644
index 000000000..5cc0a449e
--- /dev/null
+++ b/src/crystallography/reconstruction.ts
@@ -0,0 +1,14 @@
+/** crystallography reconstruction module — tsb analytics library. */
+export interface CrystallographyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyReconstructionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyReconstruction(data: number[], opts: CrystallographyReconstructionOptions = {}): CrystallographyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyReconstruction };
diff --git a/src/crystallography/registration.ts b/src/crystallography/registration.ts
new file mode 100644
index 000000000..47cd157d9
--- /dev/null
+++ b/src/crystallography/registration.ts
@@ -0,0 +1,14 @@
+/** crystallography registration module — tsb analytics library. */
+export interface CrystallographyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyRegistrationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyRegistration(data: number[], opts: CrystallographyRegistrationOptions = {}): CrystallographyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyRegistration };
diff --git a/src/crystallography/regression.ts b/src/crystallography/regression.ts
new file mode 100644
index 000000000..284b3fa62
--- /dev/null
+++ b/src/crystallography/regression.ts
@@ -0,0 +1,14 @@
+/** crystallography regression module — tsb analytics library. */
+export interface CrystallographyRegressionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyRegressionResult { values: number[]; converged: boolean; }
+export function computeCrystallographyRegression(data: number[], opts: CrystallographyRegressionOptions = {}): CrystallographyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyRegression };
diff --git a/src/crystallography/regularization.ts b/src/crystallography/regularization.ts
new file mode 100644
index 000000000..ecb7d5ee2
--- /dev/null
+++ b/src/crystallography/regularization.ts
@@ -0,0 +1,14 @@
+/** crystallography regularization module — tsb analytics library. */
+export interface CrystallographyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyRegularizationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyRegularization(data: number[], opts: CrystallographyRegularizationOptions = {}): CrystallographyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyRegularization };
diff --git a/src/crystallography/robustness.ts b/src/crystallography/robustness.ts
new file mode 100644
index 000000000..5a67844d4
--- /dev/null
+++ b/src/crystallography/robustness.ts
@@ -0,0 +1,14 @@
+/** crystallography robustness module — tsb analytics library. */
+export interface CrystallographyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyRobustnessResult { values: number[]; converged: boolean; }
+export function computeCrystallographyRobustness(data: number[], opts: CrystallographyRobustnessOptions = {}): CrystallographyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyRobustness };
diff --git a/src/crystallography/sampling.ts b/src/crystallography/sampling.ts
new file mode 100644
index 000000000..55447674b
--- /dev/null
+++ b/src/crystallography/sampling.ts
@@ -0,0 +1,14 @@
+/** crystallography sampling module — tsb analytics library. */
+export interface CrystallographySamplingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographySamplingResult { values: number[]; converged: boolean; }
+export function computeCrystallographySampling(data: number[], opts: CrystallographySamplingOptions = {}): CrystallographySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographySampling };
diff --git a/src/crystallography/sampling2.ts b/src/crystallography/sampling2.ts
new file mode 100644
index 000000000..7e9e32a59
--- /dev/null
+++ b/src/crystallography/sampling2.ts
@@ -0,0 +1,14 @@
+/** crystallography sampling2 module — tsb analytics library. */
+export interface CrystallographySamplingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographySamplingResult { values: number[]; converged: boolean; }
+export function computeCrystallographySampling(data: number[], opts: CrystallographySamplingOptions = {}): CrystallographySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographySampling };
diff --git a/src/crystallography/scaling.ts b/src/crystallography/scaling.ts
new file mode 100644
index 000000000..6e3a9550d
--- /dev/null
+++ b/src/crystallography/scaling.ts
@@ -0,0 +1,14 @@
+/** crystallography scaling module — tsb analytics library. */
+export interface CrystallographyScalingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyScalingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyScaling(data: number[], opts: CrystallographyScalingOptions = {}): CrystallographyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyScaling };
diff --git a/src/crystallography/scoring.ts b/src/crystallography/scoring.ts
new file mode 100644
index 000000000..dce8eb63c
--- /dev/null
+++ b/src/crystallography/scoring.ts
@@ -0,0 +1,14 @@
+/** crystallography scoring module — tsb analytics library. */
+export interface CrystallographyScoringOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyScoringResult { values: number[]; converged: boolean; }
+export function computeCrystallographyScoring(data: number[], opts: CrystallographyScoringOptions = {}): CrystallographyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyScoring };
diff --git a/src/crystallography/segmentation.ts b/src/crystallography/segmentation.ts
new file mode 100644
index 000000000..9a949e9a2
--- /dev/null
+++ b/src/crystallography/segmentation.ts
@@ -0,0 +1,14 @@
+/** crystallography segmentation module — tsb analytics library. */
+export interface CrystallographySegmentationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographySegmentationResult { values: number[]; converged: boolean; }
+export function computeCrystallographySegmentation(data: number[], opts: CrystallographySegmentationOptions = {}): CrystallographySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographySegmentation };
diff --git a/src/crystallography/selection.ts b/src/crystallography/selection.ts
new file mode 100644
index 000000000..c11da6ed9
--- /dev/null
+++ b/src/crystallography/selection.ts
@@ -0,0 +1,14 @@
+/** crystallography selection module — tsb analytics library. */
+export interface CrystallographySelectionOptions { tol?: number; maxIter?: number; }
+export interface CrystallographySelectionResult { values: number[]; converged: boolean; }
+export function computeCrystallographySelection(data: number[], opts: CrystallographySelectionOptions = {}): CrystallographySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographySelection };
diff --git a/src/crystallography/sensitivity.ts b/src/crystallography/sensitivity.ts
new file mode 100644
index 000000000..6779087b1
--- /dev/null
+++ b/src/crystallography/sensitivity.ts
@@ -0,0 +1,14 @@
+/** crystallography sensitivity module — tsb analytics library. */
+export interface CrystallographySensitivityOptions { tol?: number; maxIter?: number; }
+export interface CrystallographySensitivityResult { values: number[]; converged: boolean; }
+export function computeCrystallographySensitivity(data: number[], opts: CrystallographySensitivityOptions = {}): CrystallographySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographySensitivity };
diff --git a/src/crystallography/simulation.ts b/src/crystallography/simulation.ts
new file mode 100644
index 000000000..e6c3a2e71
--- /dev/null
+++ b/src/crystallography/simulation.ts
@@ -0,0 +1,14 @@
+/** crystallography simulation module — tsb analytics library. */
+export interface CrystallographySimulationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographySimulationResult { values: number[]; converged: boolean; }
+export function computeCrystallographySimulation(data: number[], opts: CrystallographySimulationOptions = {}): CrystallographySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographySimulation };
diff --git a/src/crystallography/smoothing.ts b/src/crystallography/smoothing.ts
new file mode 100644
index 000000000..4c76c5f51
--- /dev/null
+++ b/src/crystallography/smoothing.ts
@@ -0,0 +1,14 @@
+/** crystallography smoothing module — tsb analytics library. */
+export interface CrystallographySmoothingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographySmoothingResult { values: number[]; converged: boolean; }
+export function computeCrystallographySmoothing(data: number[], opts: CrystallographySmoothingOptions = {}): CrystallographySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographySmoothing };
diff --git a/src/crystallography/stability.ts b/src/crystallography/stability.ts
new file mode 100644
index 000000000..3cae5ad55
--- /dev/null
+++ b/src/crystallography/stability.ts
@@ -0,0 +1,14 @@
+/** crystallography stability module — tsb analytics library. */
+export interface CrystallographyStabilityOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyStabilityResult { values: number[]; converged: boolean; }
+export function computeCrystallographyStability(data: number[], opts: CrystallographyStabilityOptions = {}): CrystallographyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyStability };
diff --git a/src/crystallography/stacking.ts b/src/crystallography/stacking.ts
new file mode 100644
index 000000000..3283d2e8c
--- /dev/null
+++ b/src/crystallography/stacking.ts
@@ -0,0 +1,14 @@
+/** crystallography stacking module — tsb analytics library. */
+export interface CrystallographyStackingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyStackingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyStacking(data: number[], opts: CrystallographyStackingOptions = {}): CrystallographyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyStacking };
diff --git a/src/crystallography/standardization.ts b/src/crystallography/standardization.ts
new file mode 100644
index 000000000..63f00037c
--- /dev/null
+++ b/src/crystallography/standardization.ts
@@ -0,0 +1,14 @@
+/** crystallography standardization module — tsb analytics library. */
+export interface CrystallographyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyStandardizationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyStandardization(data: number[], opts: CrystallographyStandardizationOptions = {}): CrystallographyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyStandardization };
diff --git a/src/crystallography/static.ts b/src/crystallography/static.ts
new file mode 100644
index 000000000..f40381b1e
--- /dev/null
+++ b/src/crystallography/static.ts
@@ -0,0 +1,14 @@
+/** crystallography static module — tsb analytics library. */
+export interface CrystallographyStaticOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyStaticResult { values: number[]; converged: boolean; }
+export function computeCrystallographyStatic(data: number[], opts: CrystallographyStaticOptions = {}): CrystallographyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyStatic };
diff --git a/src/crystallography/stochastic.ts b/src/crystallography/stochastic.ts
new file mode 100644
index 000000000..c18d2230b
--- /dev/null
+++ b/src/crystallography/stochastic.ts
@@ -0,0 +1,14 @@
+/** crystallography stochastic module — tsb analytics library. */
+export interface CrystallographyStochasticOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyStochasticResult { values: number[]; converged: boolean; }
+export function computeCrystallographyStochastic(data: number[], opts: CrystallographyStochasticOptions = {}): CrystallographyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyStochastic };
diff --git a/src/crystallography/synthesis.ts b/src/crystallography/synthesis.ts
new file mode 100644
index 000000000..b5546c2ea
--- /dev/null
+++ b/src/crystallography/synthesis.ts
@@ -0,0 +1,14 @@
+/** crystallography synthesis module — tsb analytics library. */
+export interface CrystallographySynthesisOptions { tol?: number; maxIter?: number; }
+export interface CrystallographySynthesisResult { values: number[]; converged: boolean; }
+export function computeCrystallographySynthesis(data: number[], opts: CrystallographySynthesisOptions = {}): CrystallographySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographySynthesis };
diff --git a/src/crystallography/topology.ts b/src/crystallography/topology.ts
new file mode 100644
index 000000000..609f3520e
--- /dev/null
+++ b/src/crystallography/topology.ts
@@ -0,0 +1,14 @@
+/** crystallography topology module — tsb analytics library. */
+export interface CrystallographyTopologyOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyTopologyResult { values: number[]; converged: boolean; }
+export function computeCrystallographyTopology(data: number[], opts: CrystallographyTopologyOptions = {}): CrystallographyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyTopology };
diff --git a/src/crystallography/tracking.ts b/src/crystallography/tracking.ts
new file mode 100644
index 000000000..588f8cd95
--- /dev/null
+++ b/src/crystallography/tracking.ts
@@ -0,0 +1,14 @@
+/** crystallography tracking module — tsb analytics library. */
+export interface CrystallographyTrackingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyTrackingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyTracking(data: number[], opts: CrystallographyTrackingOptions = {}): CrystallographyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyTracking };
diff --git a/src/crystallography/transform.ts b/src/crystallography/transform.ts
new file mode 100644
index 000000000..bee99130a
--- /dev/null
+++ b/src/crystallography/transform.ts
@@ -0,0 +1,14 @@
+/** crystallography transform module — tsb analytics library. */
+export interface CrystallographyTransformOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyTransformResult { values: number[]; converged: boolean; }
+export function computeCrystallographyTransform(data: number[], opts: CrystallographyTransformOptions = {}): CrystallographyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyTransform };
diff --git a/src/crystallography/uncertainty.ts b/src/crystallography/uncertainty.ts
new file mode 100644
index 000000000..2d5ec4105
--- /dev/null
+++ b/src/crystallography/uncertainty.ts
@@ -0,0 +1,14 @@
+/** crystallography uncertainty module — tsb analytics library. */
+export interface CrystallographyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeCrystallographyUncertainty(data: number[], opts: CrystallographyUncertaintyOptions = {}): CrystallographyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyUncertainty };
diff --git a/src/crystallography/validation.ts b/src/crystallography/validation.ts
new file mode 100644
index 000000000..8ea70ee8b
--- /dev/null
+++ b/src/crystallography/validation.ts
@@ -0,0 +1,14 @@
+/** crystallography validation module — tsb analytics library. */
+export interface CrystallographyValidationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyValidationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyValidation(data: number[], opts: CrystallographyValidationOptions = {}): CrystallographyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyValidation };
diff --git a/src/crystallography/verification.ts b/src/crystallography/verification.ts
new file mode 100644
index 000000000..8d408e407
--- /dev/null
+++ b/src/crystallography/verification.ts
@@ -0,0 +1,14 @@
+/** crystallography verification module — tsb analytics library. */
+export interface CrystallographyVerificationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyVerificationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyVerification(data: number[], opts: CrystallographyVerificationOptions = {}): CrystallographyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyVerification };
diff --git a/src/crystallography/visualization.ts b/src/crystallography/visualization.ts
new file mode 100644
index 000000000..90ad97beb
--- /dev/null
+++ b/src/crystallography/visualization.ts
@@ -0,0 +1,14 @@
+/** crystallography visualization module — tsb analytics library. */
+export interface CrystallographyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyVisualizationResult { values: number[]; converged: boolean; }
+export function computeCrystallographyVisualization(data: number[], opts: CrystallographyVisualizationOptions = {}): CrystallographyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyVisualization };
diff --git a/src/crystallography/voting.ts b/src/crystallography/voting.ts
new file mode 100644
index 000000000..0aa0180f8
--- /dev/null
+++ b/src/crystallography/voting.ts
@@ -0,0 +1,14 @@
+/** crystallography voting module — tsb analytics library. */
+export interface CrystallographyVotingOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyVotingResult { values: number[]; converged: boolean; }
+export function computeCrystallographyVoting(data: number[], opts: CrystallographyVotingOptions = {}): CrystallographyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyVoting };
diff --git a/src/crystallography/wavelet.ts b/src/crystallography/wavelet.ts
new file mode 100644
index 000000000..b54b5200b
--- /dev/null
+++ b/src/crystallography/wavelet.ts
@@ -0,0 +1,14 @@
+/** crystallography wavelet module — tsb analytics library. */
+export interface CrystallographyWaveletOptions { tol?: number; maxIter?: number; }
+export interface CrystallographyWaveletResult { values: number[]; converged: boolean; }
+export function computeCrystallographyWavelet(data: number[], opts: CrystallographyWaveletOptions = {}): CrystallographyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCrystallographyWavelet };
diff --git a/src/cv/action.ts b/src/cv/action.ts
new file mode 100644
index 000000000..bc6ac57b7
--- /dev/null
+++ b/src/cv/action.ts
@@ -0,0 +1,22 @@
+/** Action module — tsb analytics library. */
+
+/** Options for Action. */
+export interface ActionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Action. */
+export interface ActionResult { values: number[]; converged: boolean; }
+
+/** Compute Action. */
+export function computeAction(data: number[], opts: ActionOptions = {}): ActionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAction };
diff --git a/src/cv/advanced.ts b/src/cv/advanced.ts
new file mode 100644
index 000000000..c1057670c
--- /dev/null
+++ b/src/cv/advanced.ts
@@ -0,0 +1,15 @@
+/** Cv Advanced module — tsb analytics library. */
+export interface Cv advancedOptions { tol?: number; maxIter?: number; }
+export interface Cv advancedResult { values: number[]; converged: boolean; }
+export function computeCv advanced(data: number[], opts: Cv advancedOptions = {}): Cv advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv advanced };
diff --git a/src/cv/augmentation.ts b/src/cv/augmentation.ts
new file mode 100644
index 000000000..26e41eb88
--- /dev/null
+++ b/src/cv/augmentation.ts
@@ -0,0 +1,22 @@
+/** Augmentation module — tsb analytics library. */
+
+/** Options for Augmentation. */
+export interface AugmentationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Augmentation. */
+export interface AugmentationResult { values: number[]; converged: boolean; }
+
+/** Compute Augmentation. */
+export function computeAugmentation(data: number[], opts: AugmentationOptions = {}): AugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAugmentation };
diff --git a/src/cv/base2.ts b/src/cv/base2.ts
new file mode 100644
index 000000000..7bfc9e0b2
--- /dev/null
+++ b/src/cv/base2.ts
@@ -0,0 +1,15 @@
+/** Cv Base2 module — tsb analytics library. */
+export interface Cv base2Options { tol?: number; maxIter?: number; }
+export interface Cv base2Result { values: number[]; converged: boolean; }
+export function computeCv base2(data: number[], opts: Cv base2Options = {}): Cv base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv base2 };
diff --git a/src/cv/batch.ts b/src/cv/batch.ts
new file mode 100644
index 000000000..9354ab3c6
--- /dev/null
+++ b/src/cv/batch.ts
@@ -0,0 +1,15 @@
+/** Cv Batch module — tsb analytics library. */
+export interface Cv batchOptions { tol?: number; maxIter?: number; }
+export interface Cv batchResult { values: number[]; converged: boolean; }
+export function computeCv batch(data: number[], opts: Cv batchOptions = {}): Cv batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv batch };
diff --git a/src/cv/beta.ts b/src/cv/beta.ts
new file mode 100644
index 000000000..2772222fc
--- /dev/null
+++ b/src/cv/beta.ts
@@ -0,0 +1,15 @@
+/** Cv Beta module — tsb analytics library. */
+export interface Cv betaOptions { tol?: number; maxIter?: number; }
+export interface Cv betaResult { values: number[]; converged: boolean; }
+export function computeCv beta(data: number[], opts: Cv betaOptions = {}): Cv betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv beta };
diff --git a/src/cv/captioning.ts b/src/cv/captioning.ts
new file mode 100644
index 000000000..9f4779445
--- /dev/null
+++ b/src/cv/captioning.ts
@@ -0,0 +1,22 @@
+/** Captioning module — tsb analytics library. */
+
+/** Options for Captioning. */
+export interface CaptioningOptions { tol?: number; maxIter?: number; }
+
+/** Result from Captioning. */
+export interface CaptioningResult { values: number[]; converged: boolean; }
+
+/** Compute Captioning. */
+export function computeCaptioning(data: number[], opts: CaptioningOptions = {}): CaptioningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCaptioning };
diff --git a/src/cv/classification.ts b/src/cv/classification.ts
new file mode 100644
index 000000000..4dd329dbf
--- /dev/null
+++ b/src/cv/classification.ts
@@ -0,0 +1,22 @@
+/** Classification module — tsb analytics library. */
+
+/** Options for Classification. */
+export interface ClassificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Classification. */
+export interface ClassificationResult { values: number[]; converged: boolean; }
+
+/** Compute Classification. */
+export function computeClassification(data: number[], opts: ClassificationOptions = {}): ClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClassification };
diff --git a/src/cv/colorization.ts b/src/cv/colorization.ts
new file mode 100644
index 000000000..2bf1723a5
--- /dev/null
+++ b/src/cv/colorization.ts
@@ -0,0 +1,22 @@
+/** Colorization module — tsb analytics library. */
+
+/** Options for Colorization. */
+export interface ColorizationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Colorization. */
+export interface ColorizationResult { values: number[]; converged: boolean; }
+
+/** Compute Colorization. */
+export function computeColorization(data: number[], opts: ColorizationOptions = {}): ColorizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeColorization };
diff --git a/src/cv/convolution.ts b/src/cv/convolution.ts
new file mode 100644
index 000000000..570e9ffb7
--- /dev/null
+++ b/src/cv/convolution.ts
@@ -0,0 +1,22 @@
+/** Convolution module — tsb analytics library. */
+
+/** Options for Convolution. */
+export interface ConvolutionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Convolution. */
+export interface ConvolutionResult { values: number[]; converged: boolean; }
+
+/** Compute Convolution. */
+export function computeConvolution(data: number[], opts: ConvolutionOptions = {}): ConvolutionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConvolution };
diff --git a/src/cv/cpu.ts b/src/cv/cpu.ts
new file mode 100644
index 000000000..b9fe440e2
--- /dev/null
+++ b/src/cv/cpu.ts
@@ -0,0 +1,15 @@
+/** Cv Cpu module — tsb analytics library. */
+export interface Cv cpuOptions { tol?: number; maxIter?: number; }
+export interface Cv cpuResult { values: number[]; converged: boolean; }
+export function computeCv cpu(data: number[], opts: Cv cpuOptions = {}): Cv cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv cpu };
diff --git a/src/cv/denoising.ts b/src/cv/denoising.ts
new file mode 100644
index 000000000..67865bc27
--- /dev/null
+++ b/src/cv/denoising.ts
@@ -0,0 +1,22 @@
+/** Denoising module — tsb analytics library. */
+
+/** Options for Denoising. */
+export interface DenoisingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Denoising. */
+export interface DenoisingResult { values: number[]; converged: boolean; }
+
+/** Compute Denoising. */
+export function computeDenoising(data: number[], opts: DenoisingOptions = {}): DenoisingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDenoising };
diff --git a/src/cv/dense.ts b/src/cv/dense.ts
new file mode 100644
index 000000000..9185d4675
--- /dev/null
+++ b/src/cv/dense.ts
@@ -0,0 +1,15 @@
+/** Cv Dense module — tsb analytics library. */
+export interface Cv denseOptions { tol?: number; maxIter?: number; }
+export interface Cv denseResult { values: number[]; converged: boolean; }
+export function computeCv dense(data: number[], opts: Cv denseOptions = {}): Cv denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv dense };
diff --git a/src/cv/depth.ts b/src/cv/depth.ts
new file mode 100644
index 000000000..49de3ab3c
--- /dev/null
+++ b/src/cv/depth.ts
@@ -0,0 +1,22 @@
+/** Depth module — tsb analytics library. */
+
+/** Options for Depth. */
+export interface DepthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Depth. */
+export interface DepthResult { values: number[]; converged: boolean; }
+
+/** Compute Depth. */
+export function computeDepth(data: number[], opts: DepthOptions = {}): DepthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDepth };
diff --git a/src/cv/detection.ts b/src/cv/detection.ts
new file mode 100644
index 000000000..63e15e447
--- /dev/null
+++ b/src/cv/detection.ts
@@ -0,0 +1,22 @@
+/** Detection module — tsb analytics library. */
+
+/** Options for Detection. */
+export interface DetectionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Detection. */
+export interface DetectionResult { values: number[]; converged: boolean; }
+
+/** Compute Detection. */
+export function computeDetection(data: number[], opts: DetectionOptions = {}): DetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDetection };
diff --git a/src/cv/distributed.ts b/src/cv/distributed.ts
new file mode 100644
index 000000000..21bf9eb54
--- /dev/null
+++ b/src/cv/distributed.ts
@@ -0,0 +1,15 @@
+/** Cv Distributed module — tsb analytics library. */
+export interface Cv distributedOptions { tol?: number; maxIter?: number; }
+export interface Cv distributedResult { values: number[]; converged: boolean; }
+export function computeCv distributed(data: number[], opts: Cv distributedOptions = {}): Cv distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv distributed };
diff --git a/src/cv/enhancement.ts b/src/cv/enhancement.ts
new file mode 100644
index 000000000..1326017e4
--- /dev/null
+++ b/src/cv/enhancement.ts
@@ -0,0 +1,22 @@
+/** Enhancement module — tsb analytics library. */
+
+/** Options for Enhancement. */
+export interface EnhancementOptions { tol?: number; maxIter?: number; }
+
+/** Result from Enhancement. */
+export interface EnhancementResult { values: number[]; converged: boolean; }
+
+/** Compute Enhancement. */
+export function computeEnhancement(data: number[], opts: EnhancementOptions = {}): EnhancementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEnhancement };
diff --git a/src/cv/experimental.ts b/src/cv/experimental.ts
new file mode 100644
index 000000000..64a906834
--- /dev/null
+++ b/src/cv/experimental.ts
@@ -0,0 +1,15 @@
+/** Cv Experimental module — tsb analytics library. */
+export interface Cv experimentalOptions { tol?: number; maxIter?: number; }
+export interface Cv experimentalResult { values: number[]; converged: boolean; }
+export function computeCv experimental(data: number[], opts: Cv experimentalOptions = {}): Cv experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv experimental };
diff --git a/src/cv/fast.ts b/src/cv/fast.ts
new file mode 100644
index 000000000..8d0bf64c1
--- /dev/null
+++ b/src/cv/fast.ts
@@ -0,0 +1,15 @@
+/** Cv Fast module — tsb analytics library. */
+export interface Cv fastOptions { tol?: number; maxIter?: number; }
+export interface Cv fastResult { values: number[]; converged: boolean; }
+export function computeCv fast(data: number[], opts: Cv fastOptions = {}): Cv fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv fast };
diff --git a/src/cv/future.ts b/src/cv/future.ts
new file mode 100644
index 000000000..4544db0b0
--- /dev/null
+++ b/src/cv/future.ts
@@ -0,0 +1,15 @@
+/** Cv Future module — tsb analytics library. */
+export interface Cv futureOptions { tol?: number; maxIter?: number; }
+export interface Cv futureResult { values: number[]; converged: boolean; }
+export function computeCv future(data: number[], opts: Cv futureOptions = {}): Cv futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv future };
diff --git a/src/cv/gan.ts b/src/cv/gan.ts
new file mode 100644
index 000000000..17be4da8b
--- /dev/null
+++ b/src/cv/gan.ts
@@ -0,0 +1,22 @@
+/** Gan module — tsb analytics library. */
+
+/** Options for Gan. */
+export interface GanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gan. */
+export interface GanResult { values: number[]; converged: boolean; }
+
+/** Compute Gan. */
+export function computeGan(data: number[], opts: GanOptions = {}): GanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGan };
diff --git a/src/cv/gpu.ts b/src/cv/gpu.ts
new file mode 100644
index 000000000..3aab7e733
--- /dev/null
+++ b/src/cv/gpu.ts
@@ -0,0 +1,15 @@
+/** Cv Gpu module — tsb analytics library. */
+export interface Cv gpuOptions { tol?: number; maxIter?: number; }
+export interface Cv gpuResult { values: number[]; converged: boolean; }
+export function computeCv gpu(data: number[], opts: Cv gpuOptions = {}): Cv gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv gpu };
diff --git a/src/cv/inpainting.ts b/src/cv/inpainting.ts
new file mode 100644
index 000000000..99b683d26
--- /dev/null
+++ b/src/cv/inpainting.ts
@@ -0,0 +1,22 @@
+/** Inpainting module — tsb analytics library. */
+
+/** Options for Inpainting. */
+export interface InpaintingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Inpainting. */
+export interface InpaintingResult { values: number[]; converged: boolean; }
+
+/** Compute Inpainting. */
+export function computeInpainting(data: number[], opts: InpaintingOptions = {}): InpaintingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInpainting };
diff --git a/src/cv/keypoints.ts b/src/cv/keypoints.ts
new file mode 100644
index 000000000..64272d5da
--- /dev/null
+++ b/src/cv/keypoints.ts
@@ -0,0 +1,22 @@
+/** Keypoints module — tsb analytics library. */
+
+/** Options for Keypoints. */
+export interface KeypointsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Keypoints. */
+export interface KeypointsResult { values: number[]; converged: boolean; }
+
+/** Compute Keypoints. */
+export function computeKeypoints(data: number[], opts: KeypointsOptions = {}): KeypointsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKeypoints };
diff --git a/src/cv/large.ts b/src/cv/large.ts
new file mode 100644
index 000000000..28e99e86d
--- /dev/null
+++ b/src/cv/large.ts
@@ -0,0 +1,15 @@
+/** Cv Large module — tsb analytics library. */
+export interface Cv largeOptions { tol?: number; maxIter?: number; }
+export interface Cv largeResult { values: number[]; converged: boolean; }
+export function computeCv large(data: number[], opts: Cv largeOptions = {}): Cv largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv large };
diff --git a/src/cv/legacy.ts b/src/cv/legacy.ts
new file mode 100644
index 000000000..474bfeb2e
--- /dev/null
+++ b/src/cv/legacy.ts
@@ -0,0 +1,15 @@
+/** Cv Legacy module — tsb analytics library. */
+export interface Cv legacyOptions { tol?: number; maxIter?: number; }
+export interface Cv legacyResult { values: number[]; converged: boolean; }
+export function computeCv legacy(data: number[], opts: Cv legacyOptions = {}): Cv legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv legacy };
diff --git a/src/cv/lite.ts b/src/cv/lite.ts
new file mode 100644
index 000000000..726121244
--- /dev/null
+++ b/src/cv/lite.ts
@@ -0,0 +1,15 @@
+/** Cv Lite module — tsb analytics library. */
+export interface Cv liteOptions { tol?: number; maxIter?: number; }
+export interface Cv liteResult { values: number[]; converged: boolean; }
+export function computeCv lite(data: number[], opts: Cv liteOptions = {}): Cv liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv lite };
diff --git a/src/cv/matting.ts b/src/cv/matting.ts
new file mode 100644
index 000000000..bacdae415
--- /dev/null
+++ b/src/cv/matting.ts
@@ -0,0 +1,22 @@
+/** Matting module — tsb analytics library. */
+
+/** Options for Matting. */
+export interface MattingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Matting. */
+export interface MattingResult { values: number[]; converged: boolean; }
+
+/** Compute Matting. */
+export function computeMatting(data: number[], opts: MattingOptions = {}): MattingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMatting };
diff --git a/src/cv/mini.ts b/src/cv/mini.ts
new file mode 100644
index 000000000..3403b58d1
--- /dev/null
+++ b/src/cv/mini.ts
@@ -0,0 +1,15 @@
+/** Cv Mini module — tsb analytics library. */
+export interface Cv miniOptions { tol?: number; maxIter?: number; }
+export interface Cv miniResult { values: number[]; converged: boolean; }
+export function computeCv mini(data: number[], opts: Cv miniOptions = {}): Cv miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv mini };
diff --git a/src/cv/next.ts b/src/cv/next.ts
new file mode 100644
index 000000000..5e4eaa48d
--- /dev/null
+++ b/src/cv/next.ts
@@ -0,0 +1,15 @@
+/** Cv Next module — tsb analytics library. */
+export interface Cv nextOptions { tol?: number; maxIter?: number; }
+export interface Cv nextResult { values: number[]; converged: boolean; }
+export function computeCv next(data: number[], opts: Cv nextOptions = {}): Cv nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv next };
diff --git a/src/cv/normalization.ts b/src/cv/normalization.ts
new file mode 100644
index 000000000..847a1696d
--- /dev/null
+++ b/src/cv/normalization.ts
@@ -0,0 +1,22 @@
+/** Normalization module — tsb analytics library. */
+
+/** Options for Normalization. */
+export interface NormalizationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Normalization. */
+export interface NormalizationResult { values: number[]; converged: boolean; }
+
+/** Compute Normalization. */
+export function computeNormalization(data: number[], opts: NormalizationOptions = {}): NormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNormalization };
diff --git a/src/cv/ocr.ts b/src/cv/ocr.ts
new file mode 100644
index 000000000..dab443faf
--- /dev/null
+++ b/src/cv/ocr.ts
@@ -0,0 +1,22 @@
+/** Ocr module — tsb analytics library. */
+
+/** Options for Ocr. */
+export interface OcrOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ocr. */
+export interface OcrResult { values: number[]; converged: boolean; }
+
+/** Compute Ocr. */
+export function computeOcr(data: number[], opts: OcrOptions = {}): OcrResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOcr };
diff --git a/src/cv/online.ts b/src/cv/online.ts
new file mode 100644
index 000000000..c23bc69c2
--- /dev/null
+++ b/src/cv/online.ts
@@ -0,0 +1,15 @@
+/** Cv Online module — tsb analytics library. */
+export interface Cv onlineOptions { tol?: number; maxIter?: number; }
+export interface Cv onlineResult { values: number[]; converged: boolean; }
+export function computeCv online(data: number[], opts: Cv onlineOptions = {}): Cv onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv online };
diff --git a/src/cv/optical_flow.ts b/src/cv/optical_flow.ts
new file mode 100644
index 000000000..96a0bb73f
--- /dev/null
+++ b/src/cv/optical_flow.ts
@@ -0,0 +1,22 @@
+/** Optical Flow module — tsb analytics library. */
+
+/** Options for Optical Flow. */
+export interface OpticalFlowOptions { tol?: number; maxIter?: number; }
+
+/** Result from Optical Flow. */
+export interface OpticalFlowResult { values: number[]; converged: boolean; }
+
+/** Compute Optical Flow. */
+export function computeOpticalFlow(data: number[], opts: OpticalFlowOptions = {}): OpticalFlowResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOpticalFlow };
diff --git a/src/cv/parallel.ts b/src/cv/parallel.ts
new file mode 100644
index 000000000..542d71413
--- /dev/null
+++ b/src/cv/parallel.ts
@@ -0,0 +1,15 @@
+/** Cv Parallel module — tsb analytics library. */
+export interface Cv parallelOptions { tol?: number; maxIter?: number; }
+export interface Cv parallelResult { values: number[]; converged: boolean; }
+export function computeCv parallel(data: number[], opts: Cv parallelOptions = {}): Cv parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv parallel };
diff --git a/src/cv/plus.ts b/src/cv/plus.ts
new file mode 100644
index 000000000..bf2110c90
--- /dev/null
+++ b/src/cv/plus.ts
@@ -0,0 +1,15 @@
+/** Cv Plus module — tsb analytics library. */
+export interface Cv plusOptions { tol?: number; maxIter?: number; }
+export interface Cv plusResult { values: number[]; converged: boolean; }
+export function computeCv plus(data: number[], opts: Cv plusOptions = {}): Cv plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv plus };
diff --git a/src/cv/pooling.ts b/src/cv/pooling.ts
new file mode 100644
index 000000000..99a42360c
--- /dev/null
+++ b/src/cv/pooling.ts
@@ -0,0 +1,22 @@
+/** Pooling module — tsb analytics library. */
+
+/** Options for Pooling. */
+export interface PoolingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pooling. */
+export interface PoolingResult { values: number[]; converged: boolean; }
+
+/** Compute Pooling. */
+export function computePooling(data: number[], opts: PoolingOptions = {}): PoolingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePooling };
diff --git a/src/cv/pose.ts b/src/cv/pose.ts
new file mode 100644
index 000000000..f7828251a
--- /dev/null
+++ b/src/cv/pose.ts
@@ -0,0 +1,22 @@
+/** Pose module — tsb analytics library. */
+
+/** Options for Pose. */
+export interface PoseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pose. */
+export interface PoseResult { values: number[]; converged: boolean; }
+
+/** Compute Pose. */
+export function computePose(data: number[], opts: PoseOptions = {}): PoseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePose };
diff --git a/src/cv/pro.ts b/src/cv/pro.ts
new file mode 100644
index 000000000..87d127185
--- /dev/null
+++ b/src/cv/pro.ts
@@ -0,0 +1,15 @@
+/** Cv Pro module — tsb analytics library. */
+export interface Cv proOptions { tol?: number; maxIter?: number; }
+export interface Cv proResult { values: number[]; converged: boolean; }
+export function computeCv pro(data: number[], opts: Cv proOptions = {}): Cv proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv pro };
diff --git a/src/cv/recognition.ts b/src/cv/recognition.ts
new file mode 100644
index 000000000..c6e5cd2d7
--- /dev/null
+++ b/src/cv/recognition.ts
@@ -0,0 +1,22 @@
+/** Recognition module — tsb analytics library. */
+
+/** Options for Recognition. */
+export interface RecognitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Recognition. */
+export interface RecognitionResult { values: number[]; converged: boolean; }
+
+/** Compute Recognition. */
+export function computeRecognition(data: number[], opts: RecognitionOptions = {}): RecognitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRecognition };
diff --git a/src/cv/robust.ts b/src/cv/robust.ts
new file mode 100644
index 000000000..ad76fc671
--- /dev/null
+++ b/src/cv/robust.ts
@@ -0,0 +1,15 @@
+/** Cv Robust module — tsb analytics library. */
+export interface Cv robustOptions { tol?: number; maxIter?: number; }
+export interface Cv robustResult { values: number[]; converged: boolean; }
+export function computeCv robust(data: number[], opts: Cv robustOptions = {}): Cv robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv robust };
diff --git a/src/cv/scene.ts b/src/cv/scene.ts
new file mode 100644
index 000000000..70118b8ad
--- /dev/null
+++ b/src/cv/scene.ts
@@ -0,0 +1,22 @@
+/** Scene module — tsb analytics library. */
+
+/** Options for Scene. */
+export interface SceneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Scene. */
+export interface SceneResult { values: number[]; converged: boolean; }
+
+/** Compute Scene. */
+export function computeScene(data: number[], opts: SceneOptions = {}): SceneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeScene };
diff --git a/src/cv/segmentation.ts b/src/cv/segmentation.ts
new file mode 100644
index 000000000..c74e19ce2
--- /dev/null
+++ b/src/cv/segmentation.ts
@@ -0,0 +1,22 @@
+/** Segmentation module — tsb analytics library. */
+
+/** Options for Segmentation. */
+export interface SegmentationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Segmentation. */
+export interface SegmentationResult { values: number[]; converged: boolean; }
+
+/** Compute Segmentation. */
+export function computeSegmentation(data: number[], opts: SegmentationOptions = {}): SegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSegmentation };
diff --git a/src/cv/small.ts b/src/cv/small.ts
new file mode 100644
index 000000000..ee5c5d1fc
--- /dev/null
+++ b/src/cv/small.ts
@@ -0,0 +1,15 @@
+/** Cv Small module — tsb analytics library. */
+export interface Cv smallOptions { tol?: number; maxIter?: number; }
+export interface Cv smallResult { values: number[]; converged: boolean; }
+export function computeCv small(data: number[], opts: Cv smallOptions = {}): Cv smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv small };
diff --git a/src/cv/sparse.ts b/src/cv/sparse.ts
new file mode 100644
index 000000000..2337b37f2
--- /dev/null
+++ b/src/cv/sparse.ts
@@ -0,0 +1,15 @@
+/** Cv Sparse module — tsb analytics library. */
+export interface Cv sparseOptions { tol?: number; maxIter?: number; }
+export interface Cv sparseResult { values: number[]; converged: boolean; }
+export function computeCv sparse(data: number[], opts: Cv sparseOptions = {}): Cv sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv sparse };
diff --git a/src/cv/stable.ts b/src/cv/stable.ts
new file mode 100644
index 000000000..98297567f
--- /dev/null
+++ b/src/cv/stable.ts
@@ -0,0 +1,15 @@
+/** Cv Stable module — tsb analytics library. */
+export interface Cv stableOptions { tol?: number; maxIter?: number; }
+export interface Cv stableResult { values: number[]; converged: boolean; }
+export function computeCv stable(data: number[], opts: Cv stableOptions = {}): Cv stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv stable };
diff --git a/src/cv/stereo.ts b/src/cv/stereo.ts
new file mode 100644
index 000000000..ba22328c1
--- /dev/null
+++ b/src/cv/stereo.ts
@@ -0,0 +1,22 @@
+/** Stereo module — tsb analytics library. */
+
+/** Options for Stereo. */
+export interface StereoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stereo. */
+export interface StereoResult { values: number[]; converged: boolean; }
+
+/** Compute Stereo. */
+export function computeStereo(data: number[], opts: StereoOptions = {}): StereoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStereo };
diff --git a/src/cv/streaming.ts b/src/cv/streaming.ts
new file mode 100644
index 000000000..b78e210ac
--- /dev/null
+++ b/src/cv/streaming.ts
@@ -0,0 +1,15 @@
+/** Cv Streaming module — tsb analytics library. */
+export interface Cv streamingOptions { tol?: number; maxIter?: number; }
+export interface Cv streamingResult { values: number[]; converged: boolean; }
+export function computeCv streaming(data: number[], opts: Cv streamingOptions = {}): Cv streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv streaming };
diff --git a/src/cv/style_transfer.ts b/src/cv/style_transfer.ts
new file mode 100644
index 000000000..11a2961b1
--- /dev/null
+++ b/src/cv/style_transfer.ts
@@ -0,0 +1,22 @@
+/** Style Transfer module — tsb analytics library. */
+
+/** Options for Style Transfer. */
+export interface StyleTransferOptions { tol?: number; maxIter?: number; }
+
+/** Result from Style Transfer. */
+export interface StyleTransferResult { values: number[]; converged: boolean; }
+
+/** Compute Style Transfer. */
+export function computeStyleTransfer(data: number[], opts: StyleTransferOptions = {}): StyleTransferResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStyleTransfer };
diff --git a/src/cv/super_resolution.ts b/src/cv/super_resolution.ts
new file mode 100644
index 000000000..8ca861225
--- /dev/null
+++ b/src/cv/super_resolution.ts
@@ -0,0 +1,22 @@
+/** Super Resolution module — tsb analytics library. */
+
+/** Options for Super Resolution. */
+export interface SuperResolutionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Super Resolution. */
+export interface SuperResolutionResult { values: number[]; converged: boolean; }
+
+/** Compute Super Resolution. */
+export function computeSuperResolution(data: number[], opts: SuperResolutionOptions = {}): SuperResolutionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSuperResolution };
diff --git a/src/cv/tracking.ts b/src/cv/tracking.ts
new file mode 100644
index 000000000..2e7304b5f
--- /dev/null
+++ b/src/cv/tracking.ts
@@ -0,0 +1,22 @@
+/** Tracking module — tsb analytics library. */
+
+/** Options for Tracking. */
+export interface TrackingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tracking. */
+export interface TrackingResult { values: number[]; converged: boolean; }
+
+/** Compute Tracking. */
+export function computeTracking(data: number[], opts: TrackingOptions = {}): TrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTracking };
diff --git a/src/cv/v2.ts b/src/cv/v2.ts
new file mode 100644
index 000000000..2d5f72087
--- /dev/null
+++ b/src/cv/v2.ts
@@ -0,0 +1,15 @@
+/** Cv V2 module — tsb analytics library. */
+export interface Cv v2Options { tol?: number; maxIter?: number; }
+export interface Cv v2Result { values: number[]; converged: boolean; }
+export function computeCv v2(data: number[], opts: Cv v2Options = {}): Cv v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv v2 };
diff --git a/src/cv/v3.ts b/src/cv/v3.ts
new file mode 100644
index 000000000..385b81966
--- /dev/null
+++ b/src/cv/v3.ts
@@ -0,0 +1,15 @@
+/** Cv V3 module — tsb analytics library. */
+export interface Cv v3Options { tol?: number; maxIter?: number; }
+export interface Cv v3Result { values: number[]; converged: boolean; }
+export function computeCv v3(data: number[], opts: Cv v3Options = {}): Cv v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv v3 };
diff --git a/src/cv/vae.ts b/src/cv/vae.ts
new file mode 100644
index 000000000..c763968dc
--- /dev/null
+++ b/src/cv/vae.ts
@@ -0,0 +1,22 @@
+/** Vae module — tsb analytics library. */
+
+/** Options for Vae. */
+export interface VaeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vae. */
+export interface VaeResult { values: number[]; converged: boolean; }
+
+/** Compute Vae. */
+export function computeVae(data: number[], opts: VaeOptions = {}): VaeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVae };
diff --git a/src/cv/verification.ts b/src/cv/verification.ts
new file mode 100644
index 000000000..327fedec0
--- /dev/null
+++ b/src/cv/verification.ts
@@ -0,0 +1,22 @@
+/** Verification module — tsb analytics library. */
+
+/** Options for Verification. */
+export interface VerificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Verification. */
+export interface VerificationResult { values: number[]; converged: boolean; }
+
+/** Compute Verification. */
+export function computeVerification(data: number[], opts: VerificationOptions = {}): VerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVerification };
diff --git a/src/cv/vqa.ts b/src/cv/vqa.ts
new file mode 100644
index 000000000..5ce2b61d2
--- /dev/null
+++ b/src/cv/vqa.ts
@@ -0,0 +1,22 @@
+/** Vqa module — tsb analytics library. */
+
+/** Options for Vqa. */
+export interface VqaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vqa. */
+export interface VqaResult { values: number[]; converged: boolean; }
+
+/** Compute Vqa. */
+export function computeVqa(data: number[], opts: VqaOptions = {}): VqaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVqa };
diff --git a/src/cv/wasm.ts b/src/cv/wasm.ts
new file mode 100644
index 000000000..f0599abd2
--- /dev/null
+++ b/src/cv/wasm.ts
@@ -0,0 +1,15 @@
+/** Cv Wasm module — tsb analytics library. */
+export interface Cv wasmOptions { tol?: number; maxIter?: number; }
+export interface Cv wasmResult { values: number[]; converged: boolean; }
+export function computeCv wasm(data: number[], opts: Cv wasmOptions = {}): Cv wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv wasm };
diff --git a/src/cv/xlarge.ts b/src/cv/xlarge.ts
new file mode 100644
index 000000000..ecf72bba7
--- /dev/null
+++ b/src/cv/xlarge.ts
@@ -0,0 +1,15 @@
+/** Cv Xlarge module — tsb analytics library. */
+export interface Cv xlargeOptions { tol?: number; maxIter?: number; }
+export interface Cv xlargeResult { values: number[]; converged: boolean; }
+export function computeCv xlarge(data: number[], opts: Cv xlargeOptions = {}): Cv xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeCv xlarge };
diff --git a/src/dark_energy_sci/adaptation.ts b/src/dark_energy_sci/adaptation.ts
new file mode 100644
index 000000000..56c5920b1
--- /dev/null
+++ b/src/dark_energy_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci adaptation module — tsb analytics library. */
+export interface DarkEnergySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciAdaptation(data: number[], opts: DarkEnergySciAdaptationOptions = {}): DarkEnergySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciAdaptation };
diff --git a/src/dark_energy_sci/aggregation.ts b/src/dark_energy_sci/aggregation.ts
new file mode 100644
index 000000000..7cc1c59a8
--- /dev/null
+++ b/src/dark_energy_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci aggregation module — tsb analytics library. */
+export interface DarkEnergySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciAggregationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciAggregation(data: number[], opts: DarkEnergySciAggregationOptions = {}): DarkEnergySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciAggregation };
diff --git a/src/dark_energy_sci/algebra.ts b/src/dark_energy_sci/algebra.ts
new file mode 100644
index 000000000..7d3e2ec47
--- /dev/null
+++ b/src/dark_energy_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci algebra module — tsb analytics library. */
+export interface DarkEnergySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciAlgebra(data: number[], opts: DarkEnergySciAlgebraOptions = {}): DarkEnergySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciAlgebra };
diff --git a/src/dark_energy_sci/alignment.ts b/src/dark_energy_sci/alignment.ts
new file mode 100644
index 000000000..ff1ad2de8
--- /dev/null
+++ b/src/dark_energy_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci alignment module — tsb analytics library. */
+export interface DarkEnergySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciAlignment(data: number[], opts: DarkEnergySciAlignmentOptions = {}): DarkEnergySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciAlignment };
diff --git a/src/dark_energy_sci/analysis.ts b/src/dark_energy_sci/analysis.ts
new file mode 100644
index 000000000..b4183b872
--- /dev/null
+++ b/src/dark_energy_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci analysis module — tsb analytics library. */
+export interface DarkEnergySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciAnalysis(data: number[], opts: DarkEnergySciAnalysisOptions = {}): DarkEnergySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciAnalysis };
diff --git a/src/dark_energy_sci/augmentation.ts b/src/dark_energy_sci/augmentation.ts
new file mode 100644
index 000000000..70b170268
--- /dev/null
+++ b/src/dark_energy_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci augmentation module — tsb analytics library. */
+export interface DarkEnergySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciAugmentation(data: number[], opts: DarkEnergySciAugmentationOptions = {}): DarkEnergySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciAugmentation };
diff --git a/src/dark_energy_sci/bagging.ts b/src/dark_energy_sci/bagging.ts
new file mode 100644
index 000000000..25964cad6
--- /dev/null
+++ b/src/dark_energy_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci bagging module — tsb analytics library. */
+export interface DarkEnergySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciBaggingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciBagging(data: number[], opts: DarkEnergySciBaggingOptions = {}): DarkEnergySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciBagging };
diff --git a/src/dark_energy_sci/basis.ts b/src/dark_energy_sci/basis.ts
new file mode 100644
index 000000000..ad570c33a
--- /dev/null
+++ b/src/dark_energy_sci/basis.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci basis module — tsb analytics library. */
+export interface DarkEnergySciBasisOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciBasisResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciBasis(data: number[], opts: DarkEnergySciBasisOptions = {}): DarkEnergySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciBasis };
diff --git a/src/dark_energy_sci/benchmarking.ts b/src/dark_energy_sci/benchmarking.ts
new file mode 100644
index 000000000..ed4ef33ab
--- /dev/null
+++ b/src/dark_energy_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci benchmarking module — tsb analytics library. */
+export interface DarkEnergySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciBenchmarking(data: number[], opts: DarkEnergySciBenchmarkingOptions = {}): DarkEnergySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciBenchmarking };
diff --git a/src/dark_energy_sci/blending.ts b/src/dark_energy_sci/blending.ts
new file mode 100644
index 000000000..a92dbd7fc
--- /dev/null
+++ b/src/dark_energy_sci/blending.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci blending module — tsb analytics library. */
+export interface DarkEnergySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciBlendingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciBlending(data: number[], opts: DarkEnergySciBlendingOptions = {}): DarkEnergySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciBlending };
diff --git a/src/dark_energy_sci/boosting.ts b/src/dark_energy_sci/boosting.ts
new file mode 100644
index 000000000..97e6cd652
--- /dev/null
+++ b/src/dark_energy_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci boosting module — tsb analytics library. */
+export interface DarkEnergySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciBoostingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciBoosting(data: number[], opts: DarkEnergySciBoostingOptions = {}): DarkEnergySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciBoosting };
diff --git a/src/dark_energy_sci/bootstrap.ts b/src/dark_energy_sci/bootstrap.ts
new file mode 100644
index 000000000..761d4b098
--- /dev/null
+++ b/src/dark_energy_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci bootstrap module — tsb analytics library. */
+export interface DarkEnergySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciBootstrap(data: number[], opts: DarkEnergySciBootstrapOptions = {}): DarkEnergySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciBootstrap };
diff --git a/src/dark_energy_sci/calculus.ts b/src/dark_energy_sci/calculus.ts
new file mode 100644
index 000000000..70149b9dc
--- /dev/null
+++ b/src/dark_energy_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci calculus module — tsb analytics library. */
+export interface DarkEnergySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciCalculusResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciCalculus(data: number[], opts: DarkEnergySciCalculusOptions = {}): DarkEnergySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciCalculus };
diff --git a/src/dark_energy_sci/calibration.ts b/src/dark_energy_sci/calibration.ts
new file mode 100644
index 000000000..520dcb8ff
--- /dev/null
+++ b/src/dark_energy_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci calibration module — tsb analytics library. */
+export interface DarkEnergySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciCalibration(data: number[], opts: DarkEnergySciCalibrationOptions = {}): DarkEnergySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciCalibration };
diff --git a/src/dark_energy_sci/characterization.ts b/src/dark_energy_sci/characterization.ts
new file mode 100644
index 000000000..98142f9b1
--- /dev/null
+++ b/src/dark_energy_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci characterization module — tsb analytics library. */
+export interface DarkEnergySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciCharacterization(data: number[], opts: DarkEnergySciCharacterizationOptions = {}): DarkEnergySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciCharacterization };
diff --git a/src/dark_energy_sci/classification.ts b/src/dark_energy_sci/classification.ts
new file mode 100644
index 000000000..1b410fe9e
--- /dev/null
+++ b/src/dark_energy_sci/classification.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci classification module — tsb analytics library. */
+export interface DarkEnergySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciClassificationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciClassification(data: number[], opts: DarkEnergySciClassificationOptions = {}): DarkEnergySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciClassification };
diff --git a/src/dark_energy_sci/clustering.ts b/src/dark_energy_sci/clustering.ts
new file mode 100644
index 000000000..c99afc9a8
--- /dev/null
+++ b/src/dark_energy_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci clustering module — tsb analytics library. */
+export interface DarkEnergySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciClusteringResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciClustering(data: number[], opts: DarkEnergySciClusteringOptions = {}): DarkEnergySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciClustering };
diff --git a/src/dark_energy_sci/compression.ts b/src/dark_energy_sci/compression.ts
new file mode 100644
index 000000000..3b0c05f26
--- /dev/null
+++ b/src/dark_energy_sci/compression.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci compression module — tsb analytics library. */
+export interface DarkEnergySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciCompressionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciCompression(data: number[], opts: DarkEnergySciCompressionOptions = {}): DarkEnergySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciCompression };
diff --git a/src/dark_energy_sci/continuous.ts b/src/dark_energy_sci/continuous.ts
new file mode 100644
index 000000000..83d235ba9
--- /dev/null
+++ b/src/dark_energy_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci continuous module — tsb analytics library. */
+export interface DarkEnergySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciContinuousResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciContinuous(data: number[], opts: DarkEnergySciContinuousOptions = {}): DarkEnergySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciContinuous };
diff --git a/src/dark_energy_sci/control.ts b/src/dark_energy_sci/control.ts
new file mode 100644
index 000000000..aff808f57
--- /dev/null
+++ b/src/dark_energy_sci/control.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci control module — tsb analytics library. */
+export interface DarkEnergySciControlOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciControlResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciControl(data: number[], opts: DarkEnergySciControlOptions = {}): DarkEnergySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciControl };
diff --git a/src/dark_energy_sci/convergence.ts b/src/dark_energy_sci/convergence.ts
new file mode 100644
index 000000000..7331b1729
--- /dev/null
+++ b/src/dark_energy_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci convergence module — tsb analytics library. */
+export interface DarkEnergySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciConvergence(data: number[], opts: DarkEnergySciConvergenceOptions = {}): DarkEnergySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciConvergence };
diff --git a/src/dark_energy_sci/convex.ts b/src/dark_energy_sci/convex.ts
new file mode 100644
index 000000000..4db269637
--- /dev/null
+++ b/src/dark_energy_sci/convex.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci convex module — tsb analytics library. */
+export interface DarkEnergySciConvexOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciConvexResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciConvex(data: number[], opts: DarkEnergySciConvexOptions = {}): DarkEnergySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciConvex };
diff --git a/src/dark_energy_sci/correlation.ts b/src/dark_energy_sci/correlation.ts
new file mode 100644
index 000000000..0b7eeb147
--- /dev/null
+++ b/src/dark_energy_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci correlation module — tsb analytics library. */
+export interface DarkEnergySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciCorrelation(data: number[], opts: DarkEnergySciCorrelationOptions = {}): DarkEnergySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciCorrelation };
diff --git a/src/dark_energy_sci/covariance.ts b/src/dark_energy_sci/covariance.ts
new file mode 100644
index 000000000..1e05fac1b
--- /dev/null
+++ b/src/dark_energy_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci covariance module — tsb analytics library. */
+export interface DarkEnergySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciCovariance(data: number[], opts: DarkEnergySciCovarianceOptions = {}): DarkEnergySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciCovariance };
diff --git a/src/dark_energy_sci/cross_validation.ts b/src/dark_energy_sci/cross_validation.ts
new file mode 100644
index 000000000..7dec4f6e2
--- /dev/null
+++ b/src/dark_energy_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci cross_validation module — tsb analytics library. */
+export interface DarkEnergySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciCrossValidation(data: number[], opts: DarkEnergySciCrossValidationOptions = {}): DarkEnergySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciCrossValidation };
diff --git a/src/dark_energy_sci/decoding.ts b/src/dark_energy_sci/decoding.ts
new file mode 100644
index 000000000..408c1d3e9
--- /dev/null
+++ b/src/dark_energy_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci decoding module — tsb analytics library. */
+export interface DarkEnergySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDecodingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDecoding(data: number[], opts: DarkEnergySciDecodingOptions = {}): DarkEnergySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDecoding };
diff --git a/src/dark_energy_sci/decomposition.ts b/src/dark_energy_sci/decomposition.ts
new file mode 100644
index 000000000..c0f087df6
--- /dev/null
+++ b/src/dark_energy_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci decomposition module — tsb analytics library. */
+export interface DarkEnergySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDecomposition(data: number[], opts: DarkEnergySciDecompositionOptions = {}): DarkEnergySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDecomposition };
diff --git a/src/dark_energy_sci/detection.ts b/src/dark_energy_sci/detection.ts
new file mode 100644
index 000000000..492ba1c37
--- /dev/null
+++ b/src/dark_energy_sci/detection.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci detection module — tsb analytics library. */
+export interface DarkEnergySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDetectionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDetection(data: number[], opts: DarkEnergySciDetectionOptions = {}): DarkEnergySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDetection };
diff --git a/src/dark_energy_sci/deterministic.ts b/src/dark_energy_sci/deterministic.ts
new file mode 100644
index 000000000..70237add5
--- /dev/null
+++ b/src/dark_energy_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci deterministic module — tsb analytics library. */
+export interface DarkEnergySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDeterministic(data: number[], opts: DarkEnergySciDeterministicOptions = {}): DarkEnergySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDeterministic };
diff --git a/src/dark_energy_sci/diagnostics.ts b/src/dark_energy_sci/diagnostics.ts
new file mode 100644
index 000000000..89f0c32fe
--- /dev/null
+++ b/src/dark_energy_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci diagnostics module — tsb analytics library. */
+export interface DarkEnergySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDiagnostics(data: number[], opts: DarkEnergySciDiagnosticsOptions = {}): DarkEnergySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDiagnostics };
diff --git a/src/dark_energy_sci/differential.ts b/src/dark_energy_sci/differential.ts
new file mode 100644
index 000000000..93fabfd74
--- /dev/null
+++ b/src/dark_energy_sci/differential.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci differential module — tsb analytics library. */
+export interface DarkEnergySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDifferential(data: number[], opts: DarkEnergySciDifferentialOptions = {}): DarkEnergySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDifferential };
diff --git a/src/dark_energy_sci/discrete.ts b/src/dark_energy_sci/discrete.ts
new file mode 100644
index 000000000..f269fd120
--- /dev/null
+++ b/src/dark_energy_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci discrete module — tsb analytics library. */
+export interface DarkEnergySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDiscrete(data: number[], opts: DarkEnergySciDiscreteOptions = {}): DarkEnergySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDiscrete };
diff --git a/src/dark_energy_sci/distribution.ts b/src/dark_energy_sci/distribution.ts
new file mode 100644
index 000000000..a7efc43e3
--- /dev/null
+++ b/src/dark_energy_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci distribution module — tsb analytics library. */
+export interface DarkEnergySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDistributionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDistribution(data: number[], opts: DarkEnergySciDistributionOptions = {}): DarkEnergySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDistribution };
diff --git a/src/dark_energy_sci/dynamic.ts b/src/dark_energy_sci/dynamic.ts
new file mode 100644
index 000000000..a40e74324
--- /dev/null
+++ b/src/dark_energy_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci dynamic module — tsb analytics library. */
+export interface DarkEnergySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciDynamicResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciDynamic(data: number[], opts: DarkEnergySciDynamicOptions = {}): DarkEnergySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciDynamic };
diff --git a/src/dark_energy_sci/embedding.ts b/src/dark_energy_sci/embedding.ts
new file mode 100644
index 000000000..f9279b995
--- /dev/null
+++ b/src/dark_energy_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci embedding module — tsb analytics library. */
+export interface DarkEnergySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciEmbedding(data: number[], opts: DarkEnergySciEmbeddingOptions = {}): DarkEnergySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciEmbedding };
diff --git a/src/dark_energy_sci/encoding.ts b/src/dark_energy_sci/encoding.ts
new file mode 100644
index 000000000..0f4e17ce9
--- /dev/null
+++ b/src/dark_energy_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci encoding module — tsb analytics library. */
+export interface DarkEnergySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciEncodingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciEncoding(data: number[], opts: DarkEnergySciEncodingOptions = {}): DarkEnergySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciEncoding };
diff --git a/src/dark_energy_sci/ensemble.ts b/src/dark_energy_sci/ensemble.ts
new file mode 100644
index 000000000..a7b531471
--- /dev/null
+++ b/src/dark_energy_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci ensemble module — tsb analytics library. */
+export interface DarkEnergySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciEnsemble(data: number[], opts: DarkEnergySciEnsembleOptions = {}): DarkEnergySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciEnsemble };
diff --git a/src/dark_energy_sci/estimation.ts b/src/dark_energy_sci/estimation.ts
new file mode 100644
index 000000000..04bcb81a0
--- /dev/null
+++ b/src/dark_energy_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci estimation module — tsb analytics library. */
+export interface DarkEnergySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciEstimationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciEstimation(data: number[], opts: DarkEnergySciEstimationOptions = {}): DarkEnergySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciEstimation };
diff --git a/src/dark_energy_sci/evaluation.ts b/src/dark_energy_sci/evaluation.ts
new file mode 100644
index 000000000..194e82e5d
--- /dev/null
+++ b/src/dark_energy_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci evaluation module — tsb analytics library. */
+export interface DarkEnergySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciEvaluation(data: number[], opts: DarkEnergySciEvaluationOptions = {}): DarkEnergySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciEvaluation };
diff --git a/src/dark_energy_sci/extrapolation.ts b/src/dark_energy_sci/extrapolation.ts
new file mode 100644
index 000000000..33f54ae0b
--- /dev/null
+++ b/src/dark_energy_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci extrapolation module — tsb analytics library. */
+export interface DarkEnergySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciExtrapolation(data: number[], opts: DarkEnergySciExtrapolationOptions = {}): DarkEnergySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciExtrapolation };
diff --git a/src/dark_energy_sci/features.ts b/src/dark_energy_sci/features.ts
new file mode 100644
index 000000000..db7dd4d94
--- /dev/null
+++ b/src/dark_energy_sci/features.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci features module — tsb analytics library. */
+export interface DarkEnergySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciFeatures(data: number[], opts: DarkEnergySciFeaturesOptions = {}): DarkEnergySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciFeatures };
diff --git a/src/dark_energy_sci/feedback.ts b/src/dark_energy_sci/feedback.ts
new file mode 100644
index 000000000..9586315aa
--- /dev/null
+++ b/src/dark_energy_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci feedback module — tsb analytics library. */
+export interface DarkEnergySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciFeedback(data: number[], opts: DarkEnergySciFeedbackOptions = {}): DarkEnergySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciFeedback };
diff --git a/src/dark_energy_sci/filtering.ts b/src/dark_energy_sci/filtering.ts
new file mode 100644
index 000000000..229d90867
--- /dev/null
+++ b/src/dark_energy_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci filtering module — tsb analytics library. */
+export interface DarkEnergySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciFilteringResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciFiltering(data: number[], opts: DarkEnergySciFilteringOptions = {}): DarkEnergySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciFiltering };
diff --git a/src/dark_energy_sci/fourier.ts b/src/dark_energy_sci/fourier.ts
new file mode 100644
index 000000000..90a822848
--- /dev/null
+++ b/src/dark_energy_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci fourier module — tsb analytics library. */
+export interface DarkEnergySciFourierOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciFourierResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciFourier(data: number[], opts: DarkEnergySciFourierOptions = {}): DarkEnergySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciFourier };
diff --git a/src/dark_energy_sci/fusion.ts b/src/dark_energy_sci/fusion.ts
new file mode 100644
index 000000000..73a32495a
--- /dev/null
+++ b/src/dark_energy_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci fusion module — tsb analytics library. */
+export interface DarkEnergySciFusionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciFusionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciFusion(data: number[], opts: DarkEnergySciFusionOptions = {}): DarkEnergySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciFusion };
diff --git a/src/dark_energy_sci/generation.ts b/src/dark_energy_sci/generation.ts
new file mode 100644
index 000000000..35b6b8c7e
--- /dev/null
+++ b/src/dark_energy_sci/generation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci generation module — tsb analytics library. */
+export interface DarkEnergySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciGenerationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciGeneration(data: number[], opts: DarkEnergySciGenerationOptions = {}): DarkEnergySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciGeneration };
diff --git a/src/dark_energy_sci/geometry.ts b/src/dark_energy_sci/geometry.ts
new file mode 100644
index 000000000..cfc35ac05
--- /dev/null
+++ b/src/dark_energy_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci geometry module — tsb analytics library. */
+export interface DarkEnergySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciGeometryResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciGeometry(data: number[], opts: DarkEnergySciGeometryOptions = {}): DarkEnergySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciGeometry };
diff --git a/src/dark_energy_sci/gradient.ts b/src/dark_energy_sci/gradient.ts
new file mode 100644
index 000000000..9983fa610
--- /dev/null
+++ b/src/dark_energy_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci gradient module — tsb analytics library. */
+export interface DarkEnergySciGradientOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciGradientResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciGradient(data: number[], opts: DarkEnergySciGradientOptions = {}): DarkEnergySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciGradient };
diff --git a/src/dark_energy_sci/hessian.ts b/src/dark_energy_sci/hessian.ts
new file mode 100644
index 000000000..180f719ba
--- /dev/null
+++ b/src/dark_energy_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci hessian module — tsb analytics library. */
+export interface DarkEnergySciHessianOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciHessianResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciHessian(data: number[], opts: DarkEnergySciHessianOptions = {}): DarkEnergySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciHessian };
diff --git a/src/dark_energy_sci/hypothesis.ts b/src/dark_energy_sci/hypothesis.ts
new file mode 100644
index 000000000..e0300a10c
--- /dev/null
+++ b/src/dark_energy_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci hypothesis module — tsb analytics library. */
+export interface DarkEnergySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciHypothesis(data: number[], opts: DarkEnergySciHypothesisOptions = {}): DarkEnergySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciHypothesis };
diff --git a/src/dark_energy_sci/inference.ts b/src/dark_energy_sci/inference.ts
new file mode 100644
index 000000000..234056477
--- /dev/null
+++ b/src/dark_energy_sci/inference.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci inference module — tsb analytics library. */
+export interface DarkEnergySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciInferenceResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciInference(data: number[], opts: DarkEnergySciInferenceOptions = {}): DarkEnergySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciInference };
diff --git a/src/dark_energy_sci/inference2.ts b/src/dark_energy_sci/inference2.ts
new file mode 100644
index 000000000..c85504a71
--- /dev/null
+++ b/src/dark_energy_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci inference2 module — tsb analytics library. */
+export interface DarkEnergySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciInferenceResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciInference(data: number[], opts: DarkEnergySciInferenceOptions = {}): DarkEnergySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciInference };
diff --git a/src/dark_energy_sci/integral.ts b/src/dark_energy_sci/integral.ts
new file mode 100644
index 000000000..0cf3d00e4
--- /dev/null
+++ b/src/dark_energy_sci/integral.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci integral module — tsb analytics library. */
+export interface DarkEnergySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciIntegralResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciIntegral(data: number[], opts: DarkEnergySciIntegralOptions = {}): DarkEnergySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciIntegral };
diff --git a/src/dark_energy_sci/integration.ts b/src/dark_energy_sci/integration.ts
new file mode 100644
index 000000000..a513dca7f
--- /dev/null
+++ b/src/dark_energy_sci/integration.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci integration module — tsb analytics library. */
+export interface DarkEnergySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciIntegration(data: number[], opts: DarkEnergySciIntegrationOptions = {}): DarkEnergySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciIntegration };
diff --git a/src/dark_energy_sci/interpolation.ts b/src/dark_energy_sci/interpolation.ts
new file mode 100644
index 000000000..ed8eb8ee6
--- /dev/null
+++ b/src/dark_energy_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci interpolation module — tsb analytics library. */
+export interface DarkEnergySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciInterpolation(data: number[], opts: DarkEnergySciInterpolationOptions = {}): DarkEnergySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciInterpolation };
diff --git a/src/dark_energy_sci/jacobian.ts b/src/dark_energy_sci/jacobian.ts
new file mode 100644
index 000000000..9432a3a40
--- /dev/null
+++ b/src/dark_energy_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci jacobian module — tsb analytics library. */
+export interface DarkEnergySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciJacobianResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciJacobian(data: number[], opts: DarkEnergySciJacobianOptions = {}): DarkEnergySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciJacobian };
diff --git a/src/dark_energy_sci/kernel.ts b/src/dark_energy_sci/kernel.ts
new file mode 100644
index 000000000..2c5a06e4c
--- /dev/null
+++ b/src/dark_energy_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci kernel module — tsb analytics library. */
+export interface DarkEnergySciKernelOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciKernelResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciKernel(data: number[], opts: DarkEnergySciKernelOptions = {}): DarkEnergySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciKernel };
diff --git a/src/dark_energy_sci/laplacian.ts b/src/dark_energy_sci/laplacian.ts
new file mode 100644
index 000000000..355352610
--- /dev/null
+++ b/src/dark_energy_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci laplacian module — tsb analytics library. */
+export interface DarkEnergySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciLaplacian(data: number[], opts: DarkEnergySciLaplacianOptions = {}): DarkEnergySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciLaplacian };
diff --git a/src/dark_energy_sci/learning.ts b/src/dark_energy_sci/learning.ts
new file mode 100644
index 000000000..44c3a6718
--- /dev/null
+++ b/src/dark_energy_sci/learning.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci learning module — tsb analytics library. */
+export interface DarkEnergySciLearningOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciLearningResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciLearning(data: number[], opts: DarkEnergySciLearningOptions = {}): DarkEnergySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciLearning };
diff --git a/src/dark_energy_sci/linear.ts b/src/dark_energy_sci/linear.ts
new file mode 100644
index 000000000..4d69ad4d5
--- /dev/null
+++ b/src/dark_energy_sci/linear.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci linear module — tsb analytics library. */
+export interface DarkEnergySciLinearOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciLinearResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciLinear(data: number[], opts: DarkEnergySciLinearOptions = {}): DarkEnergySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciLinear };
diff --git a/src/dark_energy_sci/manifold.ts b/src/dark_energy_sci/manifold.ts
new file mode 100644
index 000000000..d7aab4e42
--- /dev/null
+++ b/src/dark_energy_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci manifold module — tsb analytics library. */
+export interface DarkEnergySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciManifoldResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciManifold(data: number[], opts: DarkEnergySciManifoldOptions = {}): DarkEnergySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciManifold };
diff --git a/src/dark_energy_sci/matching.ts b/src/dark_energy_sci/matching.ts
new file mode 100644
index 000000000..0f9bcad89
--- /dev/null
+++ b/src/dark_energy_sci/matching.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci matching module — tsb analytics library. */
+export interface DarkEnergySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciMatchingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciMatching(data: number[], opts: DarkEnergySciMatchingOptions = {}): DarkEnergySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciMatching };
diff --git a/src/dark_energy_sci/measurement.ts b/src/dark_energy_sci/measurement.ts
new file mode 100644
index 000000000..dda85fb94
--- /dev/null
+++ b/src/dark_energy_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci measurement module — tsb analytics library. */
+export interface DarkEnergySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciMeasurement(data: number[], opts: DarkEnergySciMeasurementOptions = {}): DarkEnergySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciMeasurement };
diff --git a/src/dark_energy_sci/metrics.ts b/src/dark_energy_sci/metrics.ts
new file mode 100644
index 000000000..cb21b18e2
--- /dev/null
+++ b/src/dark_energy_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci metrics module — tsb analytics library. */
+export interface DarkEnergySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciMetricsResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciMetrics(data: number[], opts: DarkEnergySciMetricsOptions = {}): DarkEnergySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciMetrics };
diff --git a/src/dark_energy_sci/modeling.ts b/src/dark_energy_sci/modeling.ts
new file mode 100644
index 000000000..288bbe2c3
--- /dev/null
+++ b/src/dark_energy_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci modeling module — tsb analytics library. */
+export interface DarkEnergySciModelingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciModelingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciModeling(data: number[], opts: DarkEnergySciModelingOptions = {}): DarkEnergySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciModeling };
diff --git a/src/dark_energy_sci/monitoring.ts b/src/dark_energy_sci/monitoring.ts
new file mode 100644
index 000000000..e9a29c287
--- /dev/null
+++ b/src/dark_energy_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci monitoring module — tsb analytics library. */
+export interface DarkEnergySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciMonitoring(data: number[], opts: DarkEnergySciMonitoringOptions = {}): DarkEnergySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciMonitoring };
diff --git a/src/dark_energy_sci/nonlinear.ts b/src/dark_energy_sci/nonlinear.ts
new file mode 100644
index 000000000..7e560fef5
--- /dev/null
+++ b/src/dark_energy_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci nonlinear module — tsb analytics library. */
+export interface DarkEnergySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciNonlinear(data: number[], opts: DarkEnergySciNonlinearOptions = {}): DarkEnergySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciNonlinear };
diff --git a/src/dark_energy_sci/normalization.ts b/src/dark_energy_sci/normalization.ts
new file mode 100644
index 000000000..1ef9a6690
--- /dev/null
+++ b/src/dark_energy_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci normalization module — tsb analytics library. */
+export interface DarkEnergySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciNormalization(data: number[], opts: DarkEnergySciNormalizationOptions = {}): DarkEnergySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciNormalization };
diff --git a/src/dark_energy_sci/optimization.ts b/src/dark_energy_sci/optimization.ts
new file mode 100644
index 000000000..4529ad04e
--- /dev/null
+++ b/src/dark_energy_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci optimization module — tsb analytics library. */
+export interface DarkEnergySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciOptimization(data: number[], opts: DarkEnergySciOptimizationOptions = {}): DarkEnergySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciOptimization };
diff --git a/src/dark_energy_sci/patterns.ts b/src/dark_energy_sci/patterns.ts
new file mode 100644
index 000000000..5bf0b55e1
--- /dev/null
+++ b/src/dark_energy_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci patterns module — tsb analytics library. */
+export interface DarkEnergySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciPatternsResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciPatterns(data: number[], opts: DarkEnergySciPatternsOptions = {}): DarkEnergySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciPatterns };
diff --git a/src/dark_energy_sci/permutation.ts b/src/dark_energy_sci/permutation.ts
new file mode 100644
index 000000000..654c30e21
--- /dev/null
+++ b/src/dark_energy_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci permutation module — tsb analytics library. */
+export interface DarkEnergySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciPermutationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciPermutation(data: number[], opts: DarkEnergySciPermutationOptions = {}): DarkEnergySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciPermutation };
diff --git a/src/dark_energy_sci/prediction.ts b/src/dark_energy_sci/prediction.ts
new file mode 100644
index 000000000..9a6a933dd
--- /dev/null
+++ b/src/dark_energy_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci prediction module — tsb analytics library. */
+export interface DarkEnergySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciPredictionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciPrediction(data: number[], opts: DarkEnergySciPredictionOptions = {}): DarkEnergySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciPrediction };
diff --git a/src/dark_energy_sci/processing.ts b/src/dark_energy_sci/processing.ts
new file mode 100644
index 000000000..0e5780a80
--- /dev/null
+++ b/src/dark_energy_sci/processing.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci processing module — tsb analytics library. */
+export interface DarkEnergySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciProcessingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciProcessing(data: number[], opts: DarkEnergySciProcessingOptions = {}): DarkEnergySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciProcessing };
diff --git a/src/dark_energy_sci/profiling.ts b/src/dark_energy_sci/profiling.ts
new file mode 100644
index 000000000..0f0123e52
--- /dev/null
+++ b/src/dark_energy_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci profiling module — tsb analytics library. */
+export interface DarkEnergySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciProfilingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciProfiling(data: number[], opts: DarkEnergySciProfilingOptions = {}): DarkEnergySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciProfiling };
diff --git a/src/dark_energy_sci/projection.ts b/src/dark_energy_sci/projection.ts
new file mode 100644
index 000000000..38b6ed681
--- /dev/null
+++ b/src/dark_energy_sci/projection.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci projection module — tsb analytics library. */
+export interface DarkEnergySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciProjectionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciProjection(data: number[], opts: DarkEnergySciProjectionOptions = {}): DarkEnergySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciProjection };
diff --git a/src/dark_energy_sci/ranking.ts b/src/dark_energy_sci/ranking.ts
new file mode 100644
index 000000000..9940f45b7
--- /dev/null
+++ b/src/dark_energy_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci ranking module — tsb analytics library. */
+export interface DarkEnergySciRankingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciRankingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciRanking(data: number[], opts: DarkEnergySciRankingOptions = {}): DarkEnergySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciRanking };
diff --git a/src/dark_energy_sci/reconstruction.ts b/src/dark_energy_sci/reconstruction.ts
new file mode 100644
index 000000000..2d1195d68
--- /dev/null
+++ b/src/dark_energy_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci reconstruction module — tsb analytics library. */
+export interface DarkEnergySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciReconstruction(data: number[], opts: DarkEnergySciReconstructionOptions = {}): DarkEnergySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciReconstruction };
diff --git a/src/dark_energy_sci/registration.ts b/src/dark_energy_sci/registration.ts
new file mode 100644
index 000000000..ebc01cd10
--- /dev/null
+++ b/src/dark_energy_sci/registration.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci registration module — tsb analytics library. */
+export interface DarkEnergySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciRegistration(data: number[], opts: DarkEnergySciRegistrationOptions = {}): DarkEnergySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciRegistration };
diff --git a/src/dark_energy_sci/regression.ts b/src/dark_energy_sci/regression.ts
new file mode 100644
index 000000000..57c454e76
--- /dev/null
+++ b/src/dark_energy_sci/regression.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci regression module — tsb analytics library. */
+export interface DarkEnergySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciRegressionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciRegression(data: number[], opts: DarkEnergySciRegressionOptions = {}): DarkEnergySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciRegression };
diff --git a/src/dark_energy_sci/regularization.ts b/src/dark_energy_sci/regularization.ts
new file mode 100644
index 000000000..0a3ebb8c3
--- /dev/null
+++ b/src/dark_energy_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci regularization module — tsb analytics library. */
+export interface DarkEnergySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciRegularization(data: number[], opts: DarkEnergySciRegularizationOptions = {}): DarkEnergySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciRegularization };
diff --git a/src/dark_energy_sci/robustness.ts b/src/dark_energy_sci/robustness.ts
new file mode 100644
index 000000000..c6b8b95ac
--- /dev/null
+++ b/src/dark_energy_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci robustness module — tsb analytics library. */
+export interface DarkEnergySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciRobustness(data: number[], opts: DarkEnergySciRobustnessOptions = {}): DarkEnergySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciRobustness };
diff --git a/src/dark_energy_sci/sampling.ts b/src/dark_energy_sci/sampling.ts
new file mode 100644
index 000000000..c30ce0369
--- /dev/null
+++ b/src/dark_energy_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci sampling module — tsb analytics library. */
+export interface DarkEnergySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciSamplingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciSampling(data: number[], opts: DarkEnergySciSamplingOptions = {}): DarkEnergySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciSampling };
diff --git a/src/dark_energy_sci/sampling2.ts b/src/dark_energy_sci/sampling2.ts
new file mode 100644
index 000000000..8c4cdda0a
--- /dev/null
+++ b/src/dark_energy_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci sampling2 module — tsb analytics library. */
+export interface DarkEnergySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciSamplingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciSampling(data: number[], opts: DarkEnergySciSamplingOptions = {}): DarkEnergySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciSampling };
diff --git a/src/dark_energy_sci/scaling.ts b/src/dark_energy_sci/scaling.ts
new file mode 100644
index 000000000..7a2a58933
--- /dev/null
+++ b/src/dark_energy_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci scaling module — tsb analytics library. */
+export interface DarkEnergySciScalingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciScalingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciScaling(data: number[], opts: DarkEnergySciScalingOptions = {}): DarkEnergySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciScaling };
diff --git a/src/dark_energy_sci/scoring.ts b/src/dark_energy_sci/scoring.ts
new file mode 100644
index 000000000..02dbd41e4
--- /dev/null
+++ b/src/dark_energy_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci scoring module — tsb analytics library. */
+export interface DarkEnergySciScoringOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciScoringResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciScoring(data: number[], opts: DarkEnergySciScoringOptions = {}): DarkEnergySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciScoring };
diff --git a/src/dark_energy_sci/segmentation.ts b/src/dark_energy_sci/segmentation.ts
new file mode 100644
index 000000000..cee333f9f
--- /dev/null
+++ b/src/dark_energy_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci segmentation module — tsb analytics library. */
+export interface DarkEnergySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciSegmentation(data: number[], opts: DarkEnergySciSegmentationOptions = {}): DarkEnergySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciSegmentation };
diff --git a/src/dark_energy_sci/selection.ts b/src/dark_energy_sci/selection.ts
new file mode 100644
index 000000000..cf45ef781
--- /dev/null
+++ b/src/dark_energy_sci/selection.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci selection module — tsb analytics library. */
+export interface DarkEnergySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciSelectionResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciSelection(data: number[], opts: DarkEnergySciSelectionOptions = {}): DarkEnergySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciSelection };
diff --git a/src/dark_energy_sci/sensitivity.ts b/src/dark_energy_sci/sensitivity.ts
new file mode 100644
index 000000000..7c73b3c08
--- /dev/null
+++ b/src/dark_energy_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci sensitivity module — tsb analytics library. */
+export interface DarkEnergySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciSensitivity(data: number[], opts: DarkEnergySciSensitivityOptions = {}): DarkEnergySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciSensitivity };
diff --git a/src/dark_energy_sci/simulation.ts b/src/dark_energy_sci/simulation.ts
new file mode 100644
index 000000000..4493ce6f5
--- /dev/null
+++ b/src/dark_energy_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci simulation module — tsb analytics library. */
+export interface DarkEnergySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciSimulationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciSimulation(data: number[], opts: DarkEnergySciSimulationOptions = {}): DarkEnergySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciSimulation };
diff --git a/src/dark_energy_sci/smoothing.ts b/src/dark_energy_sci/smoothing.ts
new file mode 100644
index 000000000..dd48aba82
--- /dev/null
+++ b/src/dark_energy_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci smoothing module — tsb analytics library. */
+export interface DarkEnergySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciSmoothing(data: number[], opts: DarkEnergySciSmoothingOptions = {}): DarkEnergySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciSmoothing };
diff --git a/src/dark_energy_sci/stability.ts b/src/dark_energy_sci/stability.ts
new file mode 100644
index 000000000..87de34860
--- /dev/null
+++ b/src/dark_energy_sci/stability.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci stability module — tsb analytics library. */
+export interface DarkEnergySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciStabilityResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciStability(data: number[], opts: DarkEnergySciStabilityOptions = {}): DarkEnergySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciStability };
diff --git a/src/dark_energy_sci/stacking.ts b/src/dark_energy_sci/stacking.ts
new file mode 100644
index 000000000..408e1d198
--- /dev/null
+++ b/src/dark_energy_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci stacking module — tsb analytics library. */
+export interface DarkEnergySciStackingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciStackingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciStacking(data: number[], opts: DarkEnergySciStackingOptions = {}): DarkEnergySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciStacking };
diff --git a/src/dark_energy_sci/standardization.ts b/src/dark_energy_sci/standardization.ts
new file mode 100644
index 000000000..022f9989d
--- /dev/null
+++ b/src/dark_energy_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci standardization module — tsb analytics library. */
+export interface DarkEnergySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciStandardization(data: number[], opts: DarkEnergySciStandardizationOptions = {}): DarkEnergySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciStandardization };
diff --git a/src/dark_energy_sci/static.ts b/src/dark_energy_sci/static.ts
new file mode 100644
index 000000000..f4521b75a
--- /dev/null
+++ b/src/dark_energy_sci/static.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci static module — tsb analytics library. */
+export interface DarkEnergySciStaticOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciStaticResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciStatic(data: number[], opts: DarkEnergySciStaticOptions = {}): DarkEnergySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciStatic };
diff --git a/src/dark_energy_sci/stochastic.ts b/src/dark_energy_sci/stochastic.ts
new file mode 100644
index 000000000..084eff670
--- /dev/null
+++ b/src/dark_energy_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci stochastic module — tsb analytics library. */
+export interface DarkEnergySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciStochasticResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciStochastic(data: number[], opts: DarkEnergySciStochasticOptions = {}): DarkEnergySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciStochastic };
diff --git a/src/dark_energy_sci/synthesis.ts b/src/dark_energy_sci/synthesis.ts
new file mode 100644
index 000000000..1d0d65b37
--- /dev/null
+++ b/src/dark_energy_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci synthesis module — tsb analytics library. */
+export interface DarkEnergySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciSynthesis(data: number[], opts: DarkEnergySciSynthesisOptions = {}): DarkEnergySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciSynthesis };
diff --git a/src/dark_energy_sci/topology.ts b/src/dark_energy_sci/topology.ts
new file mode 100644
index 000000000..58f131354
--- /dev/null
+++ b/src/dark_energy_sci/topology.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci topology module — tsb analytics library. */
+export interface DarkEnergySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciTopologyResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciTopology(data: number[], opts: DarkEnergySciTopologyOptions = {}): DarkEnergySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciTopology };
diff --git a/src/dark_energy_sci/tracking.ts b/src/dark_energy_sci/tracking.ts
new file mode 100644
index 000000000..3a7dc963e
--- /dev/null
+++ b/src/dark_energy_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci tracking module — tsb analytics library. */
+export interface DarkEnergySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciTrackingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciTracking(data: number[], opts: DarkEnergySciTrackingOptions = {}): DarkEnergySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciTracking };
diff --git a/src/dark_energy_sci/transform.ts b/src/dark_energy_sci/transform.ts
new file mode 100644
index 000000000..212895cd7
--- /dev/null
+++ b/src/dark_energy_sci/transform.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci transform module — tsb analytics library. */
+export interface DarkEnergySciTransformOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciTransformResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciTransform(data: number[], opts: DarkEnergySciTransformOptions = {}): DarkEnergySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciTransform };
diff --git a/src/dark_energy_sci/uncertainty.ts b/src/dark_energy_sci/uncertainty.ts
new file mode 100644
index 000000000..866822a00
--- /dev/null
+++ b/src/dark_energy_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci uncertainty module — tsb analytics library. */
+export interface DarkEnergySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciUncertainty(data: number[], opts: DarkEnergySciUncertaintyOptions = {}): DarkEnergySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciUncertainty };
diff --git a/src/dark_energy_sci/validation.ts b/src/dark_energy_sci/validation.ts
new file mode 100644
index 000000000..ba567960a
--- /dev/null
+++ b/src/dark_energy_sci/validation.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci validation module — tsb analytics library. */
+export interface DarkEnergySciValidationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciValidationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciValidation(data: number[], opts: DarkEnergySciValidationOptions = {}): DarkEnergySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciValidation };
diff --git a/src/dark_energy_sci/verification.ts b/src/dark_energy_sci/verification.ts
new file mode 100644
index 000000000..65a0263ba
--- /dev/null
+++ b/src/dark_energy_sci/verification.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci verification module — tsb analytics library. */
+export interface DarkEnergySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciVerificationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciVerification(data: number[], opts: DarkEnergySciVerificationOptions = {}): DarkEnergySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciVerification };
diff --git a/src/dark_energy_sci/visualization.ts b/src/dark_energy_sci/visualization.ts
new file mode 100644
index 000000000..09b44034c
--- /dev/null
+++ b/src/dark_energy_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci visualization module — tsb analytics library. */
+export interface DarkEnergySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciVisualization(data: number[], opts: DarkEnergySciVisualizationOptions = {}): DarkEnergySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciVisualization };
diff --git a/src/dark_energy_sci/voting.ts b/src/dark_energy_sci/voting.ts
new file mode 100644
index 000000000..1f75a3ee3
--- /dev/null
+++ b/src/dark_energy_sci/voting.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci voting module — tsb analytics library. */
+export interface DarkEnergySciVotingOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciVotingResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciVoting(data: number[], opts: DarkEnergySciVotingOptions = {}): DarkEnergySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciVoting };
diff --git a/src/dark_energy_sci/wavelet.ts b/src/dark_energy_sci/wavelet.ts
new file mode 100644
index 000000000..5f74f0dd0
--- /dev/null
+++ b/src/dark_energy_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** dark_energy_sci wavelet module — tsb analytics library. */
+export interface DarkEnergySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface DarkEnergySciWaveletResult { values: number[]; converged: boolean; }
+export function computeDarkEnergySciWavelet(data: number[], opts: DarkEnergySciWaveletOptions = {}): DarkEnergySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkEnergySciWavelet };
diff --git a/src/dark_matter_sci/adaptation.ts b/src/dark_matter_sci/adaptation.ts
new file mode 100644
index 000000000..83fa7bcb6
--- /dev/null
+++ b/src/dark_matter_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci adaptation module — tsb analytics library. */
+export interface DarkMatterSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciAdaptation(data: number[], opts: DarkMatterSciAdaptationOptions = {}): DarkMatterSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciAdaptation };
diff --git a/src/dark_matter_sci/aggregation.ts b/src/dark_matter_sci/aggregation.ts
new file mode 100644
index 000000000..899b839bd
--- /dev/null
+++ b/src/dark_matter_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci aggregation module — tsb analytics library. */
+export interface DarkMatterSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciAggregationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciAggregation(data: number[], opts: DarkMatterSciAggregationOptions = {}): DarkMatterSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciAggregation };
diff --git a/src/dark_matter_sci/algebra.ts b/src/dark_matter_sci/algebra.ts
new file mode 100644
index 000000000..d54bab1e6
--- /dev/null
+++ b/src/dark_matter_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci algebra module — tsb analytics library. */
+export interface DarkMatterSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciAlgebra(data: number[], opts: DarkMatterSciAlgebraOptions = {}): DarkMatterSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciAlgebra };
diff --git a/src/dark_matter_sci/alignment.ts b/src/dark_matter_sci/alignment.ts
new file mode 100644
index 000000000..54fec5387
--- /dev/null
+++ b/src/dark_matter_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci alignment module — tsb analytics library. */
+export interface DarkMatterSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciAlignment(data: number[], opts: DarkMatterSciAlignmentOptions = {}): DarkMatterSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciAlignment };
diff --git a/src/dark_matter_sci/analysis.ts b/src/dark_matter_sci/analysis.ts
new file mode 100644
index 000000000..330314dd6
--- /dev/null
+++ b/src/dark_matter_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci analysis module — tsb analytics library. */
+export interface DarkMatterSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciAnalysis(data: number[], opts: DarkMatterSciAnalysisOptions = {}): DarkMatterSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciAnalysis };
diff --git a/src/dark_matter_sci/augmentation.ts b/src/dark_matter_sci/augmentation.ts
new file mode 100644
index 000000000..7abfec059
--- /dev/null
+++ b/src/dark_matter_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci augmentation module — tsb analytics library. */
+export interface DarkMatterSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciAugmentation(data: number[], opts: DarkMatterSciAugmentationOptions = {}): DarkMatterSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciAugmentation };
diff --git a/src/dark_matter_sci/bagging.ts b/src/dark_matter_sci/bagging.ts
new file mode 100644
index 000000000..e9dd0ae43
--- /dev/null
+++ b/src/dark_matter_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci bagging module — tsb analytics library. */
+export interface DarkMatterSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciBaggingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciBagging(data: number[], opts: DarkMatterSciBaggingOptions = {}): DarkMatterSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciBagging };
diff --git a/src/dark_matter_sci/basis.ts b/src/dark_matter_sci/basis.ts
new file mode 100644
index 000000000..0681d29cf
--- /dev/null
+++ b/src/dark_matter_sci/basis.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci basis module — tsb analytics library. */
+export interface DarkMatterSciBasisOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciBasisResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciBasis(data: number[], opts: DarkMatterSciBasisOptions = {}): DarkMatterSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciBasis };
diff --git a/src/dark_matter_sci/benchmarking.ts b/src/dark_matter_sci/benchmarking.ts
new file mode 100644
index 000000000..acf9be479
--- /dev/null
+++ b/src/dark_matter_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci benchmarking module — tsb analytics library. */
+export interface DarkMatterSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciBenchmarking(data: number[], opts: DarkMatterSciBenchmarkingOptions = {}): DarkMatterSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciBenchmarking };
diff --git a/src/dark_matter_sci/blending.ts b/src/dark_matter_sci/blending.ts
new file mode 100644
index 000000000..d7c91dae2
--- /dev/null
+++ b/src/dark_matter_sci/blending.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci blending module — tsb analytics library. */
+export interface DarkMatterSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciBlendingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciBlending(data: number[], opts: DarkMatterSciBlendingOptions = {}): DarkMatterSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciBlending };
diff --git a/src/dark_matter_sci/boosting.ts b/src/dark_matter_sci/boosting.ts
new file mode 100644
index 000000000..5278bb669
--- /dev/null
+++ b/src/dark_matter_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci boosting module — tsb analytics library. */
+export interface DarkMatterSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciBoostingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciBoosting(data: number[], opts: DarkMatterSciBoostingOptions = {}): DarkMatterSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciBoosting };
diff --git a/src/dark_matter_sci/bootstrap.ts b/src/dark_matter_sci/bootstrap.ts
new file mode 100644
index 000000000..85099307a
--- /dev/null
+++ b/src/dark_matter_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci bootstrap module — tsb analytics library. */
+export interface DarkMatterSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciBootstrap(data: number[], opts: DarkMatterSciBootstrapOptions = {}): DarkMatterSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciBootstrap };
diff --git a/src/dark_matter_sci/calculus.ts b/src/dark_matter_sci/calculus.ts
new file mode 100644
index 000000000..714f313c7
--- /dev/null
+++ b/src/dark_matter_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci calculus module — tsb analytics library. */
+export interface DarkMatterSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciCalculusResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciCalculus(data: number[], opts: DarkMatterSciCalculusOptions = {}): DarkMatterSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciCalculus };
diff --git a/src/dark_matter_sci/calibration.ts b/src/dark_matter_sci/calibration.ts
new file mode 100644
index 000000000..55b7ea8f3
--- /dev/null
+++ b/src/dark_matter_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci calibration module — tsb analytics library. */
+export interface DarkMatterSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciCalibration(data: number[], opts: DarkMatterSciCalibrationOptions = {}): DarkMatterSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciCalibration };
diff --git a/src/dark_matter_sci/characterization.ts b/src/dark_matter_sci/characterization.ts
new file mode 100644
index 000000000..994586b2e
--- /dev/null
+++ b/src/dark_matter_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci characterization module — tsb analytics library. */
+export interface DarkMatterSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciCharacterization(data: number[], opts: DarkMatterSciCharacterizationOptions = {}): DarkMatterSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciCharacterization };
diff --git a/src/dark_matter_sci/classification.ts b/src/dark_matter_sci/classification.ts
new file mode 100644
index 000000000..e052bee1c
--- /dev/null
+++ b/src/dark_matter_sci/classification.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci classification module — tsb analytics library. */
+export interface DarkMatterSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciClassificationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciClassification(data: number[], opts: DarkMatterSciClassificationOptions = {}): DarkMatterSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciClassification };
diff --git a/src/dark_matter_sci/clustering.ts b/src/dark_matter_sci/clustering.ts
new file mode 100644
index 000000000..5241e8f1f
--- /dev/null
+++ b/src/dark_matter_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci clustering module — tsb analytics library. */
+export interface DarkMatterSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciClusteringResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciClustering(data: number[], opts: DarkMatterSciClusteringOptions = {}): DarkMatterSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciClustering };
diff --git a/src/dark_matter_sci/compression.ts b/src/dark_matter_sci/compression.ts
new file mode 100644
index 000000000..6b19262ac
--- /dev/null
+++ b/src/dark_matter_sci/compression.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci compression module — tsb analytics library. */
+export interface DarkMatterSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciCompressionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciCompression(data: number[], opts: DarkMatterSciCompressionOptions = {}): DarkMatterSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciCompression };
diff --git a/src/dark_matter_sci/continuous.ts b/src/dark_matter_sci/continuous.ts
new file mode 100644
index 000000000..e0dfea914
--- /dev/null
+++ b/src/dark_matter_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci continuous module — tsb analytics library. */
+export interface DarkMatterSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciContinuousResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciContinuous(data: number[], opts: DarkMatterSciContinuousOptions = {}): DarkMatterSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciContinuous };
diff --git a/src/dark_matter_sci/control.ts b/src/dark_matter_sci/control.ts
new file mode 100644
index 000000000..003ee6ae1
--- /dev/null
+++ b/src/dark_matter_sci/control.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci control module — tsb analytics library. */
+export interface DarkMatterSciControlOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciControlResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciControl(data: number[], opts: DarkMatterSciControlOptions = {}): DarkMatterSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciControl };
diff --git a/src/dark_matter_sci/convergence.ts b/src/dark_matter_sci/convergence.ts
new file mode 100644
index 000000000..0904be05d
--- /dev/null
+++ b/src/dark_matter_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci convergence module — tsb analytics library. */
+export interface DarkMatterSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciConvergence(data: number[], opts: DarkMatterSciConvergenceOptions = {}): DarkMatterSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciConvergence };
diff --git a/src/dark_matter_sci/convex.ts b/src/dark_matter_sci/convex.ts
new file mode 100644
index 000000000..59493cff1
--- /dev/null
+++ b/src/dark_matter_sci/convex.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci convex module — tsb analytics library. */
+export interface DarkMatterSciConvexOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciConvexResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciConvex(data: number[], opts: DarkMatterSciConvexOptions = {}): DarkMatterSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciConvex };
diff --git a/src/dark_matter_sci/correlation.ts b/src/dark_matter_sci/correlation.ts
new file mode 100644
index 000000000..42afc4d46
--- /dev/null
+++ b/src/dark_matter_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci correlation module — tsb analytics library. */
+export interface DarkMatterSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciCorrelation(data: number[], opts: DarkMatterSciCorrelationOptions = {}): DarkMatterSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciCorrelation };
diff --git a/src/dark_matter_sci/covariance.ts b/src/dark_matter_sci/covariance.ts
new file mode 100644
index 000000000..cfebe289b
--- /dev/null
+++ b/src/dark_matter_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci covariance module — tsb analytics library. */
+export interface DarkMatterSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciCovariance(data: number[], opts: DarkMatterSciCovarianceOptions = {}): DarkMatterSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciCovariance };
diff --git a/src/dark_matter_sci/cross_validation.ts b/src/dark_matter_sci/cross_validation.ts
new file mode 100644
index 000000000..4fdf8ffbc
--- /dev/null
+++ b/src/dark_matter_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci cross_validation module — tsb analytics library. */
+export interface DarkMatterSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciCrossValidation(data: number[], opts: DarkMatterSciCrossValidationOptions = {}): DarkMatterSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciCrossValidation };
diff --git a/src/dark_matter_sci/decoding.ts b/src/dark_matter_sci/decoding.ts
new file mode 100644
index 000000000..ef5d2a1d4
--- /dev/null
+++ b/src/dark_matter_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci decoding module — tsb analytics library. */
+export interface DarkMatterSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDecodingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDecoding(data: number[], opts: DarkMatterSciDecodingOptions = {}): DarkMatterSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDecoding };
diff --git a/src/dark_matter_sci/decomposition.ts b/src/dark_matter_sci/decomposition.ts
new file mode 100644
index 000000000..780419a00
--- /dev/null
+++ b/src/dark_matter_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci decomposition module — tsb analytics library. */
+export interface DarkMatterSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDecomposition(data: number[], opts: DarkMatterSciDecompositionOptions = {}): DarkMatterSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDecomposition };
diff --git a/src/dark_matter_sci/detection.ts b/src/dark_matter_sci/detection.ts
new file mode 100644
index 000000000..32f94eb2e
--- /dev/null
+++ b/src/dark_matter_sci/detection.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci detection module — tsb analytics library. */
+export interface DarkMatterSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDetectionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDetection(data: number[], opts: DarkMatterSciDetectionOptions = {}): DarkMatterSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDetection };
diff --git a/src/dark_matter_sci/deterministic.ts b/src/dark_matter_sci/deterministic.ts
new file mode 100644
index 000000000..0f952d922
--- /dev/null
+++ b/src/dark_matter_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci deterministic module — tsb analytics library. */
+export interface DarkMatterSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDeterministic(data: number[], opts: DarkMatterSciDeterministicOptions = {}): DarkMatterSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDeterministic };
diff --git a/src/dark_matter_sci/diagnostics.ts b/src/dark_matter_sci/diagnostics.ts
new file mode 100644
index 000000000..c27ed5238
--- /dev/null
+++ b/src/dark_matter_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci diagnostics module — tsb analytics library. */
+export interface DarkMatterSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDiagnostics(data: number[], opts: DarkMatterSciDiagnosticsOptions = {}): DarkMatterSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDiagnostics };
diff --git a/src/dark_matter_sci/differential.ts b/src/dark_matter_sci/differential.ts
new file mode 100644
index 000000000..78363b9d4
--- /dev/null
+++ b/src/dark_matter_sci/differential.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci differential module — tsb analytics library. */
+export interface DarkMatterSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDifferential(data: number[], opts: DarkMatterSciDifferentialOptions = {}): DarkMatterSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDifferential };
diff --git a/src/dark_matter_sci/discrete.ts b/src/dark_matter_sci/discrete.ts
new file mode 100644
index 000000000..4c4337e36
--- /dev/null
+++ b/src/dark_matter_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci discrete module — tsb analytics library. */
+export interface DarkMatterSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDiscrete(data: number[], opts: DarkMatterSciDiscreteOptions = {}): DarkMatterSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDiscrete };
diff --git a/src/dark_matter_sci/distribution.ts b/src/dark_matter_sci/distribution.ts
new file mode 100644
index 000000000..b2acd9185
--- /dev/null
+++ b/src/dark_matter_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci distribution module — tsb analytics library. */
+export interface DarkMatterSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDistributionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDistribution(data: number[], opts: DarkMatterSciDistributionOptions = {}): DarkMatterSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDistribution };
diff --git a/src/dark_matter_sci/dynamic.ts b/src/dark_matter_sci/dynamic.ts
new file mode 100644
index 000000000..c459828d0
--- /dev/null
+++ b/src/dark_matter_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci dynamic module — tsb analytics library. */
+export interface DarkMatterSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciDynamicResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciDynamic(data: number[], opts: DarkMatterSciDynamicOptions = {}): DarkMatterSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciDynamic };
diff --git a/src/dark_matter_sci/embedding.ts b/src/dark_matter_sci/embedding.ts
new file mode 100644
index 000000000..b7acb17e6
--- /dev/null
+++ b/src/dark_matter_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci embedding module — tsb analytics library. */
+export interface DarkMatterSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciEmbedding(data: number[], opts: DarkMatterSciEmbeddingOptions = {}): DarkMatterSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciEmbedding };
diff --git a/src/dark_matter_sci/encoding.ts b/src/dark_matter_sci/encoding.ts
new file mode 100644
index 000000000..53ca749f1
--- /dev/null
+++ b/src/dark_matter_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci encoding module — tsb analytics library. */
+export interface DarkMatterSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciEncodingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciEncoding(data: number[], opts: DarkMatterSciEncodingOptions = {}): DarkMatterSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciEncoding };
diff --git a/src/dark_matter_sci/ensemble.ts b/src/dark_matter_sci/ensemble.ts
new file mode 100644
index 000000000..1c124a4b6
--- /dev/null
+++ b/src/dark_matter_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci ensemble module — tsb analytics library. */
+export interface DarkMatterSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciEnsemble(data: number[], opts: DarkMatterSciEnsembleOptions = {}): DarkMatterSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciEnsemble };
diff --git a/src/dark_matter_sci/estimation.ts b/src/dark_matter_sci/estimation.ts
new file mode 100644
index 000000000..2699f875a
--- /dev/null
+++ b/src/dark_matter_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci estimation module — tsb analytics library. */
+export interface DarkMatterSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciEstimationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciEstimation(data: number[], opts: DarkMatterSciEstimationOptions = {}): DarkMatterSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciEstimation };
diff --git a/src/dark_matter_sci/evaluation.ts b/src/dark_matter_sci/evaluation.ts
new file mode 100644
index 000000000..de33ed1d9
--- /dev/null
+++ b/src/dark_matter_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci evaluation module — tsb analytics library. */
+export interface DarkMatterSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciEvaluation(data: number[], opts: DarkMatterSciEvaluationOptions = {}): DarkMatterSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciEvaluation };
diff --git a/src/dark_matter_sci/extrapolation.ts b/src/dark_matter_sci/extrapolation.ts
new file mode 100644
index 000000000..ffafbcfa5
--- /dev/null
+++ b/src/dark_matter_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci extrapolation module — tsb analytics library. */
+export interface DarkMatterSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciExtrapolation(data: number[], opts: DarkMatterSciExtrapolationOptions = {}): DarkMatterSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciExtrapolation };
diff --git a/src/dark_matter_sci/features.ts b/src/dark_matter_sci/features.ts
new file mode 100644
index 000000000..e0a3463c1
--- /dev/null
+++ b/src/dark_matter_sci/features.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci features module — tsb analytics library. */
+export interface DarkMatterSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciFeatures(data: number[], opts: DarkMatterSciFeaturesOptions = {}): DarkMatterSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciFeatures };
diff --git a/src/dark_matter_sci/feedback.ts b/src/dark_matter_sci/feedback.ts
new file mode 100644
index 000000000..5477e1802
--- /dev/null
+++ b/src/dark_matter_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci feedback module — tsb analytics library. */
+export interface DarkMatterSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciFeedback(data: number[], opts: DarkMatterSciFeedbackOptions = {}): DarkMatterSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciFeedback };
diff --git a/src/dark_matter_sci/filtering.ts b/src/dark_matter_sci/filtering.ts
new file mode 100644
index 000000000..71e1bae1e
--- /dev/null
+++ b/src/dark_matter_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci filtering module — tsb analytics library. */
+export interface DarkMatterSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciFilteringResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciFiltering(data: number[], opts: DarkMatterSciFilteringOptions = {}): DarkMatterSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciFiltering };
diff --git a/src/dark_matter_sci/fourier.ts b/src/dark_matter_sci/fourier.ts
new file mode 100644
index 000000000..63dfa8947
--- /dev/null
+++ b/src/dark_matter_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci fourier module — tsb analytics library. */
+export interface DarkMatterSciFourierOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciFourierResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciFourier(data: number[], opts: DarkMatterSciFourierOptions = {}): DarkMatterSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciFourier };
diff --git a/src/dark_matter_sci/fusion.ts b/src/dark_matter_sci/fusion.ts
new file mode 100644
index 000000000..b54b072f5
--- /dev/null
+++ b/src/dark_matter_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci fusion module — tsb analytics library. */
+export interface DarkMatterSciFusionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciFusionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciFusion(data: number[], opts: DarkMatterSciFusionOptions = {}): DarkMatterSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciFusion };
diff --git a/src/dark_matter_sci/generation.ts b/src/dark_matter_sci/generation.ts
new file mode 100644
index 000000000..9fbb580f7
--- /dev/null
+++ b/src/dark_matter_sci/generation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci generation module — tsb analytics library. */
+export interface DarkMatterSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciGenerationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciGeneration(data: number[], opts: DarkMatterSciGenerationOptions = {}): DarkMatterSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciGeneration };
diff --git a/src/dark_matter_sci/geometry.ts b/src/dark_matter_sci/geometry.ts
new file mode 100644
index 000000000..7ae9a2a92
--- /dev/null
+++ b/src/dark_matter_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci geometry module — tsb analytics library. */
+export interface DarkMatterSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciGeometryResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciGeometry(data: number[], opts: DarkMatterSciGeometryOptions = {}): DarkMatterSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciGeometry };
diff --git a/src/dark_matter_sci/gradient.ts b/src/dark_matter_sci/gradient.ts
new file mode 100644
index 000000000..1013a6778
--- /dev/null
+++ b/src/dark_matter_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci gradient module — tsb analytics library. */
+export interface DarkMatterSciGradientOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciGradientResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciGradient(data: number[], opts: DarkMatterSciGradientOptions = {}): DarkMatterSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciGradient };
diff --git a/src/dark_matter_sci/hessian.ts b/src/dark_matter_sci/hessian.ts
new file mode 100644
index 000000000..36870e779
--- /dev/null
+++ b/src/dark_matter_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci hessian module — tsb analytics library. */
+export interface DarkMatterSciHessianOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciHessianResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciHessian(data: number[], opts: DarkMatterSciHessianOptions = {}): DarkMatterSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciHessian };
diff --git a/src/dark_matter_sci/hypothesis.ts b/src/dark_matter_sci/hypothesis.ts
new file mode 100644
index 000000000..788a9ee5c
--- /dev/null
+++ b/src/dark_matter_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci hypothesis module — tsb analytics library. */
+export interface DarkMatterSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciHypothesis(data: number[], opts: DarkMatterSciHypothesisOptions = {}): DarkMatterSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciHypothesis };
diff --git a/src/dark_matter_sci/inference.ts b/src/dark_matter_sci/inference.ts
new file mode 100644
index 000000000..fd05b1ef4
--- /dev/null
+++ b/src/dark_matter_sci/inference.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci inference module — tsb analytics library. */
+export interface DarkMatterSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciInferenceResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciInference(data: number[], opts: DarkMatterSciInferenceOptions = {}): DarkMatterSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciInference };
diff --git a/src/dark_matter_sci/inference2.ts b/src/dark_matter_sci/inference2.ts
new file mode 100644
index 000000000..731750db9
--- /dev/null
+++ b/src/dark_matter_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci inference2 module — tsb analytics library. */
+export interface DarkMatterSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciInferenceResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciInference(data: number[], opts: DarkMatterSciInferenceOptions = {}): DarkMatterSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciInference };
diff --git a/src/dark_matter_sci/integral.ts b/src/dark_matter_sci/integral.ts
new file mode 100644
index 000000000..63b6a36cb
--- /dev/null
+++ b/src/dark_matter_sci/integral.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci integral module — tsb analytics library. */
+export interface DarkMatterSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciIntegralResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciIntegral(data: number[], opts: DarkMatterSciIntegralOptions = {}): DarkMatterSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciIntegral };
diff --git a/src/dark_matter_sci/integration.ts b/src/dark_matter_sci/integration.ts
new file mode 100644
index 000000000..3bfda474f
--- /dev/null
+++ b/src/dark_matter_sci/integration.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci integration module — tsb analytics library. */
+export interface DarkMatterSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciIntegration(data: number[], opts: DarkMatterSciIntegrationOptions = {}): DarkMatterSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciIntegration };
diff --git a/src/dark_matter_sci/interpolation.ts b/src/dark_matter_sci/interpolation.ts
new file mode 100644
index 000000000..ba17c8072
--- /dev/null
+++ b/src/dark_matter_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci interpolation module — tsb analytics library. */
+export interface DarkMatterSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciInterpolation(data: number[], opts: DarkMatterSciInterpolationOptions = {}): DarkMatterSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciInterpolation };
diff --git a/src/dark_matter_sci/jacobian.ts b/src/dark_matter_sci/jacobian.ts
new file mode 100644
index 000000000..00332715d
--- /dev/null
+++ b/src/dark_matter_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci jacobian module — tsb analytics library. */
+export interface DarkMatterSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciJacobianResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciJacobian(data: number[], opts: DarkMatterSciJacobianOptions = {}): DarkMatterSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciJacobian };
diff --git a/src/dark_matter_sci/kernel.ts b/src/dark_matter_sci/kernel.ts
new file mode 100644
index 000000000..a6271208e
--- /dev/null
+++ b/src/dark_matter_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci kernel module — tsb analytics library. */
+export interface DarkMatterSciKernelOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciKernelResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciKernel(data: number[], opts: DarkMatterSciKernelOptions = {}): DarkMatterSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciKernel };
diff --git a/src/dark_matter_sci/laplacian.ts b/src/dark_matter_sci/laplacian.ts
new file mode 100644
index 000000000..18c0f8722
--- /dev/null
+++ b/src/dark_matter_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci laplacian module — tsb analytics library. */
+export interface DarkMatterSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciLaplacian(data: number[], opts: DarkMatterSciLaplacianOptions = {}): DarkMatterSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciLaplacian };
diff --git a/src/dark_matter_sci/learning.ts b/src/dark_matter_sci/learning.ts
new file mode 100644
index 000000000..d6659873d
--- /dev/null
+++ b/src/dark_matter_sci/learning.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci learning module — tsb analytics library. */
+export interface DarkMatterSciLearningOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciLearningResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciLearning(data: number[], opts: DarkMatterSciLearningOptions = {}): DarkMatterSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciLearning };
diff --git a/src/dark_matter_sci/linear.ts b/src/dark_matter_sci/linear.ts
new file mode 100644
index 000000000..746a75034
--- /dev/null
+++ b/src/dark_matter_sci/linear.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci linear module — tsb analytics library. */
+export interface DarkMatterSciLinearOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciLinearResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciLinear(data: number[], opts: DarkMatterSciLinearOptions = {}): DarkMatterSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciLinear };
diff --git a/src/dark_matter_sci/manifold.ts b/src/dark_matter_sci/manifold.ts
new file mode 100644
index 000000000..6a062d141
--- /dev/null
+++ b/src/dark_matter_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci manifold module — tsb analytics library. */
+export interface DarkMatterSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciManifoldResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciManifold(data: number[], opts: DarkMatterSciManifoldOptions = {}): DarkMatterSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciManifold };
diff --git a/src/dark_matter_sci/matching.ts b/src/dark_matter_sci/matching.ts
new file mode 100644
index 000000000..5fa20d049
--- /dev/null
+++ b/src/dark_matter_sci/matching.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci matching module — tsb analytics library. */
+export interface DarkMatterSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciMatchingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciMatching(data: number[], opts: DarkMatterSciMatchingOptions = {}): DarkMatterSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciMatching };
diff --git a/src/dark_matter_sci/measurement.ts b/src/dark_matter_sci/measurement.ts
new file mode 100644
index 000000000..72d0ee1cc
--- /dev/null
+++ b/src/dark_matter_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci measurement module — tsb analytics library. */
+export interface DarkMatterSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciMeasurement(data: number[], opts: DarkMatterSciMeasurementOptions = {}): DarkMatterSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciMeasurement };
diff --git a/src/dark_matter_sci/metrics.ts b/src/dark_matter_sci/metrics.ts
new file mode 100644
index 000000000..490344cef
--- /dev/null
+++ b/src/dark_matter_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci metrics module — tsb analytics library. */
+export interface DarkMatterSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciMetricsResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciMetrics(data: number[], opts: DarkMatterSciMetricsOptions = {}): DarkMatterSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciMetrics };
diff --git a/src/dark_matter_sci/modeling.ts b/src/dark_matter_sci/modeling.ts
new file mode 100644
index 000000000..ce832c5d9
--- /dev/null
+++ b/src/dark_matter_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci modeling module — tsb analytics library. */
+export interface DarkMatterSciModelingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciModelingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciModeling(data: number[], opts: DarkMatterSciModelingOptions = {}): DarkMatterSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciModeling };
diff --git a/src/dark_matter_sci/monitoring.ts b/src/dark_matter_sci/monitoring.ts
new file mode 100644
index 000000000..6b53a8825
--- /dev/null
+++ b/src/dark_matter_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci monitoring module — tsb analytics library. */
+export interface DarkMatterSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciMonitoring(data: number[], opts: DarkMatterSciMonitoringOptions = {}): DarkMatterSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciMonitoring };
diff --git a/src/dark_matter_sci/nonlinear.ts b/src/dark_matter_sci/nonlinear.ts
new file mode 100644
index 000000000..b7d5cf9e1
--- /dev/null
+++ b/src/dark_matter_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci nonlinear module — tsb analytics library. */
+export interface DarkMatterSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciNonlinear(data: number[], opts: DarkMatterSciNonlinearOptions = {}): DarkMatterSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciNonlinear };
diff --git a/src/dark_matter_sci/normalization.ts b/src/dark_matter_sci/normalization.ts
new file mode 100644
index 000000000..170e07bba
--- /dev/null
+++ b/src/dark_matter_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci normalization module — tsb analytics library. */
+export interface DarkMatterSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciNormalization(data: number[], opts: DarkMatterSciNormalizationOptions = {}): DarkMatterSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciNormalization };
diff --git a/src/dark_matter_sci/optimization.ts b/src/dark_matter_sci/optimization.ts
new file mode 100644
index 000000000..bc5c9e4cc
--- /dev/null
+++ b/src/dark_matter_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci optimization module — tsb analytics library. */
+export interface DarkMatterSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciOptimization(data: number[], opts: DarkMatterSciOptimizationOptions = {}): DarkMatterSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciOptimization };
diff --git a/src/dark_matter_sci/patterns.ts b/src/dark_matter_sci/patterns.ts
new file mode 100644
index 000000000..5338939da
--- /dev/null
+++ b/src/dark_matter_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci patterns module — tsb analytics library. */
+export interface DarkMatterSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciPatternsResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciPatterns(data: number[], opts: DarkMatterSciPatternsOptions = {}): DarkMatterSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciPatterns };
diff --git a/src/dark_matter_sci/permutation.ts b/src/dark_matter_sci/permutation.ts
new file mode 100644
index 000000000..98a331994
--- /dev/null
+++ b/src/dark_matter_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci permutation module — tsb analytics library. */
+export interface DarkMatterSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciPermutationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciPermutation(data: number[], opts: DarkMatterSciPermutationOptions = {}): DarkMatterSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciPermutation };
diff --git a/src/dark_matter_sci/prediction.ts b/src/dark_matter_sci/prediction.ts
new file mode 100644
index 000000000..21a8b993e
--- /dev/null
+++ b/src/dark_matter_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci prediction module — tsb analytics library. */
+export interface DarkMatterSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciPredictionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciPrediction(data: number[], opts: DarkMatterSciPredictionOptions = {}): DarkMatterSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciPrediction };
diff --git a/src/dark_matter_sci/processing.ts b/src/dark_matter_sci/processing.ts
new file mode 100644
index 000000000..640cecfee
--- /dev/null
+++ b/src/dark_matter_sci/processing.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci processing module — tsb analytics library. */
+export interface DarkMatterSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciProcessingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciProcessing(data: number[], opts: DarkMatterSciProcessingOptions = {}): DarkMatterSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciProcessing };
diff --git a/src/dark_matter_sci/profiling.ts b/src/dark_matter_sci/profiling.ts
new file mode 100644
index 000000000..5855e5984
--- /dev/null
+++ b/src/dark_matter_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci profiling module — tsb analytics library. */
+export interface DarkMatterSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciProfilingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciProfiling(data: number[], opts: DarkMatterSciProfilingOptions = {}): DarkMatterSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciProfiling };
diff --git a/src/dark_matter_sci/projection.ts b/src/dark_matter_sci/projection.ts
new file mode 100644
index 000000000..5ce47fd05
--- /dev/null
+++ b/src/dark_matter_sci/projection.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci projection module — tsb analytics library. */
+export interface DarkMatterSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciProjectionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciProjection(data: number[], opts: DarkMatterSciProjectionOptions = {}): DarkMatterSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciProjection };
diff --git a/src/dark_matter_sci/ranking.ts b/src/dark_matter_sci/ranking.ts
new file mode 100644
index 000000000..61b0370a5
--- /dev/null
+++ b/src/dark_matter_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci ranking module — tsb analytics library. */
+export interface DarkMatterSciRankingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciRankingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciRanking(data: number[], opts: DarkMatterSciRankingOptions = {}): DarkMatterSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciRanking };
diff --git a/src/dark_matter_sci/reconstruction.ts b/src/dark_matter_sci/reconstruction.ts
new file mode 100644
index 000000000..924e4dd9e
--- /dev/null
+++ b/src/dark_matter_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci reconstruction module — tsb analytics library. */
+export interface DarkMatterSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciReconstruction(data: number[], opts: DarkMatterSciReconstructionOptions = {}): DarkMatterSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciReconstruction };
diff --git a/src/dark_matter_sci/registration.ts b/src/dark_matter_sci/registration.ts
new file mode 100644
index 000000000..82f14c664
--- /dev/null
+++ b/src/dark_matter_sci/registration.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci registration module — tsb analytics library. */
+export interface DarkMatterSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciRegistration(data: number[], opts: DarkMatterSciRegistrationOptions = {}): DarkMatterSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciRegistration };
diff --git a/src/dark_matter_sci/regression.ts b/src/dark_matter_sci/regression.ts
new file mode 100644
index 000000000..319b16db6
--- /dev/null
+++ b/src/dark_matter_sci/regression.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci regression module — tsb analytics library. */
+export interface DarkMatterSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciRegressionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciRegression(data: number[], opts: DarkMatterSciRegressionOptions = {}): DarkMatterSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciRegression };
diff --git a/src/dark_matter_sci/regularization.ts b/src/dark_matter_sci/regularization.ts
new file mode 100644
index 000000000..2f9eeef8f
--- /dev/null
+++ b/src/dark_matter_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci regularization module — tsb analytics library. */
+export interface DarkMatterSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciRegularization(data: number[], opts: DarkMatterSciRegularizationOptions = {}): DarkMatterSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciRegularization };
diff --git a/src/dark_matter_sci/robustness.ts b/src/dark_matter_sci/robustness.ts
new file mode 100644
index 000000000..987a28d71
--- /dev/null
+++ b/src/dark_matter_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci robustness module — tsb analytics library. */
+export interface DarkMatterSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciRobustness(data: number[], opts: DarkMatterSciRobustnessOptions = {}): DarkMatterSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciRobustness };
diff --git a/src/dark_matter_sci/sampling.ts b/src/dark_matter_sci/sampling.ts
new file mode 100644
index 000000000..6e9a88b25
--- /dev/null
+++ b/src/dark_matter_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci sampling module — tsb analytics library. */
+export interface DarkMatterSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciSamplingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciSampling(data: number[], opts: DarkMatterSciSamplingOptions = {}): DarkMatterSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciSampling };
diff --git a/src/dark_matter_sci/sampling2.ts b/src/dark_matter_sci/sampling2.ts
new file mode 100644
index 000000000..3aa9c05d3
--- /dev/null
+++ b/src/dark_matter_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci sampling2 module — tsb analytics library. */
+export interface DarkMatterSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciSamplingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciSampling(data: number[], opts: DarkMatterSciSamplingOptions = {}): DarkMatterSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciSampling };
diff --git a/src/dark_matter_sci/scaling.ts b/src/dark_matter_sci/scaling.ts
new file mode 100644
index 000000000..6f15b068b
--- /dev/null
+++ b/src/dark_matter_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci scaling module — tsb analytics library. */
+export interface DarkMatterSciScalingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciScalingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciScaling(data: number[], opts: DarkMatterSciScalingOptions = {}): DarkMatterSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciScaling };
diff --git a/src/dark_matter_sci/scoring.ts b/src/dark_matter_sci/scoring.ts
new file mode 100644
index 000000000..c0da4a2fb
--- /dev/null
+++ b/src/dark_matter_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci scoring module — tsb analytics library. */
+export interface DarkMatterSciScoringOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciScoringResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciScoring(data: number[], opts: DarkMatterSciScoringOptions = {}): DarkMatterSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciScoring };
diff --git a/src/dark_matter_sci/segmentation.ts b/src/dark_matter_sci/segmentation.ts
new file mode 100644
index 000000000..3e78389c4
--- /dev/null
+++ b/src/dark_matter_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci segmentation module — tsb analytics library. */
+export interface DarkMatterSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciSegmentation(data: number[], opts: DarkMatterSciSegmentationOptions = {}): DarkMatterSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciSegmentation };
diff --git a/src/dark_matter_sci/selection.ts b/src/dark_matter_sci/selection.ts
new file mode 100644
index 000000000..b55707159
--- /dev/null
+++ b/src/dark_matter_sci/selection.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci selection module — tsb analytics library. */
+export interface DarkMatterSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciSelectionResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciSelection(data: number[], opts: DarkMatterSciSelectionOptions = {}): DarkMatterSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciSelection };
diff --git a/src/dark_matter_sci/sensitivity.ts b/src/dark_matter_sci/sensitivity.ts
new file mode 100644
index 000000000..295728178
--- /dev/null
+++ b/src/dark_matter_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci sensitivity module — tsb analytics library. */
+export interface DarkMatterSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciSensitivity(data: number[], opts: DarkMatterSciSensitivityOptions = {}): DarkMatterSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciSensitivity };
diff --git a/src/dark_matter_sci/simulation.ts b/src/dark_matter_sci/simulation.ts
new file mode 100644
index 000000000..4b6f41e8d
--- /dev/null
+++ b/src/dark_matter_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci simulation module — tsb analytics library. */
+export interface DarkMatterSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciSimulationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciSimulation(data: number[], opts: DarkMatterSciSimulationOptions = {}): DarkMatterSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciSimulation };
diff --git a/src/dark_matter_sci/smoothing.ts b/src/dark_matter_sci/smoothing.ts
new file mode 100644
index 000000000..d240af0c2
--- /dev/null
+++ b/src/dark_matter_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci smoothing module — tsb analytics library. */
+export interface DarkMatterSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciSmoothing(data: number[], opts: DarkMatterSciSmoothingOptions = {}): DarkMatterSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciSmoothing };
diff --git a/src/dark_matter_sci/stability.ts b/src/dark_matter_sci/stability.ts
new file mode 100644
index 000000000..825c97d0c
--- /dev/null
+++ b/src/dark_matter_sci/stability.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci stability module — tsb analytics library. */
+export interface DarkMatterSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciStabilityResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciStability(data: number[], opts: DarkMatterSciStabilityOptions = {}): DarkMatterSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciStability };
diff --git a/src/dark_matter_sci/stacking.ts b/src/dark_matter_sci/stacking.ts
new file mode 100644
index 000000000..339fe3dea
--- /dev/null
+++ b/src/dark_matter_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci stacking module — tsb analytics library. */
+export interface DarkMatterSciStackingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciStackingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciStacking(data: number[], opts: DarkMatterSciStackingOptions = {}): DarkMatterSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciStacking };
diff --git a/src/dark_matter_sci/standardization.ts b/src/dark_matter_sci/standardization.ts
new file mode 100644
index 000000000..1ac6b9157
--- /dev/null
+++ b/src/dark_matter_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci standardization module — tsb analytics library. */
+export interface DarkMatterSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciStandardization(data: number[], opts: DarkMatterSciStandardizationOptions = {}): DarkMatterSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciStandardization };
diff --git a/src/dark_matter_sci/static.ts b/src/dark_matter_sci/static.ts
new file mode 100644
index 000000000..96ad3a670
--- /dev/null
+++ b/src/dark_matter_sci/static.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci static module — tsb analytics library. */
+export interface DarkMatterSciStaticOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciStaticResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciStatic(data: number[], opts: DarkMatterSciStaticOptions = {}): DarkMatterSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciStatic };
diff --git a/src/dark_matter_sci/stochastic.ts b/src/dark_matter_sci/stochastic.ts
new file mode 100644
index 000000000..9e823e647
--- /dev/null
+++ b/src/dark_matter_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci stochastic module — tsb analytics library. */
+export interface DarkMatterSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciStochasticResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciStochastic(data: number[], opts: DarkMatterSciStochasticOptions = {}): DarkMatterSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciStochastic };
diff --git a/src/dark_matter_sci/synthesis.ts b/src/dark_matter_sci/synthesis.ts
new file mode 100644
index 000000000..ba7cc146b
--- /dev/null
+++ b/src/dark_matter_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci synthesis module — tsb analytics library. */
+export interface DarkMatterSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciSynthesis(data: number[], opts: DarkMatterSciSynthesisOptions = {}): DarkMatterSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciSynthesis };
diff --git a/src/dark_matter_sci/topology.ts b/src/dark_matter_sci/topology.ts
new file mode 100644
index 000000000..71430f85b
--- /dev/null
+++ b/src/dark_matter_sci/topology.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci topology module — tsb analytics library. */
+export interface DarkMatterSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciTopologyResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciTopology(data: number[], opts: DarkMatterSciTopologyOptions = {}): DarkMatterSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciTopology };
diff --git a/src/dark_matter_sci/tracking.ts b/src/dark_matter_sci/tracking.ts
new file mode 100644
index 000000000..720fe4b93
--- /dev/null
+++ b/src/dark_matter_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci tracking module — tsb analytics library. */
+export interface DarkMatterSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciTrackingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciTracking(data: number[], opts: DarkMatterSciTrackingOptions = {}): DarkMatterSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciTracking };
diff --git a/src/dark_matter_sci/transform.ts b/src/dark_matter_sci/transform.ts
new file mode 100644
index 000000000..ae7e3a78e
--- /dev/null
+++ b/src/dark_matter_sci/transform.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci transform module — tsb analytics library. */
+export interface DarkMatterSciTransformOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciTransformResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciTransform(data: number[], opts: DarkMatterSciTransformOptions = {}): DarkMatterSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciTransform };
diff --git a/src/dark_matter_sci/uncertainty.ts b/src/dark_matter_sci/uncertainty.ts
new file mode 100644
index 000000000..956df5151
--- /dev/null
+++ b/src/dark_matter_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci uncertainty module — tsb analytics library. */
+export interface DarkMatterSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciUncertainty(data: number[], opts: DarkMatterSciUncertaintyOptions = {}): DarkMatterSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciUncertainty };
diff --git a/src/dark_matter_sci/validation.ts b/src/dark_matter_sci/validation.ts
new file mode 100644
index 000000000..c3ad1d259
--- /dev/null
+++ b/src/dark_matter_sci/validation.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci validation module — tsb analytics library. */
+export interface DarkMatterSciValidationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciValidationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciValidation(data: number[], opts: DarkMatterSciValidationOptions = {}): DarkMatterSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciValidation };
diff --git a/src/dark_matter_sci/verification.ts b/src/dark_matter_sci/verification.ts
new file mode 100644
index 000000000..513613f15
--- /dev/null
+++ b/src/dark_matter_sci/verification.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci verification module — tsb analytics library. */
+export interface DarkMatterSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciVerificationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciVerification(data: number[], opts: DarkMatterSciVerificationOptions = {}): DarkMatterSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciVerification };
diff --git a/src/dark_matter_sci/visualization.ts b/src/dark_matter_sci/visualization.ts
new file mode 100644
index 000000000..ab8d88fff
--- /dev/null
+++ b/src/dark_matter_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci visualization module — tsb analytics library. */
+export interface DarkMatterSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciVisualization(data: number[], opts: DarkMatterSciVisualizationOptions = {}): DarkMatterSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciVisualization };
diff --git a/src/dark_matter_sci/voting.ts b/src/dark_matter_sci/voting.ts
new file mode 100644
index 000000000..4c3e33007
--- /dev/null
+++ b/src/dark_matter_sci/voting.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci voting module — tsb analytics library. */
+export interface DarkMatterSciVotingOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciVotingResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciVoting(data: number[], opts: DarkMatterSciVotingOptions = {}): DarkMatterSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciVoting };
diff --git a/src/dark_matter_sci/wavelet.ts b/src/dark_matter_sci/wavelet.ts
new file mode 100644
index 000000000..f4ca4d806
--- /dev/null
+++ b/src/dark_matter_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** dark_matter_sci wavelet module — tsb analytics library. */
+export interface DarkMatterSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface DarkMatterSciWaveletResult { values: number[]; converged: boolean; }
+export function computeDarkMatterSciWavelet(data: number[], opts: DarkMatterSciWaveletOptions = {}): DarkMatterSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDarkMatterSciWavelet };
diff --git a/src/demography/advanced.ts b/src/demography/advanced.ts
new file mode 100644
index 000000000..fb2c79b9d
--- /dev/null
+++ b/src/demography/advanced.ts
@@ -0,0 +1,15 @@
+/** Demography Advanced module — tsb analytics library. */
+export interface Demography advancedOptions { tol?: number; maxIter?: number; }
+export interface Demography advancedResult { values: number[]; converged: boolean; }
+export function computeDemography advanced(data: number[], opts: Demography advancedOptions = {}): Demography advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography advanced };
diff --git a/src/demography/aging.ts b/src/demography/aging.ts
new file mode 100644
index 000000000..46c1489b1
--- /dev/null
+++ b/src/demography/aging.ts
@@ -0,0 +1,22 @@
+/** Aging module — tsb analytics library. */
+
+/** Options for Aging. */
+export interface AgingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Aging. */
+export interface AgingResult { values: number[]; converged: boolean; }
+
+/** Compute Aging. */
+export function computeAging(data: number[], opts: AgingOptions = {}): AgingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAging };
diff --git a/src/demography/asylum.ts b/src/demography/asylum.ts
new file mode 100644
index 000000000..0de715a4a
--- /dev/null
+++ b/src/demography/asylum.ts
@@ -0,0 +1,22 @@
+/** Asylum module — tsb analytics library. */
+
+/** Options for Asylum. */
+export interface AsylumOptions { tol?: number; maxIter?: number; }
+
+/** Result from Asylum. */
+export interface AsylumResult { values: number[]; converged: boolean; }
+
+/** Compute Asylum. */
+export function computeAsylum(data: number[], opts: AsylumOptions = {}): AsylumResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAsylum };
diff --git a/src/demography/base2.ts b/src/demography/base2.ts
new file mode 100644
index 000000000..9a0ce16d2
--- /dev/null
+++ b/src/demography/base2.ts
@@ -0,0 +1,15 @@
+/** Demography Base2 module — tsb analytics library. */
+export interface Demography base2Options { tol?: number; maxIter?: number; }
+export interface Demography base2Result { values: number[]; converged: boolean; }
+export function computeDemography base2(data: number[], opts: Demography base2Options = {}): Demography base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography base2 };
diff --git a/src/demography/batch.ts b/src/demography/batch.ts
new file mode 100644
index 000000000..e864e7782
--- /dev/null
+++ b/src/demography/batch.ts
@@ -0,0 +1,15 @@
+/** Demography Batch module — tsb analytics library. */
+export interface Demography batchOptions { tol?: number; maxIter?: number; }
+export interface Demography batchResult { values: number[]; converged: boolean; }
+export function computeDemography batch(data: number[], opts: Demography batchOptions = {}): Demography batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography batch };
diff --git a/src/demography/beta.ts b/src/demography/beta.ts
new file mode 100644
index 000000000..ba7c21916
--- /dev/null
+++ b/src/demography/beta.ts
@@ -0,0 +1,15 @@
+/** Demography Beta module — tsb analytics library. */
+export interface Demography betaOptions { tol?: number; maxIter?: number; }
+export interface Demography betaResult { values: number[]; converged: boolean; }
+export function computeDemography beta(data: number[], opts: Demography betaOptions = {}): Demography betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography beta };
diff --git a/src/demography/brain_drain.ts b/src/demography/brain_drain.ts
new file mode 100644
index 000000000..4e8be9e21
--- /dev/null
+++ b/src/demography/brain_drain.ts
@@ -0,0 +1,22 @@
+/** Brain Drain module — tsb analytics library. */
+
+/** Options for Brain Drain. */
+export interface BrainDrainOptions { tol?: number; maxIter?: number; }
+
+/** Result from Brain Drain. */
+export interface BrainDrainResult { values: number[]; converged: boolean; }
+
+/** Compute Brain Drain. */
+export function computeBrainDrain(data: number[], opts: BrainDrainOptions = {}): BrainDrainResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBrainDrain };
diff --git a/src/demography/cohort_component.ts b/src/demography/cohort_component.ts
new file mode 100644
index 000000000..59b6f5734
--- /dev/null
+++ b/src/demography/cohort_component.ts
@@ -0,0 +1,22 @@
+/** Cohort Component module — tsb analytics library. */
+
+/** Options for Cohort Component. */
+export interface CohortComponentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cohort Component. */
+export interface CohortComponentResult { values: number[]; converged: boolean; }
+
+/** Compute Cohort Component. */
+export function computeCohortComponent(data: number[], opts: CohortComponentOptions = {}): CohortComponentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCohortComponent };
diff --git a/src/demography/cpu.ts b/src/demography/cpu.ts
new file mode 100644
index 000000000..c68f9bb4e
--- /dev/null
+++ b/src/demography/cpu.ts
@@ -0,0 +1,15 @@
+/** Demography Cpu module — tsb analytics library. */
+export interface Demography cpuOptions { tol?: number; maxIter?: number; }
+export interface Demography cpuResult { values: number[]; converged: boolean; }
+export function computeDemography cpu(data: number[], opts: Demography cpuOptions = {}): Demography cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography cpu };
diff --git a/src/demography/demographic_dividend.ts b/src/demography/demographic_dividend.ts
new file mode 100644
index 000000000..af4599812
--- /dev/null
+++ b/src/demography/demographic_dividend.ts
@@ -0,0 +1,22 @@
+/** Demographic Dividend module — tsb analytics library. */
+
+/** Options for Demographic Dividend. */
+export interface DemographicDividendOptions { tol?: number; maxIter?: number; }
+
+/** Result from Demographic Dividend. */
+export interface DemographicDividendResult { values: number[]; converged: boolean; }
+
+/** Compute Demographic Dividend. */
+export function computeDemographicDividend(data: number[], opts: DemographicDividendOptions = {}): DemographicDividendResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDemographicDividend };
diff --git a/src/demography/dense.ts b/src/demography/dense.ts
new file mode 100644
index 000000000..2b05b9dab
--- /dev/null
+++ b/src/demography/dense.ts
@@ -0,0 +1,15 @@
+/** Demography Dense module — tsb analytics library. */
+export interface Demography denseOptions { tol?: number; maxIter?: number; }
+export interface Demography denseResult { values: number[]; converged: boolean; }
+export function computeDemography dense(data: number[], opts: Demography denseOptions = {}): Demography denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography dense };
diff --git a/src/demography/dependency_ratio.ts b/src/demography/dependency_ratio.ts
new file mode 100644
index 000000000..9e9bd799d
--- /dev/null
+++ b/src/demography/dependency_ratio.ts
@@ -0,0 +1,22 @@
+/** Dependency Ratio module — tsb analytics library. */
+
+/** Options for Dependency Ratio. */
+export interface DependencyRatioOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dependency Ratio. */
+export interface DependencyRatioResult { values: number[]; converged: boolean; }
+
+/** Compute Dependency Ratio. */
+export function computeDependencyRatio(data: number[], opts: DependencyRatioOptions = {}): DependencyRatioResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDependencyRatio };
diff --git a/src/demography/diaspora.ts b/src/demography/diaspora.ts
new file mode 100644
index 000000000..4db1535b0
--- /dev/null
+++ b/src/demography/diaspora.ts
@@ -0,0 +1,22 @@
+/** Diaspora module — tsb analytics library. */
+
+/** Options for Diaspora. */
+export interface DiasporaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Diaspora. */
+export interface DiasporaResult { values: number[]; converged: boolean; }
+
+/** Compute Diaspora. */
+export function computeDiaspora(data: number[], opts: DiasporaOptions = {}): DiasporaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDiaspora };
diff --git a/src/demography/distributed.ts b/src/demography/distributed.ts
new file mode 100644
index 000000000..f78164aa5
--- /dev/null
+++ b/src/demography/distributed.ts
@@ -0,0 +1,15 @@
+/** Demography Distributed module — tsb analytics library. */
+export interface Demography distributedOptions { tol?: number; maxIter?: number; }
+export interface Demography distributedResult { values: number[]; converged: boolean; }
+export function computeDemography distributed(data: number[], opts: Demography distributedOptions = {}): Demography distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography distributed };
diff --git a/src/demography/epidemiological_transition.ts b/src/demography/epidemiological_transition.ts
new file mode 100644
index 000000000..4f4568a6c
--- /dev/null
+++ b/src/demography/epidemiological_transition.ts
@@ -0,0 +1,22 @@
+/** Epidemiological Transition module — tsb analytics library. */
+
+/** Options for Epidemiological Transition. */
+export interface EpidemiologicalTransitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Epidemiological Transition. */
+export interface EpidemiologicalTransitionResult { values: number[]; converged: boolean; }
+
+/** Compute Epidemiological Transition. */
+export function computeEpidemiologicalTransition(data: number[], opts: EpidemiologicalTransitionOptions = {}): EpidemiologicalTransitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEpidemiologicalTransition };
diff --git a/src/demography/experimental.ts b/src/demography/experimental.ts
new file mode 100644
index 000000000..19f858f46
--- /dev/null
+++ b/src/demography/experimental.ts
@@ -0,0 +1,15 @@
+/** Demography Experimental module — tsb analytics library. */
+export interface Demography experimentalOptions { tol?: number; maxIter?: number; }
+export interface Demography experimentalResult { values: number[]; converged: boolean; }
+export function computeDemography experimental(data: number[], opts: Demography experimentalOptions = {}): Demography experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography experimental };
diff --git a/src/demography/fast.ts b/src/demography/fast.ts
new file mode 100644
index 000000000..0ada1b488
--- /dev/null
+++ b/src/demography/fast.ts
@@ -0,0 +1,15 @@
+/** Demography Fast module — tsb analytics library. */
+export interface Demography fastOptions { tol?: number; maxIter?: number; }
+export interface Demography fastResult { values: number[]; converged: boolean; }
+export function computeDemography fast(data: number[], opts: Demography fastOptions = {}): Demography fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography fast };
diff --git a/src/demography/fertility.ts b/src/demography/fertility.ts
new file mode 100644
index 000000000..f642ffc59
--- /dev/null
+++ b/src/demography/fertility.ts
@@ -0,0 +1,22 @@
+/** Fertility module — tsb analytics library. */
+
+/** Options for Fertility. */
+export interface FertilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fertility. */
+export interface FertilityResult { values: number[]; converged: boolean; }
+
+/** Compute Fertility. */
+export function computeFertility(data: number[], opts: FertilityOptions = {}): FertilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFertility };
diff --git a/src/demography/fertility_transition.ts b/src/demography/fertility_transition.ts
new file mode 100644
index 000000000..0f6f690f9
--- /dev/null
+++ b/src/demography/fertility_transition.ts
@@ -0,0 +1,22 @@
+/** Fertility Transition module — tsb analytics library. */
+
+/** Options for Fertility Transition. */
+export interface FertilityTransitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fertility Transition. */
+export interface FertilityTransitionResult { values: number[]; converged: boolean; }
+
+/** Compute Fertility Transition. */
+export function computeFertilityTransition(data: number[], opts: FertilityTransitionOptions = {}): FertilityTransitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFertilityTransition };
diff --git a/src/demography/first_demographic_transition.ts b/src/demography/first_demographic_transition.ts
new file mode 100644
index 000000000..f48aff17a
--- /dev/null
+++ b/src/demography/first_demographic_transition.ts
@@ -0,0 +1,22 @@
+/** First Demographic Transition module — tsb analytics library. */
+
+/** Options for First Demographic Transition. */
+export interface FirstDemographicTransitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from First Demographic Transition. */
+export interface FirstDemographicTransitionResult { values: number[]; converged: boolean; }
+
+/** Compute First Demographic Transition. */
+export function computeFirstDemographicTransition(data: number[], opts: FirstDemographicTransitionOptions = {}): FirstDemographicTransitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFirstDemographicTransition };
diff --git a/src/demography/fourth.ts b/src/demography/fourth.ts
new file mode 100644
index 000000000..59063eb37
--- /dev/null
+++ b/src/demography/fourth.ts
@@ -0,0 +1,22 @@
+/** Fourth module — tsb analytics library. */
+
+/** Options for Fourth. */
+export interface FourthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fourth. */
+export interface FourthResult { values: number[]; converged: boolean; }
+
+/** Compute Fourth. */
+export function computeFourth(data: number[], opts: FourthOptions = {}): FourthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFourth };
diff --git a/src/demography/future.ts b/src/demography/future.ts
new file mode 100644
index 000000000..a80d62967
--- /dev/null
+++ b/src/demography/future.ts
@@ -0,0 +1,15 @@
+/** Demography Future module — tsb analytics library. */
+export interface Demography futureOptions { tol?: number; maxIter?: number; }
+export interface Demography futureResult { values: number[]; converged: boolean; }
+export function computeDemography future(data: number[], opts: Demography futureOptions = {}): Demography futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography future };
diff --git a/src/demography/gpu.ts b/src/demography/gpu.ts
new file mode 100644
index 000000000..1fe8b6ea3
--- /dev/null
+++ b/src/demography/gpu.ts
@@ -0,0 +1,15 @@
+/** Demography Gpu module — tsb analytics library. */
+export interface Demography gpuOptions { tol?: number; maxIter?: number; }
+export interface Demography gpuResult { values: number[]; converged: boolean; }
+export function computeDemography gpu(data: number[], opts: Demography gpuOptions = {}): Demography gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography gpu };
diff --git a/src/demography/internal_migration.ts b/src/demography/internal_migration.ts
new file mode 100644
index 000000000..f62d1d244
--- /dev/null
+++ b/src/demography/internal_migration.ts
@@ -0,0 +1,22 @@
+/** Internal Migration module — tsb analytics library. */
+
+/** Options for Internal Migration. */
+export interface InternalMigrationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Internal Migration. */
+export interface InternalMigrationResult { values: number[]; converged: boolean; }
+
+/** Compute Internal Migration. */
+export function computeInternalMigration(data: number[], opts: InternalMigrationOptions = {}): InternalMigrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInternalMigration };
diff --git a/src/demography/international_migration.ts b/src/demography/international_migration.ts
new file mode 100644
index 000000000..d7cd81c4b
--- /dev/null
+++ b/src/demography/international_migration.ts
@@ -0,0 +1,22 @@
+/** International Migration module — tsb analytics library. */
+
+/** Options for International Migration. */
+export interface InternationalMigrationOptions { tol?: number; maxIter?: number; }
+
+/** Result from International Migration. */
+export interface InternationalMigrationResult { values: number[]; converged: boolean; }
+
+/** Compute International Migration. */
+export function computeInternationalMigration(data: number[], opts: InternationalMigrationOptions = {}): InternationalMigrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInternationalMigration };
diff --git a/src/demography/large.ts b/src/demography/large.ts
new file mode 100644
index 000000000..5972c5894
--- /dev/null
+++ b/src/demography/large.ts
@@ -0,0 +1,15 @@
+/** Demography Large module — tsb analytics library. */
+export interface Demography largeOptions { tol?: number; maxIter?: number; }
+export interface Demography largeResult { values: number[]; converged: boolean; }
+export function computeDemography large(data: number[], opts: Demography largeOptions = {}): Demography largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography large };
diff --git a/src/demography/legacy.ts b/src/demography/legacy.ts
new file mode 100644
index 000000000..afcefaeb4
--- /dev/null
+++ b/src/demography/legacy.ts
@@ -0,0 +1,15 @@
+/** Demography Legacy module — tsb analytics library. */
+export interface Demography legacyOptions { tol?: number; maxIter?: number; }
+export interface Demography legacyResult { values: number[]; converged: boolean; }
+export function computeDemography legacy(data: number[], opts: Demography legacyOptions = {}): Demography legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography legacy };
diff --git a/src/demography/leslie_matrix.ts b/src/demography/leslie_matrix.ts
new file mode 100644
index 000000000..5fcdf0dd0
--- /dev/null
+++ b/src/demography/leslie_matrix.ts
@@ -0,0 +1,22 @@
+/** Leslie Matrix module — tsb analytics library. */
+
+/** Options for Leslie Matrix. */
+export interface LeslieMatrixOptions { tol?: number; maxIter?: number; }
+
+/** Result from Leslie Matrix. */
+export interface LeslieMatrixResult { values: number[]; converged: boolean; }
+
+/** Compute Leslie Matrix. */
+export function computeLeslieMatrix(data: number[], opts: LeslieMatrixOptions = {}): LeslieMatrixResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLeslieMatrix };
diff --git a/src/demography/lite.ts b/src/demography/lite.ts
new file mode 100644
index 000000000..1e3bd4ecf
--- /dev/null
+++ b/src/demography/lite.ts
@@ -0,0 +1,15 @@
+/** Demography Lite module — tsb analytics library. */
+export interface Demography liteOptions { tol?: number; maxIter?: number; }
+export interface Demography liteResult { values: number[]; converged: boolean; }
+export function computeDemography lite(data: number[], opts: Demography liteOptions = {}): Demography liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography lite };
diff --git a/src/demography/lotka_volterra.ts b/src/demography/lotka_volterra.ts
new file mode 100644
index 000000000..8d17ffe46
--- /dev/null
+++ b/src/demography/lotka_volterra.ts
@@ -0,0 +1,22 @@
+/** Lotka Volterra module — tsb analytics library. */
+
+/** Options for Lotka Volterra. */
+export interface LotkaVolterraOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lotka Volterra. */
+export interface LotkaVolterraResult { values: number[]; converged: boolean; }
+
+/** Compute Lotka Volterra. */
+export function computeLotkaVolterra(data: number[], opts: LotkaVolterraOptions = {}): LotkaVolterraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLotkaVolterra };
diff --git a/src/demography/migration_demo.ts b/src/demography/migration_demo.ts
new file mode 100644
index 000000000..732f78914
--- /dev/null
+++ b/src/demography/migration_demo.ts
@@ -0,0 +1,22 @@
+/** Migration Demo module — tsb analytics library. */
+
+/** Options for Migration Demo. */
+export interface MigrationDemoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Migration Demo. */
+export interface MigrationDemoResult { values: number[]; converged: boolean; }
+
+/** Compute Migration Demo. */
+export function computeMigrationDemo(data: number[], opts: MigrationDemoOptions = {}): MigrationDemoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMigrationDemo };
diff --git a/src/demography/mini.ts b/src/demography/mini.ts
new file mode 100644
index 000000000..5c7aa9a11
--- /dev/null
+++ b/src/demography/mini.ts
@@ -0,0 +1,15 @@
+/** Demography Mini module — tsb analytics library. */
+export interface Demography miniOptions { tol?: number; maxIter?: number; }
+export interface Demography miniResult { values: number[]; converged: boolean; }
+export function computeDemography mini(data: number[], opts: Demography miniOptions = {}): Demography miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography mini };
diff --git a/src/demography/momentum.ts b/src/demography/momentum.ts
new file mode 100644
index 000000000..fdd4f501f
--- /dev/null
+++ b/src/demography/momentum.ts
@@ -0,0 +1,22 @@
+/** Momentum module — tsb analytics library. */
+
+/** Options for Momentum. */
+export interface MomentumOptions { tol?: number; maxIter?: number; }
+
+/** Result from Momentum. */
+export interface MomentumResult { values: number[]; converged: boolean; }
+
+/** Compute Momentum. */
+export function computeMomentum(data: number[], opts: MomentumOptions = {}): MomentumResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMomentum };
diff --git a/src/demography/mortality.ts b/src/demography/mortality.ts
new file mode 100644
index 000000000..05eadb478
--- /dev/null
+++ b/src/demography/mortality.ts
@@ -0,0 +1,22 @@
+/** Mortality module — tsb analytics library. */
+
+/** Options for Mortality. */
+export interface MortalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mortality. */
+export interface MortalityResult { values: number[]; converged: boolean; }
+
+/** Compute Mortality. */
+export function computeMortality(data: number[], opts: MortalityOptions = {}): MortalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMortality };
diff --git a/src/demography/mortality_transition.ts b/src/demography/mortality_transition.ts
new file mode 100644
index 000000000..436b11b15
--- /dev/null
+++ b/src/demography/mortality_transition.ts
@@ -0,0 +1,22 @@
+/** Mortality Transition module — tsb analytics library. */
+
+/** Options for Mortality Transition. */
+export interface MortalityTransitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mortality Transition. */
+export interface MortalityTransitionResult { values: number[]; converged: boolean; }
+
+/** Compute Mortality Transition. */
+export function computeMortalityTransition(data: number[], opts: MortalityTransitionOptions = {}): MortalityTransitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMortalityTransition };
diff --git a/src/demography/next.ts b/src/demography/next.ts
new file mode 100644
index 000000000..87c28db25
--- /dev/null
+++ b/src/demography/next.ts
@@ -0,0 +1,15 @@
+/** Demography Next module — tsb analytics library. */
+export interface Demography nextOptions { tol?: number; maxIter?: number; }
+export interface Demography nextResult { values: number[]; converged: boolean; }
+export function computeDemography next(data: number[], opts: Demography nextOptions = {}): Demography nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography next };
diff --git a/src/demography/nutrition_transition.ts b/src/demography/nutrition_transition.ts
new file mode 100644
index 000000000..6920941ac
--- /dev/null
+++ b/src/demography/nutrition_transition.ts
@@ -0,0 +1,22 @@
+/** Nutrition Transition module — tsb analytics library. */
+
+/** Options for Nutrition Transition. */
+export interface NutritionTransitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nutrition Transition. */
+export interface NutritionTransitionResult { values: number[]; converged: boolean; }
+
+/** Compute Nutrition Transition. */
+export function computeNutritionTransition(data: number[], opts: NutritionTransitionOptions = {}): NutritionTransitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNutritionTransition };
diff --git a/src/demography/online.ts b/src/demography/online.ts
new file mode 100644
index 000000000..f9e28858f
--- /dev/null
+++ b/src/demography/online.ts
@@ -0,0 +1,15 @@
+/** Demography Online module — tsb analytics library. */
+export interface Demography onlineOptions { tol?: number; maxIter?: number; }
+export interface Demography onlineResult { values: number[]; converged: boolean; }
+export function computeDemography online(data: number[], opts: Demography onlineOptions = {}): Demography onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography online };
diff --git a/src/demography/parallel.ts b/src/demography/parallel.ts
new file mode 100644
index 000000000..8261d6caa
--- /dev/null
+++ b/src/demography/parallel.ts
@@ -0,0 +1,15 @@
+/** Demography Parallel module — tsb analytics library. */
+export interface Demography parallelOptions { tol?: number; maxIter?: number; }
+export interface Demography parallelResult { values: number[]; converged: boolean; }
+export function computeDemography parallel(data: number[], opts: Demography parallelOptions = {}): Demography parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography parallel };
diff --git a/src/demography/plus.ts b/src/demography/plus.ts
new file mode 100644
index 000000000..1a7807f44
--- /dev/null
+++ b/src/demography/plus.ts
@@ -0,0 +1,15 @@
+/** Demography Plus module — tsb analytics library. */
+export interface Demography plusOptions { tol?: number; maxIter?: number; }
+export interface Demography plusResult { values: number[]; converged: boolean; }
+export function computeDemography plus(data: number[], opts: Demography plusOptions = {}): Demography plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography plus };
diff --git a/src/demography/population_projection.ts b/src/demography/population_projection.ts
new file mode 100644
index 000000000..780976aab
--- /dev/null
+++ b/src/demography/population_projection.ts
@@ -0,0 +1,22 @@
+/** Population Projection module — tsb analytics library. */
+
+/** Options for Population Projection. */
+export interface PopulationProjectionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Population Projection. */
+export interface PopulationProjectionResult { values: number[]; converged: boolean; }
+
+/** Compute Population Projection. */
+export function computePopulationProjection(data: number[], opts: PopulationProjectionOptions = {}): PopulationProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePopulationProjection };
diff --git a/src/demography/pro.ts b/src/demography/pro.ts
new file mode 100644
index 000000000..ddec7e6cb
--- /dev/null
+++ b/src/demography/pro.ts
@@ -0,0 +1,15 @@
+/** Demography Pro module — tsb analytics library. */
+export interface Demography proOptions { tol?: number; maxIter?: number; }
+export interface Demography proResult { values: number[]; converged: boolean; }
+export function computeDemography pro(data: number[], opts: Demography proOptions = {}): Demography proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography pro };
diff --git a/src/demography/refugee.ts b/src/demography/refugee.ts
new file mode 100644
index 000000000..ce84a31a7
--- /dev/null
+++ b/src/demography/refugee.ts
@@ -0,0 +1,22 @@
+/** Refugee module — tsb analytics library. */
+
+/** Options for Refugee. */
+export interface RefugeeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Refugee. */
+export interface RefugeeResult { values: number[]; converged: boolean; }
+
+/** Compute Refugee. */
+export function computeRefugee(data: number[], opts: RefugeeOptions = {}): RefugeeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRefugee };
diff --git a/src/demography/remittances.ts b/src/demography/remittances.ts
new file mode 100644
index 000000000..a14c76245
--- /dev/null
+++ b/src/demography/remittances.ts
@@ -0,0 +1,22 @@
+/** Remittances module — tsb analytics library. */
+
+/** Options for Remittances. */
+export interface RemittancesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Remittances. */
+export interface RemittancesResult { values: number[]; converged: boolean; }
+
+/** Compute Remittances. */
+export function computeRemittances(data: number[], opts: RemittancesOptions = {}): RemittancesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRemittances };
diff --git a/src/demography/robust.ts b/src/demography/robust.ts
new file mode 100644
index 000000000..7c695ce9c
--- /dev/null
+++ b/src/demography/robust.ts
@@ -0,0 +1,15 @@
+/** Demography Robust module — tsb analytics library. */
+export interface Demography robustOptions { tol?: number; maxIter?: number; }
+export interface Demography robustResult { values: number[]; converged: boolean; }
+export function computeDemography robust(data: number[], opts: Demography robustOptions = {}): Demography robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography robust };
diff --git a/src/demography/second_demographic_transition.ts b/src/demography/second_demographic_transition.ts
new file mode 100644
index 000000000..ddf1bf944
--- /dev/null
+++ b/src/demography/second_demographic_transition.ts
@@ -0,0 +1,22 @@
+/** Second Demographic Transition module — tsb analytics library. */
+
+/** Options for Second Demographic Transition. */
+export interface SecondDemographicTransitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Second Demographic Transition. */
+export interface SecondDemographicTransitionResult { values: number[]; converged: boolean; }
+
+/** Compute Second Demographic Transition. */
+export function computeSecondDemographicTransition(data: number[], opts: SecondDemographicTransitionOptions = {}): SecondDemographicTransitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSecondDemographicTransition };
diff --git a/src/demography/small.ts b/src/demography/small.ts
new file mode 100644
index 000000000..157a47b47
--- /dev/null
+++ b/src/demography/small.ts
@@ -0,0 +1,15 @@
+/** Demography Small module — tsb analytics library. */
+export interface Demography smallOptions { tol?: number; maxIter?: number; }
+export interface Demography smallResult { values: number[]; converged: boolean; }
+export function computeDemography small(data: number[], opts: Demography smallOptions = {}): Demography smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography small };
diff --git a/src/demography/sparse.ts b/src/demography/sparse.ts
new file mode 100644
index 000000000..f92ee3a63
--- /dev/null
+++ b/src/demography/sparse.ts
@@ -0,0 +1,15 @@
+/** Demography Sparse module — tsb analytics library. */
+export interface Demography sparseOptions { tol?: number; maxIter?: number; }
+export interface Demography sparseResult { values: number[]; converged: boolean; }
+export function computeDemography sparse(data: number[], opts: Demography sparseOptions = {}): Demography sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography sparse };
diff --git a/src/demography/stable.ts b/src/demography/stable.ts
new file mode 100644
index 000000000..4890170ac
--- /dev/null
+++ b/src/demography/stable.ts
@@ -0,0 +1,15 @@
+/** Demography Stable module — tsb analytics library. */
+export interface Demography stableOptions { tol?: number; maxIter?: number; }
+export interface Demography stableResult { values: number[]; converged: boolean; }
+export function computeDemography stable(data: number[], opts: Demography stableOptions = {}): Demography stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography stable };
diff --git a/src/demography/stable_population.ts b/src/demography/stable_population.ts
new file mode 100644
index 000000000..30adbc7a5
--- /dev/null
+++ b/src/demography/stable_population.ts
@@ -0,0 +1,22 @@
+/** Stable Population module — tsb analytics library. */
+
+/** Options for Stable Population. */
+export interface StablePopulationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stable Population. */
+export interface StablePopulationResult { values: number[]; converged: boolean; }
+
+/** Compute Stable Population. */
+export function computeStablePopulation(data: number[], opts: StablePopulationOptions = {}): StablePopulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStablePopulation };
diff --git a/src/demography/stationary.ts b/src/demography/stationary.ts
new file mode 100644
index 000000000..2637d4a7f
--- /dev/null
+++ b/src/demography/stationary.ts
@@ -0,0 +1,22 @@
+/** Stationary module — tsb analytics library. */
+
+/** Options for Stationary. */
+export interface StationaryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stationary. */
+export interface StationaryResult { values: number[]; converged: boolean; }
+
+/** Compute Stationary. */
+export function computeStationary(data: number[], opts: StationaryOptions = {}): StationaryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStationary };
diff --git a/src/demography/streaming.ts b/src/demography/streaming.ts
new file mode 100644
index 000000000..a1723fd0c
--- /dev/null
+++ b/src/demography/streaming.ts
@@ -0,0 +1,15 @@
+/** Demography Streaming module — tsb analytics library. */
+export interface Demography streamingOptions { tol?: number; maxIter?: number; }
+export interface Demography streamingResult { values: number[]; converged: boolean; }
+export function computeDemography streaming(data: number[], opts: Demography streamingOptions = {}): Demography streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography streaming };
diff --git a/src/demography/third.ts b/src/demography/third.ts
new file mode 100644
index 000000000..1c764d35f
--- /dev/null
+++ b/src/demography/third.ts
@@ -0,0 +1,22 @@
+/** Third module — tsb analytics library. */
+
+/** Options for Third. */
+export interface ThirdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Third. */
+export interface ThirdResult { values: number[]; converged: boolean; }
+
+/** Compute Third. */
+export function computeThird(data: number[], opts: ThirdOptions = {}): ThirdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeThird };
diff --git a/src/demography/urbanization_demo.ts b/src/demography/urbanization_demo.ts
new file mode 100644
index 000000000..0aba20155
--- /dev/null
+++ b/src/demography/urbanization_demo.ts
@@ -0,0 +1,22 @@
+/** Urbanization Demo module — tsb analytics library. */
+
+/** Options for Urbanization Demo. */
+export interface UrbanizationDemoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Urbanization Demo. */
+export interface UrbanizationDemoResult { values: number[]; converged: boolean; }
+
+/** Compute Urbanization Demo. */
+export function computeUrbanizationDemo(data: number[], opts: UrbanizationDemoOptions = {}): UrbanizationDemoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeUrbanizationDemo };
diff --git a/src/demography/v2.ts b/src/demography/v2.ts
new file mode 100644
index 000000000..da45140b1
--- /dev/null
+++ b/src/demography/v2.ts
@@ -0,0 +1,15 @@
+/** Demography V2 module — tsb analytics library. */
+export interface Demography v2Options { tol?: number; maxIter?: number; }
+export interface Demography v2Result { values: number[]; converged: boolean; }
+export function computeDemography v2(data: number[], opts: Demography v2Options = {}): Demography v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography v2 };
diff --git a/src/demography/v3.ts b/src/demography/v3.ts
new file mode 100644
index 000000000..c0a12ccff
--- /dev/null
+++ b/src/demography/v3.ts
@@ -0,0 +1,15 @@
+/** Demography V3 module — tsb analytics library. */
+export interface Demography v3Options { tol?: number; maxIter?: number; }
+export interface Demography v3Result { values: number[]; converged: boolean; }
+export function computeDemography v3(data: number[], opts: Demography v3Options = {}): Demography v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography v3 };
diff --git a/src/demography/wasm.ts b/src/demography/wasm.ts
new file mode 100644
index 000000000..5e3778f11
--- /dev/null
+++ b/src/demography/wasm.ts
@@ -0,0 +1,15 @@
+/** Demography Wasm module — tsb analytics library. */
+export interface Demography wasmOptions { tol?: number; maxIter?: number; }
+export interface Demography wasmResult { values: number[]; converged: boolean; }
+export function computeDemography wasm(data: number[], opts: Demography wasmOptions = {}): Demography wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography wasm };
diff --git a/src/demography/window_of_opportunity.ts b/src/demography/window_of_opportunity.ts
new file mode 100644
index 000000000..c7afe9aab
--- /dev/null
+++ b/src/demography/window_of_opportunity.ts
@@ -0,0 +1,22 @@
+/** Window Of Opportunity module — tsb analytics library. */
+
+/** Options for Window Of Opportunity. */
+export interface WindowOfOpportunityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Window Of Opportunity. */
+export interface WindowOfOpportunityResult { values: number[]; converged: boolean; }
+
+/** Compute Window Of Opportunity. */
+export function computeWindowOfOpportunity(data: number[], opts: WindowOfOpportunityOptions = {}): WindowOfOpportunityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWindowOfOpportunity };
diff --git a/src/demography/xlarge.ts b/src/demography/xlarge.ts
new file mode 100644
index 000000000..03d4ace7e
--- /dev/null
+++ b/src/demography/xlarge.ts
@@ -0,0 +1,15 @@
+/** Demography Xlarge module — tsb analytics library. */
+export interface Demography xlargeOptions { tol?: number; maxIter?: number; }
+export interface Demography xlargeResult { values: number[]; converged: boolean; }
+export function computeDemography xlarge(data: number[], opts: Demography xlargeOptions = {}): Demography xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDemography xlarge };
diff --git a/src/dermatology_sci/adaptation.ts b/src/dermatology_sci/adaptation.ts
new file mode 100644
index 000000000..158b63772
--- /dev/null
+++ b/src/dermatology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci adaptation module — tsb analytics library. */
+export interface DermatologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciAdaptation(data: number[], opts: DermatologySciAdaptationOptions = {}): DermatologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciAdaptation };
diff --git a/src/dermatology_sci/aggregation.ts b/src/dermatology_sci/aggregation.ts
new file mode 100644
index 000000000..9df6bdff0
--- /dev/null
+++ b/src/dermatology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci aggregation module — tsb analytics library. */
+export interface DermatologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciAggregation(data: number[], opts: DermatologySciAggregationOptions = {}): DermatologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciAggregation };
diff --git a/src/dermatology_sci/algebra.ts b/src/dermatology_sci/algebra.ts
new file mode 100644
index 000000000..22e191e50
--- /dev/null
+++ b/src/dermatology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci algebra module — tsb analytics library. */
+export interface DermatologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeDermatologySciAlgebra(data: number[], opts: DermatologySciAlgebraOptions = {}): DermatologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciAlgebra };
diff --git a/src/dermatology_sci/alignment.ts b/src/dermatology_sci/alignment.ts
new file mode 100644
index 000000000..6662a0ad5
--- /dev/null
+++ b/src/dermatology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci alignment module — tsb analytics library. */
+export interface DermatologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeDermatologySciAlignment(data: number[], opts: DermatologySciAlignmentOptions = {}): DermatologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciAlignment };
diff --git a/src/dermatology_sci/analysis.ts b/src/dermatology_sci/analysis.ts
new file mode 100644
index 000000000..8048ac740
--- /dev/null
+++ b/src/dermatology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci analysis module — tsb analytics library. */
+export interface DermatologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeDermatologySciAnalysis(data: number[], opts: DermatologySciAnalysisOptions = {}): DermatologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciAnalysis };
diff --git a/src/dermatology_sci/augmentation.ts b/src/dermatology_sci/augmentation.ts
new file mode 100644
index 000000000..5486805c4
--- /dev/null
+++ b/src/dermatology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci augmentation module — tsb analytics library. */
+export interface DermatologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciAugmentation(data: number[], opts: DermatologySciAugmentationOptions = {}): DermatologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciAugmentation };
diff --git a/src/dermatology_sci/bagging.ts b/src/dermatology_sci/bagging.ts
new file mode 100644
index 000000000..7b93093ee
--- /dev/null
+++ b/src/dermatology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci bagging module — tsb analytics library. */
+export interface DermatologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciBagging(data: number[], opts: DermatologySciBaggingOptions = {}): DermatologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciBagging };
diff --git a/src/dermatology_sci/basis.ts b/src/dermatology_sci/basis.ts
new file mode 100644
index 000000000..57904caff
--- /dev/null
+++ b/src/dermatology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci basis module — tsb analytics library. */
+export interface DermatologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciBasisResult { values: number[]; converged: boolean; }
+export function computeDermatologySciBasis(data: number[], opts: DermatologySciBasisOptions = {}): DermatologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciBasis };
diff --git a/src/dermatology_sci/benchmarking.ts b/src/dermatology_sci/benchmarking.ts
new file mode 100644
index 000000000..b616802bf
--- /dev/null
+++ b/src/dermatology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci benchmarking module — tsb analytics library. */
+export interface DermatologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciBenchmarking(data: number[], opts: DermatologySciBenchmarkingOptions = {}): DermatologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciBenchmarking };
diff --git a/src/dermatology_sci/blending.ts b/src/dermatology_sci/blending.ts
new file mode 100644
index 000000000..53add10b7
--- /dev/null
+++ b/src/dermatology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci blending module — tsb analytics library. */
+export interface DermatologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciBlending(data: number[], opts: DermatologySciBlendingOptions = {}): DermatologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciBlending };
diff --git a/src/dermatology_sci/boosting.ts b/src/dermatology_sci/boosting.ts
new file mode 100644
index 000000000..86dd1087d
--- /dev/null
+++ b/src/dermatology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci boosting module — tsb analytics library. */
+export interface DermatologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciBoosting(data: number[], opts: DermatologySciBoostingOptions = {}): DermatologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciBoosting };
diff --git a/src/dermatology_sci/bootstrap.ts b/src/dermatology_sci/bootstrap.ts
new file mode 100644
index 000000000..75edc4d8a
--- /dev/null
+++ b/src/dermatology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci bootstrap module — tsb analytics library. */
+export interface DermatologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeDermatologySciBootstrap(data: number[], opts: DermatologySciBootstrapOptions = {}): DermatologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciBootstrap };
diff --git a/src/dermatology_sci/calculus.ts b/src/dermatology_sci/calculus.ts
new file mode 100644
index 000000000..9c86f0474
--- /dev/null
+++ b/src/dermatology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci calculus module — tsb analytics library. */
+export interface DermatologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeDermatologySciCalculus(data: number[], opts: DermatologySciCalculusOptions = {}): DermatologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciCalculus };
diff --git a/src/dermatology_sci/calibration.ts b/src/dermatology_sci/calibration.ts
new file mode 100644
index 000000000..127edc7b2
--- /dev/null
+++ b/src/dermatology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci calibration module — tsb analytics library. */
+export interface DermatologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciCalibration(data: number[], opts: DermatologySciCalibrationOptions = {}): DermatologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciCalibration };
diff --git a/src/dermatology_sci/characterization.ts b/src/dermatology_sci/characterization.ts
new file mode 100644
index 000000000..d2c92bb7a
--- /dev/null
+++ b/src/dermatology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci characterization module — tsb analytics library. */
+export interface DermatologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciCharacterization(data: number[], opts: DermatologySciCharacterizationOptions = {}): DermatologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciCharacterization };
diff --git a/src/dermatology_sci/classification.ts b/src/dermatology_sci/classification.ts
new file mode 100644
index 000000000..549e65a2e
--- /dev/null
+++ b/src/dermatology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci classification module — tsb analytics library. */
+export interface DermatologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciClassification(data: number[], opts: DermatologySciClassificationOptions = {}): DermatologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciClassification };
diff --git a/src/dermatology_sci/clustering.ts b/src/dermatology_sci/clustering.ts
new file mode 100644
index 000000000..ddded0dd0
--- /dev/null
+++ b/src/dermatology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci clustering module — tsb analytics library. */
+export interface DermatologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeDermatologySciClustering(data: number[], opts: DermatologySciClusteringOptions = {}): DermatologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciClustering };
diff --git a/src/dermatology_sci/compression.ts b/src/dermatology_sci/compression.ts
new file mode 100644
index 000000000..e9aaf8209
--- /dev/null
+++ b/src/dermatology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci compression module — tsb analytics library. */
+export interface DermatologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciCompression(data: number[], opts: DermatologySciCompressionOptions = {}): DermatologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciCompression };
diff --git a/src/dermatology_sci/continuous.ts b/src/dermatology_sci/continuous.ts
new file mode 100644
index 000000000..1009374b6
--- /dev/null
+++ b/src/dermatology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci continuous module — tsb analytics library. */
+export interface DermatologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeDermatologySciContinuous(data: number[], opts: DermatologySciContinuousOptions = {}): DermatologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciContinuous };
diff --git a/src/dermatology_sci/control.ts b/src/dermatology_sci/control.ts
new file mode 100644
index 000000000..d8f336e19
--- /dev/null
+++ b/src/dermatology_sci/control.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci control module — tsb analytics library. */
+export interface DermatologySciControlOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciControlResult { values: number[]; converged: boolean; }
+export function computeDermatologySciControl(data: number[], opts: DermatologySciControlOptions = {}): DermatologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciControl };
diff --git a/src/dermatology_sci/convergence.ts b/src/dermatology_sci/convergence.ts
new file mode 100644
index 000000000..480c815e2
--- /dev/null
+++ b/src/dermatology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci convergence module — tsb analytics library. */
+export interface DermatologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeDermatologySciConvergence(data: number[], opts: DermatologySciConvergenceOptions = {}): DermatologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciConvergence };
diff --git a/src/dermatology_sci/convex.ts b/src/dermatology_sci/convex.ts
new file mode 100644
index 000000000..485b6668f
--- /dev/null
+++ b/src/dermatology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci convex module — tsb analytics library. */
+export interface DermatologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciConvexResult { values: number[]; converged: boolean; }
+export function computeDermatologySciConvex(data: number[], opts: DermatologySciConvexOptions = {}): DermatologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciConvex };
diff --git a/src/dermatology_sci/correlation.ts b/src/dermatology_sci/correlation.ts
new file mode 100644
index 000000000..4b5553b0c
--- /dev/null
+++ b/src/dermatology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci correlation module — tsb analytics library. */
+export interface DermatologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciCorrelation(data: number[], opts: DermatologySciCorrelationOptions = {}): DermatologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciCorrelation };
diff --git a/src/dermatology_sci/covariance.ts b/src/dermatology_sci/covariance.ts
new file mode 100644
index 000000000..ec65dbd59
--- /dev/null
+++ b/src/dermatology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci covariance module — tsb analytics library. */
+export interface DermatologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeDermatologySciCovariance(data: number[], opts: DermatologySciCovarianceOptions = {}): DermatologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciCovariance };
diff --git a/src/dermatology_sci/cross_validation.ts b/src/dermatology_sci/cross_validation.ts
new file mode 100644
index 000000000..2380c6eb9
--- /dev/null
+++ b/src/dermatology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci cross_validation module — tsb analytics library. */
+export interface DermatologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciCrossValidation(data: number[], opts: DermatologySciCrossValidationOptions = {}): DermatologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciCrossValidation };
diff --git a/src/dermatology_sci/decoding.ts b/src/dermatology_sci/decoding.ts
new file mode 100644
index 000000000..d90e5464a
--- /dev/null
+++ b/src/dermatology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci decoding module — tsb analytics library. */
+export interface DermatologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDecoding(data: number[], opts: DermatologySciDecodingOptions = {}): DermatologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDecoding };
diff --git a/src/dermatology_sci/decomposition.ts b/src/dermatology_sci/decomposition.ts
new file mode 100644
index 000000000..d5eb5d234
--- /dev/null
+++ b/src/dermatology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci decomposition module — tsb analytics library. */
+export interface DermatologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDecomposition(data: number[], opts: DermatologySciDecompositionOptions = {}): DermatologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDecomposition };
diff --git a/src/dermatology_sci/detection.ts b/src/dermatology_sci/detection.ts
new file mode 100644
index 000000000..8fb5e914f
--- /dev/null
+++ b/src/dermatology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci detection module — tsb analytics library. */
+export interface DermatologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDetection(data: number[], opts: DermatologySciDetectionOptions = {}): DermatologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDetection };
diff --git a/src/dermatology_sci/deterministic.ts b/src/dermatology_sci/deterministic.ts
new file mode 100644
index 000000000..4699e7aa9
--- /dev/null
+++ b/src/dermatology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci deterministic module — tsb analytics library. */
+export interface DermatologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDeterministic(data: number[], opts: DermatologySciDeterministicOptions = {}): DermatologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDeterministic };
diff --git a/src/dermatology_sci/diagnostics.ts b/src/dermatology_sci/diagnostics.ts
new file mode 100644
index 000000000..32b53f4ac
--- /dev/null
+++ b/src/dermatology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci diagnostics module — tsb analytics library. */
+export interface DermatologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDiagnostics(data: number[], opts: DermatologySciDiagnosticsOptions = {}): DermatologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDiagnostics };
diff --git a/src/dermatology_sci/differential.ts b/src/dermatology_sci/differential.ts
new file mode 100644
index 000000000..67887ecae
--- /dev/null
+++ b/src/dermatology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci differential module — tsb analytics library. */
+export interface DermatologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDifferential(data: number[], opts: DermatologySciDifferentialOptions = {}): DermatologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDifferential };
diff --git a/src/dermatology_sci/discrete.ts b/src/dermatology_sci/discrete.ts
new file mode 100644
index 000000000..223552391
--- /dev/null
+++ b/src/dermatology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci discrete module — tsb analytics library. */
+export interface DermatologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDiscrete(data: number[], opts: DermatologySciDiscreteOptions = {}): DermatologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDiscrete };
diff --git a/src/dermatology_sci/distribution.ts b/src/dermatology_sci/distribution.ts
new file mode 100644
index 000000000..f9f7c8a50
--- /dev/null
+++ b/src/dermatology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci distribution module — tsb analytics library. */
+export interface DermatologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDistribution(data: number[], opts: DermatologySciDistributionOptions = {}): DermatologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDistribution };
diff --git a/src/dermatology_sci/dynamic.ts b/src/dermatology_sci/dynamic.ts
new file mode 100644
index 000000000..a190e74d8
--- /dev/null
+++ b/src/dermatology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci dynamic module — tsb analytics library. */
+export interface DermatologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeDermatologySciDynamic(data: number[], opts: DermatologySciDynamicOptions = {}): DermatologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciDynamic };
diff --git a/src/dermatology_sci/embedding.ts b/src/dermatology_sci/embedding.ts
new file mode 100644
index 000000000..ada53e0e2
--- /dev/null
+++ b/src/dermatology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci embedding module — tsb analytics library. */
+export interface DermatologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciEmbedding(data: number[], opts: DermatologySciEmbeddingOptions = {}): DermatologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciEmbedding };
diff --git a/src/dermatology_sci/encoding.ts b/src/dermatology_sci/encoding.ts
new file mode 100644
index 000000000..926e6509f
--- /dev/null
+++ b/src/dermatology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci encoding module — tsb analytics library. */
+export interface DermatologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciEncoding(data: number[], opts: DermatologySciEncodingOptions = {}): DermatologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciEncoding };
diff --git a/src/dermatology_sci/ensemble.ts b/src/dermatology_sci/ensemble.ts
new file mode 100644
index 000000000..6e4b30b73
--- /dev/null
+++ b/src/dermatology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci ensemble module — tsb analytics library. */
+export interface DermatologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeDermatologySciEnsemble(data: number[], opts: DermatologySciEnsembleOptions = {}): DermatologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciEnsemble };
diff --git a/src/dermatology_sci/estimation.ts b/src/dermatology_sci/estimation.ts
new file mode 100644
index 000000000..3f71b2b71
--- /dev/null
+++ b/src/dermatology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci estimation module — tsb analytics library. */
+export interface DermatologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciEstimation(data: number[], opts: DermatologySciEstimationOptions = {}): DermatologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciEstimation };
diff --git a/src/dermatology_sci/evaluation.ts b/src/dermatology_sci/evaluation.ts
new file mode 100644
index 000000000..59ffc6d67
--- /dev/null
+++ b/src/dermatology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci evaluation module — tsb analytics library. */
+export interface DermatologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciEvaluation(data: number[], opts: DermatologySciEvaluationOptions = {}): DermatologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciEvaluation };
diff --git a/src/dermatology_sci/extrapolation.ts b/src/dermatology_sci/extrapolation.ts
new file mode 100644
index 000000000..e447c1d9a
--- /dev/null
+++ b/src/dermatology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci extrapolation module — tsb analytics library. */
+export interface DermatologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciExtrapolation(data: number[], opts: DermatologySciExtrapolationOptions = {}): DermatologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciExtrapolation };
diff --git a/src/dermatology_sci/features.ts b/src/dermatology_sci/features.ts
new file mode 100644
index 000000000..4c134987a
--- /dev/null
+++ b/src/dermatology_sci/features.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci features module — tsb analytics library. */
+export interface DermatologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeDermatologySciFeatures(data: number[], opts: DermatologySciFeaturesOptions = {}): DermatologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciFeatures };
diff --git a/src/dermatology_sci/feedback.ts b/src/dermatology_sci/feedback.ts
new file mode 100644
index 000000000..d07ba69f6
--- /dev/null
+++ b/src/dermatology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci feedback module — tsb analytics library. */
+export interface DermatologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeDermatologySciFeedback(data: number[], opts: DermatologySciFeedbackOptions = {}): DermatologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciFeedback };
diff --git a/src/dermatology_sci/filtering.ts b/src/dermatology_sci/filtering.ts
new file mode 100644
index 000000000..e3e1ef029
--- /dev/null
+++ b/src/dermatology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci filtering module — tsb analytics library. */
+export interface DermatologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeDermatologySciFiltering(data: number[], opts: DermatologySciFilteringOptions = {}): DermatologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciFiltering };
diff --git a/src/dermatology_sci/fourier.ts b/src/dermatology_sci/fourier.ts
new file mode 100644
index 000000000..f9627361d
--- /dev/null
+++ b/src/dermatology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci fourier module — tsb analytics library. */
+export interface DermatologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciFourierResult { values: number[]; converged: boolean; }
+export function computeDermatologySciFourier(data: number[], opts: DermatologySciFourierOptions = {}): DermatologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciFourier };
diff --git a/src/dermatology_sci/fusion.ts b/src/dermatology_sci/fusion.ts
new file mode 100644
index 000000000..df09f665c
--- /dev/null
+++ b/src/dermatology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci fusion module — tsb analytics library. */
+export interface DermatologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciFusionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciFusion(data: number[], opts: DermatologySciFusionOptions = {}): DermatologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciFusion };
diff --git a/src/dermatology_sci/generation.ts b/src/dermatology_sci/generation.ts
new file mode 100644
index 000000000..99483bacb
--- /dev/null
+++ b/src/dermatology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci generation module — tsb analytics library. */
+export interface DermatologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciGeneration(data: number[], opts: DermatologySciGenerationOptions = {}): DermatologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciGeneration };
diff --git a/src/dermatology_sci/geometry.ts b/src/dermatology_sci/geometry.ts
new file mode 100644
index 000000000..7549f3caa
--- /dev/null
+++ b/src/dermatology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci geometry module — tsb analytics library. */
+export interface DermatologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeDermatologySciGeometry(data: number[], opts: DermatologySciGeometryOptions = {}): DermatologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciGeometry };
diff --git a/src/dermatology_sci/gradient.ts b/src/dermatology_sci/gradient.ts
new file mode 100644
index 000000000..0ca448759
--- /dev/null
+++ b/src/dermatology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci gradient module — tsb analytics library. */
+export interface DermatologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciGradientResult { values: number[]; converged: boolean; }
+export function computeDermatologySciGradient(data: number[], opts: DermatologySciGradientOptions = {}): DermatologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciGradient };
diff --git a/src/dermatology_sci/hessian.ts b/src/dermatology_sci/hessian.ts
new file mode 100644
index 000000000..1a9f9a19d
--- /dev/null
+++ b/src/dermatology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci hessian module — tsb analytics library. */
+export interface DermatologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciHessianResult { values: number[]; converged: boolean; }
+export function computeDermatologySciHessian(data: number[], opts: DermatologySciHessianOptions = {}): DermatologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciHessian };
diff --git a/src/dermatology_sci/hypothesis.ts b/src/dermatology_sci/hypothesis.ts
new file mode 100644
index 000000000..cfcdeb8fb
--- /dev/null
+++ b/src/dermatology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci hypothesis module — tsb analytics library. */
+export interface DermatologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeDermatologySciHypothesis(data: number[], opts: DermatologySciHypothesisOptions = {}): DermatologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciHypothesis };
diff --git a/src/dermatology_sci/inference.ts b/src/dermatology_sci/inference.ts
new file mode 100644
index 000000000..a23bb3d1d
--- /dev/null
+++ b/src/dermatology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci inference module — tsb analytics library. */
+export interface DermatologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeDermatologySciInference(data: number[], opts: DermatologySciInferenceOptions = {}): DermatologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciInference };
diff --git a/src/dermatology_sci/inference2.ts b/src/dermatology_sci/inference2.ts
new file mode 100644
index 000000000..59d3f2c62
--- /dev/null
+++ b/src/dermatology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci inference2 module — tsb analytics library. */
+export interface DermatologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeDermatologySciInference(data: number[], opts: DermatologySciInferenceOptions = {}): DermatologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciInference };
diff --git a/src/dermatology_sci/integral.ts b/src/dermatology_sci/integral.ts
new file mode 100644
index 000000000..f0ddbd840
--- /dev/null
+++ b/src/dermatology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci integral module — tsb analytics library. */
+export interface DermatologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeDermatologySciIntegral(data: number[], opts: DermatologySciIntegralOptions = {}): DermatologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciIntegral };
diff --git a/src/dermatology_sci/integration.ts b/src/dermatology_sci/integration.ts
new file mode 100644
index 000000000..6d253eee7
--- /dev/null
+++ b/src/dermatology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci integration module — tsb analytics library. */
+export interface DermatologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciIntegration(data: number[], opts: DermatologySciIntegrationOptions = {}): DermatologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciIntegration };
diff --git a/src/dermatology_sci/interpolation.ts b/src/dermatology_sci/interpolation.ts
new file mode 100644
index 000000000..78c40525f
--- /dev/null
+++ b/src/dermatology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci interpolation module — tsb analytics library. */
+export interface DermatologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciInterpolation(data: number[], opts: DermatologySciInterpolationOptions = {}): DermatologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciInterpolation };
diff --git a/src/dermatology_sci/jacobian.ts b/src/dermatology_sci/jacobian.ts
new file mode 100644
index 000000000..0aa155988
--- /dev/null
+++ b/src/dermatology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci jacobian module — tsb analytics library. */
+export interface DermatologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeDermatologySciJacobian(data: number[], opts: DermatologySciJacobianOptions = {}): DermatologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciJacobian };
diff --git a/src/dermatology_sci/kernel.ts b/src/dermatology_sci/kernel.ts
new file mode 100644
index 000000000..d28e02708
--- /dev/null
+++ b/src/dermatology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci kernel module — tsb analytics library. */
+export interface DermatologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciKernelResult { values: number[]; converged: boolean; }
+export function computeDermatologySciKernel(data: number[], opts: DermatologySciKernelOptions = {}): DermatologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciKernel };
diff --git a/src/dermatology_sci/laplacian.ts b/src/dermatology_sci/laplacian.ts
new file mode 100644
index 000000000..1f1488829
--- /dev/null
+++ b/src/dermatology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci laplacian module — tsb analytics library. */
+export interface DermatologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeDermatologySciLaplacian(data: number[], opts: DermatologySciLaplacianOptions = {}): DermatologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciLaplacian };
diff --git a/src/dermatology_sci/learning.ts b/src/dermatology_sci/learning.ts
new file mode 100644
index 000000000..05e76a4a4
--- /dev/null
+++ b/src/dermatology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci learning module — tsb analytics library. */
+export interface DermatologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciLearningResult { values: number[]; converged: boolean; }
+export function computeDermatologySciLearning(data: number[], opts: DermatologySciLearningOptions = {}): DermatologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciLearning };
diff --git a/src/dermatology_sci/linear.ts b/src/dermatology_sci/linear.ts
new file mode 100644
index 000000000..918de0fec
--- /dev/null
+++ b/src/dermatology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci linear module — tsb analytics library. */
+export interface DermatologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciLinearResult { values: number[]; converged: boolean; }
+export function computeDermatologySciLinear(data: number[], opts: DermatologySciLinearOptions = {}): DermatologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciLinear };
diff --git a/src/dermatology_sci/manifold.ts b/src/dermatology_sci/manifold.ts
new file mode 100644
index 000000000..a955a6255
--- /dev/null
+++ b/src/dermatology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci manifold module — tsb analytics library. */
+export interface DermatologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeDermatologySciManifold(data: number[], opts: DermatologySciManifoldOptions = {}): DermatologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciManifold };
diff --git a/src/dermatology_sci/matching.ts b/src/dermatology_sci/matching.ts
new file mode 100644
index 000000000..1866e0f2b
--- /dev/null
+++ b/src/dermatology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci matching module — tsb analytics library. */
+export interface DermatologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciMatching(data: number[], opts: DermatologySciMatchingOptions = {}): DermatologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciMatching };
diff --git a/src/dermatology_sci/measurement.ts b/src/dermatology_sci/measurement.ts
new file mode 100644
index 000000000..6734b1e1c
--- /dev/null
+++ b/src/dermatology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci measurement module — tsb analytics library. */
+export interface DermatologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeDermatologySciMeasurement(data: number[], opts: DermatologySciMeasurementOptions = {}): DermatologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciMeasurement };
diff --git a/src/dermatology_sci/metrics.ts b/src/dermatology_sci/metrics.ts
new file mode 100644
index 000000000..333571301
--- /dev/null
+++ b/src/dermatology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci metrics module — tsb analytics library. */
+export interface DermatologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeDermatologySciMetrics(data: number[], opts: DermatologySciMetricsOptions = {}): DermatologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciMetrics };
diff --git a/src/dermatology_sci/modeling.ts b/src/dermatology_sci/modeling.ts
new file mode 100644
index 000000000..c67b13b0d
--- /dev/null
+++ b/src/dermatology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci modeling module — tsb analytics library. */
+export interface DermatologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciModelingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciModeling(data: number[], opts: DermatologySciModelingOptions = {}): DermatologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciModeling };
diff --git a/src/dermatology_sci/monitoring.ts b/src/dermatology_sci/monitoring.ts
new file mode 100644
index 000000000..3303270c7
--- /dev/null
+++ b/src/dermatology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci monitoring module — tsb analytics library. */
+export interface DermatologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeDermatologySciMonitoring(data: number[], opts: DermatologySciMonitoringOptions = {}): DermatologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciMonitoring };
diff --git a/src/dermatology_sci/nonlinear.ts b/src/dermatology_sci/nonlinear.ts
new file mode 100644
index 000000000..052402bcd
--- /dev/null
+++ b/src/dermatology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci nonlinear module — tsb analytics library. */
+export interface DermatologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeDermatologySciNonlinear(data: number[], opts: DermatologySciNonlinearOptions = {}): DermatologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciNonlinear };
diff --git a/src/dermatology_sci/normalization.ts b/src/dermatology_sci/normalization.ts
new file mode 100644
index 000000000..0715f6ef9
--- /dev/null
+++ b/src/dermatology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci normalization module — tsb analytics library. */
+export interface DermatologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciNormalization(data: number[], opts: DermatologySciNormalizationOptions = {}): DermatologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciNormalization };
diff --git a/src/dermatology_sci/optimization.ts b/src/dermatology_sci/optimization.ts
new file mode 100644
index 000000000..ea444acd2
--- /dev/null
+++ b/src/dermatology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci optimization module — tsb analytics library. */
+export interface DermatologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciOptimization(data: number[], opts: DermatologySciOptimizationOptions = {}): DermatologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciOptimization };
diff --git a/src/dermatology_sci/patterns.ts b/src/dermatology_sci/patterns.ts
new file mode 100644
index 000000000..5e40f8eb0
--- /dev/null
+++ b/src/dermatology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci patterns module — tsb analytics library. */
+export interface DermatologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeDermatologySciPatterns(data: number[], opts: DermatologySciPatternsOptions = {}): DermatologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciPatterns };
diff --git a/src/dermatology_sci/permutation.ts b/src/dermatology_sci/permutation.ts
new file mode 100644
index 000000000..e4134dbe2
--- /dev/null
+++ b/src/dermatology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci permutation module — tsb analytics library. */
+export interface DermatologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciPermutation(data: number[], opts: DermatologySciPermutationOptions = {}): DermatologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciPermutation };
diff --git a/src/dermatology_sci/prediction.ts b/src/dermatology_sci/prediction.ts
new file mode 100644
index 000000000..43cd9d0a1
--- /dev/null
+++ b/src/dermatology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci prediction module — tsb analytics library. */
+export interface DermatologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciPrediction(data: number[], opts: DermatologySciPredictionOptions = {}): DermatologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciPrediction };
diff --git a/src/dermatology_sci/processing.ts b/src/dermatology_sci/processing.ts
new file mode 100644
index 000000000..8a5fcead7
--- /dev/null
+++ b/src/dermatology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci processing module — tsb analytics library. */
+export interface DermatologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciProcessing(data: number[], opts: DermatologySciProcessingOptions = {}): DermatologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciProcessing };
diff --git a/src/dermatology_sci/profiling.ts b/src/dermatology_sci/profiling.ts
new file mode 100644
index 000000000..6a91dfe6e
--- /dev/null
+++ b/src/dermatology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci profiling module — tsb analytics library. */
+export interface DermatologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciProfiling(data: number[], opts: DermatologySciProfilingOptions = {}): DermatologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciProfiling };
diff --git a/src/dermatology_sci/projection.ts b/src/dermatology_sci/projection.ts
new file mode 100644
index 000000000..45973cadb
--- /dev/null
+++ b/src/dermatology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci projection module — tsb analytics library. */
+export interface DermatologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciProjection(data: number[], opts: DermatologySciProjectionOptions = {}): DermatologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciProjection };
diff --git a/src/dermatology_sci/ranking.ts b/src/dermatology_sci/ranking.ts
new file mode 100644
index 000000000..cdd8a2361
--- /dev/null
+++ b/src/dermatology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci ranking module — tsb analytics library. */
+export interface DermatologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciRankingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciRanking(data: number[], opts: DermatologySciRankingOptions = {}): DermatologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciRanking };
diff --git a/src/dermatology_sci/reconstruction.ts b/src/dermatology_sci/reconstruction.ts
new file mode 100644
index 000000000..5292c0177
--- /dev/null
+++ b/src/dermatology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci reconstruction module — tsb analytics library. */
+export interface DermatologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciReconstruction(data: number[], opts: DermatologySciReconstructionOptions = {}): DermatologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciReconstruction };
diff --git a/src/dermatology_sci/registration.ts b/src/dermatology_sci/registration.ts
new file mode 100644
index 000000000..809326df7
--- /dev/null
+++ b/src/dermatology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci registration module — tsb analytics library. */
+export interface DermatologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciRegistration(data: number[], opts: DermatologySciRegistrationOptions = {}): DermatologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciRegistration };
diff --git a/src/dermatology_sci/regression.ts b/src/dermatology_sci/regression.ts
new file mode 100644
index 000000000..820521690
--- /dev/null
+++ b/src/dermatology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci regression module — tsb analytics library. */
+export interface DermatologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciRegression(data: number[], opts: DermatologySciRegressionOptions = {}): DermatologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciRegression };
diff --git a/src/dermatology_sci/regularization.ts b/src/dermatology_sci/regularization.ts
new file mode 100644
index 000000000..373acd0d0
--- /dev/null
+++ b/src/dermatology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci regularization module — tsb analytics library. */
+export interface DermatologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciRegularization(data: number[], opts: DermatologySciRegularizationOptions = {}): DermatologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciRegularization };
diff --git a/src/dermatology_sci/robustness.ts b/src/dermatology_sci/robustness.ts
new file mode 100644
index 000000000..ecc9abc78
--- /dev/null
+++ b/src/dermatology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci robustness module — tsb analytics library. */
+export interface DermatologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeDermatologySciRobustness(data: number[], opts: DermatologySciRobustnessOptions = {}): DermatologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciRobustness };
diff --git a/src/dermatology_sci/sampling.ts b/src/dermatology_sci/sampling.ts
new file mode 100644
index 000000000..a14340629
--- /dev/null
+++ b/src/dermatology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci sampling module — tsb analytics library. */
+export interface DermatologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciSampling(data: number[], opts: DermatologySciSamplingOptions = {}): DermatologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciSampling };
diff --git a/src/dermatology_sci/sampling2.ts b/src/dermatology_sci/sampling2.ts
new file mode 100644
index 000000000..c062ef8e0
--- /dev/null
+++ b/src/dermatology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci sampling2 module — tsb analytics library. */
+export interface DermatologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciSampling(data: number[], opts: DermatologySciSamplingOptions = {}): DermatologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciSampling };
diff --git a/src/dermatology_sci/scaling.ts b/src/dermatology_sci/scaling.ts
new file mode 100644
index 000000000..a7f6cf990
--- /dev/null
+++ b/src/dermatology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci scaling module — tsb analytics library. */
+export interface DermatologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciScalingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciScaling(data: number[], opts: DermatologySciScalingOptions = {}): DermatologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciScaling };
diff --git a/src/dermatology_sci/scoring.ts b/src/dermatology_sci/scoring.ts
new file mode 100644
index 000000000..b551205e7
--- /dev/null
+++ b/src/dermatology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci scoring module — tsb analytics library. */
+export interface DermatologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciScoringResult { values: number[]; converged: boolean; }
+export function computeDermatologySciScoring(data: number[], opts: DermatologySciScoringOptions = {}): DermatologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciScoring };
diff --git a/src/dermatology_sci/segmentation.ts b/src/dermatology_sci/segmentation.ts
new file mode 100644
index 000000000..1f785f884
--- /dev/null
+++ b/src/dermatology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci segmentation module — tsb analytics library. */
+export interface DermatologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciSegmentation(data: number[], opts: DermatologySciSegmentationOptions = {}): DermatologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciSegmentation };
diff --git a/src/dermatology_sci/selection.ts b/src/dermatology_sci/selection.ts
new file mode 100644
index 000000000..a6fcd1651
--- /dev/null
+++ b/src/dermatology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci selection module — tsb analytics library. */
+export interface DermatologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeDermatologySciSelection(data: number[], opts: DermatologySciSelectionOptions = {}): DermatologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciSelection };
diff --git a/src/dermatology_sci/sensitivity.ts b/src/dermatology_sci/sensitivity.ts
new file mode 100644
index 000000000..dff684d84
--- /dev/null
+++ b/src/dermatology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci sensitivity module — tsb analytics library. */
+export interface DermatologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeDermatologySciSensitivity(data: number[], opts: DermatologySciSensitivityOptions = {}): DermatologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciSensitivity };
diff --git a/src/dermatology_sci/simulation.ts b/src/dermatology_sci/simulation.ts
new file mode 100644
index 000000000..a3940445c
--- /dev/null
+++ b/src/dermatology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci simulation module — tsb analytics library. */
+export interface DermatologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciSimulation(data: number[], opts: DermatologySciSimulationOptions = {}): DermatologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciSimulation };
diff --git a/src/dermatology_sci/smoothing.ts b/src/dermatology_sci/smoothing.ts
new file mode 100644
index 000000000..c1bcad982
--- /dev/null
+++ b/src/dermatology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci smoothing module — tsb analytics library. */
+export interface DermatologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciSmoothing(data: number[], opts: DermatologySciSmoothingOptions = {}): DermatologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciSmoothing };
diff --git a/src/dermatology_sci/stability.ts b/src/dermatology_sci/stability.ts
new file mode 100644
index 000000000..f2c71fbe7
--- /dev/null
+++ b/src/dermatology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci stability module — tsb analytics library. */
+export interface DermatologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeDermatologySciStability(data: number[], opts: DermatologySciStabilityOptions = {}): DermatologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciStability };
diff --git a/src/dermatology_sci/stacking.ts b/src/dermatology_sci/stacking.ts
new file mode 100644
index 000000000..cebd556ca
--- /dev/null
+++ b/src/dermatology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci stacking module — tsb analytics library. */
+export interface DermatologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciStackingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciStacking(data: number[], opts: DermatologySciStackingOptions = {}): DermatologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciStacking };
diff --git a/src/dermatology_sci/standardization.ts b/src/dermatology_sci/standardization.ts
new file mode 100644
index 000000000..696e92bda
--- /dev/null
+++ b/src/dermatology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci standardization module — tsb analytics library. */
+export interface DermatologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciStandardization(data: number[], opts: DermatologySciStandardizationOptions = {}): DermatologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciStandardization };
diff --git a/src/dermatology_sci/static.ts b/src/dermatology_sci/static.ts
new file mode 100644
index 000000000..53348abbe
--- /dev/null
+++ b/src/dermatology_sci/static.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci static module — tsb analytics library. */
+export interface DermatologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciStaticResult { values: number[]; converged: boolean; }
+export function computeDermatologySciStatic(data: number[], opts: DermatologySciStaticOptions = {}): DermatologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciStatic };
diff --git a/src/dermatology_sci/stochastic.ts b/src/dermatology_sci/stochastic.ts
new file mode 100644
index 000000000..6731a438d
--- /dev/null
+++ b/src/dermatology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci stochastic module — tsb analytics library. */
+export interface DermatologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeDermatologySciStochastic(data: number[], opts: DermatologySciStochasticOptions = {}): DermatologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciStochastic };
diff --git a/src/dermatology_sci/synthesis.ts b/src/dermatology_sci/synthesis.ts
new file mode 100644
index 000000000..3f5c64cf9
--- /dev/null
+++ b/src/dermatology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci synthesis module — tsb analytics library. */
+export interface DermatologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeDermatologySciSynthesis(data: number[], opts: DermatologySciSynthesisOptions = {}): DermatologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciSynthesis };
diff --git a/src/dermatology_sci/topology.ts b/src/dermatology_sci/topology.ts
new file mode 100644
index 000000000..073bae391
--- /dev/null
+++ b/src/dermatology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci topology module — tsb analytics library. */
+export interface DermatologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeDermatologySciTopology(data: number[], opts: DermatologySciTopologyOptions = {}): DermatologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciTopology };
diff --git a/src/dermatology_sci/tracking.ts b/src/dermatology_sci/tracking.ts
new file mode 100644
index 000000000..0870a0e1c
--- /dev/null
+++ b/src/dermatology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci tracking module — tsb analytics library. */
+export interface DermatologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciTracking(data: number[], opts: DermatologySciTrackingOptions = {}): DermatologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciTracking };
diff --git a/src/dermatology_sci/transform.ts b/src/dermatology_sci/transform.ts
new file mode 100644
index 000000000..ee70e0fb1
--- /dev/null
+++ b/src/dermatology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci transform module — tsb analytics library. */
+export interface DermatologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciTransformResult { values: number[]; converged: boolean; }
+export function computeDermatologySciTransform(data: number[], opts: DermatologySciTransformOptions = {}): DermatologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciTransform };
diff --git a/src/dermatology_sci/uncertainty.ts b/src/dermatology_sci/uncertainty.ts
new file mode 100644
index 000000000..6d3cb3119
--- /dev/null
+++ b/src/dermatology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci uncertainty module — tsb analytics library. */
+export interface DermatologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeDermatologySciUncertainty(data: number[], opts: DermatologySciUncertaintyOptions = {}): DermatologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciUncertainty };
diff --git a/src/dermatology_sci/validation.ts b/src/dermatology_sci/validation.ts
new file mode 100644
index 000000000..bd4fa5bf0
--- /dev/null
+++ b/src/dermatology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci validation module — tsb analytics library. */
+export interface DermatologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciValidationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciValidation(data: number[], opts: DermatologySciValidationOptions = {}): DermatologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciValidation };
diff --git a/src/dermatology_sci/verification.ts b/src/dermatology_sci/verification.ts
new file mode 100644
index 000000000..7a9e844a7
--- /dev/null
+++ b/src/dermatology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci verification module — tsb analytics library. */
+export interface DermatologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciVerification(data: number[], opts: DermatologySciVerificationOptions = {}): DermatologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciVerification };
diff --git a/src/dermatology_sci/visualization.ts b/src/dermatology_sci/visualization.ts
new file mode 100644
index 000000000..19d0750be
--- /dev/null
+++ b/src/dermatology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci visualization module — tsb analytics library. */
+export interface DermatologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeDermatologySciVisualization(data: number[], opts: DermatologySciVisualizationOptions = {}): DermatologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciVisualization };
diff --git a/src/dermatology_sci/voting.ts b/src/dermatology_sci/voting.ts
new file mode 100644
index 000000000..ad2fd1ef4
--- /dev/null
+++ b/src/dermatology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci voting module — tsb analytics library. */
+export interface DermatologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciVotingResult { values: number[]; converged: boolean; }
+export function computeDermatologySciVoting(data: number[], opts: DermatologySciVotingOptions = {}): DermatologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciVoting };
diff --git a/src/dermatology_sci/wavelet.ts b/src/dermatology_sci/wavelet.ts
new file mode 100644
index 000000000..d3d7ba3ee
--- /dev/null
+++ b/src/dermatology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** dermatology_sci wavelet module — tsb analytics library. */
+export interface DermatologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface DermatologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeDermatologySciWavelet(data: number[], opts: DermatologySciWaveletOptions = {}): DermatologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDermatologySciWavelet };
diff --git a/src/developmental_bio/adaptation.ts b/src/developmental_bio/adaptation.ts
new file mode 100644
index 000000000..f5a8fdd82
--- /dev/null
+++ b/src/developmental_bio/adaptation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio adaptation module — tsb analytics library. */
+export interface DevelopmentalBioAdaptationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioAdaptationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioAdaptation(data: number[], opts: DevelopmentalBioAdaptationOptions = {}): DevelopmentalBioAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioAdaptation };
diff --git a/src/developmental_bio/aggregation.ts b/src/developmental_bio/aggregation.ts
new file mode 100644
index 000000000..3dc0189c6
--- /dev/null
+++ b/src/developmental_bio/aggregation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio aggregation module — tsb analytics library. */
+export interface DevelopmentalBioAggregationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioAggregationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioAggregation(data: number[], opts: DevelopmentalBioAggregationOptions = {}): DevelopmentalBioAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioAggregation };
diff --git a/src/developmental_bio/algebra.ts b/src/developmental_bio/algebra.ts
new file mode 100644
index 000000000..4f2eb9197
--- /dev/null
+++ b/src/developmental_bio/algebra.ts
@@ -0,0 +1,14 @@
+/** developmental_bio algebra module — tsb analytics library. */
+export interface DevelopmentalBioAlgebraOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioAlgebraResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioAlgebra(data: number[], opts: DevelopmentalBioAlgebraOptions = {}): DevelopmentalBioAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioAlgebra };
diff --git a/src/developmental_bio/alignment.ts b/src/developmental_bio/alignment.ts
new file mode 100644
index 000000000..357f20e49
--- /dev/null
+++ b/src/developmental_bio/alignment.ts
@@ -0,0 +1,14 @@
+/** developmental_bio alignment module — tsb analytics library. */
+export interface DevelopmentalBioAlignmentOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioAlignmentResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioAlignment(data: number[], opts: DevelopmentalBioAlignmentOptions = {}): DevelopmentalBioAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioAlignment };
diff --git a/src/developmental_bio/analysis.ts b/src/developmental_bio/analysis.ts
new file mode 100644
index 000000000..b207d2d5f
--- /dev/null
+++ b/src/developmental_bio/analysis.ts
@@ -0,0 +1,14 @@
+/** developmental_bio analysis module — tsb analytics library. */
+export interface DevelopmentalBioAnalysisOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioAnalysisResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioAnalysis(data: number[], opts: DevelopmentalBioAnalysisOptions = {}): DevelopmentalBioAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioAnalysis };
diff --git a/src/developmental_bio/augmentation.ts b/src/developmental_bio/augmentation.ts
new file mode 100644
index 000000000..29fe5ff77
--- /dev/null
+++ b/src/developmental_bio/augmentation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio augmentation module — tsb analytics library. */
+export interface DevelopmentalBioAugmentationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioAugmentationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioAugmentation(data: number[], opts: DevelopmentalBioAugmentationOptions = {}): DevelopmentalBioAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioAugmentation };
diff --git a/src/developmental_bio/bagging.ts b/src/developmental_bio/bagging.ts
new file mode 100644
index 000000000..6425a8da7
--- /dev/null
+++ b/src/developmental_bio/bagging.ts
@@ -0,0 +1,14 @@
+/** developmental_bio bagging module — tsb analytics library. */
+export interface DevelopmentalBioBaggingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioBaggingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioBagging(data: number[], opts: DevelopmentalBioBaggingOptions = {}): DevelopmentalBioBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioBagging };
diff --git a/src/developmental_bio/basis.ts b/src/developmental_bio/basis.ts
new file mode 100644
index 000000000..a9ad0ae0a
--- /dev/null
+++ b/src/developmental_bio/basis.ts
@@ -0,0 +1,14 @@
+/** developmental_bio basis module — tsb analytics library. */
+export interface DevelopmentalBioBasisOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioBasisResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioBasis(data: number[], opts: DevelopmentalBioBasisOptions = {}): DevelopmentalBioBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioBasis };
diff --git a/src/developmental_bio/benchmarking.ts b/src/developmental_bio/benchmarking.ts
new file mode 100644
index 000000000..a12a7b1bd
--- /dev/null
+++ b/src/developmental_bio/benchmarking.ts
@@ -0,0 +1,14 @@
+/** developmental_bio benchmarking module — tsb analytics library. */
+export interface DevelopmentalBioBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioBenchmarking(data: number[], opts: DevelopmentalBioBenchmarkingOptions = {}): DevelopmentalBioBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioBenchmarking };
diff --git a/src/developmental_bio/blending.ts b/src/developmental_bio/blending.ts
new file mode 100644
index 000000000..5eb0e9e85
--- /dev/null
+++ b/src/developmental_bio/blending.ts
@@ -0,0 +1,14 @@
+/** developmental_bio blending module — tsb analytics library. */
+export interface DevelopmentalBioBlendingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioBlendingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioBlending(data: number[], opts: DevelopmentalBioBlendingOptions = {}): DevelopmentalBioBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioBlending };
diff --git a/src/developmental_bio/boosting.ts b/src/developmental_bio/boosting.ts
new file mode 100644
index 000000000..df55db5d0
--- /dev/null
+++ b/src/developmental_bio/boosting.ts
@@ -0,0 +1,14 @@
+/** developmental_bio boosting module — tsb analytics library. */
+export interface DevelopmentalBioBoostingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioBoostingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioBoosting(data: number[], opts: DevelopmentalBioBoostingOptions = {}): DevelopmentalBioBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioBoosting };
diff --git a/src/developmental_bio/bootstrap.ts b/src/developmental_bio/bootstrap.ts
new file mode 100644
index 000000000..aef003e58
--- /dev/null
+++ b/src/developmental_bio/bootstrap.ts
@@ -0,0 +1,14 @@
+/** developmental_bio bootstrap module — tsb analytics library. */
+export interface DevelopmentalBioBootstrapOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioBootstrapResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioBootstrap(data: number[], opts: DevelopmentalBioBootstrapOptions = {}): DevelopmentalBioBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioBootstrap };
diff --git a/src/developmental_bio/calculus.ts b/src/developmental_bio/calculus.ts
new file mode 100644
index 000000000..1cbc2b87b
--- /dev/null
+++ b/src/developmental_bio/calculus.ts
@@ -0,0 +1,14 @@
+/** developmental_bio calculus module — tsb analytics library. */
+export interface DevelopmentalBioCalculusOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioCalculusResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioCalculus(data: number[], opts: DevelopmentalBioCalculusOptions = {}): DevelopmentalBioCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioCalculus };
diff --git a/src/developmental_bio/calibration.ts b/src/developmental_bio/calibration.ts
new file mode 100644
index 000000000..7e906aa15
--- /dev/null
+++ b/src/developmental_bio/calibration.ts
@@ -0,0 +1,14 @@
+/** developmental_bio calibration module — tsb analytics library. */
+export interface DevelopmentalBioCalibrationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioCalibrationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioCalibration(data: number[], opts: DevelopmentalBioCalibrationOptions = {}): DevelopmentalBioCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioCalibration };
diff --git a/src/developmental_bio/characterization.ts b/src/developmental_bio/characterization.ts
new file mode 100644
index 000000000..51dafdbd2
--- /dev/null
+++ b/src/developmental_bio/characterization.ts
@@ -0,0 +1,14 @@
+/** developmental_bio characterization module — tsb analytics library. */
+export interface DevelopmentalBioCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioCharacterizationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioCharacterization(data: number[], opts: DevelopmentalBioCharacterizationOptions = {}): DevelopmentalBioCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioCharacterization };
diff --git a/src/developmental_bio/classification.ts b/src/developmental_bio/classification.ts
new file mode 100644
index 000000000..6eca4ac15
--- /dev/null
+++ b/src/developmental_bio/classification.ts
@@ -0,0 +1,14 @@
+/** developmental_bio classification module — tsb analytics library. */
+export interface DevelopmentalBioClassificationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioClassificationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioClassification(data: number[], opts: DevelopmentalBioClassificationOptions = {}): DevelopmentalBioClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioClassification };
diff --git a/src/developmental_bio/clustering.ts b/src/developmental_bio/clustering.ts
new file mode 100644
index 000000000..e0f3dfee4
--- /dev/null
+++ b/src/developmental_bio/clustering.ts
@@ -0,0 +1,14 @@
+/** developmental_bio clustering module — tsb analytics library. */
+export interface DevelopmentalBioClusteringOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioClusteringResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioClustering(data: number[], opts: DevelopmentalBioClusteringOptions = {}): DevelopmentalBioClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioClustering };
diff --git a/src/developmental_bio/compression.ts b/src/developmental_bio/compression.ts
new file mode 100644
index 000000000..4ff7475e1
--- /dev/null
+++ b/src/developmental_bio/compression.ts
@@ -0,0 +1,14 @@
+/** developmental_bio compression module — tsb analytics library. */
+export interface DevelopmentalBioCompressionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioCompressionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioCompression(data: number[], opts: DevelopmentalBioCompressionOptions = {}): DevelopmentalBioCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioCompression };
diff --git a/src/developmental_bio/continuous.ts b/src/developmental_bio/continuous.ts
new file mode 100644
index 000000000..84e536473
--- /dev/null
+++ b/src/developmental_bio/continuous.ts
@@ -0,0 +1,14 @@
+/** developmental_bio continuous module — tsb analytics library. */
+export interface DevelopmentalBioContinuousOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioContinuousResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioContinuous(data: number[], opts: DevelopmentalBioContinuousOptions = {}): DevelopmentalBioContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioContinuous };
diff --git a/src/developmental_bio/control.ts b/src/developmental_bio/control.ts
new file mode 100644
index 000000000..d3c428b1d
--- /dev/null
+++ b/src/developmental_bio/control.ts
@@ -0,0 +1,14 @@
+/** developmental_bio control module — tsb analytics library. */
+export interface DevelopmentalBioControlOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioControlResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioControl(data: number[], opts: DevelopmentalBioControlOptions = {}): DevelopmentalBioControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioControl };
diff --git a/src/developmental_bio/convergence.ts b/src/developmental_bio/convergence.ts
new file mode 100644
index 000000000..f123917e5
--- /dev/null
+++ b/src/developmental_bio/convergence.ts
@@ -0,0 +1,14 @@
+/** developmental_bio convergence module — tsb analytics library. */
+export interface DevelopmentalBioConvergenceOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioConvergenceResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioConvergence(data: number[], opts: DevelopmentalBioConvergenceOptions = {}): DevelopmentalBioConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioConvergence };
diff --git a/src/developmental_bio/convex.ts b/src/developmental_bio/convex.ts
new file mode 100644
index 000000000..f8f41a14b
--- /dev/null
+++ b/src/developmental_bio/convex.ts
@@ -0,0 +1,14 @@
+/** developmental_bio convex module — tsb analytics library. */
+export interface DevelopmentalBioConvexOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioConvexResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioConvex(data: number[], opts: DevelopmentalBioConvexOptions = {}): DevelopmentalBioConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioConvex };
diff --git a/src/developmental_bio/correlation.ts b/src/developmental_bio/correlation.ts
new file mode 100644
index 000000000..1a9091d6c
--- /dev/null
+++ b/src/developmental_bio/correlation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio correlation module — tsb analytics library. */
+export interface DevelopmentalBioCorrelationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioCorrelationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioCorrelation(data: number[], opts: DevelopmentalBioCorrelationOptions = {}): DevelopmentalBioCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioCorrelation };
diff --git a/src/developmental_bio/covariance.ts b/src/developmental_bio/covariance.ts
new file mode 100644
index 000000000..1279a4b2a
--- /dev/null
+++ b/src/developmental_bio/covariance.ts
@@ -0,0 +1,14 @@
+/** developmental_bio covariance module — tsb analytics library. */
+export interface DevelopmentalBioCovarianceOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioCovarianceResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioCovariance(data: number[], opts: DevelopmentalBioCovarianceOptions = {}): DevelopmentalBioCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioCovariance };
diff --git a/src/developmental_bio/cross_validation.ts b/src/developmental_bio/cross_validation.ts
new file mode 100644
index 000000000..61dd2d8a1
--- /dev/null
+++ b/src/developmental_bio/cross_validation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio cross_validation module — tsb analytics library. */
+export interface DevelopmentalBioCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioCrossValidationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioCrossValidation(data: number[], opts: DevelopmentalBioCrossValidationOptions = {}): DevelopmentalBioCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioCrossValidation };
diff --git a/src/developmental_bio/decoding.ts b/src/developmental_bio/decoding.ts
new file mode 100644
index 000000000..597f2bd3e
--- /dev/null
+++ b/src/developmental_bio/decoding.ts
@@ -0,0 +1,14 @@
+/** developmental_bio decoding module — tsb analytics library. */
+export interface DevelopmentalBioDecodingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDecodingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDecoding(data: number[], opts: DevelopmentalBioDecodingOptions = {}): DevelopmentalBioDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDecoding };
diff --git a/src/developmental_bio/decomposition.ts b/src/developmental_bio/decomposition.ts
new file mode 100644
index 000000000..2340d2605
--- /dev/null
+++ b/src/developmental_bio/decomposition.ts
@@ -0,0 +1,14 @@
+/** developmental_bio decomposition module — tsb analytics library. */
+export interface DevelopmentalBioDecompositionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDecompositionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDecomposition(data: number[], opts: DevelopmentalBioDecompositionOptions = {}): DevelopmentalBioDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDecomposition };
diff --git a/src/developmental_bio/detection.ts b/src/developmental_bio/detection.ts
new file mode 100644
index 000000000..4d48839a1
--- /dev/null
+++ b/src/developmental_bio/detection.ts
@@ -0,0 +1,14 @@
+/** developmental_bio detection module — tsb analytics library. */
+export interface DevelopmentalBioDetectionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDetectionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDetection(data: number[], opts: DevelopmentalBioDetectionOptions = {}): DevelopmentalBioDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDetection };
diff --git a/src/developmental_bio/deterministic.ts b/src/developmental_bio/deterministic.ts
new file mode 100644
index 000000000..c9ed9042e
--- /dev/null
+++ b/src/developmental_bio/deterministic.ts
@@ -0,0 +1,14 @@
+/** developmental_bio deterministic module — tsb analytics library. */
+export interface DevelopmentalBioDeterministicOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDeterministicResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDeterministic(data: number[], opts: DevelopmentalBioDeterministicOptions = {}): DevelopmentalBioDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDeterministic };
diff --git a/src/developmental_bio/diagnostics.ts b/src/developmental_bio/diagnostics.ts
new file mode 100644
index 000000000..ebbdbceec
--- /dev/null
+++ b/src/developmental_bio/diagnostics.ts
@@ -0,0 +1,14 @@
+/** developmental_bio diagnostics module — tsb analytics library. */
+export interface DevelopmentalBioDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDiagnostics(data: number[], opts: DevelopmentalBioDiagnosticsOptions = {}): DevelopmentalBioDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDiagnostics };
diff --git a/src/developmental_bio/differential.ts b/src/developmental_bio/differential.ts
new file mode 100644
index 000000000..8bb4a7b35
--- /dev/null
+++ b/src/developmental_bio/differential.ts
@@ -0,0 +1,14 @@
+/** developmental_bio differential module — tsb analytics library. */
+export interface DevelopmentalBioDifferentialOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDifferentialResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDifferential(data: number[], opts: DevelopmentalBioDifferentialOptions = {}): DevelopmentalBioDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDifferential };
diff --git a/src/developmental_bio/discrete.ts b/src/developmental_bio/discrete.ts
new file mode 100644
index 000000000..847ddf4ab
--- /dev/null
+++ b/src/developmental_bio/discrete.ts
@@ -0,0 +1,14 @@
+/** developmental_bio discrete module — tsb analytics library. */
+export interface DevelopmentalBioDiscreteOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDiscreteResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDiscrete(data: number[], opts: DevelopmentalBioDiscreteOptions = {}): DevelopmentalBioDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDiscrete };
diff --git a/src/developmental_bio/distribution.ts b/src/developmental_bio/distribution.ts
new file mode 100644
index 000000000..b5a1d50b2
--- /dev/null
+++ b/src/developmental_bio/distribution.ts
@@ -0,0 +1,14 @@
+/** developmental_bio distribution module — tsb analytics library. */
+export interface DevelopmentalBioDistributionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDistributionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDistribution(data: number[], opts: DevelopmentalBioDistributionOptions = {}): DevelopmentalBioDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDistribution };
diff --git a/src/developmental_bio/dynamic.ts b/src/developmental_bio/dynamic.ts
new file mode 100644
index 000000000..cd08e7e0f
--- /dev/null
+++ b/src/developmental_bio/dynamic.ts
@@ -0,0 +1,14 @@
+/** developmental_bio dynamic module — tsb analytics library. */
+export interface DevelopmentalBioDynamicOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioDynamicResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioDynamic(data: number[], opts: DevelopmentalBioDynamicOptions = {}): DevelopmentalBioDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioDynamic };
diff --git a/src/developmental_bio/embedding.ts b/src/developmental_bio/embedding.ts
new file mode 100644
index 000000000..34a8865d8
--- /dev/null
+++ b/src/developmental_bio/embedding.ts
@@ -0,0 +1,14 @@
+/** developmental_bio embedding module — tsb analytics library. */
+export interface DevelopmentalBioEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioEmbeddingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioEmbedding(data: number[], opts: DevelopmentalBioEmbeddingOptions = {}): DevelopmentalBioEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioEmbedding };
diff --git a/src/developmental_bio/encoding.ts b/src/developmental_bio/encoding.ts
new file mode 100644
index 000000000..53fd11417
--- /dev/null
+++ b/src/developmental_bio/encoding.ts
@@ -0,0 +1,14 @@
+/** developmental_bio encoding module — tsb analytics library. */
+export interface DevelopmentalBioEncodingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioEncodingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioEncoding(data: number[], opts: DevelopmentalBioEncodingOptions = {}): DevelopmentalBioEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioEncoding };
diff --git a/src/developmental_bio/ensemble.ts b/src/developmental_bio/ensemble.ts
new file mode 100644
index 000000000..9edd50eb9
--- /dev/null
+++ b/src/developmental_bio/ensemble.ts
@@ -0,0 +1,14 @@
+/** developmental_bio ensemble module — tsb analytics library. */
+export interface DevelopmentalBioEnsembleOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioEnsembleResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioEnsemble(data: number[], opts: DevelopmentalBioEnsembleOptions = {}): DevelopmentalBioEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioEnsemble };
diff --git a/src/developmental_bio/estimation.ts b/src/developmental_bio/estimation.ts
new file mode 100644
index 000000000..b6af48328
--- /dev/null
+++ b/src/developmental_bio/estimation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio estimation module — tsb analytics library. */
+export interface DevelopmentalBioEstimationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioEstimationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioEstimation(data: number[], opts: DevelopmentalBioEstimationOptions = {}): DevelopmentalBioEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioEstimation };
diff --git a/src/developmental_bio/evaluation.ts b/src/developmental_bio/evaluation.ts
new file mode 100644
index 000000000..247b1f2b8
--- /dev/null
+++ b/src/developmental_bio/evaluation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio evaluation module — tsb analytics library. */
+export interface DevelopmentalBioEvaluationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioEvaluationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioEvaluation(data: number[], opts: DevelopmentalBioEvaluationOptions = {}): DevelopmentalBioEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioEvaluation };
diff --git a/src/developmental_bio/extrapolation.ts b/src/developmental_bio/extrapolation.ts
new file mode 100644
index 000000000..a7a29f1b5
--- /dev/null
+++ b/src/developmental_bio/extrapolation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio extrapolation module — tsb analytics library. */
+export interface DevelopmentalBioExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioExtrapolationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioExtrapolation(data: number[], opts: DevelopmentalBioExtrapolationOptions = {}): DevelopmentalBioExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioExtrapolation };
diff --git a/src/developmental_bio/features.ts b/src/developmental_bio/features.ts
new file mode 100644
index 000000000..0de95e146
--- /dev/null
+++ b/src/developmental_bio/features.ts
@@ -0,0 +1,14 @@
+/** developmental_bio features module — tsb analytics library. */
+export interface DevelopmentalBioFeaturesOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioFeaturesResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioFeatures(data: number[], opts: DevelopmentalBioFeaturesOptions = {}): DevelopmentalBioFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioFeatures };
diff --git a/src/developmental_bio/feedback.ts b/src/developmental_bio/feedback.ts
new file mode 100644
index 000000000..8c14cecd5
--- /dev/null
+++ b/src/developmental_bio/feedback.ts
@@ -0,0 +1,14 @@
+/** developmental_bio feedback module — tsb analytics library. */
+export interface DevelopmentalBioFeedbackOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioFeedbackResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioFeedback(data: number[], opts: DevelopmentalBioFeedbackOptions = {}): DevelopmentalBioFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioFeedback };
diff --git a/src/developmental_bio/filtering.ts b/src/developmental_bio/filtering.ts
new file mode 100644
index 000000000..6cf725c31
--- /dev/null
+++ b/src/developmental_bio/filtering.ts
@@ -0,0 +1,14 @@
+/** developmental_bio filtering module — tsb analytics library. */
+export interface DevelopmentalBioFilteringOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioFilteringResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioFiltering(data: number[], opts: DevelopmentalBioFilteringOptions = {}): DevelopmentalBioFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioFiltering };
diff --git a/src/developmental_bio/fourier.ts b/src/developmental_bio/fourier.ts
new file mode 100644
index 000000000..2c3456c28
--- /dev/null
+++ b/src/developmental_bio/fourier.ts
@@ -0,0 +1,14 @@
+/** developmental_bio fourier module — tsb analytics library. */
+export interface DevelopmentalBioFourierOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioFourierResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioFourier(data: number[], opts: DevelopmentalBioFourierOptions = {}): DevelopmentalBioFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioFourier };
diff --git a/src/developmental_bio/fusion.ts b/src/developmental_bio/fusion.ts
new file mode 100644
index 000000000..aa2855ef0
--- /dev/null
+++ b/src/developmental_bio/fusion.ts
@@ -0,0 +1,14 @@
+/** developmental_bio fusion module — tsb analytics library. */
+export interface DevelopmentalBioFusionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioFusionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioFusion(data: number[], opts: DevelopmentalBioFusionOptions = {}): DevelopmentalBioFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioFusion };
diff --git a/src/developmental_bio/generation.ts b/src/developmental_bio/generation.ts
new file mode 100644
index 000000000..c8d95b6ef
--- /dev/null
+++ b/src/developmental_bio/generation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio generation module — tsb analytics library. */
+export interface DevelopmentalBioGenerationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioGenerationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioGeneration(data: number[], opts: DevelopmentalBioGenerationOptions = {}): DevelopmentalBioGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioGeneration };
diff --git a/src/developmental_bio/geometry.ts b/src/developmental_bio/geometry.ts
new file mode 100644
index 000000000..5175673fe
--- /dev/null
+++ b/src/developmental_bio/geometry.ts
@@ -0,0 +1,14 @@
+/** developmental_bio geometry module — tsb analytics library. */
+export interface DevelopmentalBioGeometryOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioGeometryResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioGeometry(data: number[], opts: DevelopmentalBioGeometryOptions = {}): DevelopmentalBioGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioGeometry };
diff --git a/src/developmental_bio/gradient.ts b/src/developmental_bio/gradient.ts
new file mode 100644
index 000000000..760950f29
--- /dev/null
+++ b/src/developmental_bio/gradient.ts
@@ -0,0 +1,14 @@
+/** developmental_bio gradient module — tsb analytics library. */
+export interface DevelopmentalBioGradientOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioGradientResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioGradient(data: number[], opts: DevelopmentalBioGradientOptions = {}): DevelopmentalBioGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioGradient };
diff --git a/src/developmental_bio/hessian.ts b/src/developmental_bio/hessian.ts
new file mode 100644
index 000000000..8d9b8d3b8
--- /dev/null
+++ b/src/developmental_bio/hessian.ts
@@ -0,0 +1,14 @@
+/** developmental_bio hessian module — tsb analytics library. */
+export interface DevelopmentalBioHessianOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioHessianResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioHessian(data: number[], opts: DevelopmentalBioHessianOptions = {}): DevelopmentalBioHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioHessian };
diff --git a/src/developmental_bio/hypothesis.ts b/src/developmental_bio/hypothesis.ts
new file mode 100644
index 000000000..197b0a2e5
--- /dev/null
+++ b/src/developmental_bio/hypothesis.ts
@@ -0,0 +1,14 @@
+/** developmental_bio hypothesis module — tsb analytics library. */
+export interface DevelopmentalBioHypothesisOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioHypothesisResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioHypothesis(data: number[], opts: DevelopmentalBioHypothesisOptions = {}): DevelopmentalBioHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioHypothesis };
diff --git a/src/developmental_bio/inference.ts b/src/developmental_bio/inference.ts
new file mode 100644
index 000000000..afb3ac948
--- /dev/null
+++ b/src/developmental_bio/inference.ts
@@ -0,0 +1,14 @@
+/** developmental_bio inference module — tsb analytics library. */
+export interface DevelopmentalBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioInferenceResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioInference(data: number[], opts: DevelopmentalBioInferenceOptions = {}): DevelopmentalBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioInference };
diff --git a/src/developmental_bio/inference2.ts b/src/developmental_bio/inference2.ts
new file mode 100644
index 000000000..77dc42ab7
--- /dev/null
+++ b/src/developmental_bio/inference2.ts
@@ -0,0 +1,14 @@
+/** developmental_bio inference2 module — tsb analytics library. */
+export interface DevelopmentalBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioInferenceResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioInference(data: number[], opts: DevelopmentalBioInferenceOptions = {}): DevelopmentalBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioInference };
diff --git a/src/developmental_bio/integral.ts b/src/developmental_bio/integral.ts
new file mode 100644
index 000000000..11cf2473b
--- /dev/null
+++ b/src/developmental_bio/integral.ts
@@ -0,0 +1,14 @@
+/** developmental_bio integral module — tsb analytics library. */
+export interface DevelopmentalBioIntegralOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioIntegralResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioIntegral(data: number[], opts: DevelopmentalBioIntegralOptions = {}): DevelopmentalBioIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioIntegral };
diff --git a/src/developmental_bio/integration.ts b/src/developmental_bio/integration.ts
new file mode 100644
index 000000000..409eccff7
--- /dev/null
+++ b/src/developmental_bio/integration.ts
@@ -0,0 +1,14 @@
+/** developmental_bio integration module — tsb analytics library. */
+export interface DevelopmentalBioIntegrationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioIntegrationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioIntegration(data: number[], opts: DevelopmentalBioIntegrationOptions = {}): DevelopmentalBioIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioIntegration };
diff --git a/src/developmental_bio/interpolation.ts b/src/developmental_bio/interpolation.ts
new file mode 100644
index 000000000..6f61416c3
--- /dev/null
+++ b/src/developmental_bio/interpolation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio interpolation module — tsb analytics library. */
+export interface DevelopmentalBioInterpolationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioInterpolationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioInterpolation(data: number[], opts: DevelopmentalBioInterpolationOptions = {}): DevelopmentalBioInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioInterpolation };
diff --git a/src/developmental_bio/jacobian.ts b/src/developmental_bio/jacobian.ts
new file mode 100644
index 000000000..b379d75ae
--- /dev/null
+++ b/src/developmental_bio/jacobian.ts
@@ -0,0 +1,14 @@
+/** developmental_bio jacobian module — tsb analytics library. */
+export interface DevelopmentalBioJacobianOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioJacobianResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioJacobian(data: number[], opts: DevelopmentalBioJacobianOptions = {}): DevelopmentalBioJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioJacobian };
diff --git a/src/developmental_bio/kernel.ts b/src/developmental_bio/kernel.ts
new file mode 100644
index 000000000..078b6f813
--- /dev/null
+++ b/src/developmental_bio/kernel.ts
@@ -0,0 +1,14 @@
+/** developmental_bio kernel module — tsb analytics library. */
+export interface DevelopmentalBioKernelOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioKernelResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioKernel(data: number[], opts: DevelopmentalBioKernelOptions = {}): DevelopmentalBioKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioKernel };
diff --git a/src/developmental_bio/laplacian.ts b/src/developmental_bio/laplacian.ts
new file mode 100644
index 000000000..d1f4bee09
--- /dev/null
+++ b/src/developmental_bio/laplacian.ts
@@ -0,0 +1,14 @@
+/** developmental_bio laplacian module — tsb analytics library. */
+export interface DevelopmentalBioLaplacianOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioLaplacianResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioLaplacian(data: number[], opts: DevelopmentalBioLaplacianOptions = {}): DevelopmentalBioLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioLaplacian };
diff --git a/src/developmental_bio/learning.ts b/src/developmental_bio/learning.ts
new file mode 100644
index 000000000..b02336f10
--- /dev/null
+++ b/src/developmental_bio/learning.ts
@@ -0,0 +1,14 @@
+/** developmental_bio learning module — tsb analytics library. */
+export interface DevelopmentalBioLearningOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioLearningResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioLearning(data: number[], opts: DevelopmentalBioLearningOptions = {}): DevelopmentalBioLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioLearning };
diff --git a/src/developmental_bio/linear.ts b/src/developmental_bio/linear.ts
new file mode 100644
index 000000000..fda871f15
--- /dev/null
+++ b/src/developmental_bio/linear.ts
@@ -0,0 +1,14 @@
+/** developmental_bio linear module — tsb analytics library. */
+export interface DevelopmentalBioLinearOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioLinearResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioLinear(data: number[], opts: DevelopmentalBioLinearOptions = {}): DevelopmentalBioLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioLinear };
diff --git a/src/developmental_bio/manifold.ts b/src/developmental_bio/manifold.ts
new file mode 100644
index 000000000..39b434686
--- /dev/null
+++ b/src/developmental_bio/manifold.ts
@@ -0,0 +1,14 @@
+/** developmental_bio manifold module — tsb analytics library. */
+export interface DevelopmentalBioManifoldOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioManifoldResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioManifold(data: number[], opts: DevelopmentalBioManifoldOptions = {}): DevelopmentalBioManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioManifold };
diff --git a/src/developmental_bio/matching.ts b/src/developmental_bio/matching.ts
new file mode 100644
index 000000000..8f2b17abe
--- /dev/null
+++ b/src/developmental_bio/matching.ts
@@ -0,0 +1,14 @@
+/** developmental_bio matching module — tsb analytics library. */
+export interface DevelopmentalBioMatchingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioMatchingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioMatching(data: number[], opts: DevelopmentalBioMatchingOptions = {}): DevelopmentalBioMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioMatching };
diff --git a/src/developmental_bio/measurement.ts b/src/developmental_bio/measurement.ts
new file mode 100644
index 000000000..3a48df07b
--- /dev/null
+++ b/src/developmental_bio/measurement.ts
@@ -0,0 +1,14 @@
+/** developmental_bio measurement module — tsb analytics library. */
+export interface DevelopmentalBioMeasurementOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioMeasurementResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioMeasurement(data: number[], opts: DevelopmentalBioMeasurementOptions = {}): DevelopmentalBioMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioMeasurement };
diff --git a/src/developmental_bio/metrics.ts b/src/developmental_bio/metrics.ts
new file mode 100644
index 000000000..8787cf580
--- /dev/null
+++ b/src/developmental_bio/metrics.ts
@@ -0,0 +1,14 @@
+/** developmental_bio metrics module — tsb analytics library. */
+export interface DevelopmentalBioMetricsOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioMetricsResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioMetrics(data: number[], opts: DevelopmentalBioMetricsOptions = {}): DevelopmentalBioMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioMetrics };
diff --git a/src/developmental_bio/modeling.ts b/src/developmental_bio/modeling.ts
new file mode 100644
index 000000000..a93605b76
--- /dev/null
+++ b/src/developmental_bio/modeling.ts
@@ -0,0 +1,14 @@
+/** developmental_bio modeling module — tsb analytics library. */
+export interface DevelopmentalBioModelingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioModelingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioModeling(data: number[], opts: DevelopmentalBioModelingOptions = {}): DevelopmentalBioModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioModeling };
diff --git a/src/developmental_bio/monitoring.ts b/src/developmental_bio/monitoring.ts
new file mode 100644
index 000000000..ae4703606
--- /dev/null
+++ b/src/developmental_bio/monitoring.ts
@@ -0,0 +1,14 @@
+/** developmental_bio monitoring module — tsb analytics library. */
+export interface DevelopmentalBioMonitoringOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioMonitoringResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioMonitoring(data: number[], opts: DevelopmentalBioMonitoringOptions = {}): DevelopmentalBioMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioMonitoring };
diff --git a/src/developmental_bio/nonlinear.ts b/src/developmental_bio/nonlinear.ts
new file mode 100644
index 000000000..ce84215d0
--- /dev/null
+++ b/src/developmental_bio/nonlinear.ts
@@ -0,0 +1,14 @@
+/** developmental_bio nonlinear module — tsb analytics library. */
+export interface DevelopmentalBioNonlinearOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioNonlinearResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioNonlinear(data: number[], opts: DevelopmentalBioNonlinearOptions = {}): DevelopmentalBioNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioNonlinear };
diff --git a/src/developmental_bio/normalization.ts b/src/developmental_bio/normalization.ts
new file mode 100644
index 000000000..36fe67f7d
--- /dev/null
+++ b/src/developmental_bio/normalization.ts
@@ -0,0 +1,14 @@
+/** developmental_bio normalization module — tsb analytics library. */
+export interface DevelopmentalBioNormalizationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioNormalizationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioNormalization(data: number[], opts: DevelopmentalBioNormalizationOptions = {}): DevelopmentalBioNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioNormalization };
diff --git a/src/developmental_bio/optimization.ts b/src/developmental_bio/optimization.ts
new file mode 100644
index 000000000..5ca31b1ef
--- /dev/null
+++ b/src/developmental_bio/optimization.ts
@@ -0,0 +1,14 @@
+/** developmental_bio optimization module — tsb analytics library. */
+export interface DevelopmentalBioOptimizationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioOptimizationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioOptimization(data: number[], opts: DevelopmentalBioOptimizationOptions = {}): DevelopmentalBioOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioOptimization };
diff --git a/src/developmental_bio/patterns.ts b/src/developmental_bio/patterns.ts
new file mode 100644
index 000000000..712533323
--- /dev/null
+++ b/src/developmental_bio/patterns.ts
@@ -0,0 +1,14 @@
+/** developmental_bio patterns module — tsb analytics library. */
+export interface DevelopmentalBioPatternsOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioPatternsResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioPatterns(data: number[], opts: DevelopmentalBioPatternsOptions = {}): DevelopmentalBioPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioPatterns };
diff --git a/src/developmental_bio/permutation.ts b/src/developmental_bio/permutation.ts
new file mode 100644
index 000000000..e84edbad3
--- /dev/null
+++ b/src/developmental_bio/permutation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio permutation module — tsb analytics library. */
+export interface DevelopmentalBioPermutationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioPermutationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioPermutation(data: number[], opts: DevelopmentalBioPermutationOptions = {}): DevelopmentalBioPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioPermutation };
diff --git a/src/developmental_bio/prediction.ts b/src/developmental_bio/prediction.ts
new file mode 100644
index 000000000..ef1df0c90
--- /dev/null
+++ b/src/developmental_bio/prediction.ts
@@ -0,0 +1,14 @@
+/** developmental_bio prediction module — tsb analytics library. */
+export interface DevelopmentalBioPredictionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioPredictionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioPrediction(data: number[], opts: DevelopmentalBioPredictionOptions = {}): DevelopmentalBioPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioPrediction };
diff --git a/src/developmental_bio/processing.ts b/src/developmental_bio/processing.ts
new file mode 100644
index 000000000..539b9d075
--- /dev/null
+++ b/src/developmental_bio/processing.ts
@@ -0,0 +1,14 @@
+/** developmental_bio processing module — tsb analytics library. */
+export interface DevelopmentalBioProcessingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioProcessingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioProcessing(data: number[], opts: DevelopmentalBioProcessingOptions = {}): DevelopmentalBioProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioProcessing };
diff --git a/src/developmental_bio/profiling.ts b/src/developmental_bio/profiling.ts
new file mode 100644
index 000000000..679f3b273
--- /dev/null
+++ b/src/developmental_bio/profiling.ts
@@ -0,0 +1,14 @@
+/** developmental_bio profiling module — tsb analytics library. */
+export interface DevelopmentalBioProfilingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioProfilingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioProfiling(data: number[], opts: DevelopmentalBioProfilingOptions = {}): DevelopmentalBioProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioProfiling };
diff --git a/src/developmental_bio/projection.ts b/src/developmental_bio/projection.ts
new file mode 100644
index 000000000..14d1de15f
--- /dev/null
+++ b/src/developmental_bio/projection.ts
@@ -0,0 +1,14 @@
+/** developmental_bio projection module — tsb analytics library. */
+export interface DevelopmentalBioProjectionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioProjectionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioProjection(data: number[], opts: DevelopmentalBioProjectionOptions = {}): DevelopmentalBioProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioProjection };
diff --git a/src/developmental_bio/ranking.ts b/src/developmental_bio/ranking.ts
new file mode 100644
index 000000000..4f835344a
--- /dev/null
+++ b/src/developmental_bio/ranking.ts
@@ -0,0 +1,14 @@
+/** developmental_bio ranking module — tsb analytics library. */
+export interface DevelopmentalBioRankingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioRankingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioRanking(data: number[], opts: DevelopmentalBioRankingOptions = {}): DevelopmentalBioRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioRanking };
diff --git a/src/developmental_bio/reconstruction.ts b/src/developmental_bio/reconstruction.ts
new file mode 100644
index 000000000..bfc3e623f
--- /dev/null
+++ b/src/developmental_bio/reconstruction.ts
@@ -0,0 +1,14 @@
+/** developmental_bio reconstruction module — tsb analytics library. */
+export interface DevelopmentalBioReconstructionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioReconstructionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioReconstruction(data: number[], opts: DevelopmentalBioReconstructionOptions = {}): DevelopmentalBioReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioReconstruction };
diff --git a/src/developmental_bio/registration.ts b/src/developmental_bio/registration.ts
new file mode 100644
index 000000000..c7357874c
--- /dev/null
+++ b/src/developmental_bio/registration.ts
@@ -0,0 +1,14 @@
+/** developmental_bio registration module — tsb analytics library. */
+export interface DevelopmentalBioRegistrationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioRegistrationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioRegistration(data: number[], opts: DevelopmentalBioRegistrationOptions = {}): DevelopmentalBioRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioRegistration };
diff --git a/src/developmental_bio/regression.ts b/src/developmental_bio/regression.ts
new file mode 100644
index 000000000..650999a2c
--- /dev/null
+++ b/src/developmental_bio/regression.ts
@@ -0,0 +1,14 @@
+/** developmental_bio regression module — tsb analytics library. */
+export interface DevelopmentalBioRegressionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioRegressionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioRegression(data: number[], opts: DevelopmentalBioRegressionOptions = {}): DevelopmentalBioRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioRegression };
diff --git a/src/developmental_bio/regularization.ts b/src/developmental_bio/regularization.ts
new file mode 100644
index 000000000..c2fe242ae
--- /dev/null
+++ b/src/developmental_bio/regularization.ts
@@ -0,0 +1,14 @@
+/** developmental_bio regularization module — tsb analytics library. */
+export interface DevelopmentalBioRegularizationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioRegularizationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioRegularization(data: number[], opts: DevelopmentalBioRegularizationOptions = {}): DevelopmentalBioRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioRegularization };
diff --git a/src/developmental_bio/robustness.ts b/src/developmental_bio/robustness.ts
new file mode 100644
index 000000000..75d3a17e9
--- /dev/null
+++ b/src/developmental_bio/robustness.ts
@@ -0,0 +1,14 @@
+/** developmental_bio robustness module — tsb analytics library. */
+export interface DevelopmentalBioRobustnessOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioRobustnessResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioRobustness(data: number[], opts: DevelopmentalBioRobustnessOptions = {}): DevelopmentalBioRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioRobustness };
diff --git a/src/developmental_bio/sampling.ts b/src/developmental_bio/sampling.ts
new file mode 100644
index 000000000..8a0533138
--- /dev/null
+++ b/src/developmental_bio/sampling.ts
@@ -0,0 +1,14 @@
+/** developmental_bio sampling module — tsb analytics library. */
+export interface DevelopmentalBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioSamplingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioSampling(data: number[], opts: DevelopmentalBioSamplingOptions = {}): DevelopmentalBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioSampling };
diff --git a/src/developmental_bio/sampling2.ts b/src/developmental_bio/sampling2.ts
new file mode 100644
index 000000000..d0038e775
--- /dev/null
+++ b/src/developmental_bio/sampling2.ts
@@ -0,0 +1,14 @@
+/** developmental_bio sampling2 module — tsb analytics library. */
+export interface DevelopmentalBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioSamplingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioSampling(data: number[], opts: DevelopmentalBioSamplingOptions = {}): DevelopmentalBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioSampling };
diff --git a/src/developmental_bio/scaling.ts b/src/developmental_bio/scaling.ts
new file mode 100644
index 000000000..096010c96
--- /dev/null
+++ b/src/developmental_bio/scaling.ts
@@ -0,0 +1,14 @@
+/** developmental_bio scaling module — tsb analytics library. */
+export interface DevelopmentalBioScalingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioScalingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioScaling(data: number[], opts: DevelopmentalBioScalingOptions = {}): DevelopmentalBioScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioScaling };
diff --git a/src/developmental_bio/scoring.ts b/src/developmental_bio/scoring.ts
new file mode 100644
index 000000000..2748bbfa7
--- /dev/null
+++ b/src/developmental_bio/scoring.ts
@@ -0,0 +1,14 @@
+/** developmental_bio scoring module — tsb analytics library. */
+export interface DevelopmentalBioScoringOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioScoringResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioScoring(data: number[], opts: DevelopmentalBioScoringOptions = {}): DevelopmentalBioScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioScoring };
diff --git a/src/developmental_bio/segmentation.ts b/src/developmental_bio/segmentation.ts
new file mode 100644
index 000000000..b117a94fa
--- /dev/null
+++ b/src/developmental_bio/segmentation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio segmentation module — tsb analytics library. */
+export interface DevelopmentalBioSegmentationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioSegmentationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioSegmentation(data: number[], opts: DevelopmentalBioSegmentationOptions = {}): DevelopmentalBioSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioSegmentation };
diff --git a/src/developmental_bio/selection.ts b/src/developmental_bio/selection.ts
new file mode 100644
index 000000000..d2c7a0541
--- /dev/null
+++ b/src/developmental_bio/selection.ts
@@ -0,0 +1,14 @@
+/** developmental_bio selection module — tsb analytics library. */
+export interface DevelopmentalBioSelectionOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioSelectionResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioSelection(data: number[], opts: DevelopmentalBioSelectionOptions = {}): DevelopmentalBioSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioSelection };
diff --git a/src/developmental_bio/sensitivity.ts b/src/developmental_bio/sensitivity.ts
new file mode 100644
index 000000000..ee6e594e8
--- /dev/null
+++ b/src/developmental_bio/sensitivity.ts
@@ -0,0 +1,14 @@
+/** developmental_bio sensitivity module — tsb analytics library. */
+export interface DevelopmentalBioSensitivityOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioSensitivityResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioSensitivity(data: number[], opts: DevelopmentalBioSensitivityOptions = {}): DevelopmentalBioSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioSensitivity };
diff --git a/src/developmental_bio/simulation.ts b/src/developmental_bio/simulation.ts
new file mode 100644
index 000000000..0c864e7b7
--- /dev/null
+++ b/src/developmental_bio/simulation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio simulation module — tsb analytics library. */
+export interface DevelopmentalBioSimulationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioSimulationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioSimulation(data: number[], opts: DevelopmentalBioSimulationOptions = {}): DevelopmentalBioSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioSimulation };
diff --git a/src/developmental_bio/smoothing.ts b/src/developmental_bio/smoothing.ts
new file mode 100644
index 000000000..e520331bd
--- /dev/null
+++ b/src/developmental_bio/smoothing.ts
@@ -0,0 +1,14 @@
+/** developmental_bio smoothing module — tsb analytics library. */
+export interface DevelopmentalBioSmoothingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioSmoothingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioSmoothing(data: number[], opts: DevelopmentalBioSmoothingOptions = {}): DevelopmentalBioSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioSmoothing };
diff --git a/src/developmental_bio/stability.ts b/src/developmental_bio/stability.ts
new file mode 100644
index 000000000..eda408340
--- /dev/null
+++ b/src/developmental_bio/stability.ts
@@ -0,0 +1,14 @@
+/** developmental_bio stability module — tsb analytics library. */
+export interface DevelopmentalBioStabilityOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioStabilityResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioStability(data: number[], opts: DevelopmentalBioStabilityOptions = {}): DevelopmentalBioStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioStability };
diff --git a/src/developmental_bio/stacking.ts b/src/developmental_bio/stacking.ts
new file mode 100644
index 000000000..d4385b55b
--- /dev/null
+++ b/src/developmental_bio/stacking.ts
@@ -0,0 +1,14 @@
+/** developmental_bio stacking module — tsb analytics library. */
+export interface DevelopmentalBioStackingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioStackingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioStacking(data: number[], opts: DevelopmentalBioStackingOptions = {}): DevelopmentalBioStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioStacking };
diff --git a/src/developmental_bio/standardization.ts b/src/developmental_bio/standardization.ts
new file mode 100644
index 000000000..b49560c13
--- /dev/null
+++ b/src/developmental_bio/standardization.ts
@@ -0,0 +1,14 @@
+/** developmental_bio standardization module — tsb analytics library. */
+export interface DevelopmentalBioStandardizationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioStandardizationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioStandardization(data: number[], opts: DevelopmentalBioStandardizationOptions = {}): DevelopmentalBioStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioStandardization };
diff --git a/src/developmental_bio/static.ts b/src/developmental_bio/static.ts
new file mode 100644
index 000000000..496a31370
--- /dev/null
+++ b/src/developmental_bio/static.ts
@@ -0,0 +1,14 @@
+/** developmental_bio static module — tsb analytics library. */
+export interface DevelopmentalBioStaticOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioStaticResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioStatic(data: number[], opts: DevelopmentalBioStaticOptions = {}): DevelopmentalBioStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioStatic };
diff --git a/src/developmental_bio/stochastic.ts b/src/developmental_bio/stochastic.ts
new file mode 100644
index 000000000..1eb84f710
--- /dev/null
+++ b/src/developmental_bio/stochastic.ts
@@ -0,0 +1,14 @@
+/** developmental_bio stochastic module — tsb analytics library. */
+export interface DevelopmentalBioStochasticOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioStochasticResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioStochastic(data: number[], opts: DevelopmentalBioStochasticOptions = {}): DevelopmentalBioStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioStochastic };
diff --git a/src/developmental_bio/synthesis.ts b/src/developmental_bio/synthesis.ts
new file mode 100644
index 000000000..c6973c9fe
--- /dev/null
+++ b/src/developmental_bio/synthesis.ts
@@ -0,0 +1,14 @@
+/** developmental_bio synthesis module — tsb analytics library. */
+export interface DevelopmentalBioSynthesisOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioSynthesisResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioSynthesis(data: number[], opts: DevelopmentalBioSynthesisOptions = {}): DevelopmentalBioSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioSynthesis };
diff --git a/src/developmental_bio/topology.ts b/src/developmental_bio/topology.ts
new file mode 100644
index 000000000..d6aad7209
--- /dev/null
+++ b/src/developmental_bio/topology.ts
@@ -0,0 +1,14 @@
+/** developmental_bio topology module — tsb analytics library. */
+export interface DevelopmentalBioTopologyOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioTopologyResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioTopology(data: number[], opts: DevelopmentalBioTopologyOptions = {}): DevelopmentalBioTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioTopology };
diff --git a/src/developmental_bio/tracking.ts b/src/developmental_bio/tracking.ts
new file mode 100644
index 000000000..01b088735
--- /dev/null
+++ b/src/developmental_bio/tracking.ts
@@ -0,0 +1,14 @@
+/** developmental_bio tracking module — tsb analytics library. */
+export interface DevelopmentalBioTrackingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioTrackingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioTracking(data: number[], opts: DevelopmentalBioTrackingOptions = {}): DevelopmentalBioTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioTracking };
diff --git a/src/developmental_bio/transform.ts b/src/developmental_bio/transform.ts
new file mode 100644
index 000000000..61c4b782c
--- /dev/null
+++ b/src/developmental_bio/transform.ts
@@ -0,0 +1,14 @@
+/** developmental_bio transform module — tsb analytics library. */
+export interface DevelopmentalBioTransformOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioTransformResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioTransform(data: number[], opts: DevelopmentalBioTransformOptions = {}): DevelopmentalBioTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioTransform };
diff --git a/src/developmental_bio/uncertainty.ts b/src/developmental_bio/uncertainty.ts
new file mode 100644
index 000000000..1a11092ee
--- /dev/null
+++ b/src/developmental_bio/uncertainty.ts
@@ -0,0 +1,14 @@
+/** developmental_bio uncertainty module — tsb analytics library. */
+export interface DevelopmentalBioUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioUncertaintyResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioUncertainty(data: number[], opts: DevelopmentalBioUncertaintyOptions = {}): DevelopmentalBioUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioUncertainty };
diff --git a/src/developmental_bio/validation.ts b/src/developmental_bio/validation.ts
new file mode 100644
index 000000000..4df24bdec
--- /dev/null
+++ b/src/developmental_bio/validation.ts
@@ -0,0 +1,14 @@
+/** developmental_bio validation module — tsb analytics library. */
+export interface DevelopmentalBioValidationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioValidationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioValidation(data: number[], opts: DevelopmentalBioValidationOptions = {}): DevelopmentalBioValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioValidation };
diff --git a/src/developmental_bio/verification.ts b/src/developmental_bio/verification.ts
new file mode 100644
index 000000000..5d70b7cec
--- /dev/null
+++ b/src/developmental_bio/verification.ts
@@ -0,0 +1,14 @@
+/** developmental_bio verification module — tsb analytics library. */
+export interface DevelopmentalBioVerificationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioVerificationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioVerification(data: number[], opts: DevelopmentalBioVerificationOptions = {}): DevelopmentalBioVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioVerification };
diff --git a/src/developmental_bio/visualization.ts b/src/developmental_bio/visualization.ts
new file mode 100644
index 000000000..1d53a45b9
--- /dev/null
+++ b/src/developmental_bio/visualization.ts
@@ -0,0 +1,14 @@
+/** developmental_bio visualization module — tsb analytics library. */
+export interface DevelopmentalBioVisualizationOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioVisualizationResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioVisualization(data: number[], opts: DevelopmentalBioVisualizationOptions = {}): DevelopmentalBioVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioVisualization };
diff --git a/src/developmental_bio/voting.ts b/src/developmental_bio/voting.ts
new file mode 100644
index 000000000..5af202c84
--- /dev/null
+++ b/src/developmental_bio/voting.ts
@@ -0,0 +1,14 @@
+/** developmental_bio voting module — tsb analytics library. */
+export interface DevelopmentalBioVotingOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioVotingResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioVoting(data: number[], opts: DevelopmentalBioVotingOptions = {}): DevelopmentalBioVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioVoting };
diff --git a/src/developmental_bio/wavelet.ts b/src/developmental_bio/wavelet.ts
new file mode 100644
index 000000000..2e6307486
--- /dev/null
+++ b/src/developmental_bio/wavelet.ts
@@ -0,0 +1,14 @@
+/** developmental_bio wavelet module — tsb analytics library. */
+export interface DevelopmentalBioWaveletOptions { tol?: number; maxIter?: number; }
+export interface DevelopmentalBioWaveletResult { values: number[]; converged: boolean; }
+export function computeDevelopmentalBioWavelet(data: number[], opts: DevelopmentalBioWaveletOptions = {}): DevelopmentalBioWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeDevelopmentalBioWavelet };
diff --git a/src/ecology/advanced.ts b/src/ecology/advanced.ts
new file mode 100644
index 000000000..93459526c
--- /dev/null
+++ b/src/ecology/advanced.ts
@@ -0,0 +1,15 @@
+/** Ecology Advanced module — tsb analytics library. */
+export interface Ecology advancedOptions { tol?: number; maxIter?: number; }
+export interface Ecology advancedResult { values: number[]; converged: boolean; }
+export function computeEcology advanced(data: number[], opts: Ecology advancedOptions = {}): Ecology advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology advanced };
diff --git a/src/ecology/base2.ts b/src/ecology/base2.ts
new file mode 100644
index 000000000..e270fe413
--- /dev/null
+++ b/src/ecology/base2.ts
@@ -0,0 +1,15 @@
+/** Ecology Base2 module — tsb analytics library. */
+export interface Ecology base2Options { tol?: number; maxIter?: number; }
+export interface Ecology base2Result { values: number[]; converged: boolean; }
+export function computeEcology base2(data: number[], opts: Ecology base2Options = {}): Ecology base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology base2 };
diff --git a/src/ecology/batch.ts b/src/ecology/batch.ts
new file mode 100644
index 000000000..2e8c30cda
--- /dev/null
+++ b/src/ecology/batch.ts
@@ -0,0 +1,15 @@
+/** Ecology Batch module — tsb analytics library. */
+export interface Ecology batchOptions { tol?: number; maxIter?: number; }
+export interface Ecology batchResult { values: number[]; converged: boolean; }
+export function computeEcology batch(data: number[], opts: Ecology batchOptions = {}): Ecology batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology batch };
diff --git a/src/ecology/beta.ts b/src/ecology/beta.ts
new file mode 100644
index 000000000..b90be94ab
--- /dev/null
+++ b/src/ecology/beta.ts
@@ -0,0 +1,15 @@
+/** Ecology Beta module — tsb analytics library. */
+export interface Ecology betaOptions { tol?: number; maxIter?: number; }
+export interface Ecology betaResult { values: number[]; converged: boolean; }
+export function computeEcology beta(data: number[], opts: Ecology betaOptions = {}): Ecology betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology beta };
diff --git a/src/ecology/biodiversity.ts b/src/ecology/biodiversity.ts
new file mode 100644
index 000000000..775772606
--- /dev/null
+++ b/src/ecology/biodiversity.ts
@@ -0,0 +1,22 @@
+/** Biodiversity module — tsb analytics library. */
+
+/** Options for Biodiversity. */
+export interface BiodiversityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Biodiversity. */
+export interface BiodiversityResult { values: number[]; converged: boolean; }
+
+/** Compute Biodiversity. */
+export function computeBiodiversity(data: number[], opts: BiodiversityOptions = {}): BiodiversityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBiodiversity };
diff --git a/src/ecology/carbon_flux.ts b/src/ecology/carbon_flux.ts
new file mode 100644
index 000000000..edf42396a
--- /dev/null
+++ b/src/ecology/carbon_flux.ts
@@ -0,0 +1,22 @@
+/** Carbon Flux module — tsb analytics library. */
+
+/** Options for Carbon Flux. */
+export interface CarbonFluxOptions { tol?: number; maxIter?: number; }
+
+/** Result from Carbon Flux. */
+export interface CarbonFluxResult { values: number[]; converged: boolean; }
+
+/** Compute Carbon Flux. */
+export function computeCarbonFlux(data: number[], opts: CarbonFluxOptions = {}): CarbonFluxResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCarbonFlux };
diff --git a/src/ecology/community.ts b/src/ecology/community.ts
new file mode 100644
index 000000000..3892c46b4
--- /dev/null
+++ b/src/ecology/community.ts
@@ -0,0 +1,22 @@
+/** Community module — tsb analytics library. */
+
+/** Options for Community. */
+export interface CommunityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Community. */
+export interface CommunityResult { values: number[]; converged: boolean; }
+
+/** Compute Community. */
+export function computeCommunity(data: number[], opts: CommunityOptions = {}): CommunityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCommunity };
diff --git a/src/ecology/connectivity.ts b/src/ecology/connectivity.ts
new file mode 100644
index 000000000..1879e9b48
--- /dev/null
+++ b/src/ecology/connectivity.ts
@@ -0,0 +1,22 @@
+/** Connectivity module — tsb analytics library. */
+
+/** Options for Connectivity. */
+export interface ConnectivityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Connectivity. */
+export interface ConnectivityResult { values: number[]; converged: boolean; }
+
+/** Compute Connectivity. */
+export function computeConnectivity(data: number[], opts: ConnectivityOptions = {}): ConnectivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConnectivity };
diff --git a/src/ecology/cpu.ts b/src/ecology/cpu.ts
new file mode 100644
index 000000000..b29046b65
--- /dev/null
+++ b/src/ecology/cpu.ts
@@ -0,0 +1,15 @@
+/** Ecology Cpu module — tsb analytics library. */
+export interface Ecology cpuOptions { tol?: number; maxIter?: number; }
+export interface Ecology cpuResult { values: number[]; converged: boolean; }
+export function computeEcology cpu(data: number[], opts: Ecology cpuOptions = {}): Ecology cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology cpu };
diff --git a/src/ecology/dense.ts b/src/ecology/dense.ts
new file mode 100644
index 000000000..faad1e0fb
--- /dev/null
+++ b/src/ecology/dense.ts
@@ -0,0 +1,15 @@
+/** Ecology Dense module — tsb analytics library. */
+export interface Ecology denseOptions { tol?: number; maxIter?: number; }
+export interface Ecology denseResult { values: number[]; converged: boolean; }
+export function computeEcology dense(data: number[], opts: Ecology denseOptions = {}): Ecology denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology dense };
diff --git a/src/ecology/detection.ts b/src/ecology/detection.ts
new file mode 100644
index 000000000..63e15e447
--- /dev/null
+++ b/src/ecology/detection.ts
@@ -0,0 +1,22 @@
+/** Detection module — tsb analytics library. */
+
+/** Options for Detection. */
+export interface DetectionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Detection. */
+export interface DetectionResult { values: number[]; converged: boolean; }
+
+/** Compute Detection. */
+export function computeDetection(data: number[], opts: DetectionOptions = {}): DetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDetection };
diff --git a/src/ecology/dispersal.ts b/src/ecology/dispersal.ts
new file mode 100644
index 000000000..5b7bf462e
--- /dev/null
+++ b/src/ecology/dispersal.ts
@@ -0,0 +1,22 @@
+/** Dispersal module — tsb analytics library. */
+
+/** Options for Dispersal. */
+export interface DispersalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dispersal. */
+export interface DispersalResult { values: number[]; converged: boolean; }
+
+/** Compute Dispersal. */
+export function computeDispersal(data: number[], opts: DispersalOptions = {}): DispersalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDispersal };
diff --git a/src/ecology/distance_sampling.ts b/src/ecology/distance_sampling.ts
new file mode 100644
index 000000000..f64959360
--- /dev/null
+++ b/src/ecology/distance_sampling.ts
@@ -0,0 +1,22 @@
+/** Distance Sampling module — tsb analytics library. */
+
+/** Options for Distance Sampling. */
+export interface DistanceSamplingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Distance Sampling. */
+export interface DistanceSamplingResult { values: number[]; converged: boolean; }
+
+/** Compute Distance Sampling. */
+export function computeDistanceSampling(data: number[], opts: DistanceSamplingOptions = {}): DistanceSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDistanceSampling };
diff --git a/src/ecology/distributed.ts b/src/ecology/distributed.ts
new file mode 100644
index 000000000..dbb93a763
--- /dev/null
+++ b/src/ecology/distributed.ts
@@ -0,0 +1,15 @@
+/** Ecology Distributed module — tsb analytics library. */
+export interface Ecology distributedOptions { tol?: number; maxIter?: number; }
+export interface Ecology distributedResult { values: number[]; converged: boolean; }
+export function computeEcology distributed(data: number[], opts: Ecology distributedOptions = {}): Ecology distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology distributed };
diff --git a/src/ecology/edge.ts b/src/ecology/edge.ts
new file mode 100644
index 000000000..380c37335
--- /dev/null
+++ b/src/ecology/edge.ts
@@ -0,0 +1,22 @@
+/** Edge module — tsb analytics library. */
+
+/** Options for Edge. */
+export interface EdgeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Edge. */
+export interface EdgeResult { values: number[]; converged: boolean; }
+
+/** Compute Edge. */
+export function computeEdge(data: number[], opts: EdgeOptions = {}): EdgeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEdge };
diff --git a/src/ecology/evenness.ts b/src/ecology/evenness.ts
new file mode 100644
index 000000000..823afecd4
--- /dev/null
+++ b/src/ecology/evenness.ts
@@ -0,0 +1,22 @@
+/** Evenness module — tsb analytics library. */
+
+/** Options for Evenness. */
+export interface EvennessOptions { tol?: number; maxIter?: number; }
+
+/** Result from Evenness. */
+export interface EvennessResult { values: number[]; converged: boolean; }
+
+/** Compute Evenness. */
+export function computeEvenness(data: number[], opts: EvennessOptions = {}): EvennessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEvenness };
diff --git a/src/ecology/experimental.ts b/src/ecology/experimental.ts
new file mode 100644
index 000000000..79e18d79c
--- /dev/null
+++ b/src/ecology/experimental.ts
@@ -0,0 +1,15 @@
+/** Ecology Experimental module — tsb analytics library. */
+export interface Ecology experimentalOptions { tol?: number; maxIter?: number; }
+export interface Ecology experimentalResult { values: number[]; converged: boolean; }
+export function computeEcology experimental(data: number[], opts: Ecology experimentalOptions = {}): Ecology experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology experimental };
diff --git a/src/ecology/fast.ts b/src/ecology/fast.ts
new file mode 100644
index 000000000..a985d7c8e
--- /dev/null
+++ b/src/ecology/fast.ts
@@ -0,0 +1,15 @@
+/** Ecology Fast module — tsb analytics library. */
+export interface Ecology fastOptions { tol?: number; maxIter?: number; }
+export interface Ecology fastResult { values: number[]; converged: boolean; }
+export function computeEcology fast(data: number[], opts: Ecology fastOptions = {}): Ecology fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology fast };
diff --git a/src/ecology/food_web.ts b/src/ecology/food_web.ts
new file mode 100644
index 000000000..4e0fc6f65
--- /dev/null
+++ b/src/ecology/food_web.ts
@@ -0,0 +1,22 @@
+/** Food Web module — tsb analytics library. */
+
+/** Options for Food Web. */
+export interface FoodWebOptions { tol?: number; maxIter?: number; }
+
+/** Result from Food Web. */
+export interface FoodWebResult { values: number[]; converged: boolean; }
+
+/** Compute Food Web. */
+export function computeFoodWeb(data: number[], opts: FoodWebOptions = {}): FoodWebResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFoodWeb };
diff --git a/src/ecology/fragmentation.ts b/src/ecology/fragmentation.ts
new file mode 100644
index 000000000..20bda7ebb
--- /dev/null
+++ b/src/ecology/fragmentation.ts
@@ -0,0 +1,22 @@
+/** Fragmentation module — tsb analytics library. */
+
+/** Options for Fragmentation. */
+export interface FragmentationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fragmentation. */
+export interface FragmentationResult { values: number[]; converged: boolean; }
+
+/** Compute Fragmentation. */
+export function computeFragmentation(data: number[], opts: FragmentationOptions = {}): FragmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFragmentation };
diff --git a/src/ecology/functional_diversity.ts b/src/ecology/functional_diversity.ts
new file mode 100644
index 000000000..d1a00432a
--- /dev/null
+++ b/src/ecology/functional_diversity.ts
@@ -0,0 +1,22 @@
+/** Functional Diversity module — tsb analytics library. */
+
+/** Options for Functional Diversity. */
+export interface FunctionalDiversityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Functional Diversity. */
+export interface FunctionalDiversityResult { values: number[]; converged: boolean; }
+
+/** Compute Functional Diversity. */
+export function computeFunctionalDiversity(data: number[], opts: FunctionalDiversityOptions = {}): FunctionalDiversityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFunctionalDiversity };
diff --git a/src/ecology/future.ts b/src/ecology/future.ts
new file mode 100644
index 000000000..bd2080748
--- /dev/null
+++ b/src/ecology/future.ts
@@ -0,0 +1,15 @@
+/** Ecology Future module — tsb analytics library. */
+export interface Ecology futureOptions { tol?: number; maxIter?: number; }
+export interface Ecology futureResult { values: number[]; converged: boolean; }
+export function computeEcology future(data: number[], opts: Ecology futureOptions = {}): Ecology futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology future };
diff --git a/src/ecology/gpu.ts b/src/ecology/gpu.ts
new file mode 100644
index 000000000..427351d0b
--- /dev/null
+++ b/src/ecology/gpu.ts
@@ -0,0 +1,15 @@
+/** Ecology Gpu module — tsb analytics library. */
+export interface Ecology gpuOptions { tol?: number; maxIter?: number; }
+export interface Ecology gpuResult { values: number[]; converged: boolean; }
+export function computeEcology gpu(data: number[], opts: Ecology gpuOptions = {}): Ecology gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology gpu };
diff --git a/src/ecology/island_biogeography.ts b/src/ecology/island_biogeography.ts
new file mode 100644
index 000000000..fea3a1c82
--- /dev/null
+++ b/src/ecology/island_biogeography.ts
@@ -0,0 +1,22 @@
+/** Island Biogeography module — tsb analytics library. */
+
+/** Options for Island Biogeography. */
+export interface IslandBiogeographyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Island Biogeography. */
+export interface IslandBiogeographyResult { values: number[]; converged: boolean; }
+
+/** Compute Island Biogeography. */
+export function computeIslandBiogeography(data: number[], opts: IslandBiogeographyOptions = {}): IslandBiogeographyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIslandBiogeography };
diff --git a/src/ecology/landscape.ts b/src/ecology/landscape.ts
new file mode 100644
index 000000000..d5f7abacb
--- /dev/null
+++ b/src/ecology/landscape.ts
@@ -0,0 +1,22 @@
+/** Landscape module — tsb analytics library. */
+
+/** Options for Landscape. */
+export interface LandscapeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Landscape. */
+export interface LandscapeResult { values: number[]; converged: boolean; }
+
+/** Compute Landscape. */
+export function computeLandscape(data: number[], opts: LandscapeOptions = {}): LandscapeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLandscape };
diff --git a/src/ecology/large.ts b/src/ecology/large.ts
new file mode 100644
index 000000000..58218966b
--- /dev/null
+++ b/src/ecology/large.ts
@@ -0,0 +1,15 @@
+/** Ecology Large module — tsb analytics library. */
+export interface Ecology largeOptions { tol?: number; maxIter?: number; }
+export interface Ecology largeResult { values: number[]; converged: boolean; }
+export function computeEcology large(data: number[], opts: Ecology largeOptions = {}): Ecology largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology large };
diff --git a/src/ecology/legacy.ts b/src/ecology/legacy.ts
new file mode 100644
index 000000000..3fb35be3e
--- /dev/null
+++ b/src/ecology/legacy.ts
@@ -0,0 +1,15 @@
+/** Ecology Legacy module — tsb analytics library. */
+export interface Ecology legacyOptions { tol?: number; maxIter?: number; }
+export interface Ecology legacyResult { values: number[]; converged: boolean; }
+export function computeEcology legacy(data: number[], opts: Ecology legacyOptions = {}): Ecology legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology legacy };
diff --git a/src/ecology/line_transect.ts b/src/ecology/line_transect.ts
new file mode 100644
index 000000000..290905992
--- /dev/null
+++ b/src/ecology/line_transect.ts
@@ -0,0 +1,22 @@
+/** Line Transect module — tsb analytics library. */
+
+/** Options for Line Transect. */
+export interface LineTransectOptions { tol?: number; maxIter?: number; }
+
+/** Result from Line Transect. */
+export interface LineTransectResult { values: number[]; converged: boolean; }
+
+/** Compute Line Transect. */
+export function computeLineTransect(data: number[], opts: LineTransectOptions = {}): LineTransectResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLineTransect };
diff --git a/src/ecology/lite.ts b/src/ecology/lite.ts
new file mode 100644
index 000000000..3c74ea2d5
--- /dev/null
+++ b/src/ecology/lite.ts
@@ -0,0 +1,15 @@
+/** Ecology Lite module — tsb analytics library. */
+export interface Ecology liteOptions { tol?: number; maxIter?: number; }
+export interface Ecology liteResult { values: number[]; converged: boolean; }
+export function computeEcology lite(data: number[], opts: Ecology liteOptions = {}): Ecology liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology lite };
diff --git a/src/ecology/mark_recapture.ts b/src/ecology/mark_recapture.ts
new file mode 100644
index 000000000..7db9cdc2f
--- /dev/null
+++ b/src/ecology/mark_recapture.ts
@@ -0,0 +1,22 @@
+/** Mark Recapture module — tsb analytics library. */
+
+/** Options for Mark Recapture. */
+export interface MarkRecaptureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mark Recapture. */
+export interface MarkRecaptureResult { values: number[]; converged: boolean; }
+
+/** Compute Mark Recapture. */
+export function computeMarkRecapture(data: number[], opts: MarkRecaptureOptions = {}): MarkRecaptureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMarkRecapture };
diff --git a/src/ecology/metacommunity.ts b/src/ecology/metacommunity.ts
new file mode 100644
index 000000000..b65b5a81e
--- /dev/null
+++ b/src/ecology/metacommunity.ts
@@ -0,0 +1,22 @@
+/** Metacommunity module — tsb analytics library. */
+
+/** Options for Metacommunity. */
+export interface MetacommunityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Metacommunity. */
+export interface MetacommunityResult { values: number[]; converged: boolean; }
+
+/** Compute Metacommunity. */
+export function computeMetacommunity(data: number[], opts: MetacommunityOptions = {}): MetacommunityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMetacommunity };
diff --git a/src/ecology/metapopulation.ts b/src/ecology/metapopulation.ts
new file mode 100644
index 000000000..0def3385e
--- /dev/null
+++ b/src/ecology/metapopulation.ts
@@ -0,0 +1,22 @@
+/** Metapopulation module — tsb analytics library. */
+
+/** Options for Metapopulation. */
+export interface MetapopulationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Metapopulation. */
+export interface MetapopulationResult { values: number[]; converged: boolean; }
+
+/** Compute Metapopulation. */
+export function computeMetapopulation(data: number[], opts: MetapopulationOptions = {}): MetapopulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMetapopulation };
diff --git a/src/ecology/migration_eco.ts b/src/ecology/migration_eco.ts
new file mode 100644
index 000000000..83bb24ba9
--- /dev/null
+++ b/src/ecology/migration_eco.ts
@@ -0,0 +1,22 @@
+/** Migration Eco module — tsb analytics library. */
+
+/** Options for Migration Eco. */
+export interface MigrationEcoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Migration Eco. */
+export interface MigrationEcoResult { values: number[]; converged: boolean; }
+
+/** Compute Migration Eco. */
+export function computeMigrationEco(data: number[], opts: MigrationEcoOptions = {}): MigrationEcoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMigrationEco };
diff --git a/src/ecology/mini.ts b/src/ecology/mini.ts
new file mode 100644
index 000000000..a6e7a2f0b
--- /dev/null
+++ b/src/ecology/mini.ts
@@ -0,0 +1,15 @@
+/** Ecology Mini module — tsb analytics library. */
+export interface Ecology miniOptions { tol?: number; maxIter?: number; }
+export interface Ecology miniResult { values: number[]; converged: boolean; }
+export function computeEcology mini(data: number[], opts: Ecology miniOptions = {}): Ecology miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology mini };
diff --git a/src/ecology/next.ts b/src/ecology/next.ts
new file mode 100644
index 000000000..3b093140d
--- /dev/null
+++ b/src/ecology/next.ts
@@ -0,0 +1,15 @@
+/** Ecology Next module — tsb analytics library. */
+export interface Ecology nextOptions { tol?: number; maxIter?: number; }
+export interface Ecology nextResult { values: number[]; converged: boolean; }
+export function computeEcology next(data: number[], opts: Ecology nextOptions = {}): Ecology nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology next };
diff --git a/src/ecology/nutrient_cycling.ts b/src/ecology/nutrient_cycling.ts
new file mode 100644
index 000000000..f46825d46
--- /dev/null
+++ b/src/ecology/nutrient_cycling.ts
@@ -0,0 +1,22 @@
+/** Nutrient Cycling module — tsb analytics library. */
+
+/** Options for Nutrient Cycling. */
+export interface NutrientCyclingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nutrient Cycling. */
+export interface NutrientCyclingResult { values: number[]; converged: boolean; }
+
+/** Compute Nutrient Cycling. */
+export function computeNutrientCycling(data: number[], opts: NutrientCyclingOptions = {}): NutrientCyclingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNutrientCycling };
diff --git a/src/ecology/occupancy.ts b/src/ecology/occupancy.ts
new file mode 100644
index 000000000..e04955f2a
--- /dev/null
+++ b/src/ecology/occupancy.ts
@@ -0,0 +1,22 @@
+/** Occupancy module — tsb analytics library. */
+
+/** Options for Occupancy. */
+export interface OccupancyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Occupancy. */
+export interface OccupancyResult { values: number[]; converged: boolean; }
+
+/** Compute Occupancy. */
+export function computeOccupancy(data: number[], opts: OccupancyOptions = {}): OccupancyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOccupancy };
diff --git a/src/ecology/online.ts b/src/ecology/online.ts
new file mode 100644
index 000000000..15110490d
--- /dev/null
+++ b/src/ecology/online.ts
@@ -0,0 +1,15 @@
+/** Ecology Online module — tsb analytics library. */
+export interface Ecology onlineOptions { tol?: number; maxIter?: number; }
+export interface Ecology onlineResult { values: number[]; converged: boolean; }
+export function computeEcology online(data: number[], opts: Ecology onlineOptions = {}): Ecology onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology online };
diff --git a/src/ecology/parallel.ts b/src/ecology/parallel.ts
new file mode 100644
index 000000000..b148e0358
--- /dev/null
+++ b/src/ecology/parallel.ts
@@ -0,0 +1,15 @@
+/** Ecology Parallel module — tsb analytics library. */
+export interface Ecology parallelOptions { tol?: number; maxIter?: number; }
+export interface Ecology parallelResult { values: number[]; converged: boolean; }
+export function computeEcology parallel(data: number[], opts: Ecology parallelOptions = {}): Ecology parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology parallel };
diff --git a/src/ecology/phylogenetic_diversity.ts b/src/ecology/phylogenetic_diversity.ts
new file mode 100644
index 000000000..fd4d33213
--- /dev/null
+++ b/src/ecology/phylogenetic_diversity.ts
@@ -0,0 +1,22 @@
+/** Phylogenetic Diversity module — tsb analytics library. */
+
+/** Options for Phylogenetic Diversity. */
+export interface PhylogeneticDiversityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Phylogenetic Diversity. */
+export interface PhylogeneticDiversityResult { values: number[]; converged: boolean; }
+
+/** Compute Phylogenetic Diversity. */
+export function computePhylogeneticDiversity(data: number[], opts: PhylogeneticDiversityOptions = {}): PhylogeneticDiversityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhylogeneticDiversity };
diff --git a/src/ecology/plus.ts b/src/ecology/plus.ts
new file mode 100644
index 000000000..5be730025
--- /dev/null
+++ b/src/ecology/plus.ts
@@ -0,0 +1,15 @@
+/** Ecology Plus module — tsb analytics library. */
+export interface Ecology plusOptions { tol?: number; maxIter?: number; }
+export interface Ecology plusResult { values: number[]; converged: boolean; }
+export function computeEcology plus(data: number[], opts: Ecology plusOptions = {}): Ecology plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology plus };
diff --git a/src/ecology/point_count.ts b/src/ecology/point_count.ts
new file mode 100644
index 000000000..358a6df6e
--- /dev/null
+++ b/src/ecology/point_count.ts
@@ -0,0 +1,22 @@
+/** Point Count module — tsb analytics library. */
+
+/** Options for Point Count. */
+export interface PointCountOptions { tol?: number; maxIter?: number; }
+
+/** Result from Point Count. */
+export interface PointCountResult { values: number[]; converged: boolean; }
+
+/** Compute Point Count. */
+export function computePointCount(data: number[], opts: PointCountOptions = {}): PointCountResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePointCount };
diff --git a/src/ecology/population_dynamics.ts b/src/ecology/population_dynamics.ts
new file mode 100644
index 000000000..5bc6977b5
--- /dev/null
+++ b/src/ecology/population_dynamics.ts
@@ -0,0 +1,22 @@
+/** Population Dynamics module — tsb analytics library. */
+
+/** Options for Population Dynamics. */
+export interface PopulationDynamicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Population Dynamics. */
+export interface PopulationDynamicsResult { values: number[]; converged: boolean; }
+
+/** Compute Population Dynamics. */
+export function computePopulationDynamics(data: number[], opts: PopulationDynamicsOptions = {}): PopulationDynamicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePopulationDynamics };
diff --git a/src/ecology/pro.ts b/src/ecology/pro.ts
new file mode 100644
index 000000000..4e7218518
--- /dev/null
+++ b/src/ecology/pro.ts
@@ -0,0 +1,15 @@
+/** Ecology Pro module — tsb analytics library. */
+export interface Ecology proOptions { tol?: number; maxIter?: number; }
+export interface Ecology proResult { values: number[]; converged: boolean; }
+export function computeEcology pro(data: number[], opts: Ecology proOptions = {}): Ecology proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology pro };
diff --git a/src/ecology/radio_telemetry.ts b/src/ecology/radio_telemetry.ts
new file mode 100644
index 000000000..ab7bdcdfa
--- /dev/null
+++ b/src/ecology/radio_telemetry.ts
@@ -0,0 +1,22 @@
+/** Radio Telemetry module — tsb analytics library. */
+
+/** Options for Radio Telemetry. */
+export interface RadioTelemetryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Radio Telemetry. */
+export interface RadioTelemetryResult { values: number[]; converged: boolean; }
+
+/** Compute Radio Telemetry. */
+export function computeRadioTelemetry(data: number[], opts: RadioTelemetryOptions = {}): RadioTelemetryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRadioTelemetry };
diff --git a/src/ecology/remote_sensing_eco.ts b/src/ecology/remote_sensing_eco.ts
new file mode 100644
index 000000000..ab58d194b
--- /dev/null
+++ b/src/ecology/remote_sensing_eco.ts
@@ -0,0 +1,22 @@
+/** Remote Sensing Eco module — tsb analytics library. */
+
+/** Options for Remote Sensing Eco. */
+export interface RemoteSensingEcoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Remote Sensing Eco. */
+export interface RemoteSensingEcoResult { values: number[]; converged: boolean; }
+
+/** Compute Remote Sensing Eco. */
+export function computeRemoteSensingEco(data: number[], opts: RemoteSensingEcoOptions = {}): RemoteSensingEcoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRemoteSensingEco };
diff --git a/src/ecology/richness.ts b/src/ecology/richness.ts
new file mode 100644
index 000000000..d6b205edc
--- /dev/null
+++ b/src/ecology/richness.ts
@@ -0,0 +1,22 @@
+/** Richness module — tsb analytics library. */
+
+/** Options for Richness. */
+export interface RichnessOptions { tol?: number; maxIter?: number; }
+
+/** Result from Richness. */
+export interface RichnessResult { values: number[]; converged: boolean; }
+
+/** Compute Richness. */
+export function computeRichness(data: number[], opts: RichnessOptions = {}): RichnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRichness };
diff --git a/src/ecology/robust.ts b/src/ecology/robust.ts
new file mode 100644
index 000000000..fac4bf1ec
--- /dev/null
+++ b/src/ecology/robust.ts
@@ -0,0 +1,15 @@
+/** Ecology Robust module — tsb analytics library. */
+export interface Ecology robustOptions { tol?: number; maxIter?: number; }
+export interface Ecology robustResult { values: number[]; converged: boolean; }
+export function computeEcology robust(data: number[], opts: Ecology robustOptions = {}): Ecology robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology robust };
diff --git a/src/ecology/small.ts b/src/ecology/small.ts
new file mode 100644
index 000000000..97e23884a
--- /dev/null
+++ b/src/ecology/small.ts
@@ -0,0 +1,15 @@
+/** Ecology Small module — tsb analytics library. */
+export interface Ecology smallOptions { tol?: number; maxIter?: number; }
+export interface Ecology smallResult { values: number[]; converged: boolean; }
+export function computeEcology small(data: number[], opts: Ecology smallOptions = {}): Ecology smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology small };
diff --git a/src/ecology/source_sink.ts b/src/ecology/source_sink.ts
new file mode 100644
index 000000000..9aa7d0f3e
--- /dev/null
+++ b/src/ecology/source_sink.ts
@@ -0,0 +1,22 @@
+/** Source Sink module — tsb analytics library. */
+
+/** Options for Source Sink. */
+export interface SourceSinkOptions { tol?: number; maxIter?: number; }
+
+/** Result from Source Sink. */
+export interface SourceSinkResult { values: number[]; converged: boolean; }
+
+/** Compute Source Sink. */
+export function computeSourceSink(data: number[], opts: SourceSinkOptions = {}): SourceSinkResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSourceSink };
diff --git a/src/ecology/sparse.ts b/src/ecology/sparse.ts
new file mode 100644
index 000000000..c9696c64e
--- /dev/null
+++ b/src/ecology/sparse.ts
@@ -0,0 +1,15 @@
+/** Ecology Sparse module — tsb analytics library. */
+export interface Ecology sparseOptions { tol?: number; maxIter?: number; }
+export interface Ecology sparseResult { values: number[]; converged: boolean; }
+export function computeEcology sparse(data: number[], opts: Ecology sparseOptions = {}): Ecology sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology sparse };
diff --git a/src/ecology/species_distribution.ts b/src/ecology/species_distribution.ts
new file mode 100644
index 000000000..7ac9af947
--- /dev/null
+++ b/src/ecology/species_distribution.ts
@@ -0,0 +1,22 @@
+/** Species Distribution module — tsb analytics library. */
+
+/** Options for Species Distribution. */
+export interface SpeciesDistributionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Species Distribution. */
+export interface SpeciesDistributionResult { values: number[]; converged: boolean; }
+
+/** Compute Species Distribution. */
+export function computeSpeciesDistribution(data: number[], opts: SpeciesDistributionOptions = {}): SpeciesDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpeciesDistribution };
diff --git a/src/ecology/stable.ts b/src/ecology/stable.ts
new file mode 100644
index 000000000..6edd74c4b
--- /dev/null
+++ b/src/ecology/stable.ts
@@ -0,0 +1,15 @@
+/** Ecology Stable module — tsb analytics library. */
+export interface Ecology stableOptions { tol?: number; maxIter?: number; }
+export interface Ecology stableResult { values: number[]; converged: boolean; }
+export function computeEcology stable(data: number[], opts: Ecology stableOptions = {}): Ecology stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology stable };
diff --git a/src/ecology/streaming.ts b/src/ecology/streaming.ts
new file mode 100644
index 000000000..99aec1a89
--- /dev/null
+++ b/src/ecology/streaming.ts
@@ -0,0 +1,15 @@
+/** Ecology Streaming module — tsb analytics library. */
+export interface Ecology streamingOptions { tol?: number; maxIter?: number; }
+export interface Ecology streamingResult { values: number[]; converged: boolean; }
+export function computeEcology streaming(data: number[], opts: Ecology streamingOptions = {}): Ecology streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology streaming };
diff --git a/src/ecology/trophic.ts b/src/ecology/trophic.ts
new file mode 100644
index 000000000..46828c496
--- /dev/null
+++ b/src/ecology/trophic.ts
@@ -0,0 +1,22 @@
+/** Trophic module — tsb analytics library. */
+
+/** Options for Trophic. */
+export interface TrophicOptions { tol?: number; maxIter?: number; }
+
+/** Result from Trophic. */
+export interface TrophicResult { values: number[]; converged: boolean; }
+
+/** Compute Trophic. */
+export function computeTrophic(data: number[], opts: TrophicOptions = {}): TrophicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTrophic };
diff --git a/src/ecology/v2.ts b/src/ecology/v2.ts
new file mode 100644
index 000000000..4e5233d87
--- /dev/null
+++ b/src/ecology/v2.ts
@@ -0,0 +1,15 @@
+/** Ecology V2 module — tsb analytics library. */
+export interface Ecology v2Options { tol?: number; maxIter?: number; }
+export interface Ecology v2Result { values: number[]; converged: boolean; }
+export function computeEcology v2(data: number[], opts: Ecology v2Options = {}): Ecology v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology v2 };
diff --git a/src/ecology/v3.ts b/src/ecology/v3.ts
new file mode 100644
index 000000000..4a3998f2e
--- /dev/null
+++ b/src/ecology/v3.ts
@@ -0,0 +1,15 @@
+/** Ecology V3 module — tsb analytics library. */
+export interface Ecology v3Options { tol?: number; maxIter?: number; }
+export interface Ecology v3Result { values: number[]; converged: boolean; }
+export function computeEcology v3(data: number[], opts: Ecology v3Options = {}): Ecology v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology v3 };
diff --git a/src/ecology/wasm.ts b/src/ecology/wasm.ts
new file mode 100644
index 000000000..3d3ab249e
--- /dev/null
+++ b/src/ecology/wasm.ts
@@ -0,0 +1,15 @@
+/** Ecology Wasm module — tsb analytics library. */
+export interface Ecology wasmOptions { tol?: number; maxIter?: number; }
+export interface Ecology wasmResult { values: number[]; converged: boolean; }
+export function computeEcology wasm(data: number[], opts: Ecology wasmOptions = {}): Ecology wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology wasm };
diff --git a/src/ecology/xlarge.ts b/src/ecology/xlarge.ts
new file mode 100644
index 000000000..d605e0079
--- /dev/null
+++ b/src/ecology/xlarge.ts
@@ -0,0 +1,15 @@
+/** Ecology Xlarge module — tsb analytics library. */
+export interface Ecology xlargeOptions { tol?: number; maxIter?: number; }
+export interface Ecology xlargeResult { values: number[]; converged: boolean; }
+export function computeEcology xlarge(data: number[], opts: Ecology xlargeOptions = {}): Ecology xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcology xlarge };
diff --git a/src/econometrics/advanced.ts b/src/econometrics/advanced.ts
new file mode 100644
index 000000000..33f0b35e2
--- /dev/null
+++ b/src/econometrics/advanced.ts
@@ -0,0 +1,15 @@
+/** Econometrics Advanced module — tsb analytics library. */
+export interface Econometrics advancedOptions { tol?: number; maxIter?: number; }
+export interface Econometrics advancedResult { values: number[]; converged: boolean; }
+export function computeEconometrics advanced(data: number[], opts: Econometrics advancedOptions = {}): Econometrics advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics advanced };
diff --git a/src/econometrics/arch.ts b/src/econometrics/arch.ts
new file mode 100644
index 000000000..b86408f5c
--- /dev/null
+++ b/src/econometrics/arch.ts
@@ -0,0 +1,22 @@
+/** Arch module — tsb analytics library. */
+
+/** Options for Arch. */
+export interface ArchOptions { tol?: number; maxIter?: number; }
+
+/** Result from Arch. */
+export interface ArchResult { values: number[]; converged: boolean; }
+
+/** Compute Arch. */
+export function computeArch(data: number[], opts: ArchOptions = {}): ArchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeArch };
diff --git a/src/econometrics/base2.ts b/src/econometrics/base2.ts
new file mode 100644
index 000000000..312db8d48
--- /dev/null
+++ b/src/econometrics/base2.ts
@@ -0,0 +1,15 @@
+/** Econometrics Base2 module — tsb analytics library. */
+export interface Econometrics base2Options { tol?: number; maxIter?: number; }
+export interface Econometrics base2Result { values: number[]; converged: boolean; }
+export function computeEconometrics base2(data: number[], opts: Econometrics base2Options = {}): Econometrics base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics base2 };
diff --git a/src/econometrics/batch.ts b/src/econometrics/batch.ts
new file mode 100644
index 000000000..e91b14b6f
--- /dev/null
+++ b/src/econometrics/batch.ts
@@ -0,0 +1,15 @@
+/** Econometrics Batch module — tsb analytics library. */
+export interface Econometrics batchOptions { tol?: number; maxIter?: number; }
+export interface Econometrics batchResult { values: number[]; converged: boolean; }
+export function computeEconometrics batch(data: number[], opts: Econometrics batchOptions = {}): Econometrics batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics batch };
diff --git a/src/econometrics/bayesian_econ.ts b/src/econometrics/bayesian_econ.ts
new file mode 100644
index 000000000..1090939d0
--- /dev/null
+++ b/src/econometrics/bayesian_econ.ts
@@ -0,0 +1,22 @@
+/** Bayesian Econ module — tsb analytics library. */
+
+/** Options for Bayesian Econ. */
+export interface BayesianEconOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bayesian Econ. */
+export interface BayesianEconResult { values: number[]; converged: boolean; }
+
+/** Compute Bayesian Econ. */
+export function computeBayesianEcon(data: number[], opts: BayesianEconOptions = {}): BayesianEconResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBayesianEcon };
diff --git a/src/econometrics/beta.ts b/src/econometrics/beta.ts
new file mode 100644
index 000000000..56b1a4294
--- /dev/null
+++ b/src/econometrics/beta.ts
@@ -0,0 +1,15 @@
+/** Econometrics Beta module — tsb analytics library. */
+export interface Econometrics betaOptions { tol?: number; maxIter?: number; }
+export interface Econometrics betaResult { values: number[]; converged: boolean; }
+export function computeEconometrics beta(data: number[], opts: Econometrics betaOptions = {}): Econometrics betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics beta };
diff --git a/src/econometrics/bunching.ts b/src/econometrics/bunching.ts
new file mode 100644
index 000000000..e793831ce
--- /dev/null
+++ b/src/econometrics/bunching.ts
@@ -0,0 +1,22 @@
+/** Bunching module — tsb analytics library. */
+
+/** Options for Bunching. */
+export interface BunchingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bunching. */
+export interface BunchingResult { values: number[]; converged: boolean; }
+
+/** Compute Bunching. */
+export function computeBunching(data: number[], opts: BunchingOptions = {}): BunchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBunching };
diff --git a/src/econometrics/causal_forest.ts b/src/econometrics/causal_forest.ts
new file mode 100644
index 000000000..3c0175984
--- /dev/null
+++ b/src/econometrics/causal_forest.ts
@@ -0,0 +1,22 @@
+/** Causal Forest module — tsb analytics library. */
+
+/** Options for Causal Forest. */
+export interface CausalForestOptions { tol?: number; maxIter?: number; }
+
+/** Result from Causal Forest. */
+export interface CausalForestResult { values: number[]; converged: boolean; }
+
+/** Compute Causal Forest. */
+export function computeCausalForest(data: number[], opts: CausalForestOptions = {}): CausalForestResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCausalForest };
diff --git a/src/econometrics/cointegration.ts b/src/econometrics/cointegration.ts
new file mode 100644
index 000000000..1b657386e
--- /dev/null
+++ b/src/econometrics/cointegration.ts
@@ -0,0 +1,22 @@
+/** Cointegration module — tsb analytics library. */
+
+/** Options for Cointegration. */
+export interface CointegrationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cointegration. */
+export interface CointegrationResult { values: number[]; converged: boolean; }
+
+/** Compute Cointegration. */
+export function computeCointegration(data: number[], opts: CointegrationOptions = {}): CointegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCointegration };
diff --git a/src/econometrics/copula.ts b/src/econometrics/copula.ts
new file mode 100644
index 000000000..5d5d62b8c
--- /dev/null
+++ b/src/econometrics/copula.ts
@@ -0,0 +1,22 @@
+/** Copula module — tsb analytics library. */
+
+/** Options for Copula. */
+export interface CopulaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Copula. */
+export interface CopulaResult { values: number[]; converged: boolean; }
+
+/** Compute Copula. */
+export function computeCopula(data: number[], opts: CopulaOptions = {}): CopulaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCopula };
diff --git a/src/econometrics/count_data.ts b/src/econometrics/count_data.ts
new file mode 100644
index 000000000..e4aa9a893
--- /dev/null
+++ b/src/econometrics/count_data.ts
@@ -0,0 +1,22 @@
+/** Count Data module — tsb analytics library. */
+
+/** Options for Count Data. */
+export interface CountDataOptions { tol?: number; maxIter?: number; }
+
+/** Result from Count Data. */
+export interface CountDataResult { values: number[]; converged: boolean; }
+
+/** Compute Count Data. */
+export function computeCountData(data: number[], opts: CountDataOptions = {}): CountDataResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCountData };
diff --git a/src/econometrics/cpu.ts b/src/econometrics/cpu.ts
new file mode 100644
index 000000000..e4188b2be
--- /dev/null
+++ b/src/econometrics/cpu.ts
@@ -0,0 +1,15 @@
+/** Econometrics Cpu module — tsb analytics library. */
+export interface Econometrics cpuOptions { tol?: number; maxIter?: number; }
+export interface Econometrics cpuResult { values: number[]; converged: boolean; }
+export function computeEconometrics cpu(data: number[], opts: Econometrics cpuOptions = {}): Econometrics cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics cpu };
diff --git a/src/econometrics/debiased_ml.ts b/src/econometrics/debiased_ml.ts
new file mode 100644
index 000000000..1b4b0a582
--- /dev/null
+++ b/src/econometrics/debiased_ml.ts
@@ -0,0 +1,22 @@
+/** Debiased Ml module — tsb analytics library. */
+
+/** Options for Debiased Ml. */
+export interface DebiasedMlOptions { tol?: number; maxIter?: number; }
+
+/** Result from Debiased Ml. */
+export interface DebiasedMlResult { values: number[]; converged: boolean; }
+
+/** Compute Debiased Ml. */
+export function computeDebiasedMl(data: number[], opts: DebiasedMlOptions = {}): DebiasedMlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDebiasedMl };
diff --git a/src/econometrics/dense.ts b/src/econometrics/dense.ts
new file mode 100644
index 000000000..cb86ad343
--- /dev/null
+++ b/src/econometrics/dense.ts
@@ -0,0 +1,15 @@
+/** Econometrics Dense module — tsb analytics library. */
+export interface Econometrics denseOptions { tol?: number; maxIter?: number; }
+export interface Econometrics denseResult { values: number[]; converged: boolean; }
+export function computeEconometrics dense(data: number[], opts: Econometrics denseOptions = {}): Econometrics denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics dense };
diff --git a/src/econometrics/discrete_choice.ts b/src/econometrics/discrete_choice.ts
new file mode 100644
index 000000000..8aa9f978b
--- /dev/null
+++ b/src/econometrics/discrete_choice.ts
@@ -0,0 +1,22 @@
+/** Discrete Choice module — tsb analytics library. */
+
+/** Options for Discrete Choice. */
+export interface DiscreteChoiceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Discrete Choice. */
+export interface DiscreteChoiceResult { values: number[]; converged: boolean; }
+
+/** Compute Discrete Choice. */
+export function computeDiscreteChoice(data: number[], opts: DiscreteChoiceOptions = {}): DiscreteChoiceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDiscreteChoice };
diff --git a/src/econometrics/distributed.ts b/src/econometrics/distributed.ts
new file mode 100644
index 000000000..ef0380a51
--- /dev/null
+++ b/src/econometrics/distributed.ts
@@ -0,0 +1,15 @@
+/** Econometrics Distributed module — tsb analytics library. */
+export interface Econometrics distributedOptions { tol?: number; maxIter?: number; }
+export interface Econometrics distributedResult { values: number[]; converged: boolean; }
+export function computeEconometrics distributed(data: number[], opts: Econometrics distributedOptions = {}): Econometrics distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics distributed };
diff --git a/src/econometrics/double_ml.ts b/src/econometrics/double_ml.ts
new file mode 100644
index 000000000..828282c4c
--- /dev/null
+++ b/src/econometrics/double_ml.ts
@@ -0,0 +1,22 @@
+/** Double Ml module — tsb analytics library. */
+
+/** Options for Double Ml. */
+export interface DoubleMlOptions { tol?: number; maxIter?: number; }
+
+/** Result from Double Ml. */
+export interface DoubleMlResult { values: number[]; converged: boolean; }
+
+/** Compute Double Ml. */
+export function computeDoubleMl(data: number[], opts: DoubleMlOptions = {}): DoubleMlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDoubleMl };
diff --git a/src/econometrics/duration.ts b/src/econometrics/duration.ts
new file mode 100644
index 000000000..e3e382954
--- /dev/null
+++ b/src/econometrics/duration.ts
@@ -0,0 +1,22 @@
+/** Duration module — tsb analytics library. */
+
+/** Options for Duration. */
+export interface DurationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Duration. */
+export interface DurationResult { values: number[]; converged: boolean; }
+
+/** Compute Duration. */
+export function computeDuration(data: number[], opts: DurationOptions = {}): DurationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDuration };
diff --git a/src/econometrics/event_study.ts b/src/econometrics/event_study.ts
new file mode 100644
index 000000000..e1ac21e33
--- /dev/null
+++ b/src/econometrics/event_study.ts
@@ -0,0 +1,22 @@
+/** Event Study module — tsb analytics library. */
+
+/** Options for Event Study. */
+export interface EventStudyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Event Study. */
+export interface EventStudyResult { values: number[]; converged: boolean; }
+
+/** Compute Event Study. */
+export function computeEventStudy(data: number[], opts: EventStudyOptions = {}): EventStudyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEventStudy };
diff --git a/src/econometrics/experimental.ts b/src/econometrics/experimental.ts
new file mode 100644
index 000000000..fe6883c20
--- /dev/null
+++ b/src/econometrics/experimental.ts
@@ -0,0 +1,15 @@
+/** Econometrics Experimental module — tsb analytics library. */
+export interface Econometrics experimentalOptions { tol?: number; maxIter?: number; }
+export interface Econometrics experimentalResult { values: number[]; converged: boolean; }
+export function computeEconometrics experimental(data: number[], opts: Econometrics experimentalOptions = {}): Econometrics experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics experimental };
diff --git a/src/econometrics/fast.ts b/src/econometrics/fast.ts
new file mode 100644
index 000000000..4373b3e5e
--- /dev/null
+++ b/src/econometrics/fast.ts
@@ -0,0 +1,15 @@
+/** Econometrics Fast module — tsb analytics library. */
+export interface Econometrics fastOptions { tol?: number; maxIter?: number; }
+export interface Econometrics fastResult { values: number[]; converged: boolean; }
+export function computeEconometrics fast(data: number[], opts: Econometrics fastOptions = {}): Econometrics fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics fast };
diff --git a/src/econometrics/future.ts b/src/econometrics/future.ts
new file mode 100644
index 000000000..4cb6c78c1
--- /dev/null
+++ b/src/econometrics/future.ts
@@ -0,0 +1,15 @@
+/** Econometrics Future module — tsb analytics library. */
+export interface Econometrics futureOptions { tol?: number; maxIter?: number; }
+export interface Econometrics futureResult { values: number[]; converged: boolean; }
+export function computeEconometrics future(data: number[], opts: Econometrics futureOptions = {}): Econometrics futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics future };
diff --git a/src/econometrics/garch.ts b/src/econometrics/garch.ts
new file mode 100644
index 000000000..f251c7bb6
--- /dev/null
+++ b/src/econometrics/garch.ts
@@ -0,0 +1,22 @@
+/** Garch module — tsb analytics library. */
+
+/** Options for Garch. */
+export interface GarchOptions { tol?: number; maxIter?: number; }
+
+/** Result from Garch. */
+export interface GarchResult { values: number[]; converged: boolean; }
+
+/** Compute Garch. */
+export function computeGarch(data: number[], opts: GarchOptions = {}): GarchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGarch };
diff --git a/src/econometrics/gls.ts b/src/econometrics/gls.ts
new file mode 100644
index 000000000..75f4de03e
--- /dev/null
+++ b/src/econometrics/gls.ts
@@ -0,0 +1,22 @@
+/** Gls module — tsb analytics library. */
+
+/** Options for Gls. */
+export interface GlsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gls. */
+export interface GlsResult { values: number[]; converged: boolean; }
+
+/** Compute Gls. */
+export function computeGls(data: number[], opts: GlsOptions = {}): GlsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGls };
diff --git a/src/econometrics/gmm.ts b/src/econometrics/gmm.ts
new file mode 100644
index 000000000..ce496baa5
--- /dev/null
+++ b/src/econometrics/gmm.ts
@@ -0,0 +1,22 @@
+/** Gmm module — tsb analytics library. */
+
+/** Options for Gmm. */
+export interface GmmOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gmm. */
+export interface GmmResult { values: number[]; converged: boolean; }
+
+/** Compute Gmm. */
+export function computeGmm(data: number[], opts: GmmOptions = {}): GmmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGmm };
diff --git a/src/econometrics/gpu.ts b/src/econometrics/gpu.ts
new file mode 100644
index 000000000..8f9817de6
--- /dev/null
+++ b/src/econometrics/gpu.ts
@@ -0,0 +1,15 @@
+/** Econometrics Gpu module — tsb analytics library. */
+export interface Econometrics gpuOptions { tol?: number; maxIter?: number; }
+export interface Econometrics gpuResult { values: number[]; converged: boolean; }
+export function computeEconometrics gpu(data: number[], opts: Econometrics gpuOptions = {}): Econometrics gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics gpu };
diff --git a/src/econometrics/iv.ts b/src/econometrics/iv.ts
new file mode 100644
index 000000000..1b756ecd0
--- /dev/null
+++ b/src/econometrics/iv.ts
@@ -0,0 +1,22 @@
+/** Iv module — tsb analytics library. */
+
+/** Options for Iv. */
+export interface IvOptions { tol?: number; maxIter?: number; }
+
+/** Result from Iv. */
+export interface IvResult { values: number[]; converged: boolean; }
+
+/** Compute Iv. */
+export function computeIv(data: number[], opts: IvOptions = {}): IvResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIv };
diff --git a/src/econometrics/large.ts b/src/econometrics/large.ts
new file mode 100644
index 000000000..838056b4d
--- /dev/null
+++ b/src/econometrics/large.ts
@@ -0,0 +1,15 @@
+/** Econometrics Large module — tsb analytics library. */
+export interface Econometrics largeOptions { tol?: number; maxIter?: number; }
+export interface Econometrics largeResult { values: number[]; converged: boolean; }
+export function computeEconometrics large(data: number[], opts: Econometrics largeOptions = {}): Econometrics largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics large };
diff --git a/src/econometrics/legacy.ts b/src/econometrics/legacy.ts
new file mode 100644
index 000000000..b7ae88879
--- /dev/null
+++ b/src/econometrics/legacy.ts
@@ -0,0 +1,15 @@
+/** Econometrics Legacy module — tsb analytics library. */
+export interface Econometrics legacyOptions { tol?: number; maxIter?: number; }
+export interface Econometrics legacyResult { values: number[]; converged: boolean; }
+export function computeEconometrics legacy(data: number[], opts: Econometrics legacyOptions = {}): Econometrics legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics legacy };
diff --git a/src/econometrics/lite.ts b/src/econometrics/lite.ts
new file mode 100644
index 000000000..944f5e61b
--- /dev/null
+++ b/src/econometrics/lite.ts
@@ -0,0 +1,15 @@
+/** Econometrics Lite module — tsb analytics library. */
+export interface Econometrics liteOptions { tol?: number; maxIter?: number; }
+export interface Econometrics liteResult { values: number[]; converged: boolean; }
+export function computeEconometrics lite(data: number[], opts: Econometrics liteOptions = {}): Econometrics liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics lite };
diff --git a/src/econometrics/local_average.ts b/src/econometrics/local_average.ts
new file mode 100644
index 000000000..81605d102
--- /dev/null
+++ b/src/econometrics/local_average.ts
@@ -0,0 +1,22 @@
+/** Local Average module — tsb analytics library. */
+
+/** Options for Local Average. */
+export interface LocalAverageOptions { tol?: number; maxIter?: number; }
+
+/** Result from Local Average. */
+export interface LocalAverageResult { values: number[]; converged: boolean; }
+
+/** Compute Local Average. */
+export function computeLocalAverage(data: number[], opts: LocalAverageOptions = {}): LocalAverageResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLocalAverage };
diff --git a/src/econometrics/machine_learning_econ.ts b/src/econometrics/machine_learning_econ.ts
new file mode 100644
index 000000000..805f4cca1
--- /dev/null
+++ b/src/econometrics/machine_learning_econ.ts
@@ -0,0 +1,22 @@
+/** Machine Learning Econ module — tsb analytics library. */
+
+/** Options for Machine Learning Econ. */
+export interface MachineLearningEconOptions { tol?: number; maxIter?: number; }
+
+/** Result from Machine Learning Econ. */
+export interface MachineLearningEconResult { values: number[]; converged: boolean; }
+
+/** Compute Machine Learning Econ. */
+export function computeMachineLearningEcon(data: number[], opts: MachineLearningEconOptions = {}): MachineLearningEconResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMachineLearningEcon };
diff --git a/src/econometrics/marginal.ts b/src/econometrics/marginal.ts
new file mode 100644
index 000000000..60dee8920
--- /dev/null
+++ b/src/econometrics/marginal.ts
@@ -0,0 +1,22 @@
+/** Marginal module — tsb analytics library. */
+
+/** Options for Marginal. */
+export interface MarginalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Marginal. */
+export interface MarginalResult { values: number[]; converged: boolean; }
+
+/** Compute Marginal. */
+export function computeMarginal(data: number[], opts: MarginalOptions = {}): MarginalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMarginal };
diff --git a/src/econometrics/mini.ts b/src/econometrics/mini.ts
new file mode 100644
index 000000000..19b8b1640
--- /dev/null
+++ b/src/econometrics/mini.ts
@@ -0,0 +1,15 @@
+/** Econometrics Mini module — tsb analytics library. */
+export interface Econometrics miniOptions { tol?: number; maxIter?: number; }
+export interface Econometrics miniResult { values: number[]; converged: boolean; }
+export function computeEconometrics mini(data: number[], opts: Econometrics miniOptions = {}): Econometrics miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics mini };
diff --git a/src/econometrics/next.ts b/src/econometrics/next.ts
new file mode 100644
index 000000000..deb56e172
--- /dev/null
+++ b/src/econometrics/next.ts
@@ -0,0 +1,15 @@
+/** Econometrics Next module — tsb analytics library. */
+export interface Econometrics nextOptions { tol?: number; maxIter?: number; }
+export interface Econometrics nextResult { values: number[]; converged: boolean; }
+export function computeEconometrics next(data: number[], opts: Econometrics nextOptions = {}): Econometrics nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics next };
diff --git a/src/econometrics/nonparametric.ts b/src/econometrics/nonparametric.ts
new file mode 100644
index 000000000..7a713c742
--- /dev/null
+++ b/src/econometrics/nonparametric.ts
@@ -0,0 +1,22 @@
+/** Nonparametric module — tsb analytics library. */
+
+/** Options for Nonparametric. */
+export interface NonparametricOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nonparametric. */
+export interface NonparametricResult { values: number[]; converged: boolean; }
+
+/** Compute Nonparametric. */
+export function computeNonparametric(data: number[], opts: NonparametricOptions = {}): NonparametricResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNonparametric };
diff --git a/src/econometrics/ols.ts b/src/econometrics/ols.ts
new file mode 100644
index 000000000..4e3052d1e
--- /dev/null
+++ b/src/econometrics/ols.ts
@@ -0,0 +1,22 @@
+/** Ols module — tsb analytics library. */
+
+/** Options for Ols. */
+export interface OlsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ols. */
+export interface OlsResult { values: number[]; converged: boolean; }
+
+/** Compute Ols. */
+export function computeOls(data: number[], opts: OlsOptions = {}): OlsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOls };
diff --git a/src/econometrics/online.ts b/src/econometrics/online.ts
new file mode 100644
index 000000000..ec6176b33
--- /dev/null
+++ b/src/econometrics/online.ts
@@ -0,0 +1,15 @@
+/** Econometrics Online module — tsb analytics library. */
+export interface Econometrics onlineOptions { tol?: number; maxIter?: number; }
+export interface Econometrics onlineResult { values: number[]; converged: boolean; }
+export function computeEconometrics online(data: number[], opts: Econometrics onlineOptions = {}): Econometrics onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics online };
diff --git a/src/econometrics/panel_data.ts b/src/econometrics/panel_data.ts
new file mode 100644
index 000000000..eaa329f6d
--- /dev/null
+++ b/src/econometrics/panel_data.ts
@@ -0,0 +1,22 @@
+/** Panel Data module — tsb analytics library. */
+
+/** Options for Panel Data. */
+export interface PanelDataOptions { tol?: number; maxIter?: number; }
+
+/** Result from Panel Data. */
+export interface PanelDataResult { values: number[]; converged: boolean; }
+
+/** Compute Panel Data. */
+export function computePanelData(data: number[], opts: PanelDataOptions = {}): PanelDataResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePanelData };
diff --git a/src/econometrics/parallel.ts b/src/econometrics/parallel.ts
new file mode 100644
index 000000000..165a13735
--- /dev/null
+++ b/src/econometrics/parallel.ts
@@ -0,0 +1,15 @@
+/** Econometrics Parallel module — tsb analytics library. */
+export interface Econometrics parallelOptions { tol?: number; maxIter?: number; }
+export interface Econometrics parallelResult { values: number[]; converged: boolean; }
+export function computeEconometrics parallel(data: number[], opts: Econometrics parallelOptions = {}): Econometrics parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics parallel };
diff --git a/src/econometrics/plus.ts b/src/econometrics/plus.ts
new file mode 100644
index 000000000..8c8d35970
--- /dev/null
+++ b/src/econometrics/plus.ts
@@ -0,0 +1,15 @@
+/** Econometrics Plus module — tsb analytics library. */
+export interface Econometrics plusOptions { tol?: number; maxIter?: number; }
+export interface Econometrics plusResult { values: number[]; converged: boolean; }
+export function computeEconometrics plus(data: number[], opts: Econometrics plusOptions = {}): Econometrics plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics plus };
diff --git a/src/econometrics/pro.ts b/src/econometrics/pro.ts
new file mode 100644
index 000000000..57e0b80a3
--- /dev/null
+++ b/src/econometrics/pro.ts
@@ -0,0 +1,15 @@
+/** Econometrics Pro module — tsb analytics library. */
+export interface Econometrics proOptions { tol?: number; maxIter?: number; }
+export interface Econometrics proResult { values: number[]; converged: boolean; }
+export function computeEconometrics pro(data: number[], opts: Econometrics proOptions = {}): Econometrics proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics pro };
diff --git a/src/econometrics/quantile_reg.ts b/src/econometrics/quantile_reg.ts
new file mode 100644
index 000000000..e49e20e10
--- /dev/null
+++ b/src/econometrics/quantile_reg.ts
@@ -0,0 +1,22 @@
+/** Quantile Reg module — tsb analytics library. */
+
+/** Options for Quantile Reg. */
+export interface QuantileRegOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quantile Reg. */
+export interface QuantileRegResult { values: number[]; converged: boolean; }
+
+/** Compute Quantile Reg. */
+export function computeQuantileReg(data: number[], opts: QuantileRegOptions = {}): QuantileRegResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQuantileReg };
diff --git a/src/econometrics/regression_kink.ts b/src/econometrics/regression_kink.ts
new file mode 100644
index 000000000..454e83aa0
--- /dev/null
+++ b/src/econometrics/regression_kink.ts
@@ -0,0 +1,22 @@
+/** Regression Kink module — tsb analytics library. */
+
+/** Options for Regression Kink. */
+export interface RegressionKinkOptions { tol?: number; maxIter?: number; }
+
+/** Result from Regression Kink. */
+export interface RegressionKinkResult { values: number[]; converged: boolean; }
+
+/** Compute Regression Kink. */
+export function computeRegressionKink(data: number[], opts: RegressionKinkOptions = {}): RegressionKinkResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRegressionKink };
diff --git a/src/econometrics/robust.ts b/src/econometrics/robust.ts
new file mode 100644
index 000000000..8bc3eeebe
--- /dev/null
+++ b/src/econometrics/robust.ts
@@ -0,0 +1,22 @@
+/** Robust module — tsb analytics library. */
+
+/** Options for Robust. */
+export interface RobustOptions { tol?: number; maxIter?: number; }
+
+/** Result from Robust. */
+export interface RobustResult { values: number[]; converged: boolean; }
+
+/** Compute Robust. */
+export function computeRobust(data: number[], opts: RobustOptions = {}): RobustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRobust };
diff --git a/src/econometrics/semiparametric.ts b/src/econometrics/semiparametric.ts
new file mode 100644
index 000000000..188997e5d
--- /dev/null
+++ b/src/econometrics/semiparametric.ts
@@ -0,0 +1,22 @@
+/** Semiparametric module — tsb analytics library. */
+
+/** Options for Semiparametric. */
+export interface SemiparametricOptions { tol?: number; maxIter?: number; }
+
+/** Result from Semiparametric. */
+export interface SemiparametricResult { values: number[]; converged: boolean; }
+
+/** Compute Semiparametric. */
+export function computeSemiparametric(data: number[], opts: SemiparametricOptions = {}): SemiparametricResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSemiparametric };
diff --git a/src/econometrics/small.ts b/src/econometrics/small.ts
new file mode 100644
index 000000000..678c644f0
--- /dev/null
+++ b/src/econometrics/small.ts
@@ -0,0 +1,15 @@
+/** Econometrics Small module — tsb analytics library. */
+export interface Econometrics smallOptions { tol?: number; maxIter?: number; }
+export interface Econometrics smallResult { values: number[]; converged: boolean; }
+export function computeEconometrics small(data: number[], opts: Econometrics smallOptions = {}): Econometrics smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics small };
diff --git a/src/econometrics/sparse.ts b/src/econometrics/sparse.ts
new file mode 100644
index 000000000..037531cb9
--- /dev/null
+++ b/src/econometrics/sparse.ts
@@ -0,0 +1,15 @@
+/** Econometrics Sparse module — tsb analytics library. */
+export interface Econometrics sparseOptions { tol?: number; maxIter?: number; }
+export interface Econometrics sparseResult { values: number[]; converged: boolean; }
+export function computeEconometrics sparse(data: number[], opts: Econometrics sparseOptions = {}): Econometrics sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics sparse };
diff --git a/src/econometrics/stable.ts b/src/econometrics/stable.ts
new file mode 100644
index 000000000..4c6fd1a0e
--- /dev/null
+++ b/src/econometrics/stable.ts
@@ -0,0 +1,15 @@
+/** Econometrics Stable module — tsb analytics library. */
+export interface Econometrics stableOptions { tol?: number; maxIter?: number; }
+export interface Econometrics stableResult { values: number[]; converged: boolean; }
+export function computeEconometrics stable(data: number[], opts: Econometrics stableOptions = {}): Econometrics stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics stable };
diff --git a/src/econometrics/staggered_did.ts b/src/econometrics/staggered_did.ts
new file mode 100644
index 000000000..7f7a2a393
--- /dev/null
+++ b/src/econometrics/staggered_did.ts
@@ -0,0 +1,22 @@
+/** Staggered Did module — tsb analytics library. */
+
+/** Options for Staggered Did. */
+export interface StaggeredDidOptions { tol?: number; maxIter?: number; }
+
+/** Result from Staggered Did. */
+export interface StaggeredDidResult { values: number[]; converged: boolean; }
+
+/** Compute Staggered Did. */
+export function computeStaggeredDid(data: number[], opts: StaggeredDidOptions = {}): StaggeredDidResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStaggeredDid };
diff --git a/src/econometrics/streaming.ts b/src/econometrics/streaming.ts
new file mode 100644
index 000000000..7e8c551a1
--- /dev/null
+++ b/src/econometrics/streaming.ts
@@ -0,0 +1,15 @@
+/** Econometrics Streaming module — tsb analytics library. */
+export interface Econometrics streamingOptions { tol?: number; maxIter?: number; }
+export interface Econometrics streamingResult { values: number[]; converged: boolean; }
+export function computeEconometrics streaming(data: number[], opts: Econometrics streamingOptions = {}): Econometrics streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics streaming };
diff --git a/src/econometrics/synthetic_diff_in_diff.ts b/src/econometrics/synthetic_diff_in_diff.ts
new file mode 100644
index 000000000..31fc11591
--- /dev/null
+++ b/src/econometrics/synthetic_diff_in_diff.ts
@@ -0,0 +1,22 @@
+/** Synthetic Diff In Diff module — tsb analytics library. */
+
+/** Options for Synthetic Diff In Diff. */
+export interface SyntheticDiffInDiffOptions { tol?: number; maxIter?: number; }
+
+/** Result from Synthetic Diff In Diff. */
+export interface SyntheticDiffInDiffResult { values: number[]; converged: boolean; }
+
+/** Compute Synthetic Diff In Diff. */
+export function computeSyntheticDiffInDiff(data: number[], opts: SyntheticDiffInDiffOptions = {}): SyntheticDiffInDiffResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSyntheticDiffInDiff };
diff --git a/src/econometrics/v2.ts b/src/econometrics/v2.ts
new file mode 100644
index 000000000..376def5dc
--- /dev/null
+++ b/src/econometrics/v2.ts
@@ -0,0 +1,15 @@
+/** Econometrics V2 module — tsb analytics library. */
+export interface Econometrics v2Options { tol?: number; maxIter?: number; }
+export interface Econometrics v2Result { values: number[]; converged: boolean; }
+export function computeEconometrics v2(data: number[], opts: Econometrics v2Options = {}): Econometrics v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics v2 };
diff --git a/src/econometrics/v3.ts b/src/econometrics/v3.ts
new file mode 100644
index 000000000..cfdee4da9
--- /dev/null
+++ b/src/econometrics/v3.ts
@@ -0,0 +1,15 @@
+/** Econometrics V3 module — tsb analytics library. */
+export interface Econometrics v3Options { tol?: number; maxIter?: number; }
+export interface Econometrics v3Result { values: number[]; converged: boolean; }
+export function computeEconometrics v3(data: number[], opts: Econometrics v3Options = {}): Econometrics v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics v3 };
diff --git a/src/econometrics/var.ts b/src/econometrics/var.ts
new file mode 100644
index 000000000..0377e36cf
--- /dev/null
+++ b/src/econometrics/var.ts
@@ -0,0 +1,22 @@
+/** Var module — tsb analytics library. */
+
+/** Options for Var. */
+export interface VarOptions { tol?: number; maxIter?: number; }
+
+/** Result from Var. */
+export interface VarResult { values: number[]; converged: boolean; }
+
+/** Compute Var. */
+export function computeVar(data: number[], opts: VarOptions = {}): VarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVar };
diff --git a/src/econometrics/vecm.ts b/src/econometrics/vecm.ts
new file mode 100644
index 000000000..2b584c366
--- /dev/null
+++ b/src/econometrics/vecm.ts
@@ -0,0 +1,22 @@
+/** Vecm module — tsb analytics library. */
+
+/** Options for Vecm. */
+export interface VecmOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vecm. */
+export interface VecmResult { values: number[]; converged: boolean; }
+
+/** Compute Vecm. */
+export function computeVecm(data: number[], opts: VecmOptions = {}): VecmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVecm };
diff --git a/src/econometrics/wasm.ts b/src/econometrics/wasm.ts
new file mode 100644
index 000000000..00e4a7bd5
--- /dev/null
+++ b/src/econometrics/wasm.ts
@@ -0,0 +1,15 @@
+/** Econometrics Wasm module — tsb analytics library. */
+export interface Econometrics wasmOptions { tol?: number; maxIter?: number; }
+export interface Econometrics wasmResult { values: number[]; converged: boolean; }
+export function computeEconometrics wasm(data: number[], opts: Econometrics wasmOptions = {}): Econometrics wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics wasm };
diff --git a/src/econometrics/xlarge.ts b/src/econometrics/xlarge.ts
new file mode 100644
index 000000000..33a0df17f
--- /dev/null
+++ b/src/econometrics/xlarge.ts
@@ -0,0 +1,15 @@
+/** Econometrics Xlarge module — tsb analytics library. */
+export interface Econometrics xlargeOptions { tol?: number; maxIter?: number; }
+export interface Econometrics xlargeResult { values: number[]; converged: boolean; }
+export function computeEconometrics xlarge(data: number[], opts: Econometrics xlargeOptions = {}): Econometrics xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEconometrics xlarge };
diff --git a/src/ecosystem_sci/adaptation.ts b/src/ecosystem_sci/adaptation.ts
new file mode 100644
index 000000000..fd5cb72d9
--- /dev/null
+++ b/src/ecosystem_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci adaptation module — tsb analytics library. */
+export interface EcosystemSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciAdaptation(data: number[], opts: EcosystemSciAdaptationOptions = {}): EcosystemSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciAdaptation };
diff --git a/src/ecosystem_sci/aggregation.ts b/src/ecosystem_sci/aggregation.ts
new file mode 100644
index 000000000..94717a9f6
--- /dev/null
+++ b/src/ecosystem_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci aggregation module — tsb analytics library. */
+export interface EcosystemSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciAggregationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciAggregation(data: number[], opts: EcosystemSciAggregationOptions = {}): EcosystemSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciAggregation };
diff --git a/src/ecosystem_sci/algebra.ts b/src/ecosystem_sci/algebra.ts
new file mode 100644
index 000000000..6e2c833c9
--- /dev/null
+++ b/src/ecosystem_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci algebra module — tsb analytics library. */
+export interface EcosystemSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciAlgebra(data: number[], opts: EcosystemSciAlgebraOptions = {}): EcosystemSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciAlgebra };
diff --git a/src/ecosystem_sci/alignment.ts b/src/ecosystem_sci/alignment.ts
new file mode 100644
index 000000000..4fa78b17b
--- /dev/null
+++ b/src/ecosystem_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci alignment module — tsb analytics library. */
+export interface EcosystemSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciAlignment(data: number[], opts: EcosystemSciAlignmentOptions = {}): EcosystemSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciAlignment };
diff --git a/src/ecosystem_sci/analysis.ts b/src/ecosystem_sci/analysis.ts
new file mode 100644
index 000000000..d2413c6d7
--- /dev/null
+++ b/src/ecosystem_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci analysis module — tsb analytics library. */
+export interface EcosystemSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciAnalysis(data: number[], opts: EcosystemSciAnalysisOptions = {}): EcosystemSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciAnalysis };
diff --git a/src/ecosystem_sci/augmentation.ts b/src/ecosystem_sci/augmentation.ts
new file mode 100644
index 000000000..6f2deb101
--- /dev/null
+++ b/src/ecosystem_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci augmentation module — tsb analytics library. */
+export interface EcosystemSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciAugmentation(data: number[], opts: EcosystemSciAugmentationOptions = {}): EcosystemSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciAugmentation };
diff --git a/src/ecosystem_sci/bagging.ts b/src/ecosystem_sci/bagging.ts
new file mode 100644
index 000000000..674ffe923
--- /dev/null
+++ b/src/ecosystem_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci bagging module — tsb analytics library. */
+export interface EcosystemSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciBaggingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciBagging(data: number[], opts: EcosystemSciBaggingOptions = {}): EcosystemSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciBagging };
diff --git a/src/ecosystem_sci/basis.ts b/src/ecosystem_sci/basis.ts
new file mode 100644
index 000000000..f75d5e629
--- /dev/null
+++ b/src/ecosystem_sci/basis.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci basis module — tsb analytics library. */
+export interface EcosystemSciBasisOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciBasisResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciBasis(data: number[], opts: EcosystemSciBasisOptions = {}): EcosystemSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciBasis };
diff --git a/src/ecosystem_sci/benchmarking.ts b/src/ecosystem_sci/benchmarking.ts
new file mode 100644
index 000000000..ba9396934
--- /dev/null
+++ b/src/ecosystem_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci benchmarking module — tsb analytics library. */
+export interface EcosystemSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciBenchmarking(data: number[], opts: EcosystemSciBenchmarkingOptions = {}): EcosystemSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciBenchmarking };
diff --git a/src/ecosystem_sci/blending.ts b/src/ecosystem_sci/blending.ts
new file mode 100644
index 000000000..c99a872b2
--- /dev/null
+++ b/src/ecosystem_sci/blending.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci blending module — tsb analytics library. */
+export interface EcosystemSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciBlendingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciBlending(data: number[], opts: EcosystemSciBlendingOptions = {}): EcosystemSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciBlending };
diff --git a/src/ecosystem_sci/boosting.ts b/src/ecosystem_sci/boosting.ts
new file mode 100644
index 000000000..3b7a78d86
--- /dev/null
+++ b/src/ecosystem_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci boosting module — tsb analytics library. */
+export interface EcosystemSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciBoostingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciBoosting(data: number[], opts: EcosystemSciBoostingOptions = {}): EcosystemSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciBoosting };
diff --git a/src/ecosystem_sci/bootstrap.ts b/src/ecosystem_sci/bootstrap.ts
new file mode 100644
index 000000000..4c1231ed1
--- /dev/null
+++ b/src/ecosystem_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci bootstrap module — tsb analytics library. */
+export interface EcosystemSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciBootstrap(data: number[], opts: EcosystemSciBootstrapOptions = {}): EcosystemSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciBootstrap };
diff --git a/src/ecosystem_sci/calculus.ts b/src/ecosystem_sci/calculus.ts
new file mode 100644
index 000000000..6bab3113b
--- /dev/null
+++ b/src/ecosystem_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci calculus module — tsb analytics library. */
+export interface EcosystemSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciCalculusResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciCalculus(data: number[], opts: EcosystemSciCalculusOptions = {}): EcosystemSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciCalculus };
diff --git a/src/ecosystem_sci/calibration.ts b/src/ecosystem_sci/calibration.ts
new file mode 100644
index 000000000..ebd020f87
--- /dev/null
+++ b/src/ecosystem_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci calibration module — tsb analytics library. */
+export interface EcosystemSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciCalibration(data: number[], opts: EcosystemSciCalibrationOptions = {}): EcosystemSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciCalibration };
diff --git a/src/ecosystem_sci/characterization.ts b/src/ecosystem_sci/characterization.ts
new file mode 100644
index 000000000..850fa934d
--- /dev/null
+++ b/src/ecosystem_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci characterization module — tsb analytics library. */
+export interface EcosystemSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciCharacterization(data: number[], opts: EcosystemSciCharacterizationOptions = {}): EcosystemSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciCharacterization };
diff --git a/src/ecosystem_sci/classification.ts b/src/ecosystem_sci/classification.ts
new file mode 100644
index 000000000..3fde575af
--- /dev/null
+++ b/src/ecosystem_sci/classification.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci classification module — tsb analytics library. */
+export interface EcosystemSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciClassificationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciClassification(data: number[], opts: EcosystemSciClassificationOptions = {}): EcosystemSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciClassification };
diff --git a/src/ecosystem_sci/clustering.ts b/src/ecosystem_sci/clustering.ts
new file mode 100644
index 000000000..6a169fafa
--- /dev/null
+++ b/src/ecosystem_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci clustering module — tsb analytics library. */
+export interface EcosystemSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciClusteringResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciClustering(data: number[], opts: EcosystemSciClusteringOptions = {}): EcosystemSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciClustering };
diff --git a/src/ecosystem_sci/compression.ts b/src/ecosystem_sci/compression.ts
new file mode 100644
index 000000000..0bc66b732
--- /dev/null
+++ b/src/ecosystem_sci/compression.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci compression module — tsb analytics library. */
+export interface EcosystemSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciCompressionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciCompression(data: number[], opts: EcosystemSciCompressionOptions = {}): EcosystemSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciCompression };
diff --git a/src/ecosystem_sci/continuous.ts b/src/ecosystem_sci/continuous.ts
new file mode 100644
index 000000000..dabc06173
--- /dev/null
+++ b/src/ecosystem_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci continuous module — tsb analytics library. */
+export interface EcosystemSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciContinuousResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciContinuous(data: number[], opts: EcosystemSciContinuousOptions = {}): EcosystemSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciContinuous };
diff --git a/src/ecosystem_sci/control.ts b/src/ecosystem_sci/control.ts
new file mode 100644
index 000000000..86e2797d7
--- /dev/null
+++ b/src/ecosystem_sci/control.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci control module — tsb analytics library. */
+export interface EcosystemSciControlOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciControlResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciControl(data: number[], opts: EcosystemSciControlOptions = {}): EcosystemSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciControl };
diff --git a/src/ecosystem_sci/convergence.ts b/src/ecosystem_sci/convergence.ts
new file mode 100644
index 000000000..74f9dbf69
--- /dev/null
+++ b/src/ecosystem_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci convergence module — tsb analytics library. */
+export interface EcosystemSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciConvergence(data: number[], opts: EcosystemSciConvergenceOptions = {}): EcosystemSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciConvergence };
diff --git a/src/ecosystem_sci/convex.ts b/src/ecosystem_sci/convex.ts
new file mode 100644
index 000000000..2fb2969b6
--- /dev/null
+++ b/src/ecosystem_sci/convex.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci convex module — tsb analytics library. */
+export interface EcosystemSciConvexOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciConvexResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciConvex(data: number[], opts: EcosystemSciConvexOptions = {}): EcosystemSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciConvex };
diff --git a/src/ecosystem_sci/correlation.ts b/src/ecosystem_sci/correlation.ts
new file mode 100644
index 000000000..4fbd61e8b
--- /dev/null
+++ b/src/ecosystem_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci correlation module — tsb analytics library. */
+export interface EcosystemSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciCorrelation(data: number[], opts: EcosystemSciCorrelationOptions = {}): EcosystemSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciCorrelation };
diff --git a/src/ecosystem_sci/covariance.ts b/src/ecosystem_sci/covariance.ts
new file mode 100644
index 000000000..dff270fa2
--- /dev/null
+++ b/src/ecosystem_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci covariance module — tsb analytics library. */
+export interface EcosystemSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciCovariance(data: number[], opts: EcosystemSciCovarianceOptions = {}): EcosystemSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciCovariance };
diff --git a/src/ecosystem_sci/cross_validation.ts b/src/ecosystem_sci/cross_validation.ts
new file mode 100644
index 000000000..1491db101
--- /dev/null
+++ b/src/ecosystem_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci cross_validation module — tsb analytics library. */
+export interface EcosystemSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciCrossValidation(data: number[], opts: EcosystemSciCrossValidationOptions = {}): EcosystemSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciCrossValidation };
diff --git a/src/ecosystem_sci/decoding.ts b/src/ecosystem_sci/decoding.ts
new file mode 100644
index 000000000..ec69b8e8c
--- /dev/null
+++ b/src/ecosystem_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci decoding module — tsb analytics library. */
+export interface EcosystemSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDecodingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDecoding(data: number[], opts: EcosystemSciDecodingOptions = {}): EcosystemSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDecoding };
diff --git a/src/ecosystem_sci/decomposition.ts b/src/ecosystem_sci/decomposition.ts
new file mode 100644
index 000000000..c1ceb974e
--- /dev/null
+++ b/src/ecosystem_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci decomposition module — tsb analytics library. */
+export interface EcosystemSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDecomposition(data: number[], opts: EcosystemSciDecompositionOptions = {}): EcosystemSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDecomposition };
diff --git a/src/ecosystem_sci/detection.ts b/src/ecosystem_sci/detection.ts
new file mode 100644
index 000000000..574f7c323
--- /dev/null
+++ b/src/ecosystem_sci/detection.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci detection module — tsb analytics library. */
+export interface EcosystemSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDetectionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDetection(data: number[], opts: EcosystemSciDetectionOptions = {}): EcosystemSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDetection };
diff --git a/src/ecosystem_sci/deterministic.ts b/src/ecosystem_sci/deterministic.ts
new file mode 100644
index 000000000..089f69624
--- /dev/null
+++ b/src/ecosystem_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci deterministic module — tsb analytics library. */
+export interface EcosystemSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDeterministic(data: number[], opts: EcosystemSciDeterministicOptions = {}): EcosystemSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDeterministic };
diff --git a/src/ecosystem_sci/diagnostics.ts b/src/ecosystem_sci/diagnostics.ts
new file mode 100644
index 000000000..03ceec65e
--- /dev/null
+++ b/src/ecosystem_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci diagnostics module — tsb analytics library. */
+export interface EcosystemSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDiagnostics(data: number[], opts: EcosystemSciDiagnosticsOptions = {}): EcosystemSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDiagnostics };
diff --git a/src/ecosystem_sci/differential.ts b/src/ecosystem_sci/differential.ts
new file mode 100644
index 000000000..b0c08be3f
--- /dev/null
+++ b/src/ecosystem_sci/differential.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci differential module — tsb analytics library. */
+export interface EcosystemSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDifferential(data: number[], opts: EcosystemSciDifferentialOptions = {}): EcosystemSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDifferential };
diff --git a/src/ecosystem_sci/discrete.ts b/src/ecosystem_sci/discrete.ts
new file mode 100644
index 000000000..cf30c8ed7
--- /dev/null
+++ b/src/ecosystem_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci discrete module — tsb analytics library. */
+export interface EcosystemSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDiscrete(data: number[], opts: EcosystemSciDiscreteOptions = {}): EcosystemSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDiscrete };
diff --git a/src/ecosystem_sci/distribution.ts b/src/ecosystem_sci/distribution.ts
new file mode 100644
index 000000000..39216d90e
--- /dev/null
+++ b/src/ecosystem_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci distribution module — tsb analytics library. */
+export interface EcosystemSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDistributionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDistribution(data: number[], opts: EcosystemSciDistributionOptions = {}): EcosystemSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDistribution };
diff --git a/src/ecosystem_sci/dynamic.ts b/src/ecosystem_sci/dynamic.ts
new file mode 100644
index 000000000..46d8fed71
--- /dev/null
+++ b/src/ecosystem_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci dynamic module — tsb analytics library. */
+export interface EcosystemSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciDynamicResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciDynamic(data: number[], opts: EcosystemSciDynamicOptions = {}): EcosystemSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciDynamic };
diff --git a/src/ecosystem_sci/embedding.ts b/src/ecosystem_sci/embedding.ts
new file mode 100644
index 000000000..c2de9dcc7
--- /dev/null
+++ b/src/ecosystem_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci embedding module — tsb analytics library. */
+export interface EcosystemSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciEmbedding(data: number[], opts: EcosystemSciEmbeddingOptions = {}): EcosystemSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciEmbedding };
diff --git a/src/ecosystem_sci/encoding.ts b/src/ecosystem_sci/encoding.ts
new file mode 100644
index 000000000..53f072dea
--- /dev/null
+++ b/src/ecosystem_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci encoding module — tsb analytics library. */
+export interface EcosystemSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciEncodingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciEncoding(data: number[], opts: EcosystemSciEncodingOptions = {}): EcosystemSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciEncoding };
diff --git a/src/ecosystem_sci/ensemble.ts b/src/ecosystem_sci/ensemble.ts
new file mode 100644
index 000000000..b6dc8edf5
--- /dev/null
+++ b/src/ecosystem_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci ensemble module — tsb analytics library. */
+export interface EcosystemSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciEnsemble(data: number[], opts: EcosystemSciEnsembleOptions = {}): EcosystemSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciEnsemble };
diff --git a/src/ecosystem_sci/estimation.ts b/src/ecosystem_sci/estimation.ts
new file mode 100644
index 000000000..98b150ddc
--- /dev/null
+++ b/src/ecosystem_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci estimation module — tsb analytics library. */
+export interface EcosystemSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciEstimationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciEstimation(data: number[], opts: EcosystemSciEstimationOptions = {}): EcosystemSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciEstimation };
diff --git a/src/ecosystem_sci/evaluation.ts b/src/ecosystem_sci/evaluation.ts
new file mode 100644
index 000000000..a579e7b57
--- /dev/null
+++ b/src/ecosystem_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci evaluation module — tsb analytics library. */
+export interface EcosystemSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciEvaluation(data: number[], opts: EcosystemSciEvaluationOptions = {}): EcosystemSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciEvaluation };
diff --git a/src/ecosystem_sci/extrapolation.ts b/src/ecosystem_sci/extrapolation.ts
new file mode 100644
index 000000000..1c2c626e6
--- /dev/null
+++ b/src/ecosystem_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci extrapolation module — tsb analytics library. */
+export interface EcosystemSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciExtrapolation(data: number[], opts: EcosystemSciExtrapolationOptions = {}): EcosystemSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciExtrapolation };
diff --git a/src/ecosystem_sci/features.ts b/src/ecosystem_sci/features.ts
new file mode 100644
index 000000000..469a90e7e
--- /dev/null
+++ b/src/ecosystem_sci/features.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci features module — tsb analytics library. */
+export interface EcosystemSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciFeatures(data: number[], opts: EcosystemSciFeaturesOptions = {}): EcosystemSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciFeatures };
diff --git a/src/ecosystem_sci/feedback.ts b/src/ecosystem_sci/feedback.ts
new file mode 100644
index 000000000..4621a3a5a
--- /dev/null
+++ b/src/ecosystem_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci feedback module — tsb analytics library. */
+export interface EcosystemSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciFeedback(data: number[], opts: EcosystemSciFeedbackOptions = {}): EcosystemSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciFeedback };
diff --git a/src/ecosystem_sci/filtering.ts b/src/ecosystem_sci/filtering.ts
new file mode 100644
index 000000000..d3b7af784
--- /dev/null
+++ b/src/ecosystem_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci filtering module — tsb analytics library. */
+export interface EcosystemSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciFilteringResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciFiltering(data: number[], opts: EcosystemSciFilteringOptions = {}): EcosystemSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciFiltering };
diff --git a/src/ecosystem_sci/fourier.ts b/src/ecosystem_sci/fourier.ts
new file mode 100644
index 000000000..bfb38efe0
--- /dev/null
+++ b/src/ecosystem_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci fourier module — tsb analytics library. */
+export interface EcosystemSciFourierOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciFourierResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciFourier(data: number[], opts: EcosystemSciFourierOptions = {}): EcosystemSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciFourier };
diff --git a/src/ecosystem_sci/fusion.ts b/src/ecosystem_sci/fusion.ts
new file mode 100644
index 000000000..3688113c5
--- /dev/null
+++ b/src/ecosystem_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci fusion module — tsb analytics library. */
+export interface EcosystemSciFusionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciFusionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciFusion(data: number[], opts: EcosystemSciFusionOptions = {}): EcosystemSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciFusion };
diff --git a/src/ecosystem_sci/generation.ts b/src/ecosystem_sci/generation.ts
new file mode 100644
index 000000000..760b2a922
--- /dev/null
+++ b/src/ecosystem_sci/generation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci generation module — tsb analytics library. */
+export interface EcosystemSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciGenerationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciGeneration(data: number[], opts: EcosystemSciGenerationOptions = {}): EcosystemSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciGeneration };
diff --git a/src/ecosystem_sci/geometry.ts b/src/ecosystem_sci/geometry.ts
new file mode 100644
index 000000000..370927657
--- /dev/null
+++ b/src/ecosystem_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci geometry module — tsb analytics library. */
+export interface EcosystemSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciGeometryResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciGeometry(data: number[], opts: EcosystemSciGeometryOptions = {}): EcosystemSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciGeometry };
diff --git a/src/ecosystem_sci/gradient.ts b/src/ecosystem_sci/gradient.ts
new file mode 100644
index 000000000..760e12ff1
--- /dev/null
+++ b/src/ecosystem_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci gradient module — tsb analytics library. */
+export interface EcosystemSciGradientOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciGradientResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciGradient(data: number[], opts: EcosystemSciGradientOptions = {}): EcosystemSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciGradient };
diff --git a/src/ecosystem_sci/hessian.ts b/src/ecosystem_sci/hessian.ts
new file mode 100644
index 000000000..fbc591f32
--- /dev/null
+++ b/src/ecosystem_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci hessian module — tsb analytics library. */
+export interface EcosystemSciHessianOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciHessianResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciHessian(data: number[], opts: EcosystemSciHessianOptions = {}): EcosystemSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciHessian };
diff --git a/src/ecosystem_sci/hypothesis.ts b/src/ecosystem_sci/hypothesis.ts
new file mode 100644
index 000000000..ea78e8266
--- /dev/null
+++ b/src/ecosystem_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci hypothesis module — tsb analytics library. */
+export interface EcosystemSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciHypothesis(data: number[], opts: EcosystemSciHypothesisOptions = {}): EcosystemSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciHypothesis };
diff --git a/src/ecosystem_sci/inference.ts b/src/ecosystem_sci/inference.ts
new file mode 100644
index 000000000..2b576892d
--- /dev/null
+++ b/src/ecosystem_sci/inference.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci inference module — tsb analytics library. */
+export interface EcosystemSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciInferenceResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciInference(data: number[], opts: EcosystemSciInferenceOptions = {}): EcosystemSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciInference };
diff --git a/src/ecosystem_sci/inference2.ts b/src/ecosystem_sci/inference2.ts
new file mode 100644
index 000000000..67cc68f6a
--- /dev/null
+++ b/src/ecosystem_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci inference2 module — tsb analytics library. */
+export interface EcosystemSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciInferenceResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciInference(data: number[], opts: EcosystemSciInferenceOptions = {}): EcosystemSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciInference };
diff --git a/src/ecosystem_sci/integral.ts b/src/ecosystem_sci/integral.ts
new file mode 100644
index 000000000..ceea610d0
--- /dev/null
+++ b/src/ecosystem_sci/integral.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci integral module — tsb analytics library. */
+export interface EcosystemSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciIntegralResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciIntegral(data: number[], opts: EcosystemSciIntegralOptions = {}): EcosystemSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciIntegral };
diff --git a/src/ecosystem_sci/integration.ts b/src/ecosystem_sci/integration.ts
new file mode 100644
index 000000000..bba69d60f
--- /dev/null
+++ b/src/ecosystem_sci/integration.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci integration module — tsb analytics library. */
+export interface EcosystemSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciIntegration(data: number[], opts: EcosystemSciIntegrationOptions = {}): EcosystemSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciIntegration };
diff --git a/src/ecosystem_sci/interpolation.ts b/src/ecosystem_sci/interpolation.ts
new file mode 100644
index 000000000..5f7c17371
--- /dev/null
+++ b/src/ecosystem_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci interpolation module — tsb analytics library. */
+export interface EcosystemSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciInterpolation(data: number[], opts: EcosystemSciInterpolationOptions = {}): EcosystemSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciInterpolation };
diff --git a/src/ecosystem_sci/jacobian.ts b/src/ecosystem_sci/jacobian.ts
new file mode 100644
index 000000000..98659898d
--- /dev/null
+++ b/src/ecosystem_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci jacobian module — tsb analytics library. */
+export interface EcosystemSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciJacobianResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciJacobian(data: number[], opts: EcosystemSciJacobianOptions = {}): EcosystemSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciJacobian };
diff --git a/src/ecosystem_sci/kernel.ts b/src/ecosystem_sci/kernel.ts
new file mode 100644
index 000000000..2c6a3cf06
--- /dev/null
+++ b/src/ecosystem_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci kernel module — tsb analytics library. */
+export interface EcosystemSciKernelOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciKernelResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciKernel(data: number[], opts: EcosystemSciKernelOptions = {}): EcosystemSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciKernel };
diff --git a/src/ecosystem_sci/laplacian.ts b/src/ecosystem_sci/laplacian.ts
new file mode 100644
index 000000000..daafb6a87
--- /dev/null
+++ b/src/ecosystem_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci laplacian module — tsb analytics library. */
+export interface EcosystemSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciLaplacian(data: number[], opts: EcosystemSciLaplacianOptions = {}): EcosystemSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciLaplacian };
diff --git a/src/ecosystem_sci/learning.ts b/src/ecosystem_sci/learning.ts
new file mode 100644
index 000000000..314e2afa2
--- /dev/null
+++ b/src/ecosystem_sci/learning.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci learning module — tsb analytics library. */
+export interface EcosystemSciLearningOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciLearningResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciLearning(data: number[], opts: EcosystemSciLearningOptions = {}): EcosystemSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciLearning };
diff --git a/src/ecosystem_sci/linear.ts b/src/ecosystem_sci/linear.ts
new file mode 100644
index 000000000..57dc3bd2a
--- /dev/null
+++ b/src/ecosystem_sci/linear.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci linear module — tsb analytics library. */
+export interface EcosystemSciLinearOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciLinearResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciLinear(data: number[], opts: EcosystemSciLinearOptions = {}): EcosystemSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciLinear };
diff --git a/src/ecosystem_sci/manifold.ts b/src/ecosystem_sci/manifold.ts
new file mode 100644
index 000000000..9bfc0d2ff
--- /dev/null
+++ b/src/ecosystem_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci manifold module — tsb analytics library. */
+export interface EcosystemSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciManifoldResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciManifold(data: number[], opts: EcosystemSciManifoldOptions = {}): EcosystemSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciManifold };
diff --git a/src/ecosystem_sci/matching.ts b/src/ecosystem_sci/matching.ts
new file mode 100644
index 000000000..95ab5eaee
--- /dev/null
+++ b/src/ecosystem_sci/matching.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci matching module — tsb analytics library. */
+export interface EcosystemSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciMatchingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciMatching(data: number[], opts: EcosystemSciMatchingOptions = {}): EcosystemSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciMatching };
diff --git a/src/ecosystem_sci/measurement.ts b/src/ecosystem_sci/measurement.ts
new file mode 100644
index 000000000..407021498
--- /dev/null
+++ b/src/ecosystem_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci measurement module — tsb analytics library. */
+export interface EcosystemSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciMeasurement(data: number[], opts: EcosystemSciMeasurementOptions = {}): EcosystemSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciMeasurement };
diff --git a/src/ecosystem_sci/metrics.ts b/src/ecosystem_sci/metrics.ts
new file mode 100644
index 000000000..dda1dad2c
--- /dev/null
+++ b/src/ecosystem_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci metrics module — tsb analytics library. */
+export interface EcosystemSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciMetricsResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciMetrics(data: number[], opts: EcosystemSciMetricsOptions = {}): EcosystemSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciMetrics };
diff --git a/src/ecosystem_sci/modeling.ts b/src/ecosystem_sci/modeling.ts
new file mode 100644
index 000000000..638ea8a27
--- /dev/null
+++ b/src/ecosystem_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci modeling module — tsb analytics library. */
+export interface EcosystemSciModelingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciModelingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciModeling(data: number[], opts: EcosystemSciModelingOptions = {}): EcosystemSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciModeling };
diff --git a/src/ecosystem_sci/monitoring.ts b/src/ecosystem_sci/monitoring.ts
new file mode 100644
index 000000000..dc1386c04
--- /dev/null
+++ b/src/ecosystem_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci monitoring module — tsb analytics library. */
+export interface EcosystemSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciMonitoring(data: number[], opts: EcosystemSciMonitoringOptions = {}): EcosystemSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciMonitoring };
diff --git a/src/ecosystem_sci/nonlinear.ts b/src/ecosystem_sci/nonlinear.ts
new file mode 100644
index 000000000..675f29a79
--- /dev/null
+++ b/src/ecosystem_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci nonlinear module — tsb analytics library. */
+export interface EcosystemSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciNonlinear(data: number[], opts: EcosystemSciNonlinearOptions = {}): EcosystemSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciNonlinear };
diff --git a/src/ecosystem_sci/normalization.ts b/src/ecosystem_sci/normalization.ts
new file mode 100644
index 000000000..deb5155c0
--- /dev/null
+++ b/src/ecosystem_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci normalization module — tsb analytics library. */
+export interface EcosystemSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciNormalization(data: number[], opts: EcosystemSciNormalizationOptions = {}): EcosystemSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciNormalization };
diff --git a/src/ecosystem_sci/optimization.ts b/src/ecosystem_sci/optimization.ts
new file mode 100644
index 000000000..6bd0e9aa0
--- /dev/null
+++ b/src/ecosystem_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci optimization module — tsb analytics library. */
+export interface EcosystemSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciOptimization(data: number[], opts: EcosystemSciOptimizationOptions = {}): EcosystemSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciOptimization };
diff --git a/src/ecosystem_sci/patterns.ts b/src/ecosystem_sci/patterns.ts
new file mode 100644
index 000000000..29953f378
--- /dev/null
+++ b/src/ecosystem_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci patterns module — tsb analytics library. */
+export interface EcosystemSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciPatternsResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciPatterns(data: number[], opts: EcosystemSciPatternsOptions = {}): EcosystemSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciPatterns };
diff --git a/src/ecosystem_sci/permutation.ts b/src/ecosystem_sci/permutation.ts
new file mode 100644
index 000000000..ed911aba2
--- /dev/null
+++ b/src/ecosystem_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci permutation module — tsb analytics library. */
+export interface EcosystemSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciPermutationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciPermutation(data: number[], opts: EcosystemSciPermutationOptions = {}): EcosystemSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciPermutation };
diff --git a/src/ecosystem_sci/prediction.ts b/src/ecosystem_sci/prediction.ts
new file mode 100644
index 000000000..6039c136c
--- /dev/null
+++ b/src/ecosystem_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci prediction module — tsb analytics library. */
+export interface EcosystemSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciPredictionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciPrediction(data: number[], opts: EcosystemSciPredictionOptions = {}): EcosystemSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciPrediction };
diff --git a/src/ecosystem_sci/processing.ts b/src/ecosystem_sci/processing.ts
new file mode 100644
index 000000000..1ee1fcf97
--- /dev/null
+++ b/src/ecosystem_sci/processing.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci processing module — tsb analytics library. */
+export interface EcosystemSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciProcessingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciProcessing(data: number[], opts: EcosystemSciProcessingOptions = {}): EcosystemSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciProcessing };
diff --git a/src/ecosystem_sci/profiling.ts b/src/ecosystem_sci/profiling.ts
new file mode 100644
index 000000000..fc820ffae
--- /dev/null
+++ b/src/ecosystem_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci profiling module — tsb analytics library. */
+export interface EcosystemSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciProfilingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciProfiling(data: number[], opts: EcosystemSciProfilingOptions = {}): EcosystemSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciProfiling };
diff --git a/src/ecosystem_sci/projection.ts b/src/ecosystem_sci/projection.ts
new file mode 100644
index 000000000..801a48749
--- /dev/null
+++ b/src/ecosystem_sci/projection.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci projection module — tsb analytics library. */
+export interface EcosystemSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciProjectionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciProjection(data: number[], opts: EcosystemSciProjectionOptions = {}): EcosystemSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciProjection };
diff --git a/src/ecosystem_sci/ranking.ts b/src/ecosystem_sci/ranking.ts
new file mode 100644
index 000000000..daf8f29cc
--- /dev/null
+++ b/src/ecosystem_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci ranking module — tsb analytics library. */
+export interface EcosystemSciRankingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciRankingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciRanking(data: number[], opts: EcosystemSciRankingOptions = {}): EcosystemSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciRanking };
diff --git a/src/ecosystem_sci/reconstruction.ts b/src/ecosystem_sci/reconstruction.ts
new file mode 100644
index 000000000..fc82867f5
--- /dev/null
+++ b/src/ecosystem_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci reconstruction module — tsb analytics library. */
+export interface EcosystemSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciReconstruction(data: number[], opts: EcosystemSciReconstructionOptions = {}): EcosystemSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciReconstruction };
diff --git a/src/ecosystem_sci/registration.ts b/src/ecosystem_sci/registration.ts
new file mode 100644
index 000000000..f60d321f3
--- /dev/null
+++ b/src/ecosystem_sci/registration.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci registration module — tsb analytics library. */
+export interface EcosystemSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciRegistration(data: number[], opts: EcosystemSciRegistrationOptions = {}): EcosystemSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciRegistration };
diff --git a/src/ecosystem_sci/regression.ts b/src/ecosystem_sci/regression.ts
new file mode 100644
index 000000000..e0131e3b0
--- /dev/null
+++ b/src/ecosystem_sci/regression.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci regression module — tsb analytics library. */
+export interface EcosystemSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciRegressionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciRegression(data: number[], opts: EcosystemSciRegressionOptions = {}): EcosystemSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciRegression };
diff --git a/src/ecosystem_sci/regularization.ts b/src/ecosystem_sci/regularization.ts
new file mode 100644
index 000000000..e3b557cdf
--- /dev/null
+++ b/src/ecosystem_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci regularization module — tsb analytics library. */
+export interface EcosystemSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciRegularization(data: number[], opts: EcosystemSciRegularizationOptions = {}): EcosystemSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciRegularization };
diff --git a/src/ecosystem_sci/robustness.ts b/src/ecosystem_sci/robustness.ts
new file mode 100644
index 000000000..642e1c3ec
--- /dev/null
+++ b/src/ecosystem_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci robustness module — tsb analytics library. */
+export interface EcosystemSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciRobustness(data: number[], opts: EcosystemSciRobustnessOptions = {}): EcosystemSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciRobustness };
diff --git a/src/ecosystem_sci/sampling.ts b/src/ecosystem_sci/sampling.ts
new file mode 100644
index 000000000..46a6246f3
--- /dev/null
+++ b/src/ecosystem_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci sampling module — tsb analytics library. */
+export interface EcosystemSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciSamplingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciSampling(data: number[], opts: EcosystemSciSamplingOptions = {}): EcosystemSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciSampling };
diff --git a/src/ecosystem_sci/sampling2.ts b/src/ecosystem_sci/sampling2.ts
new file mode 100644
index 000000000..4ef98de28
--- /dev/null
+++ b/src/ecosystem_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci sampling2 module — tsb analytics library. */
+export interface EcosystemSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciSamplingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciSampling(data: number[], opts: EcosystemSciSamplingOptions = {}): EcosystemSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciSampling };
diff --git a/src/ecosystem_sci/scaling.ts b/src/ecosystem_sci/scaling.ts
new file mode 100644
index 000000000..b8f643329
--- /dev/null
+++ b/src/ecosystem_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci scaling module — tsb analytics library. */
+export interface EcosystemSciScalingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciScalingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciScaling(data: number[], opts: EcosystemSciScalingOptions = {}): EcosystemSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciScaling };
diff --git a/src/ecosystem_sci/scoring.ts b/src/ecosystem_sci/scoring.ts
new file mode 100644
index 000000000..90fa45dd5
--- /dev/null
+++ b/src/ecosystem_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci scoring module — tsb analytics library. */
+export interface EcosystemSciScoringOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciScoringResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciScoring(data: number[], opts: EcosystemSciScoringOptions = {}): EcosystemSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciScoring };
diff --git a/src/ecosystem_sci/segmentation.ts b/src/ecosystem_sci/segmentation.ts
new file mode 100644
index 000000000..5ee877771
--- /dev/null
+++ b/src/ecosystem_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci segmentation module — tsb analytics library. */
+export interface EcosystemSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciSegmentation(data: number[], opts: EcosystemSciSegmentationOptions = {}): EcosystemSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciSegmentation };
diff --git a/src/ecosystem_sci/selection.ts b/src/ecosystem_sci/selection.ts
new file mode 100644
index 000000000..ec876b0ae
--- /dev/null
+++ b/src/ecosystem_sci/selection.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci selection module — tsb analytics library. */
+export interface EcosystemSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciSelectionResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciSelection(data: number[], opts: EcosystemSciSelectionOptions = {}): EcosystemSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciSelection };
diff --git a/src/ecosystem_sci/sensitivity.ts b/src/ecosystem_sci/sensitivity.ts
new file mode 100644
index 000000000..e10afc983
--- /dev/null
+++ b/src/ecosystem_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci sensitivity module — tsb analytics library. */
+export interface EcosystemSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciSensitivity(data: number[], opts: EcosystemSciSensitivityOptions = {}): EcosystemSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciSensitivity };
diff --git a/src/ecosystem_sci/simulation.ts b/src/ecosystem_sci/simulation.ts
new file mode 100644
index 000000000..37058edee
--- /dev/null
+++ b/src/ecosystem_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci simulation module — tsb analytics library. */
+export interface EcosystemSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciSimulationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciSimulation(data: number[], opts: EcosystemSciSimulationOptions = {}): EcosystemSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciSimulation };
diff --git a/src/ecosystem_sci/smoothing.ts b/src/ecosystem_sci/smoothing.ts
new file mode 100644
index 000000000..d458468d5
--- /dev/null
+++ b/src/ecosystem_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci smoothing module — tsb analytics library. */
+export interface EcosystemSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciSmoothing(data: number[], opts: EcosystemSciSmoothingOptions = {}): EcosystemSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciSmoothing };
diff --git a/src/ecosystem_sci/stability.ts b/src/ecosystem_sci/stability.ts
new file mode 100644
index 000000000..9cd3d7df6
--- /dev/null
+++ b/src/ecosystem_sci/stability.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci stability module — tsb analytics library. */
+export interface EcosystemSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciStabilityResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciStability(data: number[], opts: EcosystemSciStabilityOptions = {}): EcosystemSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciStability };
diff --git a/src/ecosystem_sci/stacking.ts b/src/ecosystem_sci/stacking.ts
new file mode 100644
index 000000000..54b02309d
--- /dev/null
+++ b/src/ecosystem_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci stacking module — tsb analytics library. */
+export interface EcosystemSciStackingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciStackingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciStacking(data: number[], opts: EcosystemSciStackingOptions = {}): EcosystemSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciStacking };
diff --git a/src/ecosystem_sci/standardization.ts b/src/ecosystem_sci/standardization.ts
new file mode 100644
index 000000000..c73c7295e
--- /dev/null
+++ b/src/ecosystem_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci standardization module — tsb analytics library. */
+export interface EcosystemSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciStandardization(data: number[], opts: EcosystemSciStandardizationOptions = {}): EcosystemSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciStandardization };
diff --git a/src/ecosystem_sci/static.ts b/src/ecosystem_sci/static.ts
new file mode 100644
index 000000000..853e9419f
--- /dev/null
+++ b/src/ecosystem_sci/static.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci static module — tsb analytics library. */
+export interface EcosystemSciStaticOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciStaticResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciStatic(data: number[], opts: EcosystemSciStaticOptions = {}): EcosystemSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciStatic };
diff --git a/src/ecosystem_sci/stochastic.ts b/src/ecosystem_sci/stochastic.ts
new file mode 100644
index 000000000..3ada0e534
--- /dev/null
+++ b/src/ecosystem_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci stochastic module — tsb analytics library. */
+export interface EcosystemSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciStochasticResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciStochastic(data: number[], opts: EcosystemSciStochasticOptions = {}): EcosystemSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciStochastic };
diff --git a/src/ecosystem_sci/synthesis.ts b/src/ecosystem_sci/synthesis.ts
new file mode 100644
index 000000000..68cdf0069
--- /dev/null
+++ b/src/ecosystem_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci synthesis module — tsb analytics library. */
+export interface EcosystemSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciSynthesis(data: number[], opts: EcosystemSciSynthesisOptions = {}): EcosystemSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciSynthesis };
diff --git a/src/ecosystem_sci/topology.ts b/src/ecosystem_sci/topology.ts
new file mode 100644
index 000000000..904d63e01
--- /dev/null
+++ b/src/ecosystem_sci/topology.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci topology module — tsb analytics library. */
+export interface EcosystemSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciTopologyResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciTopology(data: number[], opts: EcosystemSciTopologyOptions = {}): EcosystemSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciTopology };
diff --git a/src/ecosystem_sci/tracking.ts b/src/ecosystem_sci/tracking.ts
new file mode 100644
index 000000000..111e2f444
--- /dev/null
+++ b/src/ecosystem_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci tracking module — tsb analytics library. */
+export interface EcosystemSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciTrackingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciTracking(data: number[], opts: EcosystemSciTrackingOptions = {}): EcosystemSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciTracking };
diff --git a/src/ecosystem_sci/transform.ts b/src/ecosystem_sci/transform.ts
new file mode 100644
index 000000000..dfe22eec3
--- /dev/null
+++ b/src/ecosystem_sci/transform.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci transform module — tsb analytics library. */
+export interface EcosystemSciTransformOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciTransformResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciTransform(data: number[], opts: EcosystemSciTransformOptions = {}): EcosystemSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciTransform };
diff --git a/src/ecosystem_sci/uncertainty.ts b/src/ecosystem_sci/uncertainty.ts
new file mode 100644
index 000000000..6da142147
--- /dev/null
+++ b/src/ecosystem_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci uncertainty module — tsb analytics library. */
+export interface EcosystemSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciUncertainty(data: number[], opts: EcosystemSciUncertaintyOptions = {}): EcosystemSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciUncertainty };
diff --git a/src/ecosystem_sci/validation.ts b/src/ecosystem_sci/validation.ts
new file mode 100644
index 000000000..7e1314a75
--- /dev/null
+++ b/src/ecosystem_sci/validation.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci validation module — tsb analytics library. */
+export interface EcosystemSciValidationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciValidationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciValidation(data: number[], opts: EcosystemSciValidationOptions = {}): EcosystemSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciValidation };
diff --git a/src/ecosystem_sci/verification.ts b/src/ecosystem_sci/verification.ts
new file mode 100644
index 000000000..522f7673d
--- /dev/null
+++ b/src/ecosystem_sci/verification.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci verification module — tsb analytics library. */
+export interface EcosystemSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciVerificationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciVerification(data: number[], opts: EcosystemSciVerificationOptions = {}): EcosystemSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciVerification };
diff --git a/src/ecosystem_sci/visualization.ts b/src/ecosystem_sci/visualization.ts
new file mode 100644
index 000000000..9876c7e9e
--- /dev/null
+++ b/src/ecosystem_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci visualization module — tsb analytics library. */
+export interface EcosystemSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciVisualization(data: number[], opts: EcosystemSciVisualizationOptions = {}): EcosystemSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciVisualization };
diff --git a/src/ecosystem_sci/voting.ts b/src/ecosystem_sci/voting.ts
new file mode 100644
index 000000000..38d719e7d
--- /dev/null
+++ b/src/ecosystem_sci/voting.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci voting module — tsb analytics library. */
+export interface EcosystemSciVotingOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciVotingResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciVoting(data: number[], opts: EcosystemSciVotingOptions = {}): EcosystemSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciVoting };
diff --git a/src/ecosystem_sci/wavelet.ts b/src/ecosystem_sci/wavelet.ts
new file mode 100644
index 000000000..a534553e6
--- /dev/null
+++ b/src/ecosystem_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** ecosystem_sci wavelet module — tsb analytics library. */
+export interface EcosystemSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface EcosystemSciWaveletResult { values: number[]; converged: boolean; }
+export function computeEcosystemSciWavelet(data: number[], opts: EcosystemSciWaveletOptions = {}): EcosystemSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEcosystemSciWavelet };
diff --git a/src/education/advanced.ts b/src/education/advanced.ts
new file mode 100644
index 000000000..26a542eb1
--- /dev/null
+++ b/src/education/advanced.ts
@@ -0,0 +1,15 @@
+/** Education Advanced module — tsb analytics library. */
+export interface Education advancedOptions { tol?: number; maxIter?: number; }
+export interface Education advancedResult { values: number[]; converged: boolean; }
+export function computeEducation advanced(data: number[], opts: Education advancedOptions = {}): Education advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation advanced };
diff --git a/src/education/assessment.ts b/src/education/assessment.ts
new file mode 100644
index 000000000..00a40a780
--- /dev/null
+++ b/src/education/assessment.ts
@@ -0,0 +1,22 @@
+/** Assessment module — tsb analytics library. */
+
+/** Options for Assessment. */
+export interface AssessmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Assessment. */
+export interface AssessmentResult { values: number[]; converged: boolean; }
+
+/** Compute Assessment. */
+export function computeAssessment(data: number[], opts: AssessmentOptions = {}): AssessmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAssessment };
diff --git a/src/education/base2.ts b/src/education/base2.ts
new file mode 100644
index 000000000..9c903518e
--- /dev/null
+++ b/src/education/base2.ts
@@ -0,0 +1,15 @@
+/** Education Base2 module — tsb analytics library. */
+export interface Education base2Options { tol?: number; maxIter?: number; }
+export interface Education base2Result { values: number[]; converged: boolean; }
+export function computeEducation base2(data: number[], opts: Education base2Options = {}): Education base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation base2 };
diff --git a/src/education/batch.ts b/src/education/batch.ts
new file mode 100644
index 000000000..41b4b4596
--- /dev/null
+++ b/src/education/batch.ts
@@ -0,0 +1,15 @@
+/** Education Batch module — tsb analytics library. */
+export interface Education batchOptions { tol?: number; maxIter?: number; }
+export interface Education batchResult { values: number[]; converged: boolean; }
+export function computeEducation batch(data: number[], opts: Education batchOptions = {}): Education batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation batch };
diff --git a/src/education/beta.ts b/src/education/beta.ts
new file mode 100644
index 000000000..1d61339e6
--- /dev/null
+++ b/src/education/beta.ts
@@ -0,0 +1,15 @@
+/** Education Beta module — tsb analytics library. */
+export interface Education betaOptions { tol?: number; maxIter?: number; }
+export interface Education betaResult { values: number[]; converged: boolean; }
+export function computeEducation beta(data: number[], opts: Education betaOptions = {}): Education betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation beta };
diff --git a/src/education/bunching_edu.ts b/src/education/bunching_edu.ts
new file mode 100644
index 000000000..69d201505
--- /dev/null
+++ b/src/education/bunching_edu.ts
@@ -0,0 +1,22 @@
+/** Bunching Edu module — tsb analytics library. */
+
+/** Options for Bunching Edu. */
+export interface BunchingEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bunching Edu. */
+export interface BunchingEduResult { values: number[]; converged: boolean; }
+
+/** Compute Bunching Edu. */
+export function computeBunchingEdu(data: number[], opts: BunchingEduOptions = {}): BunchingEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBunchingEdu };
diff --git a/src/education/causal_edu.ts b/src/education/causal_edu.ts
new file mode 100644
index 000000000..764c7574a
--- /dev/null
+++ b/src/education/causal_edu.ts
@@ -0,0 +1,22 @@
+/** Causal Edu module — tsb analytics library. */
+
+/** Options for Causal Edu. */
+export interface CausalEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Causal Edu. */
+export interface CausalEduResult { values: number[]; converged: boolean; }
+
+/** Compute Causal Edu. */
+export function computeCausalEdu(data: number[], opts: CausalEduOptions = {}): CausalEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCausalEdu };
diff --git a/src/education/classical_test.ts b/src/education/classical_test.ts
new file mode 100644
index 000000000..0a5fd4473
--- /dev/null
+++ b/src/education/classical_test.ts
@@ -0,0 +1,22 @@
+/** Classical Test module — tsb analytics library. */
+
+/** Options for Classical Test. */
+export interface ClassicalTestOptions { tol?: number; maxIter?: number; }
+
+/** Result from Classical Test. */
+export interface ClassicalTestResult { values: number[]; converged: boolean; }
+
+/** Compute Classical Test. */
+export function computeClassicalTest(data: number[], opts: ClassicalTestOptions = {}): ClassicalTestResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClassicalTest };
diff --git a/src/education/cpu.ts b/src/education/cpu.ts
new file mode 100644
index 000000000..c2339ecbc
--- /dev/null
+++ b/src/education/cpu.ts
@@ -0,0 +1,15 @@
+/** Education Cpu module — tsb analytics library. */
+export interface Education cpuOptions { tol?: number; maxIter?: number; }
+export interface Education cpuResult { values: number[]; converged: boolean; }
+export function computeEducation cpu(data: number[], opts: Education cpuOptions = {}): Education cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation cpu };
diff --git a/src/education/dense.ts b/src/education/dense.ts
new file mode 100644
index 000000000..46f251b02
--- /dev/null
+++ b/src/education/dense.ts
@@ -0,0 +1,15 @@
+/** Education Dense module — tsb analytics library. */
+export interface Education denseOptions { tol?: number; maxIter?: number; }
+export interface Education denseResult { values: number[]; converged: boolean; }
+export function computeEducation dense(data: number[], opts: Education denseOptions = {}): Education denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation dense };
diff --git a/src/education/difference_in_differences_edu.ts b/src/education/difference_in_differences_edu.ts
new file mode 100644
index 000000000..fee129a9a
--- /dev/null
+++ b/src/education/difference_in_differences_edu.ts
@@ -0,0 +1,22 @@
+/** Difference In Differences Edu module — tsb analytics library. */
+
+/** Options for Difference In Differences Edu. */
+export interface DifferenceInDifferencesEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Difference In Differences Edu. */
+export interface DifferenceInDifferencesEduResult { values: number[]; converged: boolean; }
+
+/** Compute Difference In Differences Edu. */
+export function computeDifferenceInDifferencesEdu(data: number[], opts: DifferenceInDifferencesEduOptions = {}): DifferenceInDifferencesEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDifferenceInDifferencesEdu };
diff --git a/src/education/distributed.ts b/src/education/distributed.ts
new file mode 100644
index 000000000..df8eefe49
--- /dev/null
+++ b/src/education/distributed.ts
@@ -0,0 +1,15 @@
+/** Education Distributed module — tsb analytics library. */
+export interface Education distributedOptions { tol?: number; maxIter?: number; }
+export interface Education distributedResult { values: number[]; converged: boolean; }
+export function computeEducation distributed(data: number[], opts: Education distributedOptions = {}): Education distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation distributed };
diff --git a/src/education/equating_edu.ts b/src/education/equating_edu.ts
new file mode 100644
index 000000000..cd49211f7
--- /dev/null
+++ b/src/education/equating_edu.ts
@@ -0,0 +1,22 @@
+/** Equating Edu module — tsb analytics library. */
+
+/** Options for Equating Edu. */
+export interface EquatingEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Equating Edu. */
+export interface EquatingEduResult { values: number[]; converged: boolean; }
+
+/** Compute Equating Edu. */
+export function computeEquatingEdu(data: number[], opts: EquatingEduOptions = {}): EquatingEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEquatingEdu };
diff --git a/src/education/experimental.ts b/src/education/experimental.ts
new file mode 100644
index 000000000..0169bf2d8
--- /dev/null
+++ b/src/education/experimental.ts
@@ -0,0 +1,22 @@
+/** Experimental module — tsb analytics library. */
+
+/** Options for Experimental. */
+export interface ExperimentalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Experimental. */
+export interface ExperimentalResult { values: number[]; converged: boolean; }
+
+/** Compute Experimental. */
+export function computeExperimental(data: number[], opts: ExperimentalOptions = {}): ExperimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExperimental };
diff --git a/src/education/factor_edu.ts b/src/education/factor_edu.ts
new file mode 100644
index 000000000..981d5ba3b
--- /dev/null
+++ b/src/education/factor_edu.ts
@@ -0,0 +1,22 @@
+/** Factor Edu module — tsb analytics library. */
+
+/** Options for Factor Edu. */
+export interface FactorEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Factor Edu. */
+export interface FactorEduResult { values: number[]; converged: boolean; }
+
+/** Compute Factor Edu. */
+export function computeFactorEdu(data: number[], opts: FactorEduOptions = {}): FactorEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFactorEdu };
diff --git a/src/education/fast.ts b/src/education/fast.ts
new file mode 100644
index 000000000..1146f1171
--- /dev/null
+++ b/src/education/fast.ts
@@ -0,0 +1,15 @@
+/** Education Fast module — tsb analytics library. */
+export interface Education fastOptions { tol?: number; maxIter?: number; }
+export interface Education fastResult { values: number[]; converged: boolean; }
+export function computeEducation fast(data: number[], opts: Education fastOptions = {}): Education fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation fast };
diff --git a/src/education/future.ts b/src/education/future.ts
new file mode 100644
index 000000000..7a0643bcb
--- /dev/null
+++ b/src/education/future.ts
@@ -0,0 +1,15 @@
+/** Education Future module — tsb analytics library. */
+export interface Education futureOptions { tol?: number; maxIter?: number; }
+export interface Education futureResult { values: number[]; converged: boolean; }
+export function computeEducation future(data: number[], opts: Education futureOptions = {}): Education futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation future };
diff --git a/src/education/generalizability.ts b/src/education/generalizability.ts
new file mode 100644
index 000000000..e1ec0fe20
--- /dev/null
+++ b/src/education/generalizability.ts
@@ -0,0 +1,22 @@
+/** Generalizability module — tsb analytics library. */
+
+/** Options for Generalizability. */
+export interface GeneralizabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Generalizability. */
+export interface GeneralizabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Generalizability. */
+export function computeGeneralizability(data: number[], opts: GeneralizabilityOptions = {}): GeneralizabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeneralizability };
diff --git a/src/education/gpu.ts b/src/education/gpu.ts
new file mode 100644
index 000000000..280d61577
--- /dev/null
+++ b/src/education/gpu.ts
@@ -0,0 +1,15 @@
+/** Education Gpu module — tsb analytics library. */
+export interface Education gpuOptions { tol?: number; maxIter?: number; }
+export interface Education gpuResult { values: number[]; converged: boolean; }
+export function computeEducation gpu(data: number[], opts: Education gpuOptions = {}): Education gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation gpu };
diff --git a/src/education/growth_model.ts b/src/education/growth_model.ts
new file mode 100644
index 000000000..92707a2b8
--- /dev/null
+++ b/src/education/growth_model.ts
@@ -0,0 +1,22 @@
+/** Growth Model module — tsb analytics library. */
+
+/** Options for Growth Model. */
+export interface GrowthModelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Growth Model. */
+export interface GrowthModelResult { values: number[]; converged: boolean; }
+
+/** Compute Growth Model. */
+export function computeGrowthModel(data: number[], opts: GrowthModelOptions = {}): GrowthModelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGrowthModel };
diff --git a/src/education/instrumental_variable_edu.ts b/src/education/instrumental_variable_edu.ts
new file mode 100644
index 000000000..9200cd28b
--- /dev/null
+++ b/src/education/instrumental_variable_edu.ts
@@ -0,0 +1,22 @@
+/** Instrumental Variable Edu module — tsb analytics library. */
+
+/** Options for Instrumental Variable Edu. */
+export interface InstrumentalVariableEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Instrumental Variable Edu. */
+export interface InstrumentalVariableEduResult { values: number[]; converged: boolean; }
+
+/** Compute Instrumental Variable Edu. */
+export function computeInstrumentalVariableEdu(data: number[], opts: InstrumentalVariableEduOptions = {}): InstrumentalVariableEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInstrumentalVariableEdu };
diff --git a/src/education/interrupted_time_series_edu.ts b/src/education/interrupted_time_series_edu.ts
new file mode 100644
index 000000000..27fe31d7e
--- /dev/null
+++ b/src/education/interrupted_time_series_edu.ts
@@ -0,0 +1,22 @@
+/** Interrupted Time Series Edu module — tsb analytics library. */
+
+/** Options for Interrupted Time Series Edu. */
+export interface InterruptedTimeSeriesEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Interrupted Time Series Edu. */
+export interface InterruptedTimeSeriesEduResult { values: number[]; converged: boolean; }
+
+/** Compute Interrupted Time Series Edu. */
+export function computeInterruptedTimeSeriesEdu(data: number[], opts: InterruptedTimeSeriesEduOptions = {}): InterruptedTimeSeriesEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInterruptedTimeSeriesEdu };
diff --git a/src/education/item_response.ts b/src/education/item_response.ts
new file mode 100644
index 000000000..b1473c126
--- /dev/null
+++ b/src/education/item_response.ts
@@ -0,0 +1,22 @@
+/** Item Response module — tsb analytics library. */
+
+/** Options for Item Response. */
+export interface ItemResponseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Item Response. */
+export interface ItemResponseResult { values: number[]; converged: boolean; }
+
+/** Compute Item Response. */
+export function computeItemResponse(data: number[], opts: ItemResponseOptions = {}): ItemResponseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeItemResponse };
diff --git a/src/education/large.ts b/src/education/large.ts
new file mode 100644
index 000000000..6463b255b
--- /dev/null
+++ b/src/education/large.ts
@@ -0,0 +1,15 @@
+/** Education Large module — tsb analytics library. */
+export interface Education largeOptions { tol?: number; maxIter?: number; }
+export interface Education largeResult { values: number[]; converged: boolean; }
+export function computeEducation large(data: number[], opts: Education largeOptions = {}): Education largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation large };
diff --git a/src/education/legacy.ts b/src/education/legacy.ts
new file mode 100644
index 000000000..76587b777
--- /dev/null
+++ b/src/education/legacy.ts
@@ -0,0 +1,15 @@
+/** Education Legacy module — tsb analytics library. */
+export interface Education legacyOptions { tol?: number; maxIter?: number; }
+export interface Education legacyResult { values: number[]; converged: boolean; }
+export function computeEducation legacy(data: number[], opts: Education legacyOptions = {}): Education legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation legacy };
diff --git a/src/education/linking.ts b/src/education/linking.ts
new file mode 100644
index 000000000..01b661a64
--- /dev/null
+++ b/src/education/linking.ts
@@ -0,0 +1,22 @@
+/** Linking module — tsb analytics library. */
+
+/** Options for Linking. */
+export interface LinkingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Linking. */
+export interface LinkingResult { values: number[]; converged: boolean; }
+
+/** Compute Linking. */
+export function computeLinking(data: number[], opts: LinkingOptions = {}): LinkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLinking };
diff --git a/src/education/lite.ts b/src/education/lite.ts
new file mode 100644
index 000000000..7bb56cf37
--- /dev/null
+++ b/src/education/lite.ts
@@ -0,0 +1,15 @@
+/** Education Lite module — tsb analytics library. */
+export interface Education liteOptions { tol?: number; maxIter?: number; }
+export interface Education liteResult { values: number[]; converged: boolean; }
+export function computeEducation lite(data: number[], opts: Education liteOptions = {}): Education liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation lite };
diff --git a/src/education/matching_edu.ts b/src/education/matching_edu.ts
new file mode 100644
index 000000000..a4fce656b
--- /dev/null
+++ b/src/education/matching_edu.ts
@@ -0,0 +1,22 @@
+/** Matching Edu module — tsb analytics library. */
+
+/** Options for Matching Edu. */
+export interface MatchingEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Matching Edu. */
+export interface MatchingEduResult { values: number[]; converged: boolean; }
+
+/** Compute Matching Edu. */
+export function computeMatchingEdu(data: number[], opts: MatchingEduOptions = {}): MatchingEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMatchingEdu };
diff --git a/src/education/measurement_edu.ts b/src/education/measurement_edu.ts
new file mode 100644
index 000000000..ba92bb546
--- /dev/null
+++ b/src/education/measurement_edu.ts
@@ -0,0 +1,22 @@
+/** Measurement Edu module — tsb analytics library. */
+
+/** Options for Measurement Edu. */
+export interface MeasurementEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Measurement Edu. */
+export interface MeasurementEduResult { values: number[]; converged: boolean; }
+
+/** Compute Measurement Edu. */
+export function computeMeasurementEdu(data: number[], opts: MeasurementEduOptions = {}): MeasurementEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMeasurementEdu };
diff --git a/src/education/mini.ts b/src/education/mini.ts
new file mode 100644
index 000000000..0daaaa6b4
--- /dev/null
+++ b/src/education/mini.ts
@@ -0,0 +1,15 @@
+/** Education Mini module — tsb analytics library. */
+export interface Education miniOptions { tol?: number; maxIter?: number; }
+export interface Education miniResult { values: number[]; converged: boolean; }
+export function computeEducation mini(data: number[], opts: Education miniOptions = {}): Education miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation mini };
diff --git a/src/education/multilevel.ts b/src/education/multilevel.ts
new file mode 100644
index 000000000..e0c3318f3
--- /dev/null
+++ b/src/education/multilevel.ts
@@ -0,0 +1,22 @@
+/** Multilevel module — tsb analytics library. */
+
+/** Options for Multilevel. */
+export interface MultilevelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Multilevel. */
+export interface MultilevelResult { values: number[]; converged: boolean; }
+
+/** Compute Multilevel. */
+export function computeMultilevel(data: number[], opts: MultilevelOptions = {}): MultilevelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMultilevel };
diff --git a/src/education/natural_experiment.ts b/src/education/natural_experiment.ts
new file mode 100644
index 000000000..5049d8a7d
--- /dev/null
+++ b/src/education/natural_experiment.ts
@@ -0,0 +1,22 @@
+/** Natural Experiment module — tsb analytics library. */
+
+/** Options for Natural Experiment. */
+export interface NaturalExperimentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Natural Experiment. */
+export interface NaturalExperimentResult { values: number[]; converged: boolean; }
+
+/** Compute Natural Experiment. */
+export function computeNaturalExperiment(data: number[], opts: NaturalExperimentOptions = {}): NaturalExperimentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNaturalExperiment };
diff --git a/src/education/next.ts b/src/education/next.ts
new file mode 100644
index 000000000..dc757b3fe
--- /dev/null
+++ b/src/education/next.ts
@@ -0,0 +1,15 @@
+/** Education Next module — tsb analytics library. */
+export interface Education nextOptions { tol?: number; maxIter?: number; }
+export interface Education nextResult { values: number[]; converged: boolean; }
+export function computeEducation next(data: number[], opts: Education nextOptions = {}): Education nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation next };
diff --git a/src/education/norming.ts b/src/education/norming.ts
new file mode 100644
index 000000000..4534795f1
--- /dev/null
+++ b/src/education/norming.ts
@@ -0,0 +1,22 @@
+/** Norming module — tsb analytics library. */
+
+/** Options for Norming. */
+export interface NormingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Norming. */
+export interface NormingResult { values: number[]; converged: boolean; }
+
+/** Compute Norming. */
+export function computeNorming(data: number[], opts: NormingOptions = {}): NormingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNorming };
diff --git a/src/education/online.ts b/src/education/online.ts
new file mode 100644
index 000000000..13f491952
--- /dev/null
+++ b/src/education/online.ts
@@ -0,0 +1,15 @@
+/** Education Online module — tsb analytics library. */
+export interface Education onlineOptions { tol?: number; maxIter?: number; }
+export interface Education onlineResult { values: number[]; converged: boolean; }
+export function computeEducation online(data: number[], opts: Education onlineOptions = {}): Education onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation online };
diff --git a/src/education/parallel.ts b/src/education/parallel.ts
new file mode 100644
index 000000000..4a0136f09
--- /dev/null
+++ b/src/education/parallel.ts
@@ -0,0 +1,15 @@
+/** Education Parallel module — tsb analytics library. */
+export interface Education parallelOptions { tol?: number; maxIter?: number; }
+export interface Education parallelResult { values: number[]; converged: boolean; }
+export function computeEducation parallel(data: number[], opts: Education parallelOptions = {}): Education parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation parallel };
diff --git a/src/education/plus.ts b/src/education/plus.ts
new file mode 100644
index 000000000..c08ce8578
--- /dev/null
+++ b/src/education/plus.ts
@@ -0,0 +1,15 @@
+/** Education Plus module — tsb analytics library. */
+export interface Education plusOptions { tol?: number; maxIter?: number; }
+export interface Education plusResult { values: number[]; converged: boolean; }
+export function computeEducation plus(data: number[], opts: Education plusOptions = {}): Education plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation plus };
diff --git a/src/education/pro.ts b/src/education/pro.ts
new file mode 100644
index 000000000..c621d534c
--- /dev/null
+++ b/src/education/pro.ts
@@ -0,0 +1,15 @@
+/** Education Pro module — tsb analytics library. */
+export interface Education proOptions { tol?: number; maxIter?: number; }
+export interface Education proResult { values: number[]; converged: boolean; }
+export function computeEducation pro(data: number[], opts: Education proOptions = {}): Education proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation pro };
diff --git a/src/education/propensity_edu.ts b/src/education/propensity_edu.ts
new file mode 100644
index 000000000..d8c8be031
--- /dev/null
+++ b/src/education/propensity_edu.ts
@@ -0,0 +1,22 @@
+/** Propensity Edu module — tsb analytics library. */
+
+/** Options for Propensity Edu. */
+export interface PropensityEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Propensity Edu. */
+export interface PropensityEduResult { values: number[]; converged: boolean; }
+
+/** Compute Propensity Edu. */
+export function computePropensityEdu(data: number[], opts: PropensityEduOptions = {}): PropensityEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePropensityEdu };
diff --git a/src/education/quasi_experimental.ts b/src/education/quasi_experimental.ts
new file mode 100644
index 000000000..d2c7603e8
--- /dev/null
+++ b/src/education/quasi_experimental.ts
@@ -0,0 +1,22 @@
+/** Quasi Experimental module — tsb analytics library. */
+
+/** Options for Quasi Experimental. */
+export interface QuasiExperimentalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quasi Experimental. */
+export interface QuasiExperimentalResult { values: number[]; converged: boolean; }
+
+/** Compute Quasi Experimental. */
+export function computeQuasiExperimental(data: number[], opts: QuasiExperimentalOptions = {}): QuasiExperimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQuasiExperimental };
diff --git a/src/education/rasch.ts b/src/education/rasch.ts
new file mode 100644
index 000000000..e09a5de02
--- /dev/null
+++ b/src/education/rasch.ts
@@ -0,0 +1,22 @@
+/** Rasch module — tsb analytics library. */
+
+/** Options for Rasch. */
+export interface RaschOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rasch. */
+export interface RaschResult { values: number[]; converged: boolean; }
+
+/** Compute Rasch. */
+export function computeRasch(data: number[], opts: RaschOptions = {}): RaschResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRasch };
diff --git a/src/education/regression_discontinuity_edu.ts b/src/education/regression_discontinuity_edu.ts
new file mode 100644
index 000000000..c6c9abdb2
--- /dev/null
+++ b/src/education/regression_discontinuity_edu.ts
@@ -0,0 +1,22 @@
+/** Regression Discontinuity Edu module — tsb analytics library. */
+
+/** Options for Regression Discontinuity Edu. */
+export interface RegressionDiscontinuityEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Regression Discontinuity Edu. */
+export interface RegressionDiscontinuityEduResult { values: number[]; converged: boolean; }
+
+/** Compute Regression Discontinuity Edu. */
+export function computeRegressionDiscontinuityEdu(data: number[], opts: RegressionDiscontinuityEduOptions = {}): RegressionDiscontinuityEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRegressionDiscontinuityEdu };
diff --git a/src/education/regression_kink_edu.ts b/src/education/regression_kink_edu.ts
new file mode 100644
index 000000000..9a9963a2c
--- /dev/null
+++ b/src/education/regression_kink_edu.ts
@@ -0,0 +1,22 @@
+/** Regression Kink Edu module — tsb analytics library. */
+
+/** Options for Regression Kink Edu. */
+export interface RegressionKinkEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Regression Kink Edu. */
+export interface RegressionKinkEduResult { values: number[]; converged: boolean; }
+
+/** Compute Regression Kink Edu. */
+export function computeRegressionKinkEdu(data: number[], opts: RegressionKinkEduOptions = {}): RegressionKinkEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRegressionKinkEdu };
diff --git a/src/education/reliability_edu.ts b/src/education/reliability_edu.ts
new file mode 100644
index 000000000..7879a1030
--- /dev/null
+++ b/src/education/reliability_edu.ts
@@ -0,0 +1,22 @@
+/** Reliability Edu module — tsb analytics library. */
+
+/** Options for Reliability Edu. */
+export interface ReliabilityEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reliability Edu. */
+export interface ReliabilityEduResult { values: number[]; converged: boolean; }
+
+/** Compute Reliability Edu. */
+export function computeReliabilityEdu(data: number[], opts: ReliabilityEduOptions = {}): ReliabilityEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReliabilityEdu };
diff --git a/src/education/robust.ts b/src/education/robust.ts
new file mode 100644
index 000000000..edc9a4ce7
--- /dev/null
+++ b/src/education/robust.ts
@@ -0,0 +1,15 @@
+/** Education Robust module — tsb analytics library. */
+export interface Education robustOptions { tol?: number; maxIter?: number; }
+export interface Education robustResult { values: number[]; converged: boolean; }
+export function computeEducation robust(data: number[], opts: Education robustOptions = {}): Education robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation robust };
diff --git a/src/education/scaling.ts b/src/education/scaling.ts
new file mode 100644
index 000000000..0a07f2333
--- /dev/null
+++ b/src/education/scaling.ts
@@ -0,0 +1,22 @@
+/** Scaling module — tsb analytics library. */
+
+/** Options for Scaling. */
+export interface ScalingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Scaling. */
+export interface ScalingResult { values: number[]; converged: boolean; }
+
+/** Compute Scaling. */
+export function computeScaling(data: number[], opts: ScalingOptions = {}): ScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeScaling };
diff --git a/src/education/sem_edu.ts b/src/education/sem_edu.ts
new file mode 100644
index 000000000..399ab0a4b
--- /dev/null
+++ b/src/education/sem_edu.ts
@@ -0,0 +1,22 @@
+/** Sem Edu module — tsb analytics library. */
+
+/** Options for Sem Edu. */
+export interface SemEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sem Edu. */
+export interface SemEduResult { values: number[]; converged: boolean; }
+
+/** Compute Sem Edu. */
+export function computeSemEdu(data: number[], opts: SemEduOptions = {}): SemEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSemEdu };
diff --git a/src/education/small.ts b/src/education/small.ts
new file mode 100644
index 000000000..c31310669
--- /dev/null
+++ b/src/education/small.ts
@@ -0,0 +1,15 @@
+/** Education Small module — tsb analytics library. */
+export interface Education smallOptions { tol?: number; maxIter?: number; }
+export interface Education smallResult { values: number[]; converged: boolean; }
+export function computeEducation small(data: number[], opts: Education smallOptions = {}): Education smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation small };
diff --git a/src/education/sparse.ts b/src/education/sparse.ts
new file mode 100644
index 000000000..e0148ed0d
--- /dev/null
+++ b/src/education/sparse.ts
@@ -0,0 +1,15 @@
+/** Education Sparse module — tsb analytics library. */
+export interface Education sparseOptions { tol?: number; maxIter?: number; }
+export interface Education sparseResult { values: number[]; converged: boolean; }
+export function computeEducation sparse(data: number[], opts: Education sparseOptions = {}): Education sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation sparse };
diff --git a/src/education/stable.ts b/src/education/stable.ts
new file mode 100644
index 000000000..4a85ba5c0
--- /dev/null
+++ b/src/education/stable.ts
@@ -0,0 +1,15 @@
+/** Education Stable module — tsb analytics library. */
+export interface Education stableOptions { tol?: number; maxIter?: number; }
+export interface Education stableResult { values: number[]; converged: boolean; }
+export function computeEducation stable(data: number[], opts: Education stableOptions = {}): Education stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation stable };
diff --git a/src/education/streaming.ts b/src/education/streaming.ts
new file mode 100644
index 000000000..729246622
--- /dev/null
+++ b/src/education/streaming.ts
@@ -0,0 +1,15 @@
+/** Education Streaming module — tsb analytics library. */
+export interface Education streamingOptions { tol?: number; maxIter?: number; }
+export interface Education streamingResult { values: number[]; converged: boolean; }
+export function computeEducation streaming(data: number[], opts: Education streamingOptions = {}): Education streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation streaming };
diff --git a/src/education/synthetic_control_edu.ts b/src/education/synthetic_control_edu.ts
new file mode 100644
index 000000000..cbee06bcc
--- /dev/null
+++ b/src/education/synthetic_control_edu.ts
@@ -0,0 +1,22 @@
+/** Synthetic Control Edu module — tsb analytics library. */
+
+/** Options for Synthetic Control Edu. */
+export interface SyntheticControlEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Synthetic Control Edu. */
+export interface SyntheticControlEduResult { values: number[]; converged: boolean; }
+
+/** Compute Synthetic Control Edu. */
+export function computeSyntheticControlEdu(data: number[], opts: SyntheticControlEduOptions = {}): SyntheticControlEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSyntheticControlEdu };
diff --git a/src/education/v2.ts b/src/education/v2.ts
new file mode 100644
index 000000000..d790daefc
--- /dev/null
+++ b/src/education/v2.ts
@@ -0,0 +1,15 @@
+/** Education V2 module — tsb analytics library. */
+export interface Education v2Options { tol?: number; maxIter?: number; }
+export interface Education v2Result { values: number[]; converged: boolean; }
+export function computeEducation v2(data: number[], opts: Education v2Options = {}): Education v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation v2 };
diff --git a/src/education/v3.ts b/src/education/v3.ts
new file mode 100644
index 000000000..7dcebf8bb
--- /dev/null
+++ b/src/education/v3.ts
@@ -0,0 +1,15 @@
+/** Education V3 module — tsb analytics library. */
+export interface Education v3Options { tol?: number; maxIter?: number; }
+export interface Education v3Result { values: number[]; converged: boolean; }
+export function computeEducation v3(data: number[], opts: Education v3Options = {}): Education v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation v3 };
diff --git a/src/education/validity_edu.ts b/src/education/validity_edu.ts
new file mode 100644
index 000000000..b17b148ba
--- /dev/null
+++ b/src/education/validity_edu.ts
@@ -0,0 +1,22 @@
+/** Validity Edu module — tsb analytics library. */
+
+/** Options for Validity Edu. */
+export interface ValidityEduOptions { tol?: number; maxIter?: number; }
+
+/** Result from Validity Edu. */
+export interface ValidityEduResult { values: number[]; converged: boolean; }
+
+/** Compute Validity Edu. */
+export function computeValidityEdu(data: number[], opts: ValidityEduOptions = {}): ValidityEduResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeValidityEdu };
diff --git a/src/education/value_added.ts b/src/education/value_added.ts
new file mode 100644
index 000000000..94011ac85
--- /dev/null
+++ b/src/education/value_added.ts
@@ -0,0 +1,22 @@
+/** Value Added module — tsb analytics library. */
+
+/** Options for Value Added. */
+export interface ValueAddedOptions { tol?: number; maxIter?: number; }
+
+/** Result from Value Added. */
+export interface ValueAddedResult { values: number[]; converged: boolean; }
+
+/** Compute Value Added. */
+export function computeValueAdded(data: number[], opts: ValueAddedOptions = {}): ValueAddedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeValueAdded };
diff --git a/src/education/wasm.ts b/src/education/wasm.ts
new file mode 100644
index 000000000..f6fffd881
--- /dev/null
+++ b/src/education/wasm.ts
@@ -0,0 +1,15 @@
+/** Education Wasm module — tsb analytics library. */
+export interface Education wasmOptions { tol?: number; maxIter?: number; }
+export interface Education wasmResult { values: number[]; converged: boolean; }
+export function computeEducation wasm(data: number[], opts: Education wasmOptions = {}): Education wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation wasm };
diff --git a/src/education/xlarge.ts b/src/education/xlarge.ts
new file mode 100644
index 000000000..35f39f645
--- /dev/null
+++ b/src/education/xlarge.ts
@@ -0,0 +1,15 @@
+/** Education Xlarge module — tsb analytics library. */
+export interface Education xlargeOptions { tol?: number; maxIter?: number; }
+export interface Education xlargeResult { values: number[]; converged: boolean; }
+export function computeEducation xlarge(data: number[], opts: Education xlargeOptions = {}): Education xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEducation xlarge };
diff --git a/src/electrochemistry/adaptation.ts b/src/electrochemistry/adaptation.ts
new file mode 100644
index 000000000..096595ee0
--- /dev/null
+++ b/src/electrochemistry/adaptation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry adaptation module — tsb analytics library. */
+export interface ElectrochemistryAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryAdaptationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryAdaptation(data: number[], opts: ElectrochemistryAdaptationOptions = {}): ElectrochemistryAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryAdaptation };
diff --git a/src/electrochemistry/aggregation.ts b/src/electrochemistry/aggregation.ts
new file mode 100644
index 000000000..3ac07959b
--- /dev/null
+++ b/src/electrochemistry/aggregation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry aggregation module — tsb analytics library. */
+export interface ElectrochemistryAggregationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryAggregationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryAggregation(data: number[], opts: ElectrochemistryAggregationOptions = {}): ElectrochemistryAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryAggregation };
diff --git a/src/electrochemistry/algebra.ts b/src/electrochemistry/algebra.ts
new file mode 100644
index 000000000..b4f7dd145
--- /dev/null
+++ b/src/electrochemistry/algebra.ts
@@ -0,0 +1,14 @@
+/** electrochemistry algebra module — tsb analytics library. */
+export interface ElectrochemistryAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryAlgebraResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryAlgebra(data: number[], opts: ElectrochemistryAlgebraOptions = {}): ElectrochemistryAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryAlgebra };
diff --git a/src/electrochemistry/alignment.ts b/src/electrochemistry/alignment.ts
new file mode 100644
index 000000000..e8e1551a5
--- /dev/null
+++ b/src/electrochemistry/alignment.ts
@@ -0,0 +1,14 @@
+/** electrochemistry alignment module — tsb analytics library. */
+export interface ElectrochemistryAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryAlignmentResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryAlignment(data: number[], opts: ElectrochemistryAlignmentOptions = {}): ElectrochemistryAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryAlignment };
diff --git a/src/electrochemistry/analysis.ts b/src/electrochemistry/analysis.ts
new file mode 100644
index 000000000..3ccec89f6
--- /dev/null
+++ b/src/electrochemistry/analysis.ts
@@ -0,0 +1,14 @@
+/** electrochemistry analysis module — tsb analytics library. */
+export interface ElectrochemistryAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryAnalysisResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryAnalysis(data: number[], opts: ElectrochemistryAnalysisOptions = {}): ElectrochemistryAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryAnalysis };
diff --git a/src/electrochemistry/augmentation.ts b/src/electrochemistry/augmentation.ts
new file mode 100644
index 000000000..36c01ee67
--- /dev/null
+++ b/src/electrochemistry/augmentation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry augmentation module — tsb analytics library. */
+export interface ElectrochemistryAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryAugmentationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryAugmentation(data: number[], opts: ElectrochemistryAugmentationOptions = {}): ElectrochemistryAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryAugmentation };
diff --git a/src/electrochemistry/bagging.ts b/src/electrochemistry/bagging.ts
new file mode 100644
index 000000000..131b71172
--- /dev/null
+++ b/src/electrochemistry/bagging.ts
@@ -0,0 +1,14 @@
+/** electrochemistry bagging module — tsb analytics library. */
+export interface ElectrochemistryBaggingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryBaggingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryBagging(data: number[], opts: ElectrochemistryBaggingOptions = {}): ElectrochemistryBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryBagging };
diff --git a/src/electrochemistry/basis.ts b/src/electrochemistry/basis.ts
new file mode 100644
index 000000000..ce876e754
--- /dev/null
+++ b/src/electrochemistry/basis.ts
@@ -0,0 +1,14 @@
+/** electrochemistry basis module — tsb analytics library. */
+export interface ElectrochemistryBasisOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryBasisResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryBasis(data: number[], opts: ElectrochemistryBasisOptions = {}): ElectrochemistryBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryBasis };
diff --git a/src/electrochemistry/benchmarking.ts b/src/electrochemistry/benchmarking.ts
new file mode 100644
index 000000000..fcebff254
--- /dev/null
+++ b/src/electrochemistry/benchmarking.ts
@@ -0,0 +1,14 @@
+/** electrochemistry benchmarking module — tsb analytics library. */
+export interface ElectrochemistryBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryBenchmarking(data: number[], opts: ElectrochemistryBenchmarkingOptions = {}): ElectrochemistryBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryBenchmarking };
diff --git a/src/electrochemistry/blending.ts b/src/electrochemistry/blending.ts
new file mode 100644
index 000000000..5cc417e60
--- /dev/null
+++ b/src/electrochemistry/blending.ts
@@ -0,0 +1,14 @@
+/** electrochemistry blending module — tsb analytics library. */
+export interface ElectrochemistryBlendingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryBlendingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryBlending(data: number[], opts: ElectrochemistryBlendingOptions = {}): ElectrochemistryBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryBlending };
diff --git a/src/electrochemistry/boosting.ts b/src/electrochemistry/boosting.ts
new file mode 100644
index 000000000..00425f025
--- /dev/null
+++ b/src/electrochemistry/boosting.ts
@@ -0,0 +1,14 @@
+/** electrochemistry boosting module — tsb analytics library. */
+export interface ElectrochemistryBoostingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryBoostingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryBoosting(data: number[], opts: ElectrochemistryBoostingOptions = {}): ElectrochemistryBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryBoosting };
diff --git a/src/electrochemistry/bootstrap.ts b/src/electrochemistry/bootstrap.ts
new file mode 100644
index 000000000..f2de232dd
--- /dev/null
+++ b/src/electrochemistry/bootstrap.ts
@@ -0,0 +1,14 @@
+/** electrochemistry bootstrap module — tsb analytics library. */
+export interface ElectrochemistryBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryBootstrapResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryBootstrap(data: number[], opts: ElectrochemistryBootstrapOptions = {}): ElectrochemistryBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryBootstrap };
diff --git a/src/electrochemistry/calculus.ts b/src/electrochemistry/calculus.ts
new file mode 100644
index 000000000..e7372fef9
--- /dev/null
+++ b/src/electrochemistry/calculus.ts
@@ -0,0 +1,14 @@
+/** electrochemistry calculus module — tsb analytics library. */
+export interface ElectrochemistryCalculusOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryCalculusResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryCalculus(data: number[], opts: ElectrochemistryCalculusOptions = {}): ElectrochemistryCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryCalculus };
diff --git a/src/electrochemistry/calibration.ts b/src/electrochemistry/calibration.ts
new file mode 100644
index 000000000..8cd64b57d
--- /dev/null
+++ b/src/electrochemistry/calibration.ts
@@ -0,0 +1,14 @@
+/** electrochemistry calibration module — tsb analytics library. */
+export interface ElectrochemistryCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryCalibrationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryCalibration(data: number[], opts: ElectrochemistryCalibrationOptions = {}): ElectrochemistryCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryCalibration };
diff --git a/src/electrochemistry/characterization.ts b/src/electrochemistry/characterization.ts
new file mode 100644
index 000000000..c0748aed6
--- /dev/null
+++ b/src/electrochemistry/characterization.ts
@@ -0,0 +1,14 @@
+/** electrochemistry characterization module — tsb analytics library. */
+export interface ElectrochemistryCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryCharacterizationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryCharacterization(data: number[], opts: ElectrochemistryCharacterizationOptions = {}): ElectrochemistryCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryCharacterization };
diff --git a/src/electrochemistry/classification.ts b/src/electrochemistry/classification.ts
new file mode 100644
index 000000000..a5fcac8c7
--- /dev/null
+++ b/src/electrochemistry/classification.ts
@@ -0,0 +1,14 @@
+/** electrochemistry classification module — tsb analytics library. */
+export interface ElectrochemistryClassificationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryClassificationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryClassification(data: number[], opts: ElectrochemistryClassificationOptions = {}): ElectrochemistryClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryClassification };
diff --git a/src/electrochemistry/clustering.ts b/src/electrochemistry/clustering.ts
new file mode 100644
index 000000000..f1be0f8cf
--- /dev/null
+++ b/src/electrochemistry/clustering.ts
@@ -0,0 +1,14 @@
+/** electrochemistry clustering module — tsb analytics library. */
+export interface ElectrochemistryClusteringOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryClusteringResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryClustering(data: number[], opts: ElectrochemistryClusteringOptions = {}): ElectrochemistryClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryClustering };
diff --git a/src/electrochemistry/compression.ts b/src/electrochemistry/compression.ts
new file mode 100644
index 000000000..5346821ee
--- /dev/null
+++ b/src/electrochemistry/compression.ts
@@ -0,0 +1,14 @@
+/** electrochemistry compression module — tsb analytics library. */
+export interface ElectrochemistryCompressionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryCompressionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryCompression(data: number[], opts: ElectrochemistryCompressionOptions = {}): ElectrochemistryCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryCompression };
diff --git a/src/electrochemistry/continuous.ts b/src/electrochemistry/continuous.ts
new file mode 100644
index 000000000..202cfd032
--- /dev/null
+++ b/src/electrochemistry/continuous.ts
@@ -0,0 +1,14 @@
+/** electrochemistry continuous module — tsb analytics library. */
+export interface ElectrochemistryContinuousOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryContinuousResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryContinuous(data: number[], opts: ElectrochemistryContinuousOptions = {}): ElectrochemistryContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryContinuous };
diff --git a/src/electrochemistry/control.ts b/src/electrochemistry/control.ts
new file mode 100644
index 000000000..f0c5cc53f
--- /dev/null
+++ b/src/electrochemistry/control.ts
@@ -0,0 +1,14 @@
+/** electrochemistry control module — tsb analytics library. */
+export interface ElectrochemistryControlOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryControlResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryControl(data: number[], opts: ElectrochemistryControlOptions = {}): ElectrochemistryControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryControl };
diff --git a/src/electrochemistry/convergence.ts b/src/electrochemistry/convergence.ts
new file mode 100644
index 000000000..0832b3843
--- /dev/null
+++ b/src/electrochemistry/convergence.ts
@@ -0,0 +1,14 @@
+/** electrochemistry convergence module — tsb analytics library. */
+export interface ElectrochemistryConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryConvergenceResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryConvergence(data: number[], opts: ElectrochemistryConvergenceOptions = {}): ElectrochemistryConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryConvergence };
diff --git a/src/electrochemistry/convex.ts b/src/electrochemistry/convex.ts
new file mode 100644
index 000000000..f16c23861
--- /dev/null
+++ b/src/electrochemistry/convex.ts
@@ -0,0 +1,14 @@
+/** electrochemistry convex module — tsb analytics library. */
+export interface ElectrochemistryConvexOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryConvexResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryConvex(data: number[], opts: ElectrochemistryConvexOptions = {}): ElectrochemistryConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryConvex };
diff --git a/src/electrochemistry/correlation.ts b/src/electrochemistry/correlation.ts
new file mode 100644
index 000000000..a51f4e7af
--- /dev/null
+++ b/src/electrochemistry/correlation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry correlation module — tsb analytics library. */
+export interface ElectrochemistryCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryCorrelationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryCorrelation(data: number[], opts: ElectrochemistryCorrelationOptions = {}): ElectrochemistryCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryCorrelation };
diff --git a/src/electrochemistry/covariance.ts b/src/electrochemistry/covariance.ts
new file mode 100644
index 000000000..db81a027c
--- /dev/null
+++ b/src/electrochemistry/covariance.ts
@@ -0,0 +1,14 @@
+/** electrochemistry covariance module — tsb analytics library. */
+export interface ElectrochemistryCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryCovarianceResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryCovariance(data: number[], opts: ElectrochemistryCovarianceOptions = {}): ElectrochemistryCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryCovariance };
diff --git a/src/electrochemistry/cross_validation.ts b/src/electrochemistry/cross_validation.ts
new file mode 100644
index 000000000..aa43ffaca
--- /dev/null
+++ b/src/electrochemistry/cross_validation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry cross_validation module — tsb analytics library. */
+export interface ElectrochemistryCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryCrossValidationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryCrossValidation(data: number[], opts: ElectrochemistryCrossValidationOptions = {}): ElectrochemistryCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryCrossValidation };
diff --git a/src/electrochemistry/decoding.ts b/src/electrochemistry/decoding.ts
new file mode 100644
index 000000000..ae9f93075
--- /dev/null
+++ b/src/electrochemistry/decoding.ts
@@ -0,0 +1,14 @@
+/** electrochemistry decoding module — tsb analytics library. */
+export interface ElectrochemistryDecodingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDecodingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDecoding(data: number[], opts: ElectrochemistryDecodingOptions = {}): ElectrochemistryDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDecoding };
diff --git a/src/electrochemistry/decomposition.ts b/src/electrochemistry/decomposition.ts
new file mode 100644
index 000000000..bd0b2b148
--- /dev/null
+++ b/src/electrochemistry/decomposition.ts
@@ -0,0 +1,14 @@
+/** electrochemistry decomposition module — tsb analytics library. */
+export interface ElectrochemistryDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDecompositionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDecomposition(data: number[], opts: ElectrochemistryDecompositionOptions = {}): ElectrochemistryDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDecomposition };
diff --git a/src/electrochemistry/detection.ts b/src/electrochemistry/detection.ts
new file mode 100644
index 000000000..7f5b70a6a
--- /dev/null
+++ b/src/electrochemistry/detection.ts
@@ -0,0 +1,14 @@
+/** electrochemistry detection module — tsb analytics library. */
+export interface ElectrochemistryDetectionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDetectionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDetection(data: number[], opts: ElectrochemistryDetectionOptions = {}): ElectrochemistryDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDetection };
diff --git a/src/electrochemistry/deterministic.ts b/src/electrochemistry/deterministic.ts
new file mode 100644
index 000000000..d9729d0f0
--- /dev/null
+++ b/src/electrochemistry/deterministic.ts
@@ -0,0 +1,14 @@
+/** electrochemistry deterministic module — tsb analytics library. */
+export interface ElectrochemistryDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDeterministicResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDeterministic(data: number[], opts: ElectrochemistryDeterministicOptions = {}): ElectrochemistryDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDeterministic };
diff --git a/src/electrochemistry/diagnostics.ts b/src/electrochemistry/diagnostics.ts
new file mode 100644
index 000000000..74e62a3a7
--- /dev/null
+++ b/src/electrochemistry/diagnostics.ts
@@ -0,0 +1,14 @@
+/** electrochemistry diagnostics module — tsb analytics library. */
+export interface ElectrochemistryDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDiagnostics(data: number[], opts: ElectrochemistryDiagnosticsOptions = {}): ElectrochemistryDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDiagnostics };
diff --git a/src/electrochemistry/differential.ts b/src/electrochemistry/differential.ts
new file mode 100644
index 000000000..502499503
--- /dev/null
+++ b/src/electrochemistry/differential.ts
@@ -0,0 +1,14 @@
+/** electrochemistry differential module — tsb analytics library. */
+export interface ElectrochemistryDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDifferentialResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDifferential(data: number[], opts: ElectrochemistryDifferentialOptions = {}): ElectrochemistryDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDifferential };
diff --git a/src/electrochemistry/discrete.ts b/src/electrochemistry/discrete.ts
new file mode 100644
index 000000000..23bd4f704
--- /dev/null
+++ b/src/electrochemistry/discrete.ts
@@ -0,0 +1,14 @@
+/** electrochemistry discrete module — tsb analytics library. */
+export interface ElectrochemistryDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDiscreteResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDiscrete(data: number[], opts: ElectrochemistryDiscreteOptions = {}): ElectrochemistryDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDiscrete };
diff --git a/src/electrochemistry/distribution.ts b/src/electrochemistry/distribution.ts
new file mode 100644
index 000000000..e78374dc8
--- /dev/null
+++ b/src/electrochemistry/distribution.ts
@@ -0,0 +1,14 @@
+/** electrochemistry distribution module — tsb analytics library. */
+export interface ElectrochemistryDistributionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDistributionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDistribution(data: number[], opts: ElectrochemistryDistributionOptions = {}): ElectrochemistryDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDistribution };
diff --git a/src/electrochemistry/dynamic.ts b/src/electrochemistry/dynamic.ts
new file mode 100644
index 000000000..6e7afc3e3
--- /dev/null
+++ b/src/electrochemistry/dynamic.ts
@@ -0,0 +1,14 @@
+/** electrochemistry dynamic module — tsb analytics library. */
+export interface ElectrochemistryDynamicOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryDynamicResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryDynamic(data: number[], opts: ElectrochemistryDynamicOptions = {}): ElectrochemistryDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryDynamic };
diff --git a/src/electrochemistry/embedding.ts b/src/electrochemistry/embedding.ts
new file mode 100644
index 000000000..378f11cc7
--- /dev/null
+++ b/src/electrochemistry/embedding.ts
@@ -0,0 +1,14 @@
+/** electrochemistry embedding module — tsb analytics library. */
+export interface ElectrochemistryEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryEmbeddingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryEmbedding(data: number[], opts: ElectrochemistryEmbeddingOptions = {}): ElectrochemistryEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryEmbedding };
diff --git a/src/electrochemistry/encoding.ts b/src/electrochemistry/encoding.ts
new file mode 100644
index 000000000..d87668890
--- /dev/null
+++ b/src/electrochemistry/encoding.ts
@@ -0,0 +1,14 @@
+/** electrochemistry encoding module — tsb analytics library. */
+export interface ElectrochemistryEncodingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryEncodingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryEncoding(data: number[], opts: ElectrochemistryEncodingOptions = {}): ElectrochemistryEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryEncoding };
diff --git a/src/electrochemistry/ensemble.ts b/src/electrochemistry/ensemble.ts
new file mode 100644
index 000000000..b09c067fa
--- /dev/null
+++ b/src/electrochemistry/ensemble.ts
@@ -0,0 +1,14 @@
+/** electrochemistry ensemble module — tsb analytics library. */
+export interface ElectrochemistryEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryEnsembleResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryEnsemble(data: number[], opts: ElectrochemistryEnsembleOptions = {}): ElectrochemistryEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryEnsemble };
diff --git a/src/electrochemistry/estimation.ts b/src/electrochemistry/estimation.ts
new file mode 100644
index 000000000..23caa1ed4
--- /dev/null
+++ b/src/electrochemistry/estimation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry estimation module — tsb analytics library. */
+export interface ElectrochemistryEstimationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryEstimationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryEstimation(data: number[], opts: ElectrochemistryEstimationOptions = {}): ElectrochemistryEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryEstimation };
diff --git a/src/electrochemistry/evaluation.ts b/src/electrochemistry/evaluation.ts
new file mode 100644
index 000000000..1cbcbcd4f
--- /dev/null
+++ b/src/electrochemistry/evaluation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry evaluation module — tsb analytics library. */
+export interface ElectrochemistryEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryEvaluationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryEvaluation(data: number[], opts: ElectrochemistryEvaluationOptions = {}): ElectrochemistryEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryEvaluation };
diff --git a/src/electrochemistry/extrapolation.ts b/src/electrochemistry/extrapolation.ts
new file mode 100644
index 000000000..6ce174dbb
--- /dev/null
+++ b/src/electrochemistry/extrapolation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry extrapolation module — tsb analytics library. */
+export interface ElectrochemistryExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryExtrapolationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryExtrapolation(data: number[], opts: ElectrochemistryExtrapolationOptions = {}): ElectrochemistryExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryExtrapolation };
diff --git a/src/electrochemistry/features.ts b/src/electrochemistry/features.ts
new file mode 100644
index 000000000..41dc4c74d
--- /dev/null
+++ b/src/electrochemistry/features.ts
@@ -0,0 +1,14 @@
+/** electrochemistry features module — tsb analytics library. */
+export interface ElectrochemistryFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryFeaturesResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryFeatures(data: number[], opts: ElectrochemistryFeaturesOptions = {}): ElectrochemistryFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryFeatures };
diff --git a/src/electrochemistry/feedback.ts b/src/electrochemistry/feedback.ts
new file mode 100644
index 000000000..9182f9d4c
--- /dev/null
+++ b/src/electrochemistry/feedback.ts
@@ -0,0 +1,14 @@
+/** electrochemistry feedback module — tsb analytics library. */
+export interface ElectrochemistryFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryFeedbackResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryFeedback(data: number[], opts: ElectrochemistryFeedbackOptions = {}): ElectrochemistryFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryFeedback };
diff --git a/src/electrochemistry/filtering.ts b/src/electrochemistry/filtering.ts
new file mode 100644
index 000000000..eb0362b74
--- /dev/null
+++ b/src/electrochemistry/filtering.ts
@@ -0,0 +1,14 @@
+/** electrochemistry filtering module — tsb analytics library. */
+export interface ElectrochemistryFilteringOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryFilteringResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryFiltering(data: number[], opts: ElectrochemistryFilteringOptions = {}): ElectrochemistryFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryFiltering };
diff --git a/src/electrochemistry/fourier.ts b/src/electrochemistry/fourier.ts
new file mode 100644
index 000000000..6b3603b2b
--- /dev/null
+++ b/src/electrochemistry/fourier.ts
@@ -0,0 +1,14 @@
+/** electrochemistry fourier module — tsb analytics library. */
+export interface ElectrochemistryFourierOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryFourierResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryFourier(data: number[], opts: ElectrochemistryFourierOptions = {}): ElectrochemistryFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryFourier };
diff --git a/src/electrochemistry/fusion.ts b/src/electrochemistry/fusion.ts
new file mode 100644
index 000000000..7ee330ec8
--- /dev/null
+++ b/src/electrochemistry/fusion.ts
@@ -0,0 +1,14 @@
+/** electrochemistry fusion module — tsb analytics library. */
+export interface ElectrochemistryFusionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryFusionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryFusion(data: number[], opts: ElectrochemistryFusionOptions = {}): ElectrochemistryFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryFusion };
diff --git a/src/electrochemistry/generation.ts b/src/electrochemistry/generation.ts
new file mode 100644
index 000000000..4f3f51178
--- /dev/null
+++ b/src/electrochemistry/generation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry generation module — tsb analytics library. */
+export interface ElectrochemistryGenerationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryGenerationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryGeneration(data: number[], opts: ElectrochemistryGenerationOptions = {}): ElectrochemistryGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryGeneration };
diff --git a/src/electrochemistry/geometry.ts b/src/electrochemistry/geometry.ts
new file mode 100644
index 000000000..bbd720287
--- /dev/null
+++ b/src/electrochemistry/geometry.ts
@@ -0,0 +1,14 @@
+/** electrochemistry geometry module — tsb analytics library. */
+export interface ElectrochemistryGeometryOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryGeometryResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryGeometry(data: number[], opts: ElectrochemistryGeometryOptions = {}): ElectrochemistryGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryGeometry };
diff --git a/src/electrochemistry/gradient.ts b/src/electrochemistry/gradient.ts
new file mode 100644
index 000000000..9f3b5e19d
--- /dev/null
+++ b/src/electrochemistry/gradient.ts
@@ -0,0 +1,14 @@
+/** electrochemistry gradient module — tsb analytics library. */
+export interface ElectrochemistryGradientOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryGradientResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryGradient(data: number[], opts: ElectrochemistryGradientOptions = {}): ElectrochemistryGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryGradient };
diff --git a/src/electrochemistry/hessian.ts b/src/electrochemistry/hessian.ts
new file mode 100644
index 000000000..e391cd43f
--- /dev/null
+++ b/src/electrochemistry/hessian.ts
@@ -0,0 +1,14 @@
+/** electrochemistry hessian module — tsb analytics library. */
+export interface ElectrochemistryHessianOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryHessianResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryHessian(data: number[], opts: ElectrochemistryHessianOptions = {}): ElectrochemistryHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryHessian };
diff --git a/src/electrochemistry/hypothesis.ts b/src/electrochemistry/hypothesis.ts
new file mode 100644
index 000000000..1167d7313
--- /dev/null
+++ b/src/electrochemistry/hypothesis.ts
@@ -0,0 +1,14 @@
+/** electrochemistry hypothesis module — tsb analytics library. */
+export interface ElectrochemistryHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryHypothesisResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryHypothesis(data: number[], opts: ElectrochemistryHypothesisOptions = {}): ElectrochemistryHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryHypothesis };
diff --git a/src/electrochemistry/inference.ts b/src/electrochemistry/inference.ts
new file mode 100644
index 000000000..8d96d1d03
--- /dev/null
+++ b/src/electrochemistry/inference.ts
@@ -0,0 +1,14 @@
+/** electrochemistry inference module — tsb analytics library. */
+export interface ElectrochemistryInferenceOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryInferenceResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryInference(data: number[], opts: ElectrochemistryInferenceOptions = {}): ElectrochemistryInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryInference };
diff --git a/src/electrochemistry/inference2.ts b/src/electrochemistry/inference2.ts
new file mode 100644
index 000000000..596f94ad8
--- /dev/null
+++ b/src/electrochemistry/inference2.ts
@@ -0,0 +1,14 @@
+/** electrochemistry inference2 module — tsb analytics library. */
+export interface ElectrochemistryInferenceOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryInferenceResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryInference(data: number[], opts: ElectrochemistryInferenceOptions = {}): ElectrochemistryInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryInference };
diff --git a/src/electrochemistry/integral.ts b/src/electrochemistry/integral.ts
new file mode 100644
index 000000000..bb8d2a70e
--- /dev/null
+++ b/src/electrochemistry/integral.ts
@@ -0,0 +1,14 @@
+/** electrochemistry integral module — tsb analytics library. */
+export interface ElectrochemistryIntegralOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryIntegralResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryIntegral(data: number[], opts: ElectrochemistryIntegralOptions = {}): ElectrochemistryIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryIntegral };
diff --git a/src/electrochemistry/integration.ts b/src/electrochemistry/integration.ts
new file mode 100644
index 000000000..4445cd391
--- /dev/null
+++ b/src/electrochemistry/integration.ts
@@ -0,0 +1,14 @@
+/** electrochemistry integration module — tsb analytics library. */
+export interface ElectrochemistryIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryIntegrationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryIntegration(data: number[], opts: ElectrochemistryIntegrationOptions = {}): ElectrochemistryIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryIntegration };
diff --git a/src/electrochemistry/interpolation.ts b/src/electrochemistry/interpolation.ts
new file mode 100644
index 000000000..e04849239
--- /dev/null
+++ b/src/electrochemistry/interpolation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry interpolation module — tsb analytics library. */
+export interface ElectrochemistryInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryInterpolationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryInterpolation(data: number[], opts: ElectrochemistryInterpolationOptions = {}): ElectrochemistryInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryInterpolation };
diff --git a/src/electrochemistry/jacobian.ts b/src/electrochemistry/jacobian.ts
new file mode 100644
index 000000000..6eedcb70f
--- /dev/null
+++ b/src/electrochemistry/jacobian.ts
@@ -0,0 +1,14 @@
+/** electrochemistry jacobian module — tsb analytics library. */
+export interface ElectrochemistryJacobianOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryJacobianResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryJacobian(data: number[], opts: ElectrochemistryJacobianOptions = {}): ElectrochemistryJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryJacobian };
diff --git a/src/electrochemistry/kernel.ts b/src/electrochemistry/kernel.ts
new file mode 100644
index 000000000..9c6d6f08f
--- /dev/null
+++ b/src/electrochemistry/kernel.ts
@@ -0,0 +1,14 @@
+/** electrochemistry kernel module — tsb analytics library. */
+export interface ElectrochemistryKernelOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryKernelResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryKernel(data: number[], opts: ElectrochemistryKernelOptions = {}): ElectrochemistryKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryKernel };
diff --git a/src/electrochemistry/laplacian.ts b/src/electrochemistry/laplacian.ts
new file mode 100644
index 000000000..6bb8c7ee8
--- /dev/null
+++ b/src/electrochemistry/laplacian.ts
@@ -0,0 +1,14 @@
+/** electrochemistry laplacian module — tsb analytics library. */
+export interface ElectrochemistryLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryLaplacianResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryLaplacian(data: number[], opts: ElectrochemistryLaplacianOptions = {}): ElectrochemistryLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryLaplacian };
diff --git a/src/electrochemistry/learning.ts b/src/electrochemistry/learning.ts
new file mode 100644
index 000000000..5d45fb632
--- /dev/null
+++ b/src/electrochemistry/learning.ts
@@ -0,0 +1,14 @@
+/** electrochemistry learning module — tsb analytics library. */
+export interface ElectrochemistryLearningOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryLearningResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryLearning(data: number[], opts: ElectrochemistryLearningOptions = {}): ElectrochemistryLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryLearning };
diff --git a/src/electrochemistry/linear.ts b/src/electrochemistry/linear.ts
new file mode 100644
index 000000000..2d033dc41
--- /dev/null
+++ b/src/electrochemistry/linear.ts
@@ -0,0 +1,14 @@
+/** electrochemistry linear module — tsb analytics library. */
+export interface ElectrochemistryLinearOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryLinearResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryLinear(data: number[], opts: ElectrochemistryLinearOptions = {}): ElectrochemistryLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryLinear };
diff --git a/src/electrochemistry/manifold.ts b/src/electrochemistry/manifold.ts
new file mode 100644
index 000000000..8ba9b6661
--- /dev/null
+++ b/src/electrochemistry/manifold.ts
@@ -0,0 +1,14 @@
+/** electrochemistry manifold module — tsb analytics library. */
+export interface ElectrochemistryManifoldOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryManifoldResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryManifold(data: number[], opts: ElectrochemistryManifoldOptions = {}): ElectrochemistryManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryManifold };
diff --git a/src/electrochemistry/matching.ts b/src/electrochemistry/matching.ts
new file mode 100644
index 000000000..11e9d1a6c
--- /dev/null
+++ b/src/electrochemistry/matching.ts
@@ -0,0 +1,14 @@
+/** electrochemistry matching module — tsb analytics library. */
+export interface ElectrochemistryMatchingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryMatchingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryMatching(data: number[], opts: ElectrochemistryMatchingOptions = {}): ElectrochemistryMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryMatching };
diff --git a/src/electrochemistry/measurement.ts b/src/electrochemistry/measurement.ts
new file mode 100644
index 000000000..eb75db1ad
--- /dev/null
+++ b/src/electrochemistry/measurement.ts
@@ -0,0 +1,14 @@
+/** electrochemistry measurement module — tsb analytics library. */
+export interface ElectrochemistryMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryMeasurementResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryMeasurement(data: number[], opts: ElectrochemistryMeasurementOptions = {}): ElectrochemistryMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryMeasurement };
diff --git a/src/electrochemistry/metrics.ts b/src/electrochemistry/metrics.ts
new file mode 100644
index 000000000..bfb7a9f76
--- /dev/null
+++ b/src/electrochemistry/metrics.ts
@@ -0,0 +1,14 @@
+/** electrochemistry metrics module — tsb analytics library. */
+export interface ElectrochemistryMetricsOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryMetricsResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryMetrics(data: number[], opts: ElectrochemistryMetricsOptions = {}): ElectrochemistryMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryMetrics };
diff --git a/src/electrochemistry/modeling.ts b/src/electrochemistry/modeling.ts
new file mode 100644
index 000000000..1310dc8de
--- /dev/null
+++ b/src/electrochemistry/modeling.ts
@@ -0,0 +1,14 @@
+/** electrochemistry modeling module — tsb analytics library. */
+export interface ElectrochemistryModelingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryModelingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryModeling(data: number[], opts: ElectrochemistryModelingOptions = {}): ElectrochemistryModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryModeling };
diff --git a/src/electrochemistry/monitoring.ts b/src/electrochemistry/monitoring.ts
new file mode 100644
index 000000000..74c29fdb5
--- /dev/null
+++ b/src/electrochemistry/monitoring.ts
@@ -0,0 +1,14 @@
+/** electrochemistry monitoring module — tsb analytics library. */
+export interface ElectrochemistryMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryMonitoringResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryMonitoring(data: number[], opts: ElectrochemistryMonitoringOptions = {}): ElectrochemistryMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryMonitoring };
diff --git a/src/electrochemistry/nonlinear.ts b/src/electrochemistry/nonlinear.ts
new file mode 100644
index 000000000..81ee9762b
--- /dev/null
+++ b/src/electrochemistry/nonlinear.ts
@@ -0,0 +1,14 @@
+/** electrochemistry nonlinear module — tsb analytics library. */
+export interface ElectrochemistryNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryNonlinearResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryNonlinear(data: number[], opts: ElectrochemistryNonlinearOptions = {}): ElectrochemistryNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryNonlinear };
diff --git a/src/electrochemistry/normalization.ts b/src/electrochemistry/normalization.ts
new file mode 100644
index 000000000..48c51c03f
--- /dev/null
+++ b/src/electrochemistry/normalization.ts
@@ -0,0 +1,14 @@
+/** electrochemistry normalization module — tsb analytics library. */
+export interface ElectrochemistryNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryNormalizationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryNormalization(data: number[], opts: ElectrochemistryNormalizationOptions = {}): ElectrochemistryNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryNormalization };
diff --git a/src/electrochemistry/optimization.ts b/src/electrochemistry/optimization.ts
new file mode 100644
index 000000000..996d6ea5b
--- /dev/null
+++ b/src/electrochemistry/optimization.ts
@@ -0,0 +1,14 @@
+/** electrochemistry optimization module — tsb analytics library. */
+export interface ElectrochemistryOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryOptimizationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryOptimization(data: number[], opts: ElectrochemistryOptimizationOptions = {}): ElectrochemistryOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryOptimization };
diff --git a/src/electrochemistry/patterns.ts b/src/electrochemistry/patterns.ts
new file mode 100644
index 000000000..5f4a57a03
--- /dev/null
+++ b/src/electrochemistry/patterns.ts
@@ -0,0 +1,14 @@
+/** electrochemistry patterns module — tsb analytics library. */
+export interface ElectrochemistryPatternsOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryPatternsResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryPatterns(data: number[], opts: ElectrochemistryPatternsOptions = {}): ElectrochemistryPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryPatterns };
diff --git a/src/electrochemistry/permutation.ts b/src/electrochemistry/permutation.ts
new file mode 100644
index 000000000..241fd8f62
--- /dev/null
+++ b/src/electrochemistry/permutation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry permutation module — tsb analytics library. */
+export interface ElectrochemistryPermutationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryPermutationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryPermutation(data: number[], opts: ElectrochemistryPermutationOptions = {}): ElectrochemistryPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryPermutation };
diff --git a/src/electrochemistry/prediction.ts b/src/electrochemistry/prediction.ts
new file mode 100644
index 000000000..09e7ca42d
--- /dev/null
+++ b/src/electrochemistry/prediction.ts
@@ -0,0 +1,14 @@
+/** electrochemistry prediction module — tsb analytics library. */
+export interface ElectrochemistryPredictionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryPredictionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryPrediction(data: number[], opts: ElectrochemistryPredictionOptions = {}): ElectrochemistryPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryPrediction };
diff --git a/src/electrochemistry/processing.ts b/src/electrochemistry/processing.ts
new file mode 100644
index 000000000..fef982984
--- /dev/null
+++ b/src/electrochemistry/processing.ts
@@ -0,0 +1,14 @@
+/** electrochemistry processing module — tsb analytics library. */
+export interface ElectrochemistryProcessingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryProcessingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryProcessing(data: number[], opts: ElectrochemistryProcessingOptions = {}): ElectrochemistryProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryProcessing };
diff --git a/src/electrochemistry/profiling.ts b/src/electrochemistry/profiling.ts
new file mode 100644
index 000000000..74763ea24
--- /dev/null
+++ b/src/electrochemistry/profiling.ts
@@ -0,0 +1,14 @@
+/** electrochemistry profiling module — tsb analytics library. */
+export interface ElectrochemistryProfilingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryProfilingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryProfiling(data: number[], opts: ElectrochemistryProfilingOptions = {}): ElectrochemistryProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryProfiling };
diff --git a/src/electrochemistry/projection.ts b/src/electrochemistry/projection.ts
new file mode 100644
index 000000000..ee38dabff
--- /dev/null
+++ b/src/electrochemistry/projection.ts
@@ -0,0 +1,14 @@
+/** electrochemistry projection module — tsb analytics library. */
+export interface ElectrochemistryProjectionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryProjectionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryProjection(data: number[], opts: ElectrochemistryProjectionOptions = {}): ElectrochemistryProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryProjection };
diff --git a/src/electrochemistry/ranking.ts b/src/electrochemistry/ranking.ts
new file mode 100644
index 000000000..1730a03fa
--- /dev/null
+++ b/src/electrochemistry/ranking.ts
@@ -0,0 +1,14 @@
+/** electrochemistry ranking module — tsb analytics library. */
+export interface ElectrochemistryRankingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryRankingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryRanking(data: number[], opts: ElectrochemistryRankingOptions = {}): ElectrochemistryRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryRanking };
diff --git a/src/electrochemistry/reconstruction.ts b/src/electrochemistry/reconstruction.ts
new file mode 100644
index 000000000..29e3009f1
--- /dev/null
+++ b/src/electrochemistry/reconstruction.ts
@@ -0,0 +1,14 @@
+/** electrochemistry reconstruction module — tsb analytics library. */
+export interface ElectrochemistryReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryReconstructionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryReconstruction(data: number[], opts: ElectrochemistryReconstructionOptions = {}): ElectrochemistryReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryReconstruction };
diff --git a/src/electrochemistry/registration.ts b/src/electrochemistry/registration.ts
new file mode 100644
index 000000000..8b227cfc7
--- /dev/null
+++ b/src/electrochemistry/registration.ts
@@ -0,0 +1,14 @@
+/** electrochemistry registration module — tsb analytics library. */
+export interface ElectrochemistryRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryRegistrationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryRegistration(data: number[], opts: ElectrochemistryRegistrationOptions = {}): ElectrochemistryRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryRegistration };
diff --git a/src/electrochemistry/regression.ts b/src/electrochemistry/regression.ts
new file mode 100644
index 000000000..c63b0a6fe
--- /dev/null
+++ b/src/electrochemistry/regression.ts
@@ -0,0 +1,14 @@
+/** electrochemistry regression module — tsb analytics library. */
+export interface ElectrochemistryRegressionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryRegressionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryRegression(data: number[], opts: ElectrochemistryRegressionOptions = {}): ElectrochemistryRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryRegression };
diff --git a/src/electrochemistry/regularization.ts b/src/electrochemistry/regularization.ts
new file mode 100644
index 000000000..ca0a39d22
--- /dev/null
+++ b/src/electrochemistry/regularization.ts
@@ -0,0 +1,14 @@
+/** electrochemistry regularization module — tsb analytics library. */
+export interface ElectrochemistryRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryRegularizationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryRegularization(data: number[], opts: ElectrochemistryRegularizationOptions = {}): ElectrochemistryRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryRegularization };
diff --git a/src/electrochemistry/robustness.ts b/src/electrochemistry/robustness.ts
new file mode 100644
index 000000000..25475c12d
--- /dev/null
+++ b/src/electrochemistry/robustness.ts
@@ -0,0 +1,14 @@
+/** electrochemistry robustness module — tsb analytics library. */
+export interface ElectrochemistryRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryRobustnessResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryRobustness(data: number[], opts: ElectrochemistryRobustnessOptions = {}): ElectrochemistryRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryRobustness };
diff --git a/src/electrochemistry/sampling.ts b/src/electrochemistry/sampling.ts
new file mode 100644
index 000000000..223f65784
--- /dev/null
+++ b/src/electrochemistry/sampling.ts
@@ -0,0 +1,14 @@
+/** electrochemistry sampling module — tsb analytics library. */
+export interface ElectrochemistrySamplingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistrySamplingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistrySampling(data: number[], opts: ElectrochemistrySamplingOptions = {}): ElectrochemistrySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistrySampling };
diff --git a/src/electrochemistry/sampling2.ts b/src/electrochemistry/sampling2.ts
new file mode 100644
index 000000000..f7f4e2190
--- /dev/null
+++ b/src/electrochemistry/sampling2.ts
@@ -0,0 +1,14 @@
+/** electrochemistry sampling2 module — tsb analytics library. */
+export interface ElectrochemistrySamplingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistrySamplingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistrySampling(data: number[], opts: ElectrochemistrySamplingOptions = {}): ElectrochemistrySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistrySampling };
diff --git a/src/electrochemistry/scaling.ts b/src/electrochemistry/scaling.ts
new file mode 100644
index 000000000..2554e04cf
--- /dev/null
+++ b/src/electrochemistry/scaling.ts
@@ -0,0 +1,14 @@
+/** electrochemistry scaling module — tsb analytics library. */
+export interface ElectrochemistryScalingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryScalingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryScaling(data: number[], opts: ElectrochemistryScalingOptions = {}): ElectrochemistryScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryScaling };
diff --git a/src/electrochemistry/scoring.ts b/src/electrochemistry/scoring.ts
new file mode 100644
index 000000000..72470e859
--- /dev/null
+++ b/src/electrochemistry/scoring.ts
@@ -0,0 +1,14 @@
+/** electrochemistry scoring module — tsb analytics library. */
+export interface ElectrochemistryScoringOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryScoringResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryScoring(data: number[], opts: ElectrochemistryScoringOptions = {}): ElectrochemistryScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryScoring };
diff --git a/src/electrochemistry/segmentation.ts b/src/electrochemistry/segmentation.ts
new file mode 100644
index 000000000..e38af3f37
--- /dev/null
+++ b/src/electrochemistry/segmentation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry segmentation module — tsb analytics library. */
+export interface ElectrochemistrySegmentationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistrySegmentationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistrySegmentation(data: number[], opts: ElectrochemistrySegmentationOptions = {}): ElectrochemistrySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistrySegmentation };
diff --git a/src/electrochemistry/selection.ts b/src/electrochemistry/selection.ts
new file mode 100644
index 000000000..ad4bcda5c
--- /dev/null
+++ b/src/electrochemistry/selection.ts
@@ -0,0 +1,14 @@
+/** electrochemistry selection module — tsb analytics library. */
+export interface ElectrochemistrySelectionOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistrySelectionResult { values: number[]; converged: boolean; }
+export function computeElectrochemistrySelection(data: number[], opts: ElectrochemistrySelectionOptions = {}): ElectrochemistrySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistrySelection };
diff --git a/src/electrochemistry/sensitivity.ts b/src/electrochemistry/sensitivity.ts
new file mode 100644
index 000000000..ce24c2204
--- /dev/null
+++ b/src/electrochemistry/sensitivity.ts
@@ -0,0 +1,14 @@
+/** electrochemistry sensitivity module — tsb analytics library. */
+export interface ElectrochemistrySensitivityOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistrySensitivityResult { values: number[]; converged: boolean; }
+export function computeElectrochemistrySensitivity(data: number[], opts: ElectrochemistrySensitivityOptions = {}): ElectrochemistrySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistrySensitivity };
diff --git a/src/electrochemistry/simulation.ts b/src/electrochemistry/simulation.ts
new file mode 100644
index 000000000..8e2b9ee68
--- /dev/null
+++ b/src/electrochemistry/simulation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry simulation module — tsb analytics library. */
+export interface ElectrochemistrySimulationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistrySimulationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistrySimulation(data: number[], opts: ElectrochemistrySimulationOptions = {}): ElectrochemistrySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistrySimulation };
diff --git a/src/electrochemistry/smoothing.ts b/src/electrochemistry/smoothing.ts
new file mode 100644
index 000000000..d9be3f6b8
--- /dev/null
+++ b/src/electrochemistry/smoothing.ts
@@ -0,0 +1,14 @@
+/** electrochemistry smoothing module — tsb analytics library. */
+export interface ElectrochemistrySmoothingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistrySmoothingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistrySmoothing(data: number[], opts: ElectrochemistrySmoothingOptions = {}): ElectrochemistrySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistrySmoothing };
diff --git a/src/electrochemistry/stability.ts b/src/electrochemistry/stability.ts
new file mode 100644
index 000000000..82b88c9c3
--- /dev/null
+++ b/src/electrochemistry/stability.ts
@@ -0,0 +1,14 @@
+/** electrochemistry stability module — tsb analytics library. */
+export interface ElectrochemistryStabilityOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryStabilityResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryStability(data: number[], opts: ElectrochemistryStabilityOptions = {}): ElectrochemistryStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryStability };
diff --git a/src/electrochemistry/stacking.ts b/src/electrochemistry/stacking.ts
new file mode 100644
index 000000000..8cb9e8a4d
--- /dev/null
+++ b/src/electrochemistry/stacking.ts
@@ -0,0 +1,14 @@
+/** electrochemistry stacking module — tsb analytics library. */
+export interface ElectrochemistryStackingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryStackingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryStacking(data: number[], opts: ElectrochemistryStackingOptions = {}): ElectrochemistryStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryStacking };
diff --git a/src/electrochemistry/standardization.ts b/src/electrochemistry/standardization.ts
new file mode 100644
index 000000000..9c86325dd
--- /dev/null
+++ b/src/electrochemistry/standardization.ts
@@ -0,0 +1,14 @@
+/** electrochemistry standardization module — tsb analytics library. */
+export interface ElectrochemistryStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryStandardizationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryStandardization(data: number[], opts: ElectrochemistryStandardizationOptions = {}): ElectrochemistryStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryStandardization };
diff --git a/src/electrochemistry/static.ts b/src/electrochemistry/static.ts
new file mode 100644
index 000000000..fafab64b5
--- /dev/null
+++ b/src/electrochemistry/static.ts
@@ -0,0 +1,14 @@
+/** electrochemistry static module — tsb analytics library. */
+export interface ElectrochemistryStaticOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryStaticResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryStatic(data: number[], opts: ElectrochemistryStaticOptions = {}): ElectrochemistryStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryStatic };
diff --git a/src/electrochemistry/stochastic.ts b/src/electrochemistry/stochastic.ts
new file mode 100644
index 000000000..47212f460
--- /dev/null
+++ b/src/electrochemistry/stochastic.ts
@@ -0,0 +1,14 @@
+/** electrochemistry stochastic module — tsb analytics library. */
+export interface ElectrochemistryStochasticOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryStochasticResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryStochastic(data: number[], opts: ElectrochemistryStochasticOptions = {}): ElectrochemistryStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryStochastic };
diff --git a/src/electrochemistry/synthesis.ts b/src/electrochemistry/synthesis.ts
new file mode 100644
index 000000000..660ff2044
--- /dev/null
+++ b/src/electrochemistry/synthesis.ts
@@ -0,0 +1,14 @@
+/** electrochemistry synthesis module — tsb analytics library. */
+export interface ElectrochemistrySynthesisOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistrySynthesisResult { values: number[]; converged: boolean; }
+export function computeElectrochemistrySynthesis(data: number[], opts: ElectrochemistrySynthesisOptions = {}): ElectrochemistrySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistrySynthesis };
diff --git a/src/electrochemistry/topology.ts b/src/electrochemistry/topology.ts
new file mode 100644
index 000000000..d26723963
--- /dev/null
+++ b/src/electrochemistry/topology.ts
@@ -0,0 +1,14 @@
+/** electrochemistry topology module — tsb analytics library. */
+export interface ElectrochemistryTopologyOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryTopologyResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryTopology(data: number[], opts: ElectrochemistryTopologyOptions = {}): ElectrochemistryTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryTopology };
diff --git a/src/electrochemistry/tracking.ts b/src/electrochemistry/tracking.ts
new file mode 100644
index 000000000..decf2186d
--- /dev/null
+++ b/src/electrochemistry/tracking.ts
@@ -0,0 +1,14 @@
+/** electrochemistry tracking module — tsb analytics library. */
+export interface ElectrochemistryTrackingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryTrackingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryTracking(data: number[], opts: ElectrochemistryTrackingOptions = {}): ElectrochemistryTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryTracking };
diff --git a/src/electrochemistry/transform.ts b/src/electrochemistry/transform.ts
new file mode 100644
index 000000000..5230026ec
--- /dev/null
+++ b/src/electrochemistry/transform.ts
@@ -0,0 +1,14 @@
+/** electrochemistry transform module — tsb analytics library. */
+export interface ElectrochemistryTransformOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryTransformResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryTransform(data: number[], opts: ElectrochemistryTransformOptions = {}): ElectrochemistryTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryTransform };
diff --git a/src/electrochemistry/uncertainty.ts b/src/electrochemistry/uncertainty.ts
new file mode 100644
index 000000000..c74d1d869
--- /dev/null
+++ b/src/electrochemistry/uncertainty.ts
@@ -0,0 +1,14 @@
+/** electrochemistry uncertainty module — tsb analytics library. */
+export interface ElectrochemistryUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryUncertaintyResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryUncertainty(data: number[], opts: ElectrochemistryUncertaintyOptions = {}): ElectrochemistryUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryUncertainty };
diff --git a/src/electrochemistry/validation.ts b/src/electrochemistry/validation.ts
new file mode 100644
index 000000000..a65bda298
--- /dev/null
+++ b/src/electrochemistry/validation.ts
@@ -0,0 +1,14 @@
+/** electrochemistry validation module — tsb analytics library. */
+export interface ElectrochemistryValidationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryValidationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryValidation(data: number[], opts: ElectrochemistryValidationOptions = {}): ElectrochemistryValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryValidation };
diff --git a/src/electrochemistry/verification.ts b/src/electrochemistry/verification.ts
new file mode 100644
index 000000000..f150fdbae
--- /dev/null
+++ b/src/electrochemistry/verification.ts
@@ -0,0 +1,14 @@
+/** electrochemistry verification module — tsb analytics library. */
+export interface ElectrochemistryVerificationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryVerificationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryVerification(data: number[], opts: ElectrochemistryVerificationOptions = {}): ElectrochemistryVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryVerification };
diff --git a/src/electrochemistry/visualization.ts b/src/electrochemistry/visualization.ts
new file mode 100644
index 000000000..b06f42089
--- /dev/null
+++ b/src/electrochemistry/visualization.ts
@@ -0,0 +1,14 @@
+/** electrochemistry visualization module — tsb analytics library. */
+export interface ElectrochemistryVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryVisualizationResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryVisualization(data: number[], opts: ElectrochemistryVisualizationOptions = {}): ElectrochemistryVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryVisualization };
diff --git a/src/electrochemistry/voting.ts b/src/electrochemistry/voting.ts
new file mode 100644
index 000000000..194998a0d
--- /dev/null
+++ b/src/electrochemistry/voting.ts
@@ -0,0 +1,14 @@
+/** electrochemistry voting module — tsb analytics library. */
+export interface ElectrochemistryVotingOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryVotingResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryVoting(data: number[], opts: ElectrochemistryVotingOptions = {}): ElectrochemistryVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryVoting };
diff --git a/src/electrochemistry/wavelet.ts b/src/electrochemistry/wavelet.ts
new file mode 100644
index 000000000..bcedcd2df
--- /dev/null
+++ b/src/electrochemistry/wavelet.ts
@@ -0,0 +1,14 @@
+/** electrochemistry wavelet module — tsb analytics library. */
+export interface ElectrochemistryWaveletOptions { tol?: number; maxIter?: number; }
+export interface ElectrochemistryWaveletResult { values: number[]; converged: boolean; }
+export function computeElectrochemistryWavelet(data: number[], opts: ElectrochemistryWaveletOptions = {}): ElectrochemistryWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeElectrochemistryWavelet };
diff --git a/src/endocrinology/adaptation.ts b/src/endocrinology/adaptation.ts
new file mode 100644
index 000000000..e94e7639b
--- /dev/null
+++ b/src/endocrinology/adaptation.ts
@@ -0,0 +1,14 @@
+/** endocrinology adaptation module — tsb analytics library. */
+export interface EndocrinologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyAdaptation(data: number[], opts: EndocrinologyAdaptationOptions = {}): EndocrinologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyAdaptation };
diff --git a/src/endocrinology/aggregation.ts b/src/endocrinology/aggregation.ts
new file mode 100644
index 000000000..5db8fa24f
--- /dev/null
+++ b/src/endocrinology/aggregation.ts
@@ -0,0 +1,14 @@
+/** endocrinology aggregation module — tsb analytics library. */
+export interface EndocrinologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyAggregationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyAggregation(data: number[], opts: EndocrinologyAggregationOptions = {}): EndocrinologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyAggregation };
diff --git a/src/endocrinology/algebra.ts b/src/endocrinology/algebra.ts
new file mode 100644
index 000000000..9fd3f5671
--- /dev/null
+++ b/src/endocrinology/algebra.ts
@@ -0,0 +1,14 @@
+/** endocrinology algebra module — tsb analytics library. */
+export interface EndocrinologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyAlgebra(data: number[], opts: EndocrinologyAlgebraOptions = {}): EndocrinologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyAlgebra };
diff --git a/src/endocrinology/alignment.ts b/src/endocrinology/alignment.ts
new file mode 100644
index 000000000..73e35f6e4
--- /dev/null
+++ b/src/endocrinology/alignment.ts
@@ -0,0 +1,14 @@
+/** endocrinology alignment module — tsb analytics library. */
+export interface EndocrinologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyAlignment(data: number[], opts: EndocrinologyAlignmentOptions = {}): EndocrinologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyAlignment };
diff --git a/src/endocrinology/analysis.ts b/src/endocrinology/analysis.ts
new file mode 100644
index 000000000..2d75089c5
--- /dev/null
+++ b/src/endocrinology/analysis.ts
@@ -0,0 +1,14 @@
+/** endocrinology analysis module — tsb analytics library. */
+export interface EndocrinologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyAnalysis(data: number[], opts: EndocrinologyAnalysisOptions = {}): EndocrinologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyAnalysis };
diff --git a/src/endocrinology/augmentation.ts b/src/endocrinology/augmentation.ts
new file mode 100644
index 000000000..9e6290bb7
--- /dev/null
+++ b/src/endocrinology/augmentation.ts
@@ -0,0 +1,14 @@
+/** endocrinology augmentation module — tsb analytics library. */
+export interface EndocrinologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyAugmentation(data: number[], opts: EndocrinologyAugmentationOptions = {}): EndocrinologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyAugmentation };
diff --git a/src/endocrinology/bagging.ts b/src/endocrinology/bagging.ts
new file mode 100644
index 000000000..0157e47c2
--- /dev/null
+++ b/src/endocrinology/bagging.ts
@@ -0,0 +1,14 @@
+/** endocrinology bagging module — tsb analytics library. */
+export interface EndocrinologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyBaggingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyBagging(data: number[], opts: EndocrinologyBaggingOptions = {}): EndocrinologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyBagging };
diff --git a/src/endocrinology/basis.ts b/src/endocrinology/basis.ts
new file mode 100644
index 000000000..ddec9a52b
--- /dev/null
+++ b/src/endocrinology/basis.ts
@@ -0,0 +1,14 @@
+/** endocrinology basis module — tsb analytics library. */
+export interface EndocrinologyBasisOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyBasisResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyBasis(data: number[], opts: EndocrinologyBasisOptions = {}): EndocrinologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyBasis };
diff --git a/src/endocrinology/benchmarking.ts b/src/endocrinology/benchmarking.ts
new file mode 100644
index 000000000..3ea6a15f5
--- /dev/null
+++ b/src/endocrinology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** endocrinology benchmarking module — tsb analytics library. */
+export interface EndocrinologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyBenchmarking(data: number[], opts: EndocrinologyBenchmarkingOptions = {}): EndocrinologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyBenchmarking };
diff --git a/src/endocrinology/blending.ts b/src/endocrinology/blending.ts
new file mode 100644
index 000000000..727776e7d
--- /dev/null
+++ b/src/endocrinology/blending.ts
@@ -0,0 +1,14 @@
+/** endocrinology blending module — tsb analytics library. */
+export interface EndocrinologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyBlendingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyBlending(data: number[], opts: EndocrinologyBlendingOptions = {}): EndocrinologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyBlending };
diff --git a/src/endocrinology/boosting.ts b/src/endocrinology/boosting.ts
new file mode 100644
index 000000000..0257c643d
--- /dev/null
+++ b/src/endocrinology/boosting.ts
@@ -0,0 +1,14 @@
+/** endocrinology boosting module — tsb analytics library. */
+export interface EndocrinologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyBoostingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyBoosting(data: number[], opts: EndocrinologyBoostingOptions = {}): EndocrinologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyBoosting };
diff --git a/src/endocrinology/bootstrap.ts b/src/endocrinology/bootstrap.ts
new file mode 100644
index 000000000..557e93a49
--- /dev/null
+++ b/src/endocrinology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** endocrinology bootstrap module — tsb analytics library. */
+export interface EndocrinologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyBootstrap(data: number[], opts: EndocrinologyBootstrapOptions = {}): EndocrinologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyBootstrap };
diff --git a/src/endocrinology/calculus.ts b/src/endocrinology/calculus.ts
new file mode 100644
index 000000000..e26c0ae54
--- /dev/null
+++ b/src/endocrinology/calculus.ts
@@ -0,0 +1,14 @@
+/** endocrinology calculus module — tsb analytics library. */
+export interface EndocrinologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyCalculusResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyCalculus(data: number[], opts: EndocrinologyCalculusOptions = {}): EndocrinologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyCalculus };
diff --git a/src/endocrinology/calibration.ts b/src/endocrinology/calibration.ts
new file mode 100644
index 000000000..ebd518199
--- /dev/null
+++ b/src/endocrinology/calibration.ts
@@ -0,0 +1,14 @@
+/** endocrinology calibration module — tsb analytics library. */
+export interface EndocrinologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyCalibration(data: number[], opts: EndocrinologyCalibrationOptions = {}): EndocrinologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyCalibration };
diff --git a/src/endocrinology/characterization.ts b/src/endocrinology/characterization.ts
new file mode 100644
index 000000000..fc43b2b7e
--- /dev/null
+++ b/src/endocrinology/characterization.ts
@@ -0,0 +1,14 @@
+/** endocrinology characterization module — tsb analytics library. */
+export interface EndocrinologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyCharacterization(data: number[], opts: EndocrinologyCharacterizationOptions = {}): EndocrinologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyCharacterization };
diff --git a/src/endocrinology/classification.ts b/src/endocrinology/classification.ts
new file mode 100644
index 000000000..db0b94af5
--- /dev/null
+++ b/src/endocrinology/classification.ts
@@ -0,0 +1,14 @@
+/** endocrinology classification module — tsb analytics library. */
+export interface EndocrinologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyClassificationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyClassification(data: number[], opts: EndocrinologyClassificationOptions = {}): EndocrinologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyClassification };
diff --git a/src/endocrinology/clustering.ts b/src/endocrinology/clustering.ts
new file mode 100644
index 000000000..69b17277f
--- /dev/null
+++ b/src/endocrinology/clustering.ts
@@ -0,0 +1,14 @@
+/** endocrinology clustering module — tsb analytics library. */
+export interface EndocrinologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyClusteringResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyClustering(data: number[], opts: EndocrinologyClusteringOptions = {}): EndocrinologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyClustering };
diff --git a/src/endocrinology/compression.ts b/src/endocrinology/compression.ts
new file mode 100644
index 000000000..20a67a446
--- /dev/null
+++ b/src/endocrinology/compression.ts
@@ -0,0 +1,14 @@
+/** endocrinology compression module — tsb analytics library. */
+export interface EndocrinologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyCompressionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyCompression(data: number[], opts: EndocrinologyCompressionOptions = {}): EndocrinologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyCompression };
diff --git a/src/endocrinology/continuous.ts b/src/endocrinology/continuous.ts
new file mode 100644
index 000000000..33b74d250
--- /dev/null
+++ b/src/endocrinology/continuous.ts
@@ -0,0 +1,14 @@
+/** endocrinology continuous module — tsb analytics library. */
+export interface EndocrinologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyContinuousResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyContinuous(data: number[], opts: EndocrinologyContinuousOptions = {}): EndocrinologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyContinuous };
diff --git a/src/endocrinology/control.ts b/src/endocrinology/control.ts
new file mode 100644
index 000000000..088b00691
--- /dev/null
+++ b/src/endocrinology/control.ts
@@ -0,0 +1,14 @@
+/** endocrinology control module — tsb analytics library. */
+export interface EndocrinologyControlOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyControlResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyControl(data: number[], opts: EndocrinologyControlOptions = {}): EndocrinologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyControl };
diff --git a/src/endocrinology/convergence.ts b/src/endocrinology/convergence.ts
new file mode 100644
index 000000000..25485fc6a
--- /dev/null
+++ b/src/endocrinology/convergence.ts
@@ -0,0 +1,14 @@
+/** endocrinology convergence module — tsb analytics library. */
+export interface EndocrinologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyConvergence(data: number[], opts: EndocrinologyConvergenceOptions = {}): EndocrinologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyConvergence };
diff --git a/src/endocrinology/convex.ts b/src/endocrinology/convex.ts
new file mode 100644
index 000000000..2622cf0b7
--- /dev/null
+++ b/src/endocrinology/convex.ts
@@ -0,0 +1,14 @@
+/** endocrinology convex module — tsb analytics library. */
+export interface EndocrinologyConvexOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyConvexResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyConvex(data: number[], opts: EndocrinologyConvexOptions = {}): EndocrinologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyConvex };
diff --git a/src/endocrinology/correlation.ts b/src/endocrinology/correlation.ts
new file mode 100644
index 000000000..c00614c09
--- /dev/null
+++ b/src/endocrinology/correlation.ts
@@ -0,0 +1,14 @@
+/** endocrinology correlation module — tsb analytics library. */
+export interface EndocrinologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyCorrelation(data: number[], opts: EndocrinologyCorrelationOptions = {}): EndocrinologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyCorrelation };
diff --git a/src/endocrinology/covariance.ts b/src/endocrinology/covariance.ts
new file mode 100644
index 000000000..2a7378cf2
--- /dev/null
+++ b/src/endocrinology/covariance.ts
@@ -0,0 +1,14 @@
+/** endocrinology covariance module — tsb analytics library. */
+export interface EndocrinologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyCovariance(data: number[], opts: EndocrinologyCovarianceOptions = {}): EndocrinologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyCovariance };
diff --git a/src/endocrinology/cross_validation.ts b/src/endocrinology/cross_validation.ts
new file mode 100644
index 000000000..23452f1af
--- /dev/null
+++ b/src/endocrinology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** endocrinology cross_validation module — tsb analytics library. */
+export interface EndocrinologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyCrossValidation(data: number[], opts: EndocrinologyCrossValidationOptions = {}): EndocrinologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyCrossValidation };
diff --git a/src/endocrinology/decoding.ts b/src/endocrinology/decoding.ts
new file mode 100644
index 000000000..69d823a1c
--- /dev/null
+++ b/src/endocrinology/decoding.ts
@@ -0,0 +1,14 @@
+/** endocrinology decoding module — tsb analytics library. */
+export interface EndocrinologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDecodingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDecoding(data: number[], opts: EndocrinologyDecodingOptions = {}): EndocrinologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDecoding };
diff --git a/src/endocrinology/decomposition.ts b/src/endocrinology/decomposition.ts
new file mode 100644
index 000000000..fb446aba6
--- /dev/null
+++ b/src/endocrinology/decomposition.ts
@@ -0,0 +1,14 @@
+/** endocrinology decomposition module — tsb analytics library. */
+export interface EndocrinologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDecomposition(data: number[], opts: EndocrinologyDecompositionOptions = {}): EndocrinologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDecomposition };
diff --git a/src/endocrinology/detection.ts b/src/endocrinology/detection.ts
new file mode 100644
index 000000000..e1bb84fe0
--- /dev/null
+++ b/src/endocrinology/detection.ts
@@ -0,0 +1,14 @@
+/** endocrinology detection module — tsb analytics library. */
+export interface EndocrinologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDetectionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDetection(data: number[], opts: EndocrinologyDetectionOptions = {}): EndocrinologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDetection };
diff --git a/src/endocrinology/deterministic.ts b/src/endocrinology/deterministic.ts
new file mode 100644
index 000000000..84fa70041
--- /dev/null
+++ b/src/endocrinology/deterministic.ts
@@ -0,0 +1,14 @@
+/** endocrinology deterministic module — tsb analytics library. */
+export interface EndocrinologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDeterministic(data: number[], opts: EndocrinologyDeterministicOptions = {}): EndocrinologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDeterministic };
diff --git a/src/endocrinology/diagnostics.ts b/src/endocrinology/diagnostics.ts
new file mode 100644
index 000000000..ccb568a51
--- /dev/null
+++ b/src/endocrinology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** endocrinology diagnostics module — tsb analytics library. */
+export interface EndocrinologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDiagnostics(data: number[], opts: EndocrinologyDiagnosticsOptions = {}): EndocrinologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDiagnostics };
diff --git a/src/endocrinology/differential.ts b/src/endocrinology/differential.ts
new file mode 100644
index 000000000..fdd0296c6
--- /dev/null
+++ b/src/endocrinology/differential.ts
@@ -0,0 +1,14 @@
+/** endocrinology differential module — tsb analytics library. */
+export interface EndocrinologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDifferential(data: number[], opts: EndocrinologyDifferentialOptions = {}): EndocrinologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDifferential };
diff --git a/src/endocrinology/discrete.ts b/src/endocrinology/discrete.ts
new file mode 100644
index 000000000..6655d8e13
--- /dev/null
+++ b/src/endocrinology/discrete.ts
@@ -0,0 +1,14 @@
+/** endocrinology discrete module — tsb analytics library. */
+export interface EndocrinologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDiscrete(data: number[], opts: EndocrinologyDiscreteOptions = {}): EndocrinologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDiscrete };
diff --git a/src/endocrinology/distribution.ts b/src/endocrinology/distribution.ts
new file mode 100644
index 000000000..4a48a6710
--- /dev/null
+++ b/src/endocrinology/distribution.ts
@@ -0,0 +1,14 @@
+/** endocrinology distribution module — tsb analytics library. */
+export interface EndocrinologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDistributionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDistribution(data: number[], opts: EndocrinologyDistributionOptions = {}): EndocrinologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDistribution };
diff --git a/src/endocrinology/dynamic.ts b/src/endocrinology/dynamic.ts
new file mode 100644
index 000000000..b26e18ff1
--- /dev/null
+++ b/src/endocrinology/dynamic.ts
@@ -0,0 +1,14 @@
+/** endocrinology dynamic module — tsb analytics library. */
+export interface EndocrinologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyDynamicResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyDynamic(data: number[], opts: EndocrinologyDynamicOptions = {}): EndocrinologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyDynamic };
diff --git a/src/endocrinology/embedding.ts b/src/endocrinology/embedding.ts
new file mode 100644
index 000000000..ce8d761cd
--- /dev/null
+++ b/src/endocrinology/embedding.ts
@@ -0,0 +1,14 @@
+/** endocrinology embedding module — tsb analytics library. */
+export interface EndocrinologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyEmbedding(data: number[], opts: EndocrinologyEmbeddingOptions = {}): EndocrinologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyEmbedding };
diff --git a/src/endocrinology/encoding.ts b/src/endocrinology/encoding.ts
new file mode 100644
index 000000000..34eb78936
--- /dev/null
+++ b/src/endocrinology/encoding.ts
@@ -0,0 +1,14 @@
+/** endocrinology encoding module — tsb analytics library. */
+export interface EndocrinologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyEncodingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyEncoding(data: number[], opts: EndocrinologyEncodingOptions = {}): EndocrinologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyEncoding };
diff --git a/src/endocrinology/ensemble.ts b/src/endocrinology/ensemble.ts
new file mode 100644
index 000000000..bc5f4d486
--- /dev/null
+++ b/src/endocrinology/ensemble.ts
@@ -0,0 +1,14 @@
+/** endocrinology ensemble module — tsb analytics library. */
+export interface EndocrinologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyEnsemble(data: number[], opts: EndocrinologyEnsembleOptions = {}): EndocrinologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyEnsemble };
diff --git a/src/endocrinology/estimation.ts b/src/endocrinology/estimation.ts
new file mode 100644
index 000000000..0108d05ba
--- /dev/null
+++ b/src/endocrinology/estimation.ts
@@ -0,0 +1,14 @@
+/** endocrinology estimation module — tsb analytics library. */
+export interface EndocrinologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyEstimationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyEstimation(data: number[], opts: EndocrinologyEstimationOptions = {}): EndocrinologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyEstimation };
diff --git a/src/endocrinology/evaluation.ts b/src/endocrinology/evaluation.ts
new file mode 100644
index 000000000..79912d2b3
--- /dev/null
+++ b/src/endocrinology/evaluation.ts
@@ -0,0 +1,14 @@
+/** endocrinology evaluation module — tsb analytics library. */
+export interface EndocrinologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyEvaluation(data: number[], opts: EndocrinologyEvaluationOptions = {}): EndocrinologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyEvaluation };
diff --git a/src/endocrinology/extrapolation.ts b/src/endocrinology/extrapolation.ts
new file mode 100644
index 000000000..b2abd58db
--- /dev/null
+++ b/src/endocrinology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** endocrinology extrapolation module — tsb analytics library. */
+export interface EndocrinologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyExtrapolation(data: number[], opts: EndocrinologyExtrapolationOptions = {}): EndocrinologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyExtrapolation };
diff --git a/src/endocrinology/features.ts b/src/endocrinology/features.ts
new file mode 100644
index 000000000..f2a5def10
--- /dev/null
+++ b/src/endocrinology/features.ts
@@ -0,0 +1,14 @@
+/** endocrinology features module — tsb analytics library. */
+export interface EndocrinologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyFeatures(data: number[], opts: EndocrinologyFeaturesOptions = {}): EndocrinologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyFeatures };
diff --git a/src/endocrinology/feedback.ts b/src/endocrinology/feedback.ts
new file mode 100644
index 000000000..13b5b2cd4
--- /dev/null
+++ b/src/endocrinology/feedback.ts
@@ -0,0 +1,14 @@
+/** endocrinology feedback module — tsb analytics library. */
+export interface EndocrinologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyFeedback(data: number[], opts: EndocrinologyFeedbackOptions = {}): EndocrinologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyFeedback };
diff --git a/src/endocrinology/filtering.ts b/src/endocrinology/filtering.ts
new file mode 100644
index 000000000..a6ccdf86b
--- /dev/null
+++ b/src/endocrinology/filtering.ts
@@ -0,0 +1,14 @@
+/** endocrinology filtering module — tsb analytics library. */
+export interface EndocrinologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyFilteringResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyFiltering(data: number[], opts: EndocrinologyFilteringOptions = {}): EndocrinologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyFiltering };
diff --git a/src/endocrinology/fourier.ts b/src/endocrinology/fourier.ts
new file mode 100644
index 000000000..3c9023d01
--- /dev/null
+++ b/src/endocrinology/fourier.ts
@@ -0,0 +1,14 @@
+/** endocrinology fourier module — tsb analytics library. */
+export interface EndocrinologyFourierOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyFourierResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyFourier(data: number[], opts: EndocrinologyFourierOptions = {}): EndocrinologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyFourier };
diff --git a/src/endocrinology/fusion.ts b/src/endocrinology/fusion.ts
new file mode 100644
index 000000000..622eb1ece
--- /dev/null
+++ b/src/endocrinology/fusion.ts
@@ -0,0 +1,14 @@
+/** endocrinology fusion module — tsb analytics library. */
+export interface EndocrinologyFusionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyFusionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyFusion(data: number[], opts: EndocrinologyFusionOptions = {}): EndocrinologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyFusion };
diff --git a/src/endocrinology/generation.ts b/src/endocrinology/generation.ts
new file mode 100644
index 000000000..f3a254f28
--- /dev/null
+++ b/src/endocrinology/generation.ts
@@ -0,0 +1,14 @@
+/** endocrinology generation module — tsb analytics library. */
+export interface EndocrinologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyGenerationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyGeneration(data: number[], opts: EndocrinologyGenerationOptions = {}): EndocrinologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyGeneration };
diff --git a/src/endocrinology/geometry.ts b/src/endocrinology/geometry.ts
new file mode 100644
index 000000000..8ecf5c876
--- /dev/null
+++ b/src/endocrinology/geometry.ts
@@ -0,0 +1,14 @@
+/** endocrinology geometry module — tsb analytics library. */
+export interface EndocrinologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyGeometryResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyGeometry(data: number[], opts: EndocrinologyGeometryOptions = {}): EndocrinologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyGeometry };
diff --git a/src/endocrinology/gradient.ts b/src/endocrinology/gradient.ts
new file mode 100644
index 000000000..eb2d5d62c
--- /dev/null
+++ b/src/endocrinology/gradient.ts
@@ -0,0 +1,14 @@
+/** endocrinology gradient module — tsb analytics library. */
+export interface EndocrinologyGradientOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyGradientResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyGradient(data: number[], opts: EndocrinologyGradientOptions = {}): EndocrinologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyGradient };
diff --git a/src/endocrinology/hessian.ts b/src/endocrinology/hessian.ts
new file mode 100644
index 000000000..df678bcd2
--- /dev/null
+++ b/src/endocrinology/hessian.ts
@@ -0,0 +1,14 @@
+/** endocrinology hessian module — tsb analytics library. */
+export interface EndocrinologyHessianOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyHessianResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyHessian(data: number[], opts: EndocrinologyHessianOptions = {}): EndocrinologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyHessian };
diff --git a/src/endocrinology/hypothesis.ts b/src/endocrinology/hypothesis.ts
new file mode 100644
index 000000000..a78680877
--- /dev/null
+++ b/src/endocrinology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** endocrinology hypothesis module — tsb analytics library. */
+export interface EndocrinologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyHypothesis(data: number[], opts: EndocrinologyHypothesisOptions = {}): EndocrinologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyHypothesis };
diff --git a/src/endocrinology/inference.ts b/src/endocrinology/inference.ts
new file mode 100644
index 000000000..90246d27f
--- /dev/null
+++ b/src/endocrinology/inference.ts
@@ -0,0 +1,14 @@
+/** endocrinology inference module — tsb analytics library. */
+export interface EndocrinologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyInferenceResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyInference(data: number[], opts: EndocrinologyInferenceOptions = {}): EndocrinologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyInference };
diff --git a/src/endocrinology/inference2.ts b/src/endocrinology/inference2.ts
new file mode 100644
index 000000000..84ebf63cf
--- /dev/null
+++ b/src/endocrinology/inference2.ts
@@ -0,0 +1,14 @@
+/** endocrinology inference2 module — tsb analytics library. */
+export interface EndocrinologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyInferenceResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyInference(data: number[], opts: EndocrinologyInferenceOptions = {}): EndocrinologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyInference };
diff --git a/src/endocrinology/integral.ts b/src/endocrinology/integral.ts
new file mode 100644
index 000000000..0d8b5f5b4
--- /dev/null
+++ b/src/endocrinology/integral.ts
@@ -0,0 +1,14 @@
+/** endocrinology integral module — tsb analytics library. */
+export interface EndocrinologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyIntegralResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyIntegral(data: number[], opts: EndocrinologyIntegralOptions = {}): EndocrinologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyIntegral };
diff --git a/src/endocrinology/integration.ts b/src/endocrinology/integration.ts
new file mode 100644
index 000000000..d19ed50d4
--- /dev/null
+++ b/src/endocrinology/integration.ts
@@ -0,0 +1,14 @@
+/** endocrinology integration module — tsb analytics library. */
+export interface EndocrinologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyIntegration(data: number[], opts: EndocrinologyIntegrationOptions = {}): EndocrinologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyIntegration };
diff --git a/src/endocrinology/interpolation.ts b/src/endocrinology/interpolation.ts
new file mode 100644
index 000000000..89645c556
--- /dev/null
+++ b/src/endocrinology/interpolation.ts
@@ -0,0 +1,14 @@
+/** endocrinology interpolation module — tsb analytics library. */
+export interface EndocrinologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyInterpolation(data: number[], opts: EndocrinologyInterpolationOptions = {}): EndocrinologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyInterpolation };
diff --git a/src/endocrinology/jacobian.ts b/src/endocrinology/jacobian.ts
new file mode 100644
index 000000000..c433f8646
--- /dev/null
+++ b/src/endocrinology/jacobian.ts
@@ -0,0 +1,14 @@
+/** endocrinology jacobian module — tsb analytics library. */
+export interface EndocrinologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyJacobianResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyJacobian(data: number[], opts: EndocrinologyJacobianOptions = {}): EndocrinologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyJacobian };
diff --git a/src/endocrinology/kernel.ts b/src/endocrinology/kernel.ts
new file mode 100644
index 000000000..ac62b70a1
--- /dev/null
+++ b/src/endocrinology/kernel.ts
@@ -0,0 +1,14 @@
+/** endocrinology kernel module — tsb analytics library. */
+export interface EndocrinologyKernelOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyKernelResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyKernel(data: number[], opts: EndocrinologyKernelOptions = {}): EndocrinologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyKernel };
diff --git a/src/endocrinology/laplacian.ts b/src/endocrinology/laplacian.ts
new file mode 100644
index 000000000..6e5f82a55
--- /dev/null
+++ b/src/endocrinology/laplacian.ts
@@ -0,0 +1,14 @@
+/** endocrinology laplacian module — tsb analytics library. */
+export interface EndocrinologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyLaplacian(data: number[], opts: EndocrinologyLaplacianOptions = {}): EndocrinologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyLaplacian };
diff --git a/src/endocrinology/learning.ts b/src/endocrinology/learning.ts
new file mode 100644
index 000000000..ca7c98c53
--- /dev/null
+++ b/src/endocrinology/learning.ts
@@ -0,0 +1,14 @@
+/** endocrinology learning module — tsb analytics library. */
+export interface EndocrinologyLearningOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyLearningResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyLearning(data: number[], opts: EndocrinologyLearningOptions = {}): EndocrinologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyLearning };
diff --git a/src/endocrinology/linear.ts b/src/endocrinology/linear.ts
new file mode 100644
index 000000000..4e4dc1505
--- /dev/null
+++ b/src/endocrinology/linear.ts
@@ -0,0 +1,14 @@
+/** endocrinology linear module — tsb analytics library. */
+export interface EndocrinologyLinearOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyLinearResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyLinear(data: number[], opts: EndocrinologyLinearOptions = {}): EndocrinologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyLinear };
diff --git a/src/endocrinology/manifold.ts b/src/endocrinology/manifold.ts
new file mode 100644
index 000000000..7bac341a1
--- /dev/null
+++ b/src/endocrinology/manifold.ts
@@ -0,0 +1,14 @@
+/** endocrinology manifold module — tsb analytics library. */
+export interface EndocrinologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyManifoldResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyManifold(data: number[], opts: EndocrinologyManifoldOptions = {}): EndocrinologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyManifold };
diff --git a/src/endocrinology/matching.ts b/src/endocrinology/matching.ts
new file mode 100644
index 000000000..180b3eb29
--- /dev/null
+++ b/src/endocrinology/matching.ts
@@ -0,0 +1,14 @@
+/** endocrinology matching module — tsb analytics library. */
+export interface EndocrinologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyMatchingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyMatching(data: number[], opts: EndocrinologyMatchingOptions = {}): EndocrinologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyMatching };
diff --git a/src/endocrinology/measurement.ts b/src/endocrinology/measurement.ts
new file mode 100644
index 000000000..e7cfb2060
--- /dev/null
+++ b/src/endocrinology/measurement.ts
@@ -0,0 +1,14 @@
+/** endocrinology measurement module — tsb analytics library. */
+export interface EndocrinologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyMeasurement(data: number[], opts: EndocrinologyMeasurementOptions = {}): EndocrinologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyMeasurement };
diff --git a/src/endocrinology/metrics.ts b/src/endocrinology/metrics.ts
new file mode 100644
index 000000000..e01d9bda9
--- /dev/null
+++ b/src/endocrinology/metrics.ts
@@ -0,0 +1,14 @@
+/** endocrinology metrics module — tsb analytics library. */
+export interface EndocrinologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyMetricsResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyMetrics(data: number[], opts: EndocrinologyMetricsOptions = {}): EndocrinologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyMetrics };
diff --git a/src/endocrinology/modeling.ts b/src/endocrinology/modeling.ts
new file mode 100644
index 000000000..88092537c
--- /dev/null
+++ b/src/endocrinology/modeling.ts
@@ -0,0 +1,14 @@
+/** endocrinology modeling module — tsb analytics library. */
+export interface EndocrinologyModelingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyModelingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyModeling(data: number[], opts: EndocrinologyModelingOptions = {}): EndocrinologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyModeling };
diff --git a/src/endocrinology/monitoring.ts b/src/endocrinology/monitoring.ts
new file mode 100644
index 000000000..8c48df721
--- /dev/null
+++ b/src/endocrinology/monitoring.ts
@@ -0,0 +1,14 @@
+/** endocrinology monitoring module — tsb analytics library. */
+export interface EndocrinologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyMonitoring(data: number[], opts: EndocrinologyMonitoringOptions = {}): EndocrinologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyMonitoring };
diff --git a/src/endocrinology/nonlinear.ts b/src/endocrinology/nonlinear.ts
new file mode 100644
index 000000000..09cc71dce
--- /dev/null
+++ b/src/endocrinology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** endocrinology nonlinear module — tsb analytics library. */
+export interface EndocrinologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyNonlinear(data: number[], opts: EndocrinologyNonlinearOptions = {}): EndocrinologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyNonlinear };
diff --git a/src/endocrinology/normalization.ts b/src/endocrinology/normalization.ts
new file mode 100644
index 000000000..b27e36bbd
--- /dev/null
+++ b/src/endocrinology/normalization.ts
@@ -0,0 +1,14 @@
+/** endocrinology normalization module — tsb analytics library. */
+export interface EndocrinologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyNormalization(data: number[], opts: EndocrinologyNormalizationOptions = {}): EndocrinologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyNormalization };
diff --git a/src/endocrinology/optimization.ts b/src/endocrinology/optimization.ts
new file mode 100644
index 000000000..bacff2807
--- /dev/null
+++ b/src/endocrinology/optimization.ts
@@ -0,0 +1,14 @@
+/** endocrinology optimization module — tsb analytics library. */
+export interface EndocrinologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyOptimization(data: number[], opts: EndocrinologyOptimizationOptions = {}): EndocrinologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyOptimization };
diff --git a/src/endocrinology/patterns.ts b/src/endocrinology/patterns.ts
new file mode 100644
index 000000000..f4996b9db
--- /dev/null
+++ b/src/endocrinology/patterns.ts
@@ -0,0 +1,14 @@
+/** endocrinology patterns module — tsb analytics library. */
+export interface EndocrinologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyPatternsResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyPatterns(data: number[], opts: EndocrinologyPatternsOptions = {}): EndocrinologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyPatterns };
diff --git a/src/endocrinology/permutation.ts b/src/endocrinology/permutation.ts
new file mode 100644
index 000000000..3fe24b6e9
--- /dev/null
+++ b/src/endocrinology/permutation.ts
@@ -0,0 +1,14 @@
+/** endocrinology permutation module — tsb analytics library. */
+export interface EndocrinologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyPermutationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyPermutation(data: number[], opts: EndocrinologyPermutationOptions = {}): EndocrinologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyPermutation };
diff --git a/src/endocrinology/prediction.ts b/src/endocrinology/prediction.ts
new file mode 100644
index 000000000..b841233c1
--- /dev/null
+++ b/src/endocrinology/prediction.ts
@@ -0,0 +1,14 @@
+/** endocrinology prediction module — tsb analytics library. */
+export interface EndocrinologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyPredictionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyPrediction(data: number[], opts: EndocrinologyPredictionOptions = {}): EndocrinologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyPrediction };
diff --git a/src/endocrinology/processing.ts b/src/endocrinology/processing.ts
new file mode 100644
index 000000000..c5465c5cf
--- /dev/null
+++ b/src/endocrinology/processing.ts
@@ -0,0 +1,14 @@
+/** endocrinology processing module — tsb analytics library. */
+export interface EndocrinologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyProcessingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyProcessing(data: number[], opts: EndocrinologyProcessingOptions = {}): EndocrinologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyProcessing };
diff --git a/src/endocrinology/profiling.ts b/src/endocrinology/profiling.ts
new file mode 100644
index 000000000..2b514e29c
--- /dev/null
+++ b/src/endocrinology/profiling.ts
@@ -0,0 +1,14 @@
+/** endocrinology profiling module — tsb analytics library. */
+export interface EndocrinologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyProfilingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyProfiling(data: number[], opts: EndocrinologyProfilingOptions = {}): EndocrinologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyProfiling };
diff --git a/src/endocrinology/projection.ts b/src/endocrinology/projection.ts
new file mode 100644
index 000000000..0e3337c74
--- /dev/null
+++ b/src/endocrinology/projection.ts
@@ -0,0 +1,14 @@
+/** endocrinology projection module — tsb analytics library. */
+export interface EndocrinologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyProjectionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyProjection(data: number[], opts: EndocrinologyProjectionOptions = {}): EndocrinologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyProjection };
diff --git a/src/endocrinology/ranking.ts b/src/endocrinology/ranking.ts
new file mode 100644
index 000000000..5e82c28ff
--- /dev/null
+++ b/src/endocrinology/ranking.ts
@@ -0,0 +1,14 @@
+/** endocrinology ranking module — tsb analytics library. */
+export interface EndocrinologyRankingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyRankingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyRanking(data: number[], opts: EndocrinologyRankingOptions = {}): EndocrinologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyRanking };
diff --git a/src/endocrinology/reconstruction.ts b/src/endocrinology/reconstruction.ts
new file mode 100644
index 000000000..d8ae776db
--- /dev/null
+++ b/src/endocrinology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** endocrinology reconstruction module — tsb analytics library. */
+export interface EndocrinologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyReconstruction(data: number[], opts: EndocrinologyReconstructionOptions = {}): EndocrinologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyReconstruction };
diff --git a/src/endocrinology/registration.ts b/src/endocrinology/registration.ts
new file mode 100644
index 000000000..34995ddf0
--- /dev/null
+++ b/src/endocrinology/registration.ts
@@ -0,0 +1,14 @@
+/** endocrinology registration module — tsb analytics library. */
+export interface EndocrinologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyRegistration(data: number[], opts: EndocrinologyRegistrationOptions = {}): EndocrinologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyRegistration };
diff --git a/src/endocrinology/regression.ts b/src/endocrinology/regression.ts
new file mode 100644
index 000000000..4d63e1498
--- /dev/null
+++ b/src/endocrinology/regression.ts
@@ -0,0 +1,14 @@
+/** endocrinology regression module — tsb analytics library. */
+export interface EndocrinologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyRegressionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyRegression(data: number[], opts: EndocrinologyRegressionOptions = {}): EndocrinologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyRegression };
diff --git a/src/endocrinology/regularization.ts b/src/endocrinology/regularization.ts
new file mode 100644
index 000000000..ab578f320
--- /dev/null
+++ b/src/endocrinology/regularization.ts
@@ -0,0 +1,14 @@
+/** endocrinology regularization module — tsb analytics library. */
+export interface EndocrinologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyRegularization(data: number[], opts: EndocrinologyRegularizationOptions = {}): EndocrinologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyRegularization };
diff --git a/src/endocrinology/robustness.ts b/src/endocrinology/robustness.ts
new file mode 100644
index 000000000..84546174c
--- /dev/null
+++ b/src/endocrinology/robustness.ts
@@ -0,0 +1,14 @@
+/** endocrinology robustness module — tsb analytics library. */
+export interface EndocrinologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyRobustness(data: number[], opts: EndocrinologyRobustnessOptions = {}): EndocrinologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyRobustness };
diff --git a/src/endocrinology/sampling.ts b/src/endocrinology/sampling.ts
new file mode 100644
index 000000000..120e00eb8
--- /dev/null
+++ b/src/endocrinology/sampling.ts
@@ -0,0 +1,14 @@
+/** endocrinology sampling module — tsb analytics library. */
+export interface EndocrinologySamplingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologySamplingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologySampling(data: number[], opts: EndocrinologySamplingOptions = {}): EndocrinologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologySampling };
diff --git a/src/endocrinology/sampling2.ts b/src/endocrinology/sampling2.ts
new file mode 100644
index 000000000..b3e493387
--- /dev/null
+++ b/src/endocrinology/sampling2.ts
@@ -0,0 +1,14 @@
+/** endocrinology sampling2 module — tsb analytics library. */
+export interface EndocrinologySamplingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologySamplingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologySampling(data: number[], opts: EndocrinologySamplingOptions = {}): EndocrinologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologySampling };
diff --git a/src/endocrinology/scaling.ts b/src/endocrinology/scaling.ts
new file mode 100644
index 000000000..7c52af3b9
--- /dev/null
+++ b/src/endocrinology/scaling.ts
@@ -0,0 +1,14 @@
+/** endocrinology scaling module — tsb analytics library. */
+export interface EndocrinologyScalingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyScalingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyScaling(data: number[], opts: EndocrinologyScalingOptions = {}): EndocrinologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyScaling };
diff --git a/src/endocrinology/scoring.ts b/src/endocrinology/scoring.ts
new file mode 100644
index 000000000..efe6df1d1
--- /dev/null
+++ b/src/endocrinology/scoring.ts
@@ -0,0 +1,14 @@
+/** endocrinology scoring module — tsb analytics library. */
+export interface EndocrinologyScoringOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyScoringResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyScoring(data: number[], opts: EndocrinologyScoringOptions = {}): EndocrinologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyScoring };
diff --git a/src/endocrinology/segmentation.ts b/src/endocrinology/segmentation.ts
new file mode 100644
index 000000000..f0b791ae8
--- /dev/null
+++ b/src/endocrinology/segmentation.ts
@@ -0,0 +1,14 @@
+/** endocrinology segmentation module — tsb analytics library. */
+export interface EndocrinologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologySegmentationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologySegmentation(data: number[], opts: EndocrinologySegmentationOptions = {}): EndocrinologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologySegmentation };
diff --git a/src/endocrinology/selection.ts b/src/endocrinology/selection.ts
new file mode 100644
index 000000000..21717260e
--- /dev/null
+++ b/src/endocrinology/selection.ts
@@ -0,0 +1,14 @@
+/** endocrinology selection module — tsb analytics library. */
+export interface EndocrinologySelectionOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologySelectionResult { values: number[]; converged: boolean; }
+export function computeEndocrinologySelection(data: number[], opts: EndocrinologySelectionOptions = {}): EndocrinologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologySelection };
diff --git a/src/endocrinology/sensitivity.ts b/src/endocrinology/sensitivity.ts
new file mode 100644
index 000000000..2d48f22cb
--- /dev/null
+++ b/src/endocrinology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** endocrinology sensitivity module — tsb analytics library. */
+export interface EndocrinologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologySensitivityResult { values: number[]; converged: boolean; }
+export function computeEndocrinologySensitivity(data: number[], opts: EndocrinologySensitivityOptions = {}): EndocrinologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologySensitivity };
diff --git a/src/endocrinology/simulation.ts b/src/endocrinology/simulation.ts
new file mode 100644
index 000000000..23d40282c
--- /dev/null
+++ b/src/endocrinology/simulation.ts
@@ -0,0 +1,14 @@
+/** endocrinology simulation module — tsb analytics library. */
+export interface EndocrinologySimulationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologySimulationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologySimulation(data: number[], opts: EndocrinologySimulationOptions = {}): EndocrinologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologySimulation };
diff --git a/src/endocrinology/smoothing.ts b/src/endocrinology/smoothing.ts
new file mode 100644
index 000000000..7c3ad02fe
--- /dev/null
+++ b/src/endocrinology/smoothing.ts
@@ -0,0 +1,14 @@
+/** endocrinology smoothing module — tsb analytics library. */
+export interface EndocrinologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologySmoothingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologySmoothing(data: number[], opts: EndocrinologySmoothingOptions = {}): EndocrinologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologySmoothing };
diff --git a/src/endocrinology/stability.ts b/src/endocrinology/stability.ts
new file mode 100644
index 000000000..5904362fa
--- /dev/null
+++ b/src/endocrinology/stability.ts
@@ -0,0 +1,14 @@
+/** endocrinology stability module — tsb analytics library. */
+export interface EndocrinologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyStabilityResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyStability(data: number[], opts: EndocrinologyStabilityOptions = {}): EndocrinologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyStability };
diff --git a/src/endocrinology/stacking.ts b/src/endocrinology/stacking.ts
new file mode 100644
index 000000000..9bf5558d2
--- /dev/null
+++ b/src/endocrinology/stacking.ts
@@ -0,0 +1,14 @@
+/** endocrinology stacking module — tsb analytics library. */
+export interface EndocrinologyStackingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyStackingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyStacking(data: number[], opts: EndocrinologyStackingOptions = {}): EndocrinologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyStacking };
diff --git a/src/endocrinology/standardization.ts b/src/endocrinology/standardization.ts
new file mode 100644
index 000000000..13e1daea2
--- /dev/null
+++ b/src/endocrinology/standardization.ts
@@ -0,0 +1,14 @@
+/** endocrinology standardization module — tsb analytics library. */
+export interface EndocrinologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyStandardization(data: number[], opts: EndocrinologyStandardizationOptions = {}): EndocrinologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyStandardization };
diff --git a/src/endocrinology/static.ts b/src/endocrinology/static.ts
new file mode 100644
index 000000000..a876f40d8
--- /dev/null
+++ b/src/endocrinology/static.ts
@@ -0,0 +1,14 @@
+/** endocrinology static module — tsb analytics library. */
+export interface EndocrinologyStaticOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyStaticResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyStatic(data: number[], opts: EndocrinologyStaticOptions = {}): EndocrinologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyStatic };
diff --git a/src/endocrinology/stochastic.ts b/src/endocrinology/stochastic.ts
new file mode 100644
index 000000000..31cde7cf4
--- /dev/null
+++ b/src/endocrinology/stochastic.ts
@@ -0,0 +1,14 @@
+/** endocrinology stochastic module — tsb analytics library. */
+export interface EndocrinologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyStochasticResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyStochastic(data: number[], opts: EndocrinologyStochasticOptions = {}): EndocrinologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyStochastic };
diff --git a/src/endocrinology/synthesis.ts b/src/endocrinology/synthesis.ts
new file mode 100644
index 000000000..cccc84884
--- /dev/null
+++ b/src/endocrinology/synthesis.ts
@@ -0,0 +1,14 @@
+/** endocrinology synthesis module — tsb analytics library. */
+export interface EndocrinologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologySynthesisResult { values: number[]; converged: boolean; }
+export function computeEndocrinologySynthesis(data: number[], opts: EndocrinologySynthesisOptions = {}): EndocrinologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologySynthesis };
diff --git a/src/endocrinology/topology.ts b/src/endocrinology/topology.ts
new file mode 100644
index 000000000..643c6b092
--- /dev/null
+++ b/src/endocrinology/topology.ts
@@ -0,0 +1,14 @@
+/** endocrinology topology module — tsb analytics library. */
+export interface EndocrinologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyTopologyResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyTopology(data: number[], opts: EndocrinologyTopologyOptions = {}): EndocrinologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyTopology };
diff --git a/src/endocrinology/tracking.ts b/src/endocrinology/tracking.ts
new file mode 100644
index 000000000..60ea37ec9
--- /dev/null
+++ b/src/endocrinology/tracking.ts
@@ -0,0 +1,14 @@
+/** endocrinology tracking module — tsb analytics library. */
+export interface EndocrinologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyTrackingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyTracking(data: number[], opts: EndocrinologyTrackingOptions = {}): EndocrinologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyTracking };
diff --git a/src/endocrinology/transform.ts b/src/endocrinology/transform.ts
new file mode 100644
index 000000000..b9145fa87
--- /dev/null
+++ b/src/endocrinology/transform.ts
@@ -0,0 +1,14 @@
+/** endocrinology transform module — tsb analytics library. */
+export interface EndocrinologyTransformOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyTransformResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyTransform(data: number[], opts: EndocrinologyTransformOptions = {}): EndocrinologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyTransform };
diff --git a/src/endocrinology/uncertainty.ts b/src/endocrinology/uncertainty.ts
new file mode 100644
index 000000000..30647ee6b
--- /dev/null
+++ b/src/endocrinology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** endocrinology uncertainty module — tsb analytics library. */
+export interface EndocrinologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyUncertainty(data: number[], opts: EndocrinologyUncertaintyOptions = {}): EndocrinologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyUncertainty };
diff --git a/src/endocrinology/validation.ts b/src/endocrinology/validation.ts
new file mode 100644
index 000000000..1a698fdd6
--- /dev/null
+++ b/src/endocrinology/validation.ts
@@ -0,0 +1,14 @@
+/** endocrinology validation module — tsb analytics library. */
+export interface EndocrinologyValidationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyValidationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyValidation(data: number[], opts: EndocrinologyValidationOptions = {}): EndocrinologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyValidation };
diff --git a/src/endocrinology/verification.ts b/src/endocrinology/verification.ts
new file mode 100644
index 000000000..1343a2a3d
--- /dev/null
+++ b/src/endocrinology/verification.ts
@@ -0,0 +1,14 @@
+/** endocrinology verification module — tsb analytics library. */
+export interface EndocrinologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyVerificationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyVerification(data: number[], opts: EndocrinologyVerificationOptions = {}): EndocrinologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyVerification };
diff --git a/src/endocrinology/visualization.ts b/src/endocrinology/visualization.ts
new file mode 100644
index 000000000..efa20a1b6
--- /dev/null
+++ b/src/endocrinology/visualization.ts
@@ -0,0 +1,14 @@
+/** endocrinology visualization module — tsb analytics library. */
+export interface EndocrinologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyVisualization(data: number[], opts: EndocrinologyVisualizationOptions = {}): EndocrinologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyVisualization };
diff --git a/src/endocrinology/voting.ts b/src/endocrinology/voting.ts
new file mode 100644
index 000000000..4c6892c2e
--- /dev/null
+++ b/src/endocrinology/voting.ts
@@ -0,0 +1,14 @@
+/** endocrinology voting module — tsb analytics library. */
+export interface EndocrinologyVotingOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyVotingResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyVoting(data: number[], opts: EndocrinologyVotingOptions = {}): EndocrinologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyVoting };
diff --git a/src/endocrinology/wavelet.ts b/src/endocrinology/wavelet.ts
new file mode 100644
index 000000000..a853b3d80
--- /dev/null
+++ b/src/endocrinology/wavelet.ts
@@ -0,0 +1,14 @@
+/** endocrinology wavelet module — tsb analytics library. */
+export interface EndocrinologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface EndocrinologyWaveletResult { values: number[]; converged: boolean; }
+export function computeEndocrinologyWavelet(data: number[], opts: EndocrinologyWaveletOptions = {}): EndocrinologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEndocrinologyWavelet };
diff --git a/src/energy/advanced.ts b/src/energy/advanced.ts
new file mode 100644
index 000000000..7d76a0c79
--- /dev/null
+++ b/src/energy/advanced.ts
@@ -0,0 +1,15 @@
+/** Energy Advanced module — tsb analytics library. */
+export interface Energy advancedOptions { tol?: number; maxIter?: number; }
+export interface Energy advancedResult { values: number[]; converged: boolean; }
+export function computeEnergy advanced(data: number[], opts: Energy advancedOptions = {}): Energy advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy advanced };
diff --git a/src/energy/agriculture_energy.ts b/src/energy/agriculture_energy.ts
new file mode 100644
index 000000000..03ba1b5a1
--- /dev/null
+++ b/src/energy/agriculture_energy.ts
@@ -0,0 +1,22 @@
+/** Agriculture Energy module — tsb analytics library. */
+
+/** Options for Agriculture Energy. */
+export interface AgricultureEnergyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Agriculture Energy. */
+export interface AgricultureEnergyResult { values: number[]; converged: boolean; }
+
+/** Compute Agriculture Energy. */
+export function computeAgricultureEnergy(data: number[], opts: AgricultureEnergyOptions = {}): AgricultureEnergyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAgricultureEnergy };
diff --git a/src/energy/base2.ts b/src/energy/base2.ts
new file mode 100644
index 000000000..b2fe944df
--- /dev/null
+++ b/src/energy/base2.ts
@@ -0,0 +1,15 @@
+/** Energy Base2 module — tsb analytics library. */
+export interface Energy base2Options { tol?: number; maxIter?: number; }
+export interface Energy base2Result { values: number[]; converged: boolean; }
+export function computeEnergy base2(data: number[], opts: Energy base2Options = {}): Energy base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy base2 };
diff --git a/src/energy/batch.ts b/src/energy/batch.ts
new file mode 100644
index 000000000..ef9e48033
--- /dev/null
+++ b/src/energy/batch.ts
@@ -0,0 +1,15 @@
+/** Energy Batch module — tsb analytics library. */
+export interface Energy batchOptions { tol?: number; maxIter?: number; }
+export interface Energy batchResult { values: number[]; converged: boolean; }
+export function computeEnergy batch(data: number[], opts: Energy batchOptions = {}): Energy batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy batch };
diff --git a/src/energy/beta.ts b/src/energy/beta.ts
new file mode 100644
index 000000000..74bc85a72
--- /dev/null
+++ b/src/energy/beta.ts
@@ -0,0 +1,15 @@
+/** Energy Beta module — tsb analytics library. */
+export interface Energy betaOptions { tol?: number; maxIter?: number; }
+export interface Energy betaResult { values: number[]; converged: boolean; }
+export function computeEnergy beta(data: number[], opts: Energy betaOptions = {}): Energy betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy beta };
diff --git a/src/energy/biomass.ts b/src/energy/biomass.ts
new file mode 100644
index 000000000..e1ef77263
--- /dev/null
+++ b/src/energy/biomass.ts
@@ -0,0 +1,22 @@
+/** Biomass module — tsb analytics library. */
+
+/** Options for Biomass. */
+export interface BiomassOptions { tol?: number; maxIter?: number; }
+
+/** Result from Biomass. */
+export interface BiomassResult { values: number[]; converged: boolean; }
+
+/** Compute Biomass. */
+export function computeBiomass(data: number[], opts: BiomassOptions = {}): BiomassResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBiomass };
diff --git a/src/energy/building.ts b/src/energy/building.ts
new file mode 100644
index 000000000..bab5658c8
--- /dev/null
+++ b/src/energy/building.ts
@@ -0,0 +1,22 @@
+/** Building module — tsb analytics library. */
+
+/** Options for Building. */
+export interface BuildingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Building. */
+export interface BuildingResult { values: number[]; converged: boolean; }
+
+/** Compute Building. */
+export function computeBuilding(data: number[], opts: BuildingOptions = {}): BuildingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBuilding };
diff --git a/src/energy/carbon_price.ts b/src/energy/carbon_price.ts
new file mode 100644
index 000000000..4656fe7ed
--- /dev/null
+++ b/src/energy/carbon_price.ts
@@ -0,0 +1,22 @@
+/** Carbon Price module — tsb analytics library. */
+
+/** Options for Carbon Price. */
+export interface CarbonPriceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Carbon Price. */
+export interface CarbonPriceResult { values: number[]; converged: boolean; }
+
+/** Compute Carbon Price. */
+export function computeCarbonPrice(data: number[], opts: CarbonPriceOptions = {}): CarbonPriceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCarbonPrice };
diff --git a/src/energy/coal.ts b/src/energy/coal.ts
new file mode 100644
index 000000000..8777c1e63
--- /dev/null
+++ b/src/energy/coal.ts
@@ -0,0 +1,22 @@
+/** Coal module — tsb analytics library. */
+
+/** Options for Coal. */
+export interface CoalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coal. */
+export interface CoalResult { values: number[]; converged: boolean; }
+
+/** Compute Coal. */
+export function computeCoal(data: number[], opts: CoalOptions = {}): CoalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCoal };
diff --git a/src/energy/conservation.ts b/src/energy/conservation.ts
new file mode 100644
index 000000000..2d38218ae
--- /dev/null
+++ b/src/energy/conservation.ts
@@ -0,0 +1,22 @@
+/** Conservation module — tsb analytics library. */
+
+/** Options for Conservation. */
+export interface ConservationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Conservation. */
+export interface ConservationResult { values: number[]; converged: boolean; }
+
+/** Compute Conservation. */
+export function computeConservation(data: number[], opts: ConservationOptions = {}): ConservationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConservation };
diff --git a/src/energy/cpu.ts b/src/energy/cpu.ts
new file mode 100644
index 000000000..9848ea058
--- /dev/null
+++ b/src/energy/cpu.ts
@@ -0,0 +1,15 @@
+/** Energy Cpu module — tsb analytics library. */
+export interface Energy cpuOptions { tol?: number; maxIter?: number; }
+export interface Energy cpuResult { values: number[]; converged: boolean; }
+export function computeEnergy cpu(data: number[], opts: Energy cpuOptions = {}): Energy cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy cpu };
diff --git a/src/energy/demand_response.ts b/src/energy/demand_response.ts
new file mode 100644
index 000000000..7445cfc98
--- /dev/null
+++ b/src/energy/demand_response.ts
@@ -0,0 +1,22 @@
+/** Demand Response module — tsb analytics library. */
+
+/** Options for Demand Response. */
+export interface DemandResponseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Demand Response. */
+export interface DemandResponseResult { values: number[]; converged: boolean; }
+
+/** Compute Demand Response. */
+export function computeDemandResponse(data: number[], opts: DemandResponseOptions = {}): DemandResponseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDemandResponse };
diff --git a/src/energy/dense.ts b/src/energy/dense.ts
new file mode 100644
index 000000000..d15c815fa
--- /dev/null
+++ b/src/energy/dense.ts
@@ -0,0 +1,15 @@
+/** Energy Dense module — tsb analytics library. */
+export interface Energy denseOptions { tol?: number; maxIter?: number; }
+export interface Energy denseResult { values: number[]; converged: boolean; }
+export function computeEnergy dense(data: number[], opts: Energy denseOptions = {}): Energy denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy dense };
diff --git a/src/energy/distributed.ts b/src/energy/distributed.ts
new file mode 100644
index 000000000..d74b455e1
--- /dev/null
+++ b/src/energy/distributed.ts
@@ -0,0 +1,15 @@
+/** Energy Distributed module — tsb analytics library. */
+export interface Energy distributedOptions { tol?: number; maxIter?: number; }
+export interface Energy distributedResult { values: number[]; converged: boolean; }
+export function computeEnergy distributed(data: number[], opts: Energy distributedOptions = {}): Energy distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy distributed };
diff --git a/src/energy/distribution.ts b/src/energy/distribution.ts
new file mode 100644
index 000000000..0d6b21d5e
--- /dev/null
+++ b/src/energy/distribution.ts
@@ -0,0 +1,22 @@
+/** Distribution module — tsb analytics library. */
+
+/** Options for Distribution. */
+export interface DistributionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Distribution. */
+export interface DistributionResult { values: number[]; converged: boolean; }
+
+/** Compute Distribution. */
+export function computeDistribution(data: number[], opts: DistributionOptions = {}): DistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDistribution };
diff --git a/src/energy/efficiency.ts b/src/energy/efficiency.ts
new file mode 100644
index 000000000..020460695
--- /dev/null
+++ b/src/energy/efficiency.ts
@@ -0,0 +1,22 @@
+/** Efficiency module — tsb analytics library. */
+
+/** Options for Efficiency. */
+export interface EfficiencyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Efficiency. */
+export interface EfficiencyResult { values: number[]; converged: boolean; }
+
+/** Compute Efficiency. */
+export function computeEfficiency(data: number[], opts: EfficiencyOptions = {}): EfficiencyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEfficiency };
diff --git a/src/energy/emissions.ts b/src/energy/emissions.ts
new file mode 100644
index 000000000..eaa5e87e2
--- /dev/null
+++ b/src/energy/emissions.ts
@@ -0,0 +1,22 @@
+/** Emissions module — tsb analytics library. */
+
+/** Options for Emissions. */
+export interface EmissionsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Emissions. */
+export interface EmissionsResult { values: number[]; converged: boolean; }
+
+/** Compute Emissions. */
+export function computeEmissions(data: number[], opts: EmissionsOptions = {}): EmissionsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEmissions };
diff --git a/src/energy/experimental.ts b/src/energy/experimental.ts
new file mode 100644
index 000000000..2adb03a23
--- /dev/null
+++ b/src/energy/experimental.ts
@@ -0,0 +1,15 @@
+/** Energy Experimental module — tsb analytics library. */
+export interface Energy experimentalOptions { tol?: number; maxIter?: number; }
+export interface Energy experimentalResult { values: number[]; converged: boolean; }
+export function computeEnergy experimental(data: number[], opts: Energy experimentalOptions = {}): Energy experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy experimental };
diff --git a/src/energy/fast.ts b/src/energy/fast.ts
new file mode 100644
index 000000000..92e8b89e2
--- /dev/null
+++ b/src/energy/fast.ts
@@ -0,0 +1,15 @@
+/** Energy Fast module — tsb analytics library. */
+export interface Energy fastOptions { tol?: number; maxIter?: number; }
+export interface Energy fastResult { values: number[]; converged: boolean; }
+export function computeEnergy fast(data: number[], opts: Energy fastOptions = {}): Energy fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy fast };
diff --git a/src/energy/flexibility.ts b/src/energy/flexibility.ts
new file mode 100644
index 000000000..7a806b771
--- /dev/null
+++ b/src/energy/flexibility.ts
@@ -0,0 +1,22 @@
+/** Flexibility module — tsb analytics library. */
+
+/** Options for Flexibility. */
+export interface FlexibilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Flexibility. */
+export interface FlexibilityResult { values: number[]; converged: boolean; }
+
+/** Compute Flexibility. */
+export function computeFlexibility(data: number[], opts: FlexibilityOptions = {}): FlexibilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFlexibility };
diff --git a/src/energy/fossil_fuel.ts b/src/energy/fossil_fuel.ts
new file mode 100644
index 000000000..0447a77bf
--- /dev/null
+++ b/src/energy/fossil_fuel.ts
@@ -0,0 +1,22 @@
+/** Fossil Fuel module — tsb analytics library. */
+
+/** Options for Fossil Fuel. */
+export interface FossilFuelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fossil Fuel. */
+export interface FossilFuelResult { values: number[]; converged: boolean; }
+
+/** Compute Fossil Fuel. */
+export function computeFossilFuel(data: number[], opts: FossilFuelOptions = {}): FossilFuelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFossilFuel };
diff --git a/src/energy/future.ts b/src/energy/future.ts
new file mode 100644
index 000000000..4b6e76d89
--- /dev/null
+++ b/src/energy/future.ts
@@ -0,0 +1,15 @@
+/** Energy Future module — tsb analytics library. */
+export interface Energy futureOptions { tol?: number; maxIter?: number; }
+export interface Energy futureResult { values: number[]; converged: boolean; }
+export function computeEnergy future(data: number[], opts: Energy futureOptions = {}): Energy futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy future };
diff --git a/src/energy/gas.ts b/src/energy/gas.ts
new file mode 100644
index 000000000..b152d243d
--- /dev/null
+++ b/src/energy/gas.ts
@@ -0,0 +1,22 @@
+/** Gas module — tsb analytics library. */
+
+/** Options for Gas. */
+export interface GasOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gas. */
+export interface GasResult { values: number[]; converged: boolean; }
+
+/** Compute Gas. */
+export function computeGas(data: number[], opts: GasOptions = {}): GasResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGas };
diff --git a/src/energy/generation.ts b/src/energy/generation.ts
new file mode 100644
index 000000000..2b8e594c8
--- /dev/null
+++ b/src/energy/generation.ts
@@ -0,0 +1,22 @@
+/** Generation module — tsb analytics library. */
+
+/** Options for Generation. */
+export interface GenerationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Generation. */
+export interface GenerationResult { values: number[]; converged: boolean; }
+
+/** Compute Generation. */
+export function computeGeneration(data: number[], opts: GenerationOptions = {}): GenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeneration };
diff --git a/src/energy/geothermal.ts b/src/energy/geothermal.ts
new file mode 100644
index 000000000..386cb4203
--- /dev/null
+++ b/src/energy/geothermal.ts
@@ -0,0 +1,22 @@
+/** Geothermal module — tsb analytics library. */
+
+/** Options for Geothermal. */
+export interface GeothermalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Geothermal. */
+export interface GeothermalResult { values: number[]; converged: boolean; }
+
+/** Compute Geothermal. */
+export function computeGeothermal(data: number[], opts: GeothermalOptions = {}): GeothermalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeothermal };
diff --git a/src/energy/gpu.ts b/src/energy/gpu.ts
new file mode 100644
index 000000000..9671fcae3
--- /dev/null
+++ b/src/energy/gpu.ts
@@ -0,0 +1,15 @@
+/** Energy Gpu module — tsb analytics library. */
+export interface Energy gpuOptions { tol?: number; maxIter?: number; }
+export interface Energy gpuResult { values: number[]; converged: boolean; }
+export function computeEnergy gpu(data: number[], opts: Energy gpuOptions = {}): Energy gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy gpu };
diff --git a/src/energy/grid.ts b/src/energy/grid.ts
new file mode 100644
index 000000000..bedf0e6b2
--- /dev/null
+++ b/src/energy/grid.ts
@@ -0,0 +1,22 @@
+/** Grid module — tsb analytics library. */
+
+/** Options for Grid. */
+export interface GridOptions { tol?: number; maxIter?: number; }
+
+/** Result from Grid. */
+export interface GridResult { values: number[]; converged: boolean; }
+
+/** Compute Grid. */
+export function computeGrid(data: number[], opts: GridOptions = {}): GridResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGrid };
diff --git a/src/energy/hydro.ts b/src/energy/hydro.ts
new file mode 100644
index 000000000..234244316
--- /dev/null
+++ b/src/energy/hydro.ts
@@ -0,0 +1,22 @@
+/** Hydro module — tsb analytics library. */
+
+/** Options for Hydro. */
+export interface HydroOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hydro. */
+export interface HydroResult { values: number[]; converged: boolean; }
+
+/** Compute Hydro. */
+export function computeHydro(data: number[], opts: HydroOptions = {}): HydroResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHydro };
diff --git a/src/energy/industry_energy.ts b/src/energy/industry_energy.ts
new file mode 100644
index 000000000..10d2347bd
--- /dev/null
+++ b/src/energy/industry_energy.ts
@@ -0,0 +1,22 @@
+/** Industry Energy module — tsb analytics library. */
+
+/** Options for Industry Energy. */
+export interface IndustryEnergyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Industry Energy. */
+export interface IndustryEnergyResult { values: number[]; converged: boolean; }
+
+/** Compute Industry Energy. */
+export function computeIndustryEnergy(data: number[], opts: IndustryEnergyOptions = {}): IndustryEnergyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIndustryEnergy };
diff --git a/src/energy/large.ts b/src/energy/large.ts
new file mode 100644
index 000000000..67944dc60
--- /dev/null
+++ b/src/energy/large.ts
@@ -0,0 +1,15 @@
+/** Energy Large module — tsb analytics library. */
+export interface Energy largeOptions { tol?: number; maxIter?: number; }
+export interface Energy largeResult { values: number[]; converged: boolean; }
+export function computeEnergy large(data: number[], opts: Energy largeOptions = {}): Energy largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy large };
diff --git a/src/energy/legacy.ts b/src/energy/legacy.ts
new file mode 100644
index 000000000..d0f2009b7
--- /dev/null
+++ b/src/energy/legacy.ts
@@ -0,0 +1,15 @@
+/** Energy Legacy module — tsb analytics library. */
+export interface Energy legacyOptions { tol?: number; maxIter?: number; }
+export interface Energy legacyResult { values: number[]; converged: boolean; }
+export function computeEnergy legacy(data: number[], opts: Energy legacyOptions = {}): Energy legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy legacy };
diff --git a/src/energy/lite.ts b/src/energy/lite.ts
new file mode 100644
index 000000000..b207543ff
--- /dev/null
+++ b/src/energy/lite.ts
@@ -0,0 +1,15 @@
+/** Energy Lite module — tsb analytics library. */
+export interface Energy liteOptions { tol?: number; maxIter?: number; }
+export interface Energy liteResult { values: number[]; converged: boolean; }
+export function computeEnergy lite(data: number[], opts: Energy liteOptions = {}): Energy liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy lite };
diff --git a/src/energy/market_energy.ts b/src/energy/market_energy.ts
new file mode 100644
index 000000000..cedc60496
--- /dev/null
+++ b/src/energy/market_energy.ts
@@ -0,0 +1,22 @@
+/** Market Energy module — tsb analytics library. */
+
+/** Options for Market Energy. */
+export interface MarketEnergyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Market Energy. */
+export interface MarketEnergyResult { values: number[]; converged: boolean; }
+
+/** Compute Market Energy. */
+export function computeMarketEnergy(data: number[], opts: MarketEnergyOptions = {}): MarketEnergyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMarketEnergy };
diff --git a/src/energy/mini.ts b/src/energy/mini.ts
new file mode 100644
index 000000000..89841b55f
--- /dev/null
+++ b/src/energy/mini.ts
@@ -0,0 +1,15 @@
+/** Energy Mini module — tsb analytics library. */
+export interface Energy miniOptions { tol?: number; maxIter?: number; }
+export interface Energy miniResult { values: number[]; converged: boolean; }
+export function computeEnergy mini(data: number[], opts: Energy miniOptions = {}): Energy miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy mini };
diff --git a/src/energy/next.ts b/src/energy/next.ts
new file mode 100644
index 000000000..e44a0559b
--- /dev/null
+++ b/src/energy/next.ts
@@ -0,0 +1,15 @@
+/** Energy Next module — tsb analytics library. */
+export interface Energy nextOptions { tol?: number; maxIter?: number; }
+export interface Energy nextResult { values: number[]; converged: boolean; }
+export function computeEnergy next(data: number[], opts: Energy nextOptions = {}): Energy nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy next };
diff --git a/src/energy/nuclear_energy.ts b/src/energy/nuclear_energy.ts
new file mode 100644
index 000000000..1ebbb81e7
--- /dev/null
+++ b/src/energy/nuclear_energy.ts
@@ -0,0 +1,22 @@
+/** Nuclear Energy module — tsb analytics library. */
+
+/** Options for Nuclear Energy. */
+export interface NuclearEnergyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nuclear Energy. */
+export interface NuclearEnergyResult { values: number[]; converged: boolean; }
+
+/** Compute Nuclear Energy. */
+export function computeNuclearEnergy(data: number[], opts: NuclearEnergyOptions = {}): NuclearEnergyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNuclearEnergy };
diff --git a/src/energy/oil.ts b/src/energy/oil.ts
new file mode 100644
index 000000000..b343b3636
--- /dev/null
+++ b/src/energy/oil.ts
@@ -0,0 +1,22 @@
+/** Oil module — tsb analytics library. */
+
+/** Options for Oil. */
+export interface OilOptions { tol?: number; maxIter?: number; }
+
+/** Result from Oil. */
+export interface OilResult { values: number[]; converged: boolean; }
+
+/** Compute Oil. */
+export function computeOil(data: number[], opts: OilOptions = {}): OilResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOil };
diff --git a/src/energy/online.ts b/src/energy/online.ts
new file mode 100644
index 000000000..89e8fcf0f
--- /dev/null
+++ b/src/energy/online.ts
@@ -0,0 +1,15 @@
+/** Energy Online module — tsb analytics library. */
+export interface Energy onlineOptions { tol?: number; maxIter?: number; }
+export interface Energy onlineResult { values: number[]; converged: boolean; }
+export function computeEnergy online(data: number[], opts: Energy onlineOptions = {}): Energy onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy online };
diff --git a/src/energy/parallel.ts b/src/energy/parallel.ts
new file mode 100644
index 000000000..e9eafbb0c
--- /dev/null
+++ b/src/energy/parallel.ts
@@ -0,0 +1,15 @@
+/** Energy Parallel module — tsb analytics library. */
+export interface Energy parallelOptions { tol?: number; maxIter?: number; }
+export interface Energy parallelResult { values: number[]; converged: boolean; }
+export function computeEnergy parallel(data: number[], opts: Energy parallelOptions = {}): Energy parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy parallel };
diff --git a/src/energy/planning_energy.ts b/src/energy/planning_energy.ts
new file mode 100644
index 000000000..a37a58d64
--- /dev/null
+++ b/src/energy/planning_energy.ts
@@ -0,0 +1,22 @@
+/** Planning Energy module — tsb analytics library. */
+
+/** Options for Planning Energy. */
+export interface PlanningEnergyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Planning Energy. */
+export interface PlanningEnergyResult { values: number[]; converged: boolean; }
+
+/** Compute Planning Energy. */
+export function computePlanningEnergy(data: number[], opts: PlanningEnergyOptions = {}): PlanningEnergyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePlanningEnergy };
diff --git a/src/energy/plus.ts b/src/energy/plus.ts
new file mode 100644
index 000000000..3a4a201fa
--- /dev/null
+++ b/src/energy/plus.ts
@@ -0,0 +1,15 @@
+/** Energy Plus module — tsb analytics library. */
+export interface Energy plusOptions { tol?: number; maxIter?: number; }
+export interface Energy plusResult { values: number[]; converged: boolean; }
+export function computeEnergy plus(data: number[], opts: Energy plusOptions = {}): Energy plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy plus };
diff --git a/src/energy/policy_energy.ts b/src/energy/policy_energy.ts
new file mode 100644
index 000000000..9f15e6356
--- /dev/null
+++ b/src/energy/policy_energy.ts
@@ -0,0 +1,22 @@
+/** Policy Energy module — tsb analytics library. */
+
+/** Options for Policy Energy. */
+export interface PolicyEnergyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Policy Energy. */
+export interface PolicyEnergyResult { values: number[]; converged: boolean; }
+
+/** Compute Policy Energy. */
+export function computePolicyEnergy(data: number[], opts: PolicyEnergyOptions = {}): PolicyEnergyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePolicyEnergy };
diff --git a/src/energy/pro.ts b/src/energy/pro.ts
new file mode 100644
index 000000000..38e0662e8
--- /dev/null
+++ b/src/energy/pro.ts
@@ -0,0 +1,15 @@
+/** Energy Pro module — tsb analytics library. */
+export interface Energy proOptions { tol?: number; maxIter?: number; }
+export interface Energy proResult { values: number[]; converged: boolean; }
+export function computeEnergy pro(data: number[], opts: Energy proOptions = {}): Energy proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy pro };
diff --git a/src/energy/renewable.ts b/src/energy/renewable.ts
new file mode 100644
index 000000000..71d62ad35
--- /dev/null
+++ b/src/energy/renewable.ts
@@ -0,0 +1,22 @@
+/** Renewable module — tsb analytics library. */
+
+/** Options for Renewable. */
+export interface RenewableOptions { tol?: number; maxIter?: number; }
+
+/** Result from Renewable. */
+export interface RenewableResult { values: number[]; converged: boolean; }
+
+/** Compute Renewable. */
+export function computeRenewable(data: number[], opts: RenewableOptions = {}): RenewableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRenewable };
diff --git a/src/energy/robust.ts b/src/energy/robust.ts
new file mode 100644
index 000000000..4fd15c747
--- /dev/null
+++ b/src/energy/robust.ts
@@ -0,0 +1,15 @@
+/** Energy Robust module — tsb analytics library. */
+export interface Energy robustOptions { tol?: number; maxIter?: number; }
+export interface Energy robustResult { values: number[]; converged: boolean; }
+export function computeEnergy robust(data: number[], opts: Energy robustOptions = {}): Energy robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy robust };
diff --git a/src/energy/small.ts b/src/energy/small.ts
new file mode 100644
index 000000000..7bc6363b9
--- /dev/null
+++ b/src/energy/small.ts
@@ -0,0 +1,15 @@
+/** Energy Small module — tsb analytics library. */
+export interface Energy smallOptions { tol?: number; maxIter?: number; }
+export interface Energy smallResult { values: number[]; converged: boolean; }
+export function computeEnergy small(data: number[], opts: Energy smallOptions = {}): Energy smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy small };
diff --git a/src/energy/smart_grid.ts b/src/energy/smart_grid.ts
new file mode 100644
index 000000000..ccc4a1448
--- /dev/null
+++ b/src/energy/smart_grid.ts
@@ -0,0 +1,22 @@
+/** Smart Grid module — tsb analytics library. */
+
+/** Options for Smart Grid. */
+export interface SmartGridOptions { tol?: number; maxIter?: number; }
+
+/** Result from Smart Grid. */
+export interface SmartGridResult { values: number[]; converged: boolean; }
+
+/** Compute Smart Grid. */
+export function computeSmartGrid(data: number[], opts: SmartGridOptions = {}): SmartGridResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSmartGrid };
diff --git a/src/energy/solar.ts b/src/energy/solar.ts
new file mode 100644
index 000000000..59e46f03d
--- /dev/null
+++ b/src/energy/solar.ts
@@ -0,0 +1,22 @@
+/** Solar module — tsb analytics library. */
+
+/** Options for Solar. */
+export interface SolarOptions { tol?: number; maxIter?: number; }
+
+/** Result from Solar. */
+export interface SolarResult { values: number[]; converged: boolean; }
+
+/** Compute Solar. */
+export function computeSolar(data: number[], opts: SolarOptions = {}): SolarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSolar };
diff --git a/src/energy/sparse.ts b/src/energy/sparse.ts
new file mode 100644
index 000000000..a68b1db18
--- /dev/null
+++ b/src/energy/sparse.ts
@@ -0,0 +1,15 @@
+/** Energy Sparse module — tsb analytics library. */
+export interface Energy sparseOptions { tol?: number; maxIter?: number; }
+export interface Energy sparseResult { values: number[]; converged: boolean; }
+export function computeEnergy sparse(data: number[], opts: Energy sparseOptions = {}): Energy sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy sparse };
diff --git a/src/energy/stable.ts b/src/energy/stable.ts
new file mode 100644
index 000000000..e2ec4c0e6
--- /dev/null
+++ b/src/energy/stable.ts
@@ -0,0 +1,15 @@
+/** Energy Stable module — tsb analytics library. */
+export interface Energy stableOptions { tol?: number; maxIter?: number; }
+export interface Energy stableResult { values: number[]; converged: boolean; }
+export function computeEnergy stable(data: number[], opts: Energy stableOptions = {}): Energy stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy stable };
diff --git a/src/energy/storage.ts b/src/energy/storage.ts
new file mode 100644
index 000000000..640228639
--- /dev/null
+++ b/src/energy/storage.ts
@@ -0,0 +1,22 @@
+/** Storage module — tsb analytics library. */
+
+/** Options for Storage. */
+export interface StorageOptions { tol?: number; maxIter?: number; }
+
+/** Result from Storage. */
+export interface StorageResult { values: number[]; converged: boolean; }
+
+/** Compute Storage. */
+export function computeStorage(data: number[], opts: StorageOptions = {}): StorageResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStorage };
diff --git a/src/energy/streaming.ts b/src/energy/streaming.ts
new file mode 100644
index 000000000..5b051919a
--- /dev/null
+++ b/src/energy/streaming.ts
@@ -0,0 +1,15 @@
+/** Energy Streaming module — tsb analytics library. */
+export interface Energy streamingOptions { tol?: number; maxIter?: number; }
+export interface Energy streamingResult { values: number[]; converged: boolean; }
+export function computeEnergy streaming(data: number[], opts: Energy streamingOptions = {}): Energy streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy streaming };
diff --git a/src/energy/transmission.ts b/src/energy/transmission.ts
new file mode 100644
index 000000000..ee1edbd30
--- /dev/null
+++ b/src/energy/transmission.ts
@@ -0,0 +1,22 @@
+/** Transmission module — tsb analytics library. */
+
+/** Options for Transmission. */
+export interface TransmissionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Transmission. */
+export interface TransmissionResult { values: number[]; converged: boolean; }
+
+/** Compute Transmission. */
+export function computeTransmission(data: number[], opts: TransmissionOptions = {}): TransmissionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTransmission };
diff --git a/src/energy/transport_energy.ts b/src/energy/transport_energy.ts
new file mode 100644
index 000000000..f564543f3
--- /dev/null
+++ b/src/energy/transport_energy.ts
@@ -0,0 +1,22 @@
+/** Transport Energy module — tsb analytics library. */
+
+/** Options for Transport Energy. */
+export interface TransportEnergyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Transport Energy. */
+export interface TransportEnergyResult { values: number[]; converged: boolean; }
+
+/** Compute Transport Energy. */
+export function computeTransportEnergy(data: number[], opts: TransportEnergyOptions = {}): TransportEnergyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTransportEnergy };
diff --git a/src/energy/v2.ts b/src/energy/v2.ts
new file mode 100644
index 000000000..a42edf0e3
--- /dev/null
+++ b/src/energy/v2.ts
@@ -0,0 +1,15 @@
+/** Energy V2 module — tsb analytics library. */
+export interface Energy v2Options { tol?: number; maxIter?: number; }
+export interface Energy v2Result { values: number[]; converged: boolean; }
+export function computeEnergy v2(data: number[], opts: Energy v2Options = {}): Energy v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy v2 };
diff --git a/src/energy/v3.ts b/src/energy/v3.ts
new file mode 100644
index 000000000..9bdc00d0f
--- /dev/null
+++ b/src/energy/v3.ts
@@ -0,0 +1,15 @@
+/** Energy V3 module — tsb analytics library. */
+export interface Energy v3Options { tol?: number; maxIter?: number; }
+export interface Energy v3Result { values: number[]; converged: boolean; }
+export function computeEnergy v3(data: number[], opts: Energy v3Options = {}): Energy v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy v3 };
diff --git a/src/energy/wasm.ts b/src/energy/wasm.ts
new file mode 100644
index 000000000..86e837114
--- /dev/null
+++ b/src/energy/wasm.ts
@@ -0,0 +1,15 @@
+/** Energy Wasm module — tsb analytics library. */
+export interface Energy wasmOptions { tol?: number; maxIter?: number; }
+export interface Energy wasmResult { values: number[]; converged: boolean; }
+export function computeEnergy wasm(data: number[], opts: Energy wasmOptions = {}): Energy wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy wasm };
diff --git a/src/energy/wind.ts b/src/energy/wind.ts
new file mode 100644
index 000000000..1b1abca4b
--- /dev/null
+++ b/src/energy/wind.ts
@@ -0,0 +1,22 @@
+/** Wind module — tsb analytics library. */
+
+/** Options for Wind. */
+export interface WindOptions { tol?: number; maxIter?: number; }
+
+/** Result from Wind. */
+export interface WindResult { values: number[]; converged: boolean; }
+
+/** Compute Wind. */
+export function computeWind(data: number[], opts: WindOptions = {}): WindResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWind };
diff --git a/src/energy/xlarge.ts b/src/energy/xlarge.ts
new file mode 100644
index 000000000..f24e966c9
--- /dev/null
+++ b/src/energy/xlarge.ts
@@ -0,0 +1,15 @@
+/** Energy Xlarge module — tsb analytics library. */
+export interface Energy xlargeOptions { tol?: number; maxIter?: number; }
+export interface Energy xlargeResult { values: number[]; converged: boolean; }
+export function computeEnergy xlarge(data: number[], opts: Energy xlargeOptions = {}): Energy xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnergy xlarge };
diff --git a/src/enzymology/adaptation.ts b/src/enzymology/adaptation.ts
new file mode 100644
index 000000000..f170f1b8a
--- /dev/null
+++ b/src/enzymology/adaptation.ts
@@ -0,0 +1,14 @@
+/** enzymology adaptation module — tsb analytics library. */
+export interface EnzymologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyAdaptation(data: number[], opts: EnzymologyAdaptationOptions = {}): EnzymologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyAdaptation };
diff --git a/src/enzymology/aggregation.ts b/src/enzymology/aggregation.ts
new file mode 100644
index 000000000..8cc951718
--- /dev/null
+++ b/src/enzymology/aggregation.ts
@@ -0,0 +1,14 @@
+/** enzymology aggregation module — tsb analytics library. */
+export interface EnzymologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyAggregationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyAggregation(data: number[], opts: EnzymologyAggregationOptions = {}): EnzymologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyAggregation };
diff --git a/src/enzymology/algebra.ts b/src/enzymology/algebra.ts
new file mode 100644
index 000000000..85189696a
--- /dev/null
+++ b/src/enzymology/algebra.ts
@@ -0,0 +1,14 @@
+/** enzymology algebra module — tsb analytics library. */
+export interface EnzymologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeEnzymologyAlgebra(data: number[], opts: EnzymologyAlgebraOptions = {}): EnzymologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyAlgebra };
diff --git a/src/enzymology/alignment.ts b/src/enzymology/alignment.ts
new file mode 100644
index 000000000..4d19fe63f
--- /dev/null
+++ b/src/enzymology/alignment.ts
@@ -0,0 +1,14 @@
+/** enzymology alignment module — tsb analytics library. */
+export interface EnzymologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeEnzymologyAlignment(data: number[], opts: EnzymologyAlignmentOptions = {}): EnzymologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyAlignment };
diff --git a/src/enzymology/analysis.ts b/src/enzymology/analysis.ts
new file mode 100644
index 000000000..ef5bf04b7
--- /dev/null
+++ b/src/enzymology/analysis.ts
@@ -0,0 +1,14 @@
+/** enzymology analysis module — tsb analytics library. */
+export interface EnzymologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeEnzymologyAnalysis(data: number[], opts: EnzymologyAnalysisOptions = {}): EnzymologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyAnalysis };
diff --git a/src/enzymology/augmentation.ts b/src/enzymology/augmentation.ts
new file mode 100644
index 000000000..bb1454f0e
--- /dev/null
+++ b/src/enzymology/augmentation.ts
@@ -0,0 +1,14 @@
+/** enzymology augmentation module — tsb analytics library. */
+export interface EnzymologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyAugmentation(data: number[], opts: EnzymologyAugmentationOptions = {}): EnzymologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyAugmentation };
diff --git a/src/enzymology/bagging.ts b/src/enzymology/bagging.ts
new file mode 100644
index 000000000..48a9d2a1a
--- /dev/null
+++ b/src/enzymology/bagging.ts
@@ -0,0 +1,14 @@
+/** enzymology bagging module — tsb analytics library. */
+export interface EnzymologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyBaggingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyBagging(data: number[], opts: EnzymologyBaggingOptions = {}): EnzymologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyBagging };
diff --git a/src/enzymology/basis.ts b/src/enzymology/basis.ts
new file mode 100644
index 000000000..2d36b1eb3
--- /dev/null
+++ b/src/enzymology/basis.ts
@@ -0,0 +1,14 @@
+/** enzymology basis module — tsb analytics library. */
+export interface EnzymologyBasisOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyBasisResult { values: number[]; converged: boolean; }
+export function computeEnzymologyBasis(data: number[], opts: EnzymologyBasisOptions = {}): EnzymologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyBasis };
diff --git a/src/enzymology/benchmarking.ts b/src/enzymology/benchmarking.ts
new file mode 100644
index 000000000..c88102ce5
--- /dev/null
+++ b/src/enzymology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** enzymology benchmarking module — tsb analytics library. */
+export interface EnzymologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyBenchmarking(data: number[], opts: EnzymologyBenchmarkingOptions = {}): EnzymologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyBenchmarking };
diff --git a/src/enzymology/blending.ts b/src/enzymology/blending.ts
new file mode 100644
index 000000000..36424843d
--- /dev/null
+++ b/src/enzymology/blending.ts
@@ -0,0 +1,14 @@
+/** enzymology blending module — tsb analytics library. */
+export interface EnzymologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyBlendingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyBlending(data: number[], opts: EnzymologyBlendingOptions = {}): EnzymologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyBlending };
diff --git a/src/enzymology/boosting.ts b/src/enzymology/boosting.ts
new file mode 100644
index 000000000..97eed0354
--- /dev/null
+++ b/src/enzymology/boosting.ts
@@ -0,0 +1,14 @@
+/** enzymology boosting module — tsb analytics library. */
+export interface EnzymologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyBoostingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyBoosting(data: number[], opts: EnzymologyBoostingOptions = {}): EnzymologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyBoosting };
diff --git a/src/enzymology/bootstrap.ts b/src/enzymology/bootstrap.ts
new file mode 100644
index 000000000..d2326b1f2
--- /dev/null
+++ b/src/enzymology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** enzymology bootstrap module — tsb analytics library. */
+export interface EnzymologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeEnzymologyBootstrap(data: number[], opts: EnzymologyBootstrapOptions = {}): EnzymologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyBootstrap };
diff --git a/src/enzymology/calculus.ts b/src/enzymology/calculus.ts
new file mode 100644
index 000000000..c00b0ecb5
--- /dev/null
+++ b/src/enzymology/calculus.ts
@@ -0,0 +1,14 @@
+/** enzymology calculus module — tsb analytics library. */
+export interface EnzymologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyCalculusResult { values: number[]; converged: boolean; }
+export function computeEnzymologyCalculus(data: number[], opts: EnzymologyCalculusOptions = {}): EnzymologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyCalculus };
diff --git a/src/enzymology/calibration.ts b/src/enzymology/calibration.ts
new file mode 100644
index 000000000..acb825eb3
--- /dev/null
+++ b/src/enzymology/calibration.ts
@@ -0,0 +1,14 @@
+/** enzymology calibration module — tsb analytics library. */
+export interface EnzymologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyCalibration(data: number[], opts: EnzymologyCalibrationOptions = {}): EnzymologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyCalibration };
diff --git a/src/enzymology/characterization.ts b/src/enzymology/characterization.ts
new file mode 100644
index 000000000..eb59888ec
--- /dev/null
+++ b/src/enzymology/characterization.ts
@@ -0,0 +1,14 @@
+/** enzymology characterization module — tsb analytics library. */
+export interface EnzymologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyCharacterization(data: number[], opts: EnzymologyCharacterizationOptions = {}): EnzymologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyCharacterization };
diff --git a/src/enzymology/classification.ts b/src/enzymology/classification.ts
new file mode 100644
index 000000000..5cc3e9ece
--- /dev/null
+++ b/src/enzymology/classification.ts
@@ -0,0 +1,14 @@
+/** enzymology classification module — tsb analytics library. */
+export interface EnzymologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyClassificationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyClassification(data: number[], opts: EnzymologyClassificationOptions = {}): EnzymologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyClassification };
diff --git a/src/enzymology/clustering.ts b/src/enzymology/clustering.ts
new file mode 100644
index 000000000..961b9d277
--- /dev/null
+++ b/src/enzymology/clustering.ts
@@ -0,0 +1,14 @@
+/** enzymology clustering module — tsb analytics library. */
+export interface EnzymologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyClusteringResult { values: number[]; converged: boolean; }
+export function computeEnzymologyClustering(data: number[], opts: EnzymologyClusteringOptions = {}): EnzymologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyClustering };
diff --git a/src/enzymology/compression.ts b/src/enzymology/compression.ts
new file mode 100644
index 000000000..ac826df6b
--- /dev/null
+++ b/src/enzymology/compression.ts
@@ -0,0 +1,14 @@
+/** enzymology compression module — tsb analytics library. */
+export interface EnzymologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyCompressionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyCompression(data: number[], opts: EnzymologyCompressionOptions = {}): EnzymologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyCompression };
diff --git a/src/enzymology/continuous.ts b/src/enzymology/continuous.ts
new file mode 100644
index 000000000..aa2af7195
--- /dev/null
+++ b/src/enzymology/continuous.ts
@@ -0,0 +1,14 @@
+/** enzymology continuous module — tsb analytics library. */
+export interface EnzymologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyContinuousResult { values: number[]; converged: boolean; }
+export function computeEnzymologyContinuous(data: number[], opts: EnzymologyContinuousOptions = {}): EnzymologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyContinuous };
diff --git a/src/enzymology/control.ts b/src/enzymology/control.ts
new file mode 100644
index 000000000..0d767e260
--- /dev/null
+++ b/src/enzymology/control.ts
@@ -0,0 +1,14 @@
+/** enzymology control module — tsb analytics library. */
+export interface EnzymologyControlOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyControlResult { values: number[]; converged: boolean; }
+export function computeEnzymologyControl(data: number[], opts: EnzymologyControlOptions = {}): EnzymologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyControl };
diff --git a/src/enzymology/convergence.ts b/src/enzymology/convergence.ts
new file mode 100644
index 000000000..7113fefa6
--- /dev/null
+++ b/src/enzymology/convergence.ts
@@ -0,0 +1,14 @@
+/** enzymology convergence module — tsb analytics library. */
+export interface EnzymologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeEnzymologyConvergence(data: number[], opts: EnzymologyConvergenceOptions = {}): EnzymologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyConvergence };
diff --git a/src/enzymology/convex.ts b/src/enzymology/convex.ts
new file mode 100644
index 000000000..74a6ee670
--- /dev/null
+++ b/src/enzymology/convex.ts
@@ -0,0 +1,14 @@
+/** enzymology convex module — tsb analytics library. */
+export interface EnzymologyConvexOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyConvexResult { values: number[]; converged: boolean; }
+export function computeEnzymologyConvex(data: number[], opts: EnzymologyConvexOptions = {}): EnzymologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyConvex };
diff --git a/src/enzymology/correlation.ts b/src/enzymology/correlation.ts
new file mode 100644
index 000000000..4d63a1a1c
--- /dev/null
+++ b/src/enzymology/correlation.ts
@@ -0,0 +1,14 @@
+/** enzymology correlation module — tsb analytics library. */
+export interface EnzymologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyCorrelation(data: number[], opts: EnzymologyCorrelationOptions = {}): EnzymologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyCorrelation };
diff --git a/src/enzymology/covariance.ts b/src/enzymology/covariance.ts
new file mode 100644
index 000000000..d933ddc45
--- /dev/null
+++ b/src/enzymology/covariance.ts
@@ -0,0 +1,14 @@
+/** enzymology covariance module — tsb analytics library. */
+export interface EnzymologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeEnzymologyCovariance(data: number[], opts: EnzymologyCovarianceOptions = {}): EnzymologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyCovariance };
diff --git a/src/enzymology/cross_validation.ts b/src/enzymology/cross_validation.ts
new file mode 100644
index 000000000..a66f43f0a
--- /dev/null
+++ b/src/enzymology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** enzymology cross_validation module — tsb analytics library. */
+export interface EnzymologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyCrossValidation(data: number[], opts: EnzymologyCrossValidationOptions = {}): EnzymologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyCrossValidation };
diff --git a/src/enzymology/decoding.ts b/src/enzymology/decoding.ts
new file mode 100644
index 000000000..e3a1f9fbe
--- /dev/null
+++ b/src/enzymology/decoding.ts
@@ -0,0 +1,14 @@
+/** enzymology decoding module — tsb analytics library. */
+export interface EnzymologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDecodingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDecoding(data: number[], opts: EnzymologyDecodingOptions = {}): EnzymologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDecoding };
diff --git a/src/enzymology/decomposition.ts b/src/enzymology/decomposition.ts
new file mode 100644
index 000000000..a4f15830d
--- /dev/null
+++ b/src/enzymology/decomposition.ts
@@ -0,0 +1,14 @@
+/** enzymology decomposition module — tsb analytics library. */
+export interface EnzymologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDecomposition(data: number[], opts: EnzymologyDecompositionOptions = {}): EnzymologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDecomposition };
diff --git a/src/enzymology/detection.ts b/src/enzymology/detection.ts
new file mode 100644
index 000000000..39468066f
--- /dev/null
+++ b/src/enzymology/detection.ts
@@ -0,0 +1,14 @@
+/** enzymology detection module — tsb analytics library. */
+export interface EnzymologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDetectionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDetection(data: number[], opts: EnzymologyDetectionOptions = {}): EnzymologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDetection };
diff --git a/src/enzymology/deterministic.ts b/src/enzymology/deterministic.ts
new file mode 100644
index 000000000..83977a35f
--- /dev/null
+++ b/src/enzymology/deterministic.ts
@@ -0,0 +1,14 @@
+/** enzymology deterministic module — tsb analytics library. */
+export interface EnzymologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDeterministic(data: number[], opts: EnzymologyDeterministicOptions = {}): EnzymologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDeterministic };
diff --git a/src/enzymology/diagnostics.ts b/src/enzymology/diagnostics.ts
new file mode 100644
index 000000000..848b0df00
--- /dev/null
+++ b/src/enzymology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** enzymology diagnostics module — tsb analytics library. */
+export interface EnzymologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDiagnostics(data: number[], opts: EnzymologyDiagnosticsOptions = {}): EnzymologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDiagnostics };
diff --git a/src/enzymology/differential.ts b/src/enzymology/differential.ts
new file mode 100644
index 000000000..e375b13f1
--- /dev/null
+++ b/src/enzymology/differential.ts
@@ -0,0 +1,14 @@
+/** enzymology differential module — tsb analytics library. */
+export interface EnzymologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDifferential(data: number[], opts: EnzymologyDifferentialOptions = {}): EnzymologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDifferential };
diff --git a/src/enzymology/discrete.ts b/src/enzymology/discrete.ts
new file mode 100644
index 000000000..b5f23b794
--- /dev/null
+++ b/src/enzymology/discrete.ts
@@ -0,0 +1,14 @@
+/** enzymology discrete module — tsb analytics library. */
+export interface EnzymologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDiscrete(data: number[], opts: EnzymologyDiscreteOptions = {}): EnzymologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDiscrete };
diff --git a/src/enzymology/distribution.ts b/src/enzymology/distribution.ts
new file mode 100644
index 000000000..0a32ad6f9
--- /dev/null
+++ b/src/enzymology/distribution.ts
@@ -0,0 +1,14 @@
+/** enzymology distribution module — tsb analytics library. */
+export interface EnzymologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDistributionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDistribution(data: number[], opts: EnzymologyDistributionOptions = {}): EnzymologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDistribution };
diff --git a/src/enzymology/dynamic.ts b/src/enzymology/dynamic.ts
new file mode 100644
index 000000000..a768a1206
--- /dev/null
+++ b/src/enzymology/dynamic.ts
@@ -0,0 +1,14 @@
+/** enzymology dynamic module — tsb analytics library. */
+export interface EnzymologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyDynamicResult { values: number[]; converged: boolean; }
+export function computeEnzymologyDynamic(data: number[], opts: EnzymologyDynamicOptions = {}): EnzymologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyDynamic };
diff --git a/src/enzymology/embedding.ts b/src/enzymology/embedding.ts
new file mode 100644
index 000000000..a2afe7379
--- /dev/null
+++ b/src/enzymology/embedding.ts
@@ -0,0 +1,14 @@
+/** enzymology embedding module — tsb analytics library. */
+export interface EnzymologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyEmbedding(data: number[], opts: EnzymologyEmbeddingOptions = {}): EnzymologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyEmbedding };
diff --git a/src/enzymology/encoding.ts b/src/enzymology/encoding.ts
new file mode 100644
index 000000000..004d91068
--- /dev/null
+++ b/src/enzymology/encoding.ts
@@ -0,0 +1,14 @@
+/** enzymology encoding module — tsb analytics library. */
+export interface EnzymologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyEncodingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyEncoding(data: number[], opts: EnzymologyEncodingOptions = {}): EnzymologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyEncoding };
diff --git a/src/enzymology/ensemble.ts b/src/enzymology/ensemble.ts
new file mode 100644
index 000000000..25328188b
--- /dev/null
+++ b/src/enzymology/ensemble.ts
@@ -0,0 +1,14 @@
+/** enzymology ensemble module — tsb analytics library. */
+export interface EnzymologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeEnzymologyEnsemble(data: number[], opts: EnzymologyEnsembleOptions = {}): EnzymologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyEnsemble };
diff --git a/src/enzymology/estimation.ts b/src/enzymology/estimation.ts
new file mode 100644
index 000000000..fa1bfcf64
--- /dev/null
+++ b/src/enzymology/estimation.ts
@@ -0,0 +1,14 @@
+/** enzymology estimation module — tsb analytics library. */
+export interface EnzymologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyEstimationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyEstimation(data: number[], opts: EnzymologyEstimationOptions = {}): EnzymologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyEstimation };
diff --git a/src/enzymology/evaluation.ts b/src/enzymology/evaluation.ts
new file mode 100644
index 000000000..14db3f3ee
--- /dev/null
+++ b/src/enzymology/evaluation.ts
@@ -0,0 +1,14 @@
+/** enzymology evaluation module — tsb analytics library. */
+export interface EnzymologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyEvaluation(data: number[], opts: EnzymologyEvaluationOptions = {}): EnzymologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyEvaluation };
diff --git a/src/enzymology/extrapolation.ts b/src/enzymology/extrapolation.ts
new file mode 100644
index 000000000..5a2e76dc8
--- /dev/null
+++ b/src/enzymology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** enzymology extrapolation module — tsb analytics library. */
+export interface EnzymologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyExtrapolation(data: number[], opts: EnzymologyExtrapolationOptions = {}): EnzymologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyExtrapolation };
diff --git a/src/enzymology/features.ts b/src/enzymology/features.ts
new file mode 100644
index 000000000..dcfb4400c
--- /dev/null
+++ b/src/enzymology/features.ts
@@ -0,0 +1,14 @@
+/** enzymology features module — tsb analytics library. */
+export interface EnzymologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeEnzymologyFeatures(data: number[], opts: EnzymologyFeaturesOptions = {}): EnzymologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyFeatures };
diff --git a/src/enzymology/feedback.ts b/src/enzymology/feedback.ts
new file mode 100644
index 000000000..6bcc31591
--- /dev/null
+++ b/src/enzymology/feedback.ts
@@ -0,0 +1,14 @@
+/** enzymology feedback module — tsb analytics library. */
+export interface EnzymologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeEnzymologyFeedback(data: number[], opts: EnzymologyFeedbackOptions = {}): EnzymologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyFeedback };
diff --git a/src/enzymology/filtering.ts b/src/enzymology/filtering.ts
new file mode 100644
index 000000000..df1b15156
--- /dev/null
+++ b/src/enzymology/filtering.ts
@@ -0,0 +1,14 @@
+/** enzymology filtering module — tsb analytics library. */
+export interface EnzymologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyFilteringResult { values: number[]; converged: boolean; }
+export function computeEnzymologyFiltering(data: number[], opts: EnzymologyFilteringOptions = {}): EnzymologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyFiltering };
diff --git a/src/enzymology/fourier.ts b/src/enzymology/fourier.ts
new file mode 100644
index 000000000..d872d6b67
--- /dev/null
+++ b/src/enzymology/fourier.ts
@@ -0,0 +1,14 @@
+/** enzymology fourier module — tsb analytics library. */
+export interface EnzymologyFourierOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyFourierResult { values: number[]; converged: boolean; }
+export function computeEnzymologyFourier(data: number[], opts: EnzymologyFourierOptions = {}): EnzymologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyFourier };
diff --git a/src/enzymology/fusion.ts b/src/enzymology/fusion.ts
new file mode 100644
index 000000000..18e0b00cc
--- /dev/null
+++ b/src/enzymology/fusion.ts
@@ -0,0 +1,14 @@
+/** enzymology fusion module — tsb analytics library. */
+export interface EnzymologyFusionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyFusionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyFusion(data: number[], opts: EnzymologyFusionOptions = {}): EnzymologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyFusion };
diff --git a/src/enzymology/generation.ts b/src/enzymology/generation.ts
new file mode 100644
index 000000000..675196ba8
--- /dev/null
+++ b/src/enzymology/generation.ts
@@ -0,0 +1,14 @@
+/** enzymology generation module — tsb analytics library. */
+export interface EnzymologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyGenerationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyGeneration(data: number[], opts: EnzymologyGenerationOptions = {}): EnzymologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyGeneration };
diff --git a/src/enzymology/geometry.ts b/src/enzymology/geometry.ts
new file mode 100644
index 000000000..3b5c3d42b
--- /dev/null
+++ b/src/enzymology/geometry.ts
@@ -0,0 +1,14 @@
+/** enzymology geometry module — tsb analytics library. */
+export interface EnzymologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyGeometryResult { values: number[]; converged: boolean; }
+export function computeEnzymologyGeometry(data: number[], opts: EnzymologyGeometryOptions = {}): EnzymologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyGeometry };
diff --git a/src/enzymology/gradient.ts b/src/enzymology/gradient.ts
new file mode 100644
index 000000000..7479af742
--- /dev/null
+++ b/src/enzymology/gradient.ts
@@ -0,0 +1,14 @@
+/** enzymology gradient module — tsb analytics library. */
+export interface EnzymologyGradientOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyGradientResult { values: number[]; converged: boolean; }
+export function computeEnzymologyGradient(data: number[], opts: EnzymologyGradientOptions = {}): EnzymologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyGradient };
diff --git a/src/enzymology/hessian.ts b/src/enzymology/hessian.ts
new file mode 100644
index 000000000..932751bc2
--- /dev/null
+++ b/src/enzymology/hessian.ts
@@ -0,0 +1,14 @@
+/** enzymology hessian module — tsb analytics library. */
+export interface EnzymologyHessianOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyHessianResult { values: number[]; converged: boolean; }
+export function computeEnzymologyHessian(data: number[], opts: EnzymologyHessianOptions = {}): EnzymologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyHessian };
diff --git a/src/enzymology/hypothesis.ts b/src/enzymology/hypothesis.ts
new file mode 100644
index 000000000..4194f3986
--- /dev/null
+++ b/src/enzymology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** enzymology hypothesis module — tsb analytics library. */
+export interface EnzymologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeEnzymologyHypothesis(data: number[], opts: EnzymologyHypothesisOptions = {}): EnzymologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyHypothesis };
diff --git a/src/enzymology/inference.ts b/src/enzymology/inference.ts
new file mode 100644
index 000000000..67b9983fb
--- /dev/null
+++ b/src/enzymology/inference.ts
@@ -0,0 +1,14 @@
+/** enzymology inference module — tsb analytics library. */
+export interface EnzymologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyInferenceResult { values: number[]; converged: boolean; }
+export function computeEnzymologyInference(data: number[], opts: EnzymologyInferenceOptions = {}): EnzymologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyInference };
diff --git a/src/enzymology/inference2.ts b/src/enzymology/inference2.ts
new file mode 100644
index 000000000..e89e55db1
--- /dev/null
+++ b/src/enzymology/inference2.ts
@@ -0,0 +1,14 @@
+/** enzymology inference2 module — tsb analytics library. */
+export interface EnzymologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyInferenceResult { values: number[]; converged: boolean; }
+export function computeEnzymologyInference(data: number[], opts: EnzymologyInferenceOptions = {}): EnzymologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyInference };
diff --git a/src/enzymology/integral.ts b/src/enzymology/integral.ts
new file mode 100644
index 000000000..7c9336752
--- /dev/null
+++ b/src/enzymology/integral.ts
@@ -0,0 +1,14 @@
+/** enzymology integral module — tsb analytics library. */
+export interface EnzymologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyIntegralResult { values: number[]; converged: boolean; }
+export function computeEnzymologyIntegral(data: number[], opts: EnzymologyIntegralOptions = {}): EnzymologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyIntegral };
diff --git a/src/enzymology/integration.ts b/src/enzymology/integration.ts
new file mode 100644
index 000000000..e330ab8f9
--- /dev/null
+++ b/src/enzymology/integration.ts
@@ -0,0 +1,14 @@
+/** enzymology integration module — tsb analytics library. */
+export interface EnzymologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyIntegration(data: number[], opts: EnzymologyIntegrationOptions = {}): EnzymologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyIntegration };
diff --git a/src/enzymology/interpolation.ts b/src/enzymology/interpolation.ts
new file mode 100644
index 000000000..3f886e9b8
--- /dev/null
+++ b/src/enzymology/interpolation.ts
@@ -0,0 +1,14 @@
+/** enzymology interpolation module — tsb analytics library. */
+export interface EnzymologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyInterpolation(data: number[], opts: EnzymologyInterpolationOptions = {}): EnzymologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyInterpolation };
diff --git a/src/enzymology/jacobian.ts b/src/enzymology/jacobian.ts
new file mode 100644
index 000000000..2a7977655
--- /dev/null
+++ b/src/enzymology/jacobian.ts
@@ -0,0 +1,14 @@
+/** enzymology jacobian module — tsb analytics library. */
+export interface EnzymologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyJacobianResult { values: number[]; converged: boolean; }
+export function computeEnzymologyJacobian(data: number[], opts: EnzymologyJacobianOptions = {}): EnzymologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyJacobian };
diff --git a/src/enzymology/kernel.ts b/src/enzymology/kernel.ts
new file mode 100644
index 000000000..a2ba878c1
--- /dev/null
+++ b/src/enzymology/kernel.ts
@@ -0,0 +1,14 @@
+/** enzymology kernel module — tsb analytics library. */
+export interface EnzymologyKernelOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyKernelResult { values: number[]; converged: boolean; }
+export function computeEnzymologyKernel(data: number[], opts: EnzymologyKernelOptions = {}): EnzymologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyKernel };
diff --git a/src/enzymology/laplacian.ts b/src/enzymology/laplacian.ts
new file mode 100644
index 000000000..6b378f69a
--- /dev/null
+++ b/src/enzymology/laplacian.ts
@@ -0,0 +1,14 @@
+/** enzymology laplacian module — tsb analytics library. */
+export interface EnzymologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeEnzymologyLaplacian(data: number[], opts: EnzymologyLaplacianOptions = {}): EnzymologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyLaplacian };
diff --git a/src/enzymology/learning.ts b/src/enzymology/learning.ts
new file mode 100644
index 000000000..3dc1b4012
--- /dev/null
+++ b/src/enzymology/learning.ts
@@ -0,0 +1,14 @@
+/** enzymology learning module — tsb analytics library. */
+export interface EnzymologyLearningOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyLearningResult { values: number[]; converged: boolean; }
+export function computeEnzymologyLearning(data: number[], opts: EnzymologyLearningOptions = {}): EnzymologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyLearning };
diff --git a/src/enzymology/linear.ts b/src/enzymology/linear.ts
new file mode 100644
index 000000000..4c490e1e2
--- /dev/null
+++ b/src/enzymology/linear.ts
@@ -0,0 +1,14 @@
+/** enzymology linear module — tsb analytics library. */
+export interface EnzymologyLinearOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyLinearResult { values: number[]; converged: boolean; }
+export function computeEnzymologyLinear(data: number[], opts: EnzymologyLinearOptions = {}): EnzymologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyLinear };
diff --git a/src/enzymology/manifold.ts b/src/enzymology/manifold.ts
new file mode 100644
index 000000000..466fe7fa2
--- /dev/null
+++ b/src/enzymology/manifold.ts
@@ -0,0 +1,14 @@
+/** enzymology manifold module — tsb analytics library. */
+export interface EnzymologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyManifoldResult { values: number[]; converged: boolean; }
+export function computeEnzymologyManifold(data: number[], opts: EnzymologyManifoldOptions = {}): EnzymologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyManifold };
diff --git a/src/enzymology/matching.ts b/src/enzymology/matching.ts
new file mode 100644
index 000000000..dff160a76
--- /dev/null
+++ b/src/enzymology/matching.ts
@@ -0,0 +1,14 @@
+/** enzymology matching module — tsb analytics library. */
+export interface EnzymologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyMatchingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyMatching(data: number[], opts: EnzymologyMatchingOptions = {}): EnzymologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyMatching };
diff --git a/src/enzymology/measurement.ts b/src/enzymology/measurement.ts
new file mode 100644
index 000000000..8ee2dc722
--- /dev/null
+++ b/src/enzymology/measurement.ts
@@ -0,0 +1,14 @@
+/** enzymology measurement module — tsb analytics library. */
+export interface EnzymologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeEnzymologyMeasurement(data: number[], opts: EnzymologyMeasurementOptions = {}): EnzymologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyMeasurement };
diff --git a/src/enzymology/metrics.ts b/src/enzymology/metrics.ts
new file mode 100644
index 000000000..a9cf4a9f7
--- /dev/null
+++ b/src/enzymology/metrics.ts
@@ -0,0 +1,14 @@
+/** enzymology metrics module — tsb analytics library. */
+export interface EnzymologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyMetricsResult { values: number[]; converged: boolean; }
+export function computeEnzymologyMetrics(data: number[], opts: EnzymologyMetricsOptions = {}): EnzymologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyMetrics };
diff --git a/src/enzymology/modeling.ts b/src/enzymology/modeling.ts
new file mode 100644
index 000000000..885eb2c0d
--- /dev/null
+++ b/src/enzymology/modeling.ts
@@ -0,0 +1,14 @@
+/** enzymology modeling module — tsb analytics library. */
+export interface EnzymologyModelingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyModelingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyModeling(data: number[], opts: EnzymologyModelingOptions = {}): EnzymologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyModeling };
diff --git a/src/enzymology/monitoring.ts b/src/enzymology/monitoring.ts
new file mode 100644
index 000000000..f851001e4
--- /dev/null
+++ b/src/enzymology/monitoring.ts
@@ -0,0 +1,14 @@
+/** enzymology monitoring module — tsb analytics library. */
+export interface EnzymologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeEnzymologyMonitoring(data: number[], opts: EnzymologyMonitoringOptions = {}): EnzymologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyMonitoring };
diff --git a/src/enzymology/nonlinear.ts b/src/enzymology/nonlinear.ts
new file mode 100644
index 000000000..a3bf5e60e
--- /dev/null
+++ b/src/enzymology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** enzymology nonlinear module — tsb analytics library. */
+export interface EnzymologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeEnzymologyNonlinear(data: number[], opts: EnzymologyNonlinearOptions = {}): EnzymologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyNonlinear };
diff --git a/src/enzymology/normalization.ts b/src/enzymology/normalization.ts
new file mode 100644
index 000000000..2a33012cc
--- /dev/null
+++ b/src/enzymology/normalization.ts
@@ -0,0 +1,14 @@
+/** enzymology normalization module — tsb analytics library. */
+export interface EnzymologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyNormalization(data: number[], opts: EnzymologyNormalizationOptions = {}): EnzymologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyNormalization };
diff --git a/src/enzymology/optimization.ts b/src/enzymology/optimization.ts
new file mode 100644
index 000000000..f3c96ea11
--- /dev/null
+++ b/src/enzymology/optimization.ts
@@ -0,0 +1,14 @@
+/** enzymology optimization module — tsb analytics library. */
+export interface EnzymologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyOptimization(data: number[], opts: EnzymologyOptimizationOptions = {}): EnzymologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyOptimization };
diff --git a/src/enzymology/patterns.ts b/src/enzymology/patterns.ts
new file mode 100644
index 000000000..1efd53d0b
--- /dev/null
+++ b/src/enzymology/patterns.ts
@@ -0,0 +1,14 @@
+/** enzymology patterns module — tsb analytics library. */
+export interface EnzymologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyPatternsResult { values: number[]; converged: boolean; }
+export function computeEnzymologyPatterns(data: number[], opts: EnzymologyPatternsOptions = {}): EnzymologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyPatterns };
diff --git a/src/enzymology/permutation.ts b/src/enzymology/permutation.ts
new file mode 100644
index 000000000..5f9c879a3
--- /dev/null
+++ b/src/enzymology/permutation.ts
@@ -0,0 +1,14 @@
+/** enzymology permutation module — tsb analytics library. */
+export interface EnzymologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyPermutationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyPermutation(data: number[], opts: EnzymologyPermutationOptions = {}): EnzymologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyPermutation };
diff --git a/src/enzymology/prediction.ts b/src/enzymology/prediction.ts
new file mode 100644
index 000000000..77290a29b
--- /dev/null
+++ b/src/enzymology/prediction.ts
@@ -0,0 +1,14 @@
+/** enzymology prediction module — tsb analytics library. */
+export interface EnzymologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyPredictionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyPrediction(data: number[], opts: EnzymologyPredictionOptions = {}): EnzymologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyPrediction };
diff --git a/src/enzymology/processing.ts b/src/enzymology/processing.ts
new file mode 100644
index 000000000..dd96699fa
--- /dev/null
+++ b/src/enzymology/processing.ts
@@ -0,0 +1,14 @@
+/** enzymology processing module — tsb analytics library. */
+export interface EnzymologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyProcessingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyProcessing(data: number[], opts: EnzymologyProcessingOptions = {}): EnzymologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyProcessing };
diff --git a/src/enzymology/profiling.ts b/src/enzymology/profiling.ts
new file mode 100644
index 000000000..5d58c8713
--- /dev/null
+++ b/src/enzymology/profiling.ts
@@ -0,0 +1,14 @@
+/** enzymology profiling module — tsb analytics library. */
+export interface EnzymologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyProfilingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyProfiling(data: number[], opts: EnzymologyProfilingOptions = {}): EnzymologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyProfiling };
diff --git a/src/enzymology/projection.ts b/src/enzymology/projection.ts
new file mode 100644
index 000000000..2e68f2b86
--- /dev/null
+++ b/src/enzymology/projection.ts
@@ -0,0 +1,14 @@
+/** enzymology projection module — tsb analytics library. */
+export interface EnzymologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyProjectionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyProjection(data: number[], opts: EnzymologyProjectionOptions = {}): EnzymologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyProjection };
diff --git a/src/enzymology/ranking.ts b/src/enzymology/ranking.ts
new file mode 100644
index 000000000..4d357166c
--- /dev/null
+++ b/src/enzymology/ranking.ts
@@ -0,0 +1,14 @@
+/** enzymology ranking module — tsb analytics library. */
+export interface EnzymologyRankingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyRankingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyRanking(data: number[], opts: EnzymologyRankingOptions = {}): EnzymologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyRanking };
diff --git a/src/enzymology/reconstruction.ts b/src/enzymology/reconstruction.ts
new file mode 100644
index 000000000..6650c2afe
--- /dev/null
+++ b/src/enzymology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** enzymology reconstruction module — tsb analytics library. */
+export interface EnzymologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyReconstruction(data: number[], opts: EnzymologyReconstructionOptions = {}): EnzymologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyReconstruction };
diff --git a/src/enzymology/registration.ts b/src/enzymology/registration.ts
new file mode 100644
index 000000000..6f239a505
--- /dev/null
+++ b/src/enzymology/registration.ts
@@ -0,0 +1,14 @@
+/** enzymology registration module — tsb analytics library. */
+export interface EnzymologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyRegistration(data: number[], opts: EnzymologyRegistrationOptions = {}): EnzymologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyRegistration };
diff --git a/src/enzymology/regression.ts b/src/enzymology/regression.ts
new file mode 100644
index 000000000..48b369c06
--- /dev/null
+++ b/src/enzymology/regression.ts
@@ -0,0 +1,14 @@
+/** enzymology regression module — tsb analytics library. */
+export interface EnzymologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyRegressionResult { values: number[]; converged: boolean; }
+export function computeEnzymologyRegression(data: number[], opts: EnzymologyRegressionOptions = {}): EnzymologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyRegression };
diff --git a/src/enzymology/regularization.ts b/src/enzymology/regularization.ts
new file mode 100644
index 000000000..3b0f51cf8
--- /dev/null
+++ b/src/enzymology/regularization.ts
@@ -0,0 +1,14 @@
+/** enzymology regularization module — tsb analytics library. */
+export interface EnzymologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyRegularization(data: number[], opts: EnzymologyRegularizationOptions = {}): EnzymologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyRegularization };
diff --git a/src/enzymology/robustness.ts b/src/enzymology/robustness.ts
new file mode 100644
index 000000000..9e154eb71
--- /dev/null
+++ b/src/enzymology/robustness.ts
@@ -0,0 +1,14 @@
+/** enzymology robustness module — tsb analytics library. */
+export interface EnzymologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeEnzymologyRobustness(data: number[], opts: EnzymologyRobustnessOptions = {}): EnzymologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyRobustness };
diff --git a/src/enzymology/sampling.ts b/src/enzymology/sampling.ts
new file mode 100644
index 000000000..92cc40570
--- /dev/null
+++ b/src/enzymology/sampling.ts
@@ -0,0 +1,14 @@
+/** enzymology sampling module — tsb analytics library. */
+export interface EnzymologySamplingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologySamplingResult { values: number[]; converged: boolean; }
+export function computeEnzymologySampling(data: number[], opts: EnzymologySamplingOptions = {}): EnzymologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologySampling };
diff --git a/src/enzymology/sampling2.ts b/src/enzymology/sampling2.ts
new file mode 100644
index 000000000..d44bf2b78
--- /dev/null
+++ b/src/enzymology/sampling2.ts
@@ -0,0 +1,14 @@
+/** enzymology sampling2 module — tsb analytics library. */
+export interface EnzymologySamplingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologySamplingResult { values: number[]; converged: boolean; }
+export function computeEnzymologySampling(data: number[], opts: EnzymologySamplingOptions = {}): EnzymologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologySampling };
diff --git a/src/enzymology/scaling.ts b/src/enzymology/scaling.ts
new file mode 100644
index 000000000..4955d6832
--- /dev/null
+++ b/src/enzymology/scaling.ts
@@ -0,0 +1,14 @@
+/** enzymology scaling module — tsb analytics library. */
+export interface EnzymologyScalingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyScalingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyScaling(data: number[], opts: EnzymologyScalingOptions = {}): EnzymologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyScaling };
diff --git a/src/enzymology/scoring.ts b/src/enzymology/scoring.ts
new file mode 100644
index 000000000..2e5939636
--- /dev/null
+++ b/src/enzymology/scoring.ts
@@ -0,0 +1,14 @@
+/** enzymology scoring module — tsb analytics library. */
+export interface EnzymologyScoringOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyScoringResult { values: number[]; converged: boolean; }
+export function computeEnzymologyScoring(data: number[], opts: EnzymologyScoringOptions = {}): EnzymologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyScoring };
diff --git a/src/enzymology/segmentation.ts b/src/enzymology/segmentation.ts
new file mode 100644
index 000000000..3b434302c
--- /dev/null
+++ b/src/enzymology/segmentation.ts
@@ -0,0 +1,14 @@
+/** enzymology segmentation module — tsb analytics library. */
+export interface EnzymologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologySegmentationResult { values: number[]; converged: boolean; }
+export function computeEnzymologySegmentation(data: number[], opts: EnzymologySegmentationOptions = {}): EnzymologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologySegmentation };
diff --git a/src/enzymology/selection.ts b/src/enzymology/selection.ts
new file mode 100644
index 000000000..0c32d8678
--- /dev/null
+++ b/src/enzymology/selection.ts
@@ -0,0 +1,14 @@
+/** enzymology selection module — tsb analytics library. */
+export interface EnzymologySelectionOptions { tol?: number; maxIter?: number; }
+export interface EnzymologySelectionResult { values: number[]; converged: boolean; }
+export function computeEnzymologySelection(data: number[], opts: EnzymologySelectionOptions = {}): EnzymologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologySelection };
diff --git a/src/enzymology/sensitivity.ts b/src/enzymology/sensitivity.ts
new file mode 100644
index 000000000..8fa1e996a
--- /dev/null
+++ b/src/enzymology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** enzymology sensitivity module — tsb analytics library. */
+export interface EnzymologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface EnzymologySensitivityResult { values: number[]; converged: boolean; }
+export function computeEnzymologySensitivity(data: number[], opts: EnzymologySensitivityOptions = {}): EnzymologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologySensitivity };
diff --git a/src/enzymology/simulation.ts b/src/enzymology/simulation.ts
new file mode 100644
index 000000000..263b63c30
--- /dev/null
+++ b/src/enzymology/simulation.ts
@@ -0,0 +1,14 @@
+/** enzymology simulation module — tsb analytics library. */
+export interface EnzymologySimulationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologySimulationResult { values: number[]; converged: boolean; }
+export function computeEnzymologySimulation(data: number[], opts: EnzymologySimulationOptions = {}): EnzymologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologySimulation };
diff --git a/src/enzymology/smoothing.ts b/src/enzymology/smoothing.ts
new file mode 100644
index 000000000..8a4b63682
--- /dev/null
+++ b/src/enzymology/smoothing.ts
@@ -0,0 +1,14 @@
+/** enzymology smoothing module — tsb analytics library. */
+export interface EnzymologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologySmoothingResult { values: number[]; converged: boolean; }
+export function computeEnzymologySmoothing(data: number[], opts: EnzymologySmoothingOptions = {}): EnzymologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologySmoothing };
diff --git a/src/enzymology/stability.ts b/src/enzymology/stability.ts
new file mode 100644
index 000000000..4e4aa3c6c
--- /dev/null
+++ b/src/enzymology/stability.ts
@@ -0,0 +1,14 @@
+/** enzymology stability module — tsb analytics library. */
+export interface EnzymologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyStabilityResult { values: number[]; converged: boolean; }
+export function computeEnzymologyStability(data: number[], opts: EnzymologyStabilityOptions = {}): EnzymologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyStability };
diff --git a/src/enzymology/stacking.ts b/src/enzymology/stacking.ts
new file mode 100644
index 000000000..48a9f1b36
--- /dev/null
+++ b/src/enzymology/stacking.ts
@@ -0,0 +1,14 @@
+/** enzymology stacking module — tsb analytics library. */
+export interface EnzymologyStackingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyStackingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyStacking(data: number[], opts: EnzymologyStackingOptions = {}): EnzymologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyStacking };
diff --git a/src/enzymology/standardization.ts b/src/enzymology/standardization.ts
new file mode 100644
index 000000000..2f0869934
--- /dev/null
+++ b/src/enzymology/standardization.ts
@@ -0,0 +1,14 @@
+/** enzymology standardization module — tsb analytics library. */
+export interface EnzymologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyStandardization(data: number[], opts: EnzymologyStandardizationOptions = {}): EnzymologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyStandardization };
diff --git a/src/enzymology/static.ts b/src/enzymology/static.ts
new file mode 100644
index 000000000..130c43da3
--- /dev/null
+++ b/src/enzymology/static.ts
@@ -0,0 +1,14 @@
+/** enzymology static module — tsb analytics library. */
+export interface EnzymologyStaticOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyStaticResult { values: number[]; converged: boolean; }
+export function computeEnzymologyStatic(data: number[], opts: EnzymologyStaticOptions = {}): EnzymologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyStatic };
diff --git a/src/enzymology/stochastic.ts b/src/enzymology/stochastic.ts
new file mode 100644
index 000000000..c2f3f9341
--- /dev/null
+++ b/src/enzymology/stochastic.ts
@@ -0,0 +1,14 @@
+/** enzymology stochastic module — tsb analytics library. */
+export interface EnzymologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyStochasticResult { values: number[]; converged: boolean; }
+export function computeEnzymologyStochastic(data: number[], opts: EnzymologyStochasticOptions = {}): EnzymologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyStochastic };
diff --git a/src/enzymology/synthesis.ts b/src/enzymology/synthesis.ts
new file mode 100644
index 000000000..1f675a416
--- /dev/null
+++ b/src/enzymology/synthesis.ts
@@ -0,0 +1,14 @@
+/** enzymology synthesis module — tsb analytics library. */
+export interface EnzymologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface EnzymologySynthesisResult { values: number[]; converged: boolean; }
+export function computeEnzymologySynthesis(data: number[], opts: EnzymologySynthesisOptions = {}): EnzymologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologySynthesis };
diff --git a/src/enzymology/topology.ts b/src/enzymology/topology.ts
new file mode 100644
index 000000000..79c114913
--- /dev/null
+++ b/src/enzymology/topology.ts
@@ -0,0 +1,14 @@
+/** enzymology topology module — tsb analytics library. */
+export interface EnzymologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyTopologyResult { values: number[]; converged: boolean; }
+export function computeEnzymologyTopology(data: number[], opts: EnzymologyTopologyOptions = {}): EnzymologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyTopology };
diff --git a/src/enzymology/tracking.ts b/src/enzymology/tracking.ts
new file mode 100644
index 000000000..2cfdf4674
--- /dev/null
+++ b/src/enzymology/tracking.ts
@@ -0,0 +1,14 @@
+/** enzymology tracking module — tsb analytics library. */
+export interface EnzymologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyTrackingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyTracking(data: number[], opts: EnzymologyTrackingOptions = {}): EnzymologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyTracking };
diff --git a/src/enzymology/transform.ts b/src/enzymology/transform.ts
new file mode 100644
index 000000000..0870c8413
--- /dev/null
+++ b/src/enzymology/transform.ts
@@ -0,0 +1,14 @@
+/** enzymology transform module — tsb analytics library. */
+export interface EnzymologyTransformOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyTransformResult { values: number[]; converged: boolean; }
+export function computeEnzymologyTransform(data: number[], opts: EnzymologyTransformOptions = {}): EnzymologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyTransform };
diff --git a/src/enzymology/uncertainty.ts b/src/enzymology/uncertainty.ts
new file mode 100644
index 000000000..94e80caa7
--- /dev/null
+++ b/src/enzymology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** enzymology uncertainty module — tsb analytics library. */
+export interface EnzymologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeEnzymologyUncertainty(data: number[], opts: EnzymologyUncertaintyOptions = {}): EnzymologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyUncertainty };
diff --git a/src/enzymology/validation.ts b/src/enzymology/validation.ts
new file mode 100644
index 000000000..546c676ce
--- /dev/null
+++ b/src/enzymology/validation.ts
@@ -0,0 +1,14 @@
+/** enzymology validation module — tsb analytics library. */
+export interface EnzymologyValidationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyValidationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyValidation(data: number[], opts: EnzymologyValidationOptions = {}): EnzymologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyValidation };
diff --git a/src/enzymology/verification.ts b/src/enzymology/verification.ts
new file mode 100644
index 000000000..eecb82415
--- /dev/null
+++ b/src/enzymology/verification.ts
@@ -0,0 +1,14 @@
+/** enzymology verification module — tsb analytics library. */
+export interface EnzymologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyVerificationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyVerification(data: number[], opts: EnzymologyVerificationOptions = {}): EnzymologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyVerification };
diff --git a/src/enzymology/visualization.ts b/src/enzymology/visualization.ts
new file mode 100644
index 000000000..3f0064a73
--- /dev/null
+++ b/src/enzymology/visualization.ts
@@ -0,0 +1,14 @@
+/** enzymology visualization module — tsb analytics library. */
+export interface EnzymologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeEnzymologyVisualization(data: number[], opts: EnzymologyVisualizationOptions = {}): EnzymologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyVisualization };
diff --git a/src/enzymology/voting.ts b/src/enzymology/voting.ts
new file mode 100644
index 000000000..20646db55
--- /dev/null
+++ b/src/enzymology/voting.ts
@@ -0,0 +1,14 @@
+/** enzymology voting module — tsb analytics library. */
+export interface EnzymologyVotingOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyVotingResult { values: number[]; converged: boolean; }
+export function computeEnzymologyVoting(data: number[], opts: EnzymologyVotingOptions = {}): EnzymologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyVoting };
diff --git a/src/enzymology/wavelet.ts b/src/enzymology/wavelet.ts
new file mode 100644
index 000000000..4d107e110
--- /dev/null
+++ b/src/enzymology/wavelet.ts
@@ -0,0 +1,14 @@
+/** enzymology wavelet module — tsb analytics library. */
+export interface EnzymologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface EnzymologyWaveletResult { values: number[]; converged: boolean; }
+export function computeEnzymologyWavelet(data: number[], opts: EnzymologyWaveletOptions = {}): EnzymologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEnzymologyWavelet };
diff --git a/src/epidemiology/advanced.ts b/src/epidemiology/advanced.ts
new file mode 100644
index 000000000..cf5619741
--- /dev/null
+++ b/src/epidemiology/advanced.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Advanced module — tsb analytics library. */
+export interface Epidemiology advancedOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology advancedResult { values: number[]; converged: boolean; }
+export function computeEpidemiology advanced(data: number[], opts: Epidemiology advancedOptions = {}): Epidemiology advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology advanced };
diff --git a/src/epidemiology/age_structured.ts b/src/epidemiology/age_structured.ts
new file mode 100644
index 000000000..98dab4d74
--- /dev/null
+++ b/src/epidemiology/age_structured.ts
@@ -0,0 +1,22 @@
+/** Age Structured module — tsb analytics library. */
+
+/** Options for Age Structured. */
+export interface AgeStructuredOptions { tol?: number; maxIter?: number; }
+
+/** Result from Age Structured. */
+export interface AgeStructuredResult { values: number[]; converged: boolean; }
+
+/** Compute Age Structured. */
+export function computeAgeStructured(data: number[], opts: AgeStructuredOptions = {}): AgeStructuredResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAgeStructured };
diff --git a/src/epidemiology/airborne.ts b/src/epidemiology/airborne.ts
new file mode 100644
index 000000000..b97debf6c
--- /dev/null
+++ b/src/epidemiology/airborne.ts
@@ -0,0 +1,22 @@
+/** Airborne module — tsb analytics library. */
+
+/** Options for Airborne. */
+export interface AirborneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Airborne. */
+export interface AirborneResult { values: number[]; converged: boolean; }
+
+/** Compute Airborne. */
+export function computeAirborne(data: number[], opts: AirborneOptions = {}): AirborneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAirborne };
diff --git a/src/epidemiology/attack_rate.ts b/src/epidemiology/attack_rate.ts
new file mode 100644
index 000000000..1f249a1f9
--- /dev/null
+++ b/src/epidemiology/attack_rate.ts
@@ -0,0 +1,22 @@
+/** Attack Rate module — tsb analytics library. */
+
+/** Options for Attack Rate. */
+export interface AttackRateOptions { tol?: number; maxIter?: number; }
+
+/** Result from Attack Rate. */
+export interface AttackRateResult { values: number[]; converged: boolean; }
+
+/** Compute Attack Rate. */
+export function computeAttackRate(data: number[], opts: AttackRateOptions = {}): AttackRateResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAttackRate };
diff --git a/src/epidemiology/base2.ts b/src/epidemiology/base2.ts
new file mode 100644
index 000000000..8e9cc83f5
--- /dev/null
+++ b/src/epidemiology/base2.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Base2 module — tsb analytics library. */
+export interface Epidemiology base2Options { tol?: number; maxIter?: number; }
+export interface Epidemiology base2Result { values: number[]; converged: boolean; }
+export function computeEpidemiology base2(data: number[], opts: Epidemiology base2Options = {}): Epidemiology base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology base2 };
diff --git a/src/epidemiology/batch.ts b/src/epidemiology/batch.ts
new file mode 100644
index 000000000..f6468d2c5
--- /dev/null
+++ b/src/epidemiology/batch.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Batch module — tsb analytics library. */
+export interface Epidemiology batchOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology batchResult { values: number[]; converged: boolean; }
+export function computeEpidemiology batch(data: number[], opts: Epidemiology batchOptions = {}): Epidemiology batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology batch };
diff --git a/src/epidemiology/beta.ts b/src/epidemiology/beta.ts
new file mode 100644
index 000000000..68c8f62b3
--- /dev/null
+++ b/src/epidemiology/beta.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Beta module — tsb analytics library. */
+export interface Epidemiology betaOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology betaResult { values: number[]; converged: boolean; }
+export function computeEpidemiology beta(data: number[], opts: Epidemiology betaOptions = {}): Epidemiology betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology beta };
diff --git a/src/epidemiology/boosting.ts b/src/epidemiology/boosting.ts
new file mode 100644
index 000000000..67dfc3f7e
--- /dev/null
+++ b/src/epidemiology/boosting.ts
@@ -0,0 +1,22 @@
+/** Boosting module — tsb analytics library. */
+
+/** Options for Boosting. */
+export interface BoostingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Boosting. */
+export interface BoostingResult { values: number[]; converged: boolean; }
+
+/** Compute Boosting. */
+export function computeBoosting(data: number[], opts: BoostingOptions = {}): BoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBoosting };
diff --git a/src/epidemiology/case_fatality.ts b/src/epidemiology/case_fatality.ts
new file mode 100644
index 000000000..8c469462f
--- /dev/null
+++ b/src/epidemiology/case_fatality.ts
@@ -0,0 +1,22 @@
+/** Case Fatality module — tsb analytics library. */
+
+/** Options for Case Fatality. */
+export interface CaseFatalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Case Fatality. */
+export interface CaseFatalityResult { values: number[]; converged: boolean; }
+
+/** Compute Case Fatality. */
+export function computeCaseFatality(data: number[], opts: CaseFatalityOptions = {}): CaseFatalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCaseFatality };
diff --git a/src/epidemiology/contact_tracing.ts b/src/epidemiology/contact_tracing.ts
new file mode 100644
index 000000000..3130eb48d
--- /dev/null
+++ b/src/epidemiology/contact_tracing.ts
@@ -0,0 +1,22 @@
+/** Contact Tracing module — tsb analytics library. */
+
+/** Options for Contact Tracing. */
+export interface ContactTracingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Contact Tracing. */
+export interface ContactTracingResult { values: number[]; converged: boolean; }
+
+/** Compute Contact Tracing. */
+export function computeContactTracing(data: number[], opts: ContactTracingOptions = {}): ContactTracingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeContactTracing };
diff --git a/src/epidemiology/cpu.ts b/src/epidemiology/cpu.ts
new file mode 100644
index 000000000..2dfca6759
--- /dev/null
+++ b/src/epidemiology/cpu.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Cpu module — tsb analytics library. */
+export interface Epidemiology cpuOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology cpuResult { values: number[]; converged: boolean; }
+export function computeEpidemiology cpu(data: number[], opts: Epidemiology cpuOptions = {}): Epidemiology cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology cpu };
diff --git a/src/epidemiology/cross_immunity.ts b/src/epidemiology/cross_immunity.ts
new file mode 100644
index 000000000..a31c94fca
--- /dev/null
+++ b/src/epidemiology/cross_immunity.ts
@@ -0,0 +1,22 @@
+/** Cross Immunity module — tsb analytics library. */
+
+/** Options for Cross Immunity. */
+export interface CrossImmunityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cross Immunity. */
+export interface CrossImmunityResult { values: number[]; converged: boolean; }
+
+/** Compute Cross Immunity. */
+export function computeCrossImmunity(data: number[], opts: CrossImmunityOptions = {}): CrossImmunityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCrossImmunity };
diff --git a/src/epidemiology/dense.ts b/src/epidemiology/dense.ts
new file mode 100644
index 000000000..10ac677bf
--- /dev/null
+++ b/src/epidemiology/dense.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Dense module — tsb analytics library. */
+export interface Epidemiology denseOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology denseResult { values: number[]; converged: boolean; }
+export function computeEpidemiology dense(data: number[], opts: Epidemiology denseOptions = {}): Epidemiology denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology dense };
diff --git a/src/epidemiology/deterministic.ts b/src/epidemiology/deterministic.ts
new file mode 100644
index 000000000..668b13585
--- /dev/null
+++ b/src/epidemiology/deterministic.ts
@@ -0,0 +1,22 @@
+/** Deterministic module — tsb analytics library. */
+
+/** Options for Deterministic. */
+export interface DeterministicOptions { tol?: number; maxIter?: number; }
+
+/** Result from Deterministic. */
+export interface DeterministicResult { values: number[]; converged: boolean; }
+
+/** Compute Deterministic. */
+export function computeDeterministic(data: number[], opts: DeterministicOptions = {}): DeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDeterministic };
diff --git a/src/epidemiology/distributed.ts b/src/epidemiology/distributed.ts
new file mode 100644
index 000000000..b97d17d31
--- /dev/null
+++ b/src/epidemiology/distributed.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Distributed module — tsb analytics library. */
+export interface Epidemiology distributedOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology distributedResult { values: number[]; converged: boolean; }
+export function computeEpidemiology distributed(data: number[], opts: Epidemiology distributedOptions = {}): Epidemiology distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology distributed };
diff --git a/src/epidemiology/experimental.ts b/src/epidemiology/experimental.ts
new file mode 100644
index 000000000..6ccc642c2
--- /dev/null
+++ b/src/epidemiology/experimental.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Experimental module — tsb analytics library. */
+export interface Epidemiology experimentalOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology experimentalResult { values: number[]; converged: boolean; }
+export function computeEpidemiology experimental(data: number[], opts: Epidemiology experimentalOptions = {}): Epidemiology experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology experimental };
diff --git a/src/epidemiology/fast.ts b/src/epidemiology/fast.ts
new file mode 100644
index 000000000..33095cafb
--- /dev/null
+++ b/src/epidemiology/fast.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Fast module — tsb analytics library. */
+export interface Epidemiology fastOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology fastResult { values: number[]; converged: boolean; }
+export function computeEpidemiology fast(data: number[], opts: Epidemiology fastOptions = {}): Epidemiology fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology fast };
diff --git a/src/epidemiology/fomite.ts b/src/epidemiology/fomite.ts
new file mode 100644
index 000000000..f0621f855
--- /dev/null
+++ b/src/epidemiology/fomite.ts
@@ -0,0 +1,22 @@
+/** Fomite module — tsb analytics library. */
+
+/** Options for Fomite. */
+export interface FomiteOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fomite. */
+export interface FomiteResult { values: number[]; converged: boolean; }
+
+/** Compute Fomite. */
+export function computeFomite(data: number[], opts: FomiteOptions = {}): FomiteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFomite };
diff --git a/src/epidemiology/future.ts b/src/epidemiology/future.ts
new file mode 100644
index 000000000..407537258
--- /dev/null
+++ b/src/epidemiology/future.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Future module — tsb analytics library. */
+export interface Epidemiology futureOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology futureResult { values: number[]; converged: boolean; }
+export function computeEpidemiology future(data: number[], opts: Epidemiology futureOptions = {}): Epidemiology futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology future };
diff --git a/src/epidemiology/genomic_epi.ts b/src/epidemiology/genomic_epi.ts
new file mode 100644
index 000000000..9bb7b157a
--- /dev/null
+++ b/src/epidemiology/genomic_epi.ts
@@ -0,0 +1,22 @@
+/** Genomic Epi module — tsb analytics library. */
+
+/** Options for Genomic Epi. */
+export interface GenomicEpiOptions { tol?: number; maxIter?: number; }
+
+/** Result from Genomic Epi. */
+export interface GenomicEpiResult { values: number[]; converged: boolean; }
+
+/** Compute Genomic Epi. */
+export function computeGenomicEpi(data: number[], opts: GenomicEpiOptions = {}): GenomicEpiResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGenomicEpi };
diff --git a/src/epidemiology/gpu.ts b/src/epidemiology/gpu.ts
new file mode 100644
index 000000000..b831ef189
--- /dev/null
+++ b/src/epidemiology/gpu.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Gpu module — tsb analytics library. */
+export interface Epidemiology gpuOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology gpuResult { values: number[]; converged: boolean; }
+export function computeEpidemiology gpu(data: number[], opts: Epidemiology gpuOptions = {}): Epidemiology gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology gpu };
diff --git a/src/epidemiology/herd_immunity.ts b/src/epidemiology/herd_immunity.ts
new file mode 100644
index 000000000..bc117b2ef
--- /dev/null
+++ b/src/epidemiology/herd_immunity.ts
@@ -0,0 +1,22 @@
+/** Herd Immunity module — tsb analytics library. */
+
+/** Options for Herd Immunity. */
+export interface HerdImmunityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Herd Immunity. */
+export interface HerdImmunityResult { values: number[]; converged: boolean; }
+
+/** Compute Herd Immunity. */
+export function computeHerdImmunity(data: number[], opts: HerdImmunityOptions = {}): HerdImmunityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHerdImmunity };
diff --git a/src/epidemiology/infection_fatality.ts b/src/epidemiology/infection_fatality.ts
new file mode 100644
index 000000000..3b1071b0d
--- /dev/null
+++ b/src/epidemiology/infection_fatality.ts
@@ -0,0 +1,22 @@
+/** Infection Fatality module — tsb analytics library. */
+
+/** Options for Infection Fatality. */
+export interface InfectionFatalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Infection Fatality. */
+export interface InfectionFatalityResult { values: number[]; converged: boolean; }
+
+/** Compute Infection Fatality. */
+export function computeInfectionFatality(data: number[], opts: InfectionFatalityOptions = {}): InfectionFatalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInfectionFatality };
diff --git a/src/epidemiology/large.ts b/src/epidemiology/large.ts
new file mode 100644
index 000000000..dabb92899
--- /dev/null
+++ b/src/epidemiology/large.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Large module — tsb analytics library. */
+export interface Epidemiology largeOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology largeResult { values: number[]; converged: boolean; }
+export function computeEpidemiology large(data: number[], opts: Epidemiology largeOptions = {}): Epidemiology largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology large };
diff --git a/src/epidemiology/legacy.ts b/src/epidemiology/legacy.ts
new file mode 100644
index 000000000..2c9e8cbd7
--- /dev/null
+++ b/src/epidemiology/legacy.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Legacy module — tsb analytics library. */
+export interface Epidemiology legacyOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology legacyResult { values: number[]; converged: boolean; }
+export function computeEpidemiology legacy(data: number[], opts: Epidemiology legacyOptions = {}): Epidemiology legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology legacy };
diff --git a/src/epidemiology/lite.ts b/src/epidemiology/lite.ts
new file mode 100644
index 000000000..76bec5cb9
--- /dev/null
+++ b/src/epidemiology/lite.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Lite module — tsb analytics library. */
+export interface Epidemiology liteOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology liteResult { values: number[]; converged: boolean; }
+export function computeEpidemiology lite(data: number[], opts: Epidemiology liteOptions = {}): Epidemiology liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology lite };
diff --git a/src/epidemiology/mini.ts b/src/epidemiology/mini.ts
new file mode 100644
index 000000000..e74719a93
--- /dev/null
+++ b/src/epidemiology/mini.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Mini module — tsb analytics library. */
+export interface Epidemiology miniOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology miniResult { values: number[]; converged: boolean; }
+export function computeEpidemiology mini(data: number[], opts: Epidemiology miniOptions = {}): Epidemiology miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology mini };
diff --git a/src/epidemiology/network_epi.ts b/src/epidemiology/network_epi.ts
new file mode 100644
index 000000000..57ef7a6f7
--- /dev/null
+++ b/src/epidemiology/network_epi.ts
@@ -0,0 +1,22 @@
+/** Network Epi module — tsb analytics library. */
+
+/** Options for Network Epi. */
+export interface NetworkEpiOptions { tol?: number; maxIter?: number; }
+
+/** Result from Network Epi. */
+export interface NetworkEpiResult { values: number[]; converged: boolean; }
+
+/** Compute Network Epi. */
+export function computeNetworkEpi(data: number[], opts: NetworkEpiOptions = {}): NetworkEpiResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNetworkEpi };
diff --git a/src/epidemiology/next.ts b/src/epidemiology/next.ts
new file mode 100644
index 000000000..24193d54e
--- /dev/null
+++ b/src/epidemiology/next.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Next module — tsb analytics library. */
+export interface Epidemiology nextOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology nextResult { values: number[]; converged: boolean; }
+export function computeEpidemiology next(data: number[], opts: Epidemiology nextOptions = {}): Epidemiology nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology next };
diff --git a/src/epidemiology/online.ts b/src/epidemiology/online.ts
new file mode 100644
index 000000000..800f3c69c
--- /dev/null
+++ b/src/epidemiology/online.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Online module — tsb analytics library. */
+export interface Epidemiology onlineOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology onlineResult { values: number[]; converged: boolean; }
+export function computeEpidemiology online(data: number[], opts: Epidemiology onlineOptions = {}): Epidemiology onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology online };
diff --git a/src/epidemiology/outbreak.ts b/src/epidemiology/outbreak.ts
new file mode 100644
index 000000000..060173cab
--- /dev/null
+++ b/src/epidemiology/outbreak.ts
@@ -0,0 +1,22 @@
+/** Outbreak module — tsb analytics library. */
+
+/** Options for Outbreak. */
+export interface OutbreakOptions { tol?: number; maxIter?: number; }
+
+/** Result from Outbreak. */
+export interface OutbreakResult { values: number[]; converged: boolean; }
+
+/** Compute Outbreak. */
+export function computeOutbreak(data: number[], opts: OutbreakOptions = {}): OutbreakResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOutbreak };
diff --git a/src/epidemiology/parallel.ts b/src/epidemiology/parallel.ts
new file mode 100644
index 000000000..3392c07e9
--- /dev/null
+++ b/src/epidemiology/parallel.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Parallel module — tsb analytics library. */
+export interface Epidemiology parallelOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology parallelResult { values: number[]; converged: boolean; }
+export function computeEpidemiology parallel(data: number[], opts: Epidemiology parallelOptions = {}): Epidemiology parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology parallel };
diff --git a/src/epidemiology/plus.ts b/src/epidemiology/plus.ts
new file mode 100644
index 000000000..9e2565b6f
--- /dev/null
+++ b/src/epidemiology/plus.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Plus module — tsb analytics library. */
+export interface Epidemiology plusOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology plusResult { values: number[]; converged: boolean; }
+export function computeEpidemiology plus(data: number[], opts: Epidemiology plusOptions = {}): Epidemiology plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology plus };
diff --git a/src/epidemiology/pro.ts b/src/epidemiology/pro.ts
new file mode 100644
index 000000000..1e2ab4fb2
--- /dev/null
+++ b/src/epidemiology/pro.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Pro module — tsb analytics library. */
+export interface Epidemiology proOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology proResult { values: number[]; converged: boolean; }
+export function computeEpidemiology pro(data: number[], opts: Epidemiology proOptions = {}): Epidemiology proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology pro };
diff --git a/src/epidemiology/reproduction_number.ts b/src/epidemiology/reproduction_number.ts
new file mode 100644
index 000000000..bd90c9175
--- /dev/null
+++ b/src/epidemiology/reproduction_number.ts
@@ -0,0 +1,22 @@
+/** Reproduction Number module — tsb analytics library. */
+
+/** Options for Reproduction Number. */
+export interface ReproductionNumberOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reproduction Number. */
+export interface ReproductionNumberResult { values: number[]; converged: boolean; }
+
+/** Compute Reproduction Number. */
+export function computeReproductionNumber(data: number[], opts: ReproductionNumberOptions = {}): ReproductionNumberResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReproductionNumber };
diff --git a/src/epidemiology/robust.ts b/src/epidemiology/robust.ts
new file mode 100644
index 000000000..39bc7d118
--- /dev/null
+++ b/src/epidemiology/robust.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Robust module — tsb analytics library. */
+export interface Epidemiology robustOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology robustResult { values: number[]; converged: boolean; }
+export function computeEpidemiology robust(data: number[], opts: Epidemiology robustOptions = {}): Epidemiology robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology robust };
diff --git a/src/epidemiology/seir.ts b/src/epidemiology/seir.ts
new file mode 100644
index 000000000..556452920
--- /dev/null
+++ b/src/epidemiology/seir.ts
@@ -0,0 +1,22 @@
+/** Seir module — tsb analytics library. */
+
+/** Options for Seir. */
+export interface SeirOptions { tol?: number; maxIter?: number; }
+
+/** Result from Seir. */
+export interface SeirResult { values: number[]; converged: boolean; }
+
+/** Compute Seir. */
+export function computeSeir(data: number[], opts: SeirOptions = {}): SeirResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeir };
diff --git a/src/epidemiology/seirs.ts b/src/epidemiology/seirs.ts
new file mode 100644
index 000000000..1e2d79b5d
--- /dev/null
+++ b/src/epidemiology/seirs.ts
@@ -0,0 +1,22 @@
+/** Seirs module — tsb analytics library. */
+
+/** Options for Seirs. */
+export interface SeirsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Seirs. */
+export interface SeirsResult { values: number[]; converged: boolean; }
+
+/** Compute Seirs. */
+export function computeSeirs(data: number[], opts: SeirsOptions = {}): SeirsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeirs };
diff --git a/src/epidemiology/sierd.ts b/src/epidemiology/sierd.ts
new file mode 100644
index 000000000..e63a45234
--- /dev/null
+++ b/src/epidemiology/sierd.ts
@@ -0,0 +1,22 @@
+/** Sierd module — tsb analytics library. */
+
+/** Options for Sierd. */
+export interface SierdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sierd. */
+export interface SierdResult { values: number[]; converged: boolean; }
+
+/** Compute Sierd. */
+export function computeSierd(data: number[], opts: SierdOptions = {}): SierdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSierd };
diff --git a/src/epidemiology/sir.ts b/src/epidemiology/sir.ts
new file mode 100644
index 000000000..2b33a1e95
--- /dev/null
+++ b/src/epidemiology/sir.ts
@@ -0,0 +1,22 @@
+/** Sir module — tsb analytics library. */
+
+/** Options for Sir. */
+export interface SirOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sir. */
+export interface SirResult { values: number[]; converged: boolean; }
+
+/** Compute Sir. */
+export function computeSir(data: number[], opts: SirOptions = {}): SirResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSir };
diff --git a/src/epidemiology/sird.ts b/src/epidemiology/sird.ts
new file mode 100644
index 000000000..072e971dc
--- /dev/null
+++ b/src/epidemiology/sird.ts
@@ -0,0 +1,22 @@
+/** Sird module — tsb analytics library. */
+
+/** Options for Sird. */
+export interface SirdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sird. */
+export interface SirdResult { values: number[]; converged: boolean; }
+
+/** Compute Sird. */
+export function computeSird(data: number[], opts: SirdOptions = {}): SirdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSird };
diff --git a/src/epidemiology/small.ts b/src/epidemiology/small.ts
new file mode 100644
index 000000000..08fd19c8b
--- /dev/null
+++ b/src/epidemiology/small.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Small module — tsb analytics library. */
+export interface Epidemiology smallOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology smallResult { values: number[]; converged: boolean; }
+export function computeEpidemiology small(data: number[], opts: Epidemiology smallOptions = {}): Epidemiology smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology small };
diff --git a/src/epidemiology/sparse.ts b/src/epidemiology/sparse.ts
new file mode 100644
index 000000000..3441ccb69
--- /dev/null
+++ b/src/epidemiology/sparse.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Sparse module — tsb analytics library. */
+export interface Epidemiology sparseOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology sparseResult { values: number[]; converged: boolean; }
+export function computeEpidemiology sparse(data: number[], opts: Epidemiology sparseOptions = {}): Epidemiology sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology sparse };
diff --git a/src/epidemiology/spatial_epi.ts b/src/epidemiology/spatial_epi.ts
new file mode 100644
index 000000000..0395b4322
--- /dev/null
+++ b/src/epidemiology/spatial_epi.ts
@@ -0,0 +1,22 @@
+/** Spatial Epi module — tsb analytics library. */
+
+/** Options for Spatial Epi. */
+export interface SpatialEpiOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spatial Epi. */
+export interface SpatialEpiResult { values: number[]; converged: boolean; }
+
+/** Compute Spatial Epi. */
+export function computeSpatialEpi(data: number[], opts: SpatialEpiOptions = {}): SpatialEpiResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpatialEpi };
diff --git a/src/epidemiology/spillover.ts b/src/epidemiology/spillover.ts
new file mode 100644
index 000000000..a9d12533e
--- /dev/null
+++ b/src/epidemiology/spillover.ts
@@ -0,0 +1,22 @@
+/** Spillover module — tsb analytics library. */
+
+/** Options for Spillover. */
+export interface SpilloverOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spillover. */
+export interface SpilloverResult { values: number[]; converged: boolean; }
+
+/** Compute Spillover. */
+export function computeSpillover(data: number[], opts: SpilloverOptions = {}): SpilloverResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpillover };
diff --git a/src/epidemiology/stable.ts b/src/epidemiology/stable.ts
new file mode 100644
index 000000000..62fe7306b
--- /dev/null
+++ b/src/epidemiology/stable.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Stable module — tsb analytics library. */
+export interface Epidemiology stableOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology stableResult { values: number[]; converged: boolean; }
+export function computeEpidemiology stable(data: number[], opts: Epidemiology stableOptions = {}): Epidemiology stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology stable };
diff --git a/src/epidemiology/stochastic_epi.ts b/src/epidemiology/stochastic_epi.ts
new file mode 100644
index 000000000..218bcb38a
--- /dev/null
+++ b/src/epidemiology/stochastic_epi.ts
@@ -0,0 +1,22 @@
+/** Stochastic Epi module — tsb analytics library. */
+
+/** Options for Stochastic Epi. */
+export interface StochasticEpiOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stochastic Epi. */
+export interface StochasticEpiResult { values: number[]; converged: boolean; }
+
+/** Compute Stochastic Epi. */
+export function computeStochasticEpi(data: number[], opts: StochasticEpiOptions = {}): StochasticEpiResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStochasticEpi };
diff --git a/src/epidemiology/streaming.ts b/src/epidemiology/streaming.ts
new file mode 100644
index 000000000..de2108e05
--- /dev/null
+++ b/src/epidemiology/streaming.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Streaming module — tsb analytics library. */
+export interface Epidemiology streamingOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology streamingResult { values: number[]; converged: boolean; }
+export function computeEpidemiology streaming(data: number[], opts: Epidemiology streamingOptions = {}): Epidemiology streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology streaming };
diff --git a/src/epidemiology/surveillance.ts b/src/epidemiology/surveillance.ts
new file mode 100644
index 000000000..65a22f356
--- /dev/null
+++ b/src/epidemiology/surveillance.ts
@@ -0,0 +1,22 @@
+/** Surveillance module — tsb analytics library. */
+
+/** Options for Surveillance. */
+export interface SurveillanceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Surveillance. */
+export interface SurveillanceResult { values: number[]; converged: boolean; }
+
+/** Compute Surveillance. */
+export function computeSurveillance(data: number[], opts: SurveillanceOptions = {}): SurveillanceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSurveillance };
diff --git a/src/epidemiology/v2.ts b/src/epidemiology/v2.ts
new file mode 100644
index 000000000..ec2d50004
--- /dev/null
+++ b/src/epidemiology/v2.ts
@@ -0,0 +1,15 @@
+/** Epidemiology V2 module — tsb analytics library. */
+export interface Epidemiology v2Options { tol?: number; maxIter?: number; }
+export interface Epidemiology v2Result { values: number[]; converged: boolean; }
+export function computeEpidemiology v2(data: number[], opts: Epidemiology v2Options = {}): Epidemiology v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology v2 };
diff --git a/src/epidemiology/v3.ts b/src/epidemiology/v3.ts
new file mode 100644
index 000000000..43cb15b82
--- /dev/null
+++ b/src/epidemiology/v3.ts
@@ -0,0 +1,15 @@
+/** Epidemiology V3 module — tsb analytics library. */
+export interface Epidemiology v3Options { tol?: number; maxIter?: number; }
+export interface Epidemiology v3Result { values: number[]; converged: boolean; }
+export function computeEpidemiology v3(data: number[], opts: Epidemiology v3Options = {}): Epidemiology v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology v3 };
diff --git a/src/epidemiology/vaccine_efficacy.ts b/src/epidemiology/vaccine_efficacy.ts
new file mode 100644
index 000000000..14a955320
--- /dev/null
+++ b/src/epidemiology/vaccine_efficacy.ts
@@ -0,0 +1,22 @@
+/** Vaccine Efficacy module — tsb analytics library. */
+
+/** Options for Vaccine Efficacy. */
+export interface VaccineEfficacyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vaccine Efficacy. */
+export interface VaccineEfficacyResult { values: number[]; converged: boolean; }
+
+/** Compute Vaccine Efficacy. */
+export function computeVaccineEfficacy(data: number[], opts: VaccineEfficacyOptions = {}): VaccineEfficacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVaccineEfficacy };
diff --git a/src/epidemiology/vector_borne.ts b/src/epidemiology/vector_borne.ts
new file mode 100644
index 000000000..51f4006ba
--- /dev/null
+++ b/src/epidemiology/vector_borne.ts
@@ -0,0 +1,22 @@
+/** Vector Borne module — tsb analytics library. */
+
+/** Options for Vector Borne. */
+export interface VectorBorneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vector Borne. */
+export interface VectorBorneResult { values: number[]; converged: boolean; }
+
+/** Compute Vector Borne. */
+export function computeVectorBorne(data: number[], opts: VectorBorneOptions = {}): VectorBorneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVectorBorne };
diff --git a/src/epidemiology/waning_immunity.ts b/src/epidemiology/waning_immunity.ts
new file mode 100644
index 000000000..d1666d476
--- /dev/null
+++ b/src/epidemiology/waning_immunity.ts
@@ -0,0 +1,22 @@
+/** Waning Immunity module — tsb analytics library. */
+
+/** Options for Waning Immunity. */
+export interface WaningImmunityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Waning Immunity. */
+export interface WaningImmunityResult { values: number[]; converged: boolean; }
+
+/** Compute Waning Immunity. */
+export function computeWaningImmunity(data: number[], opts: WaningImmunityOptions = {}): WaningImmunityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWaningImmunity };
diff --git a/src/epidemiology/wasm.ts b/src/epidemiology/wasm.ts
new file mode 100644
index 000000000..67c56cdbc
--- /dev/null
+++ b/src/epidemiology/wasm.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Wasm module — tsb analytics library. */
+export interface Epidemiology wasmOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology wasmResult { values: number[]; converged: boolean; }
+export function computeEpidemiology wasm(data: number[], opts: Epidemiology wasmOptions = {}): Epidemiology wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology wasm };
diff --git a/src/epidemiology/waterborne.ts b/src/epidemiology/waterborne.ts
new file mode 100644
index 000000000..6066cf085
--- /dev/null
+++ b/src/epidemiology/waterborne.ts
@@ -0,0 +1,22 @@
+/** Waterborne module — tsb analytics library. */
+
+/** Options for Waterborne. */
+export interface WaterborneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Waterborne. */
+export interface WaterborneResult { values: number[]; converged: boolean; }
+
+/** Compute Waterborne. */
+export function computeWaterborne(data: number[], opts: WaterborneOptions = {}): WaterborneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWaterborne };
diff --git a/src/epidemiology/xlarge.ts b/src/epidemiology/xlarge.ts
new file mode 100644
index 000000000..8f95a33a8
--- /dev/null
+++ b/src/epidemiology/xlarge.ts
@@ -0,0 +1,15 @@
+/** Epidemiology Xlarge module — tsb analytics library. */
+export interface Epidemiology xlargeOptions { tol?: number; maxIter?: number; }
+export interface Epidemiology xlargeResult { values: number[]; converged: boolean; }
+export function computeEpidemiology xlarge(data: number[], opts: Epidemiology xlargeOptions = {}): Epidemiology xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpidemiology xlarge };
diff --git a/src/epidemiology/zoonotic.ts b/src/epidemiology/zoonotic.ts
new file mode 100644
index 000000000..d13cee7d1
--- /dev/null
+++ b/src/epidemiology/zoonotic.ts
@@ -0,0 +1,22 @@
+/** Zoonotic module — tsb analytics library. */
+
+/** Options for Zoonotic. */
+export interface ZoonoticOptions { tol?: number; maxIter?: number; }
+
+/** Result from Zoonotic. */
+export interface ZoonoticResult { values: number[]; converged: boolean; }
+
+/** Compute Zoonotic. */
+export function computeZoonotic(data: number[], opts: ZoonoticOptions = {}): ZoonoticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeZoonotic };
diff --git a/src/epigenomics/adaptation.ts b/src/epigenomics/adaptation.ts
new file mode 100644
index 000000000..9e911d419
--- /dev/null
+++ b/src/epigenomics/adaptation.ts
@@ -0,0 +1,14 @@
+/** epigenomics adaptation module — tsb analytics library. */
+export interface EpigenomicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsAdaptation(data: number[], opts: EpigenomicsAdaptationOptions = {}): EpigenomicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsAdaptation };
diff --git a/src/epigenomics/aggregation.ts b/src/epigenomics/aggregation.ts
new file mode 100644
index 000000000..25e8dcc86
--- /dev/null
+++ b/src/epigenomics/aggregation.ts
@@ -0,0 +1,14 @@
+/** epigenomics aggregation module — tsb analytics library. */
+export interface EpigenomicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsAggregationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsAggregation(data: number[], opts: EpigenomicsAggregationOptions = {}): EpigenomicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsAggregation };
diff --git a/src/epigenomics/algebra.ts b/src/epigenomics/algebra.ts
new file mode 100644
index 000000000..9a9876017
--- /dev/null
+++ b/src/epigenomics/algebra.ts
@@ -0,0 +1,14 @@
+/** epigenomics algebra module — tsb analytics library. */
+export interface EpigenomicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsAlgebra(data: number[], opts: EpigenomicsAlgebraOptions = {}): EpigenomicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsAlgebra };
diff --git a/src/epigenomics/alignment.ts b/src/epigenomics/alignment.ts
new file mode 100644
index 000000000..c42df3bfa
--- /dev/null
+++ b/src/epigenomics/alignment.ts
@@ -0,0 +1,14 @@
+/** epigenomics alignment module — tsb analytics library. */
+export interface EpigenomicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsAlignment(data: number[], opts: EpigenomicsAlignmentOptions = {}): EpigenomicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsAlignment };
diff --git a/src/epigenomics/analysis.ts b/src/epigenomics/analysis.ts
new file mode 100644
index 000000000..ae21a17d9
--- /dev/null
+++ b/src/epigenomics/analysis.ts
@@ -0,0 +1,14 @@
+/** epigenomics analysis module — tsb analytics library. */
+export interface EpigenomicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsAnalysis(data: number[], opts: EpigenomicsAnalysisOptions = {}): EpigenomicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsAnalysis };
diff --git a/src/epigenomics/augmentation.ts b/src/epigenomics/augmentation.ts
new file mode 100644
index 000000000..43c111e03
--- /dev/null
+++ b/src/epigenomics/augmentation.ts
@@ -0,0 +1,14 @@
+/** epigenomics augmentation module — tsb analytics library. */
+export interface EpigenomicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsAugmentation(data: number[], opts: EpigenomicsAugmentationOptions = {}): EpigenomicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsAugmentation };
diff --git a/src/epigenomics/bagging.ts b/src/epigenomics/bagging.ts
new file mode 100644
index 000000000..22735e560
--- /dev/null
+++ b/src/epigenomics/bagging.ts
@@ -0,0 +1,14 @@
+/** epigenomics bagging module — tsb analytics library. */
+export interface EpigenomicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsBaggingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsBagging(data: number[], opts: EpigenomicsBaggingOptions = {}): EpigenomicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsBagging };
diff --git a/src/epigenomics/basis.ts b/src/epigenomics/basis.ts
new file mode 100644
index 000000000..56fcaf696
--- /dev/null
+++ b/src/epigenomics/basis.ts
@@ -0,0 +1,14 @@
+/** epigenomics basis module — tsb analytics library. */
+export interface EpigenomicsBasisOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsBasisResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsBasis(data: number[], opts: EpigenomicsBasisOptions = {}): EpigenomicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsBasis };
diff --git a/src/epigenomics/benchmarking.ts b/src/epigenomics/benchmarking.ts
new file mode 100644
index 000000000..adb6964a1
--- /dev/null
+++ b/src/epigenomics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** epigenomics benchmarking module — tsb analytics library. */
+export interface EpigenomicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsBenchmarking(data: number[], opts: EpigenomicsBenchmarkingOptions = {}): EpigenomicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsBenchmarking };
diff --git a/src/epigenomics/blending.ts b/src/epigenomics/blending.ts
new file mode 100644
index 000000000..4e80a4ef3
--- /dev/null
+++ b/src/epigenomics/blending.ts
@@ -0,0 +1,14 @@
+/** epigenomics blending module — tsb analytics library. */
+export interface EpigenomicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsBlendingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsBlending(data: number[], opts: EpigenomicsBlendingOptions = {}): EpigenomicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsBlending };
diff --git a/src/epigenomics/boosting.ts b/src/epigenomics/boosting.ts
new file mode 100644
index 000000000..dc267dd2c
--- /dev/null
+++ b/src/epigenomics/boosting.ts
@@ -0,0 +1,14 @@
+/** epigenomics boosting module — tsb analytics library. */
+export interface EpigenomicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsBoostingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsBoosting(data: number[], opts: EpigenomicsBoostingOptions = {}): EpigenomicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsBoosting };
diff --git a/src/epigenomics/bootstrap.ts b/src/epigenomics/bootstrap.ts
new file mode 100644
index 000000000..6cfb5576f
--- /dev/null
+++ b/src/epigenomics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** epigenomics bootstrap module — tsb analytics library. */
+export interface EpigenomicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsBootstrap(data: number[], opts: EpigenomicsBootstrapOptions = {}): EpigenomicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsBootstrap };
diff --git a/src/epigenomics/calculus.ts b/src/epigenomics/calculus.ts
new file mode 100644
index 000000000..01981335b
--- /dev/null
+++ b/src/epigenomics/calculus.ts
@@ -0,0 +1,14 @@
+/** epigenomics calculus module — tsb analytics library. */
+export interface EpigenomicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsCalculusResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsCalculus(data: number[], opts: EpigenomicsCalculusOptions = {}): EpigenomicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsCalculus };
diff --git a/src/epigenomics/calibration.ts b/src/epigenomics/calibration.ts
new file mode 100644
index 000000000..90a63a940
--- /dev/null
+++ b/src/epigenomics/calibration.ts
@@ -0,0 +1,14 @@
+/** epigenomics calibration module — tsb analytics library. */
+export interface EpigenomicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsCalibration(data: number[], opts: EpigenomicsCalibrationOptions = {}): EpigenomicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsCalibration };
diff --git a/src/epigenomics/characterization.ts b/src/epigenomics/characterization.ts
new file mode 100644
index 000000000..58666e86b
--- /dev/null
+++ b/src/epigenomics/characterization.ts
@@ -0,0 +1,14 @@
+/** epigenomics characterization module — tsb analytics library. */
+export interface EpigenomicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsCharacterization(data: number[], opts: EpigenomicsCharacterizationOptions = {}): EpigenomicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsCharacterization };
diff --git a/src/epigenomics/classification.ts b/src/epigenomics/classification.ts
new file mode 100644
index 000000000..cdedb7bf7
--- /dev/null
+++ b/src/epigenomics/classification.ts
@@ -0,0 +1,14 @@
+/** epigenomics classification module — tsb analytics library. */
+export interface EpigenomicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsClassificationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsClassification(data: number[], opts: EpigenomicsClassificationOptions = {}): EpigenomicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsClassification };
diff --git a/src/epigenomics/clustering.ts b/src/epigenomics/clustering.ts
new file mode 100644
index 000000000..654d3828c
--- /dev/null
+++ b/src/epigenomics/clustering.ts
@@ -0,0 +1,14 @@
+/** epigenomics clustering module — tsb analytics library. */
+export interface EpigenomicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsClusteringResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsClustering(data: number[], opts: EpigenomicsClusteringOptions = {}): EpigenomicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsClustering };
diff --git a/src/epigenomics/compression.ts b/src/epigenomics/compression.ts
new file mode 100644
index 000000000..703407773
--- /dev/null
+++ b/src/epigenomics/compression.ts
@@ -0,0 +1,14 @@
+/** epigenomics compression module — tsb analytics library. */
+export interface EpigenomicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsCompressionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsCompression(data: number[], opts: EpigenomicsCompressionOptions = {}): EpigenomicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsCompression };
diff --git a/src/epigenomics/continuous.ts b/src/epigenomics/continuous.ts
new file mode 100644
index 000000000..f1108299e
--- /dev/null
+++ b/src/epigenomics/continuous.ts
@@ -0,0 +1,14 @@
+/** epigenomics continuous module — tsb analytics library. */
+export interface EpigenomicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsContinuousResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsContinuous(data: number[], opts: EpigenomicsContinuousOptions = {}): EpigenomicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsContinuous };
diff --git a/src/epigenomics/control.ts b/src/epigenomics/control.ts
new file mode 100644
index 000000000..9f2a6e48a
--- /dev/null
+++ b/src/epigenomics/control.ts
@@ -0,0 +1,14 @@
+/** epigenomics control module — tsb analytics library. */
+export interface EpigenomicsControlOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsControlResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsControl(data: number[], opts: EpigenomicsControlOptions = {}): EpigenomicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsControl };
diff --git a/src/epigenomics/convergence.ts b/src/epigenomics/convergence.ts
new file mode 100644
index 000000000..1911fcebd
--- /dev/null
+++ b/src/epigenomics/convergence.ts
@@ -0,0 +1,14 @@
+/** epigenomics convergence module — tsb analytics library. */
+export interface EpigenomicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsConvergence(data: number[], opts: EpigenomicsConvergenceOptions = {}): EpigenomicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsConvergence };
diff --git a/src/epigenomics/convex.ts b/src/epigenomics/convex.ts
new file mode 100644
index 000000000..b49b7775d
--- /dev/null
+++ b/src/epigenomics/convex.ts
@@ -0,0 +1,14 @@
+/** epigenomics convex module — tsb analytics library. */
+export interface EpigenomicsConvexOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsConvexResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsConvex(data: number[], opts: EpigenomicsConvexOptions = {}): EpigenomicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsConvex };
diff --git a/src/epigenomics/correlation.ts b/src/epigenomics/correlation.ts
new file mode 100644
index 000000000..c6ce992e7
--- /dev/null
+++ b/src/epigenomics/correlation.ts
@@ -0,0 +1,14 @@
+/** epigenomics correlation module — tsb analytics library. */
+export interface EpigenomicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsCorrelation(data: number[], opts: EpigenomicsCorrelationOptions = {}): EpigenomicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsCorrelation };
diff --git a/src/epigenomics/covariance.ts b/src/epigenomics/covariance.ts
new file mode 100644
index 000000000..e5c0f2d72
--- /dev/null
+++ b/src/epigenomics/covariance.ts
@@ -0,0 +1,14 @@
+/** epigenomics covariance module — tsb analytics library. */
+export interface EpigenomicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsCovariance(data: number[], opts: EpigenomicsCovarianceOptions = {}): EpigenomicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsCovariance };
diff --git a/src/epigenomics/cross_validation.ts b/src/epigenomics/cross_validation.ts
new file mode 100644
index 000000000..004b6cd51
--- /dev/null
+++ b/src/epigenomics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** epigenomics cross_validation module — tsb analytics library. */
+export interface EpigenomicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsCrossValidation(data: number[], opts: EpigenomicsCrossValidationOptions = {}): EpigenomicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsCrossValidation };
diff --git a/src/epigenomics/decoding.ts b/src/epigenomics/decoding.ts
new file mode 100644
index 000000000..b017b1614
--- /dev/null
+++ b/src/epigenomics/decoding.ts
@@ -0,0 +1,14 @@
+/** epigenomics decoding module — tsb analytics library. */
+export interface EpigenomicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDecodingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDecoding(data: number[], opts: EpigenomicsDecodingOptions = {}): EpigenomicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDecoding };
diff --git a/src/epigenomics/decomposition.ts b/src/epigenomics/decomposition.ts
new file mode 100644
index 000000000..820ac4847
--- /dev/null
+++ b/src/epigenomics/decomposition.ts
@@ -0,0 +1,14 @@
+/** epigenomics decomposition module — tsb analytics library. */
+export interface EpigenomicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDecomposition(data: number[], opts: EpigenomicsDecompositionOptions = {}): EpigenomicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDecomposition };
diff --git a/src/epigenomics/detection.ts b/src/epigenomics/detection.ts
new file mode 100644
index 000000000..fea338857
--- /dev/null
+++ b/src/epigenomics/detection.ts
@@ -0,0 +1,14 @@
+/** epigenomics detection module — tsb analytics library. */
+export interface EpigenomicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDetectionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDetection(data: number[], opts: EpigenomicsDetectionOptions = {}): EpigenomicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDetection };
diff --git a/src/epigenomics/deterministic.ts b/src/epigenomics/deterministic.ts
new file mode 100644
index 000000000..d516be666
--- /dev/null
+++ b/src/epigenomics/deterministic.ts
@@ -0,0 +1,14 @@
+/** epigenomics deterministic module — tsb analytics library. */
+export interface EpigenomicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDeterministic(data: number[], opts: EpigenomicsDeterministicOptions = {}): EpigenomicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDeterministic };
diff --git a/src/epigenomics/diagnostics.ts b/src/epigenomics/diagnostics.ts
new file mode 100644
index 000000000..6ebdc21ac
--- /dev/null
+++ b/src/epigenomics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** epigenomics diagnostics module — tsb analytics library. */
+export interface EpigenomicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDiagnostics(data: number[], opts: EpigenomicsDiagnosticsOptions = {}): EpigenomicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDiagnostics };
diff --git a/src/epigenomics/differential.ts b/src/epigenomics/differential.ts
new file mode 100644
index 000000000..417c4f9a4
--- /dev/null
+++ b/src/epigenomics/differential.ts
@@ -0,0 +1,14 @@
+/** epigenomics differential module — tsb analytics library. */
+export interface EpigenomicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDifferential(data: number[], opts: EpigenomicsDifferentialOptions = {}): EpigenomicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDifferential };
diff --git a/src/epigenomics/discrete.ts b/src/epigenomics/discrete.ts
new file mode 100644
index 000000000..38bde861a
--- /dev/null
+++ b/src/epigenomics/discrete.ts
@@ -0,0 +1,14 @@
+/** epigenomics discrete module — tsb analytics library. */
+export interface EpigenomicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDiscrete(data: number[], opts: EpigenomicsDiscreteOptions = {}): EpigenomicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDiscrete };
diff --git a/src/epigenomics/distribution.ts b/src/epigenomics/distribution.ts
new file mode 100644
index 000000000..46f0eb7bf
--- /dev/null
+++ b/src/epigenomics/distribution.ts
@@ -0,0 +1,14 @@
+/** epigenomics distribution module — tsb analytics library. */
+export interface EpigenomicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDistributionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDistribution(data: number[], opts: EpigenomicsDistributionOptions = {}): EpigenomicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDistribution };
diff --git a/src/epigenomics/dynamic.ts b/src/epigenomics/dynamic.ts
new file mode 100644
index 000000000..878556a7d
--- /dev/null
+++ b/src/epigenomics/dynamic.ts
@@ -0,0 +1,14 @@
+/** epigenomics dynamic module — tsb analytics library. */
+export interface EpigenomicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsDynamicResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsDynamic(data: number[], opts: EpigenomicsDynamicOptions = {}): EpigenomicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsDynamic };
diff --git a/src/epigenomics/embedding.ts b/src/epigenomics/embedding.ts
new file mode 100644
index 000000000..750644d08
--- /dev/null
+++ b/src/epigenomics/embedding.ts
@@ -0,0 +1,14 @@
+/** epigenomics embedding module — tsb analytics library. */
+export interface EpigenomicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsEmbedding(data: number[], opts: EpigenomicsEmbeddingOptions = {}): EpigenomicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsEmbedding };
diff --git a/src/epigenomics/encoding.ts b/src/epigenomics/encoding.ts
new file mode 100644
index 000000000..c29a73318
--- /dev/null
+++ b/src/epigenomics/encoding.ts
@@ -0,0 +1,14 @@
+/** epigenomics encoding module — tsb analytics library. */
+export interface EpigenomicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsEncodingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsEncoding(data: number[], opts: EpigenomicsEncodingOptions = {}): EpigenomicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsEncoding };
diff --git a/src/epigenomics/ensemble.ts b/src/epigenomics/ensemble.ts
new file mode 100644
index 000000000..82bd0eddf
--- /dev/null
+++ b/src/epigenomics/ensemble.ts
@@ -0,0 +1,14 @@
+/** epigenomics ensemble module — tsb analytics library. */
+export interface EpigenomicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsEnsemble(data: number[], opts: EpigenomicsEnsembleOptions = {}): EpigenomicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsEnsemble };
diff --git a/src/epigenomics/estimation.ts b/src/epigenomics/estimation.ts
new file mode 100644
index 000000000..b77db95ee
--- /dev/null
+++ b/src/epigenomics/estimation.ts
@@ -0,0 +1,14 @@
+/** epigenomics estimation module — tsb analytics library. */
+export interface EpigenomicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsEstimationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsEstimation(data: number[], opts: EpigenomicsEstimationOptions = {}): EpigenomicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsEstimation };
diff --git a/src/epigenomics/evaluation.ts b/src/epigenomics/evaluation.ts
new file mode 100644
index 000000000..bde548950
--- /dev/null
+++ b/src/epigenomics/evaluation.ts
@@ -0,0 +1,14 @@
+/** epigenomics evaluation module — tsb analytics library. */
+export interface EpigenomicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsEvaluation(data: number[], opts: EpigenomicsEvaluationOptions = {}): EpigenomicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsEvaluation };
diff --git a/src/epigenomics/extrapolation.ts b/src/epigenomics/extrapolation.ts
new file mode 100644
index 000000000..84d617cc6
--- /dev/null
+++ b/src/epigenomics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** epigenomics extrapolation module — tsb analytics library. */
+export interface EpigenomicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsExtrapolation(data: number[], opts: EpigenomicsExtrapolationOptions = {}): EpigenomicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsExtrapolation };
diff --git a/src/epigenomics/features.ts b/src/epigenomics/features.ts
new file mode 100644
index 000000000..9e0197210
--- /dev/null
+++ b/src/epigenomics/features.ts
@@ -0,0 +1,14 @@
+/** epigenomics features module — tsb analytics library. */
+export interface EpigenomicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsFeatures(data: number[], opts: EpigenomicsFeaturesOptions = {}): EpigenomicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsFeatures };
diff --git a/src/epigenomics/feedback.ts b/src/epigenomics/feedback.ts
new file mode 100644
index 000000000..0aa535449
--- /dev/null
+++ b/src/epigenomics/feedback.ts
@@ -0,0 +1,14 @@
+/** epigenomics feedback module — tsb analytics library. */
+export interface EpigenomicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsFeedback(data: number[], opts: EpigenomicsFeedbackOptions = {}): EpigenomicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsFeedback };
diff --git a/src/epigenomics/filtering.ts b/src/epigenomics/filtering.ts
new file mode 100644
index 000000000..443fe7393
--- /dev/null
+++ b/src/epigenomics/filtering.ts
@@ -0,0 +1,14 @@
+/** epigenomics filtering module — tsb analytics library. */
+export interface EpigenomicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsFilteringResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsFiltering(data: number[], opts: EpigenomicsFilteringOptions = {}): EpigenomicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsFiltering };
diff --git a/src/epigenomics/fourier.ts b/src/epigenomics/fourier.ts
new file mode 100644
index 000000000..a77adb0da
--- /dev/null
+++ b/src/epigenomics/fourier.ts
@@ -0,0 +1,14 @@
+/** epigenomics fourier module — tsb analytics library. */
+export interface EpigenomicsFourierOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsFourierResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsFourier(data: number[], opts: EpigenomicsFourierOptions = {}): EpigenomicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsFourier };
diff --git a/src/epigenomics/fusion.ts b/src/epigenomics/fusion.ts
new file mode 100644
index 000000000..477d6e6d1
--- /dev/null
+++ b/src/epigenomics/fusion.ts
@@ -0,0 +1,14 @@
+/** epigenomics fusion module — tsb analytics library. */
+export interface EpigenomicsFusionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsFusionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsFusion(data: number[], opts: EpigenomicsFusionOptions = {}): EpigenomicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsFusion };
diff --git a/src/epigenomics/generation.ts b/src/epigenomics/generation.ts
new file mode 100644
index 000000000..ed05997d4
--- /dev/null
+++ b/src/epigenomics/generation.ts
@@ -0,0 +1,14 @@
+/** epigenomics generation module — tsb analytics library. */
+export interface EpigenomicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsGenerationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsGeneration(data: number[], opts: EpigenomicsGenerationOptions = {}): EpigenomicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsGeneration };
diff --git a/src/epigenomics/geometry.ts b/src/epigenomics/geometry.ts
new file mode 100644
index 000000000..e047314eb
--- /dev/null
+++ b/src/epigenomics/geometry.ts
@@ -0,0 +1,14 @@
+/** epigenomics geometry module — tsb analytics library. */
+export interface EpigenomicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsGeometryResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsGeometry(data: number[], opts: EpigenomicsGeometryOptions = {}): EpigenomicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsGeometry };
diff --git a/src/epigenomics/gradient.ts b/src/epigenomics/gradient.ts
new file mode 100644
index 000000000..a6d782bcb
--- /dev/null
+++ b/src/epigenomics/gradient.ts
@@ -0,0 +1,14 @@
+/** epigenomics gradient module — tsb analytics library. */
+export interface EpigenomicsGradientOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsGradientResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsGradient(data: number[], opts: EpigenomicsGradientOptions = {}): EpigenomicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsGradient };
diff --git a/src/epigenomics/hessian.ts b/src/epigenomics/hessian.ts
new file mode 100644
index 000000000..646eb51a7
--- /dev/null
+++ b/src/epigenomics/hessian.ts
@@ -0,0 +1,14 @@
+/** epigenomics hessian module — tsb analytics library. */
+export interface EpigenomicsHessianOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsHessianResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsHessian(data: number[], opts: EpigenomicsHessianOptions = {}): EpigenomicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsHessian };
diff --git a/src/epigenomics/hypothesis.ts b/src/epigenomics/hypothesis.ts
new file mode 100644
index 000000000..2a8597e94
--- /dev/null
+++ b/src/epigenomics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** epigenomics hypothesis module — tsb analytics library. */
+export interface EpigenomicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsHypothesis(data: number[], opts: EpigenomicsHypothesisOptions = {}): EpigenomicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsHypothesis };
diff --git a/src/epigenomics/inference.ts b/src/epigenomics/inference.ts
new file mode 100644
index 000000000..a9c3f2d79
--- /dev/null
+++ b/src/epigenomics/inference.ts
@@ -0,0 +1,14 @@
+/** epigenomics inference module — tsb analytics library. */
+export interface EpigenomicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsInferenceResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsInference(data: number[], opts: EpigenomicsInferenceOptions = {}): EpigenomicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsInference };
diff --git a/src/epigenomics/inference2.ts b/src/epigenomics/inference2.ts
new file mode 100644
index 000000000..efc054a2a
--- /dev/null
+++ b/src/epigenomics/inference2.ts
@@ -0,0 +1,14 @@
+/** epigenomics inference2 module — tsb analytics library. */
+export interface EpigenomicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsInferenceResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsInference(data: number[], opts: EpigenomicsInferenceOptions = {}): EpigenomicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsInference };
diff --git a/src/epigenomics/integral.ts b/src/epigenomics/integral.ts
new file mode 100644
index 000000000..639dd095b
--- /dev/null
+++ b/src/epigenomics/integral.ts
@@ -0,0 +1,14 @@
+/** epigenomics integral module — tsb analytics library. */
+export interface EpigenomicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsIntegralResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsIntegral(data: number[], opts: EpigenomicsIntegralOptions = {}): EpigenomicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsIntegral };
diff --git a/src/epigenomics/integration.ts b/src/epigenomics/integration.ts
new file mode 100644
index 000000000..49c4807f3
--- /dev/null
+++ b/src/epigenomics/integration.ts
@@ -0,0 +1,14 @@
+/** epigenomics integration module — tsb analytics library. */
+export interface EpigenomicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsIntegration(data: number[], opts: EpigenomicsIntegrationOptions = {}): EpigenomicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsIntegration };
diff --git a/src/epigenomics/interpolation.ts b/src/epigenomics/interpolation.ts
new file mode 100644
index 000000000..cfbc10a66
--- /dev/null
+++ b/src/epigenomics/interpolation.ts
@@ -0,0 +1,14 @@
+/** epigenomics interpolation module — tsb analytics library. */
+export interface EpigenomicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsInterpolation(data: number[], opts: EpigenomicsInterpolationOptions = {}): EpigenomicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsInterpolation };
diff --git a/src/epigenomics/jacobian.ts b/src/epigenomics/jacobian.ts
new file mode 100644
index 000000000..f8b3142f2
--- /dev/null
+++ b/src/epigenomics/jacobian.ts
@@ -0,0 +1,14 @@
+/** epigenomics jacobian module — tsb analytics library. */
+export interface EpigenomicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsJacobianResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsJacobian(data: number[], opts: EpigenomicsJacobianOptions = {}): EpigenomicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsJacobian };
diff --git a/src/epigenomics/kernel.ts b/src/epigenomics/kernel.ts
new file mode 100644
index 000000000..f0f1f9e9e
--- /dev/null
+++ b/src/epigenomics/kernel.ts
@@ -0,0 +1,14 @@
+/** epigenomics kernel module — tsb analytics library. */
+export interface EpigenomicsKernelOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsKernelResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsKernel(data: number[], opts: EpigenomicsKernelOptions = {}): EpigenomicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsKernel };
diff --git a/src/epigenomics/laplacian.ts b/src/epigenomics/laplacian.ts
new file mode 100644
index 000000000..0649a127e
--- /dev/null
+++ b/src/epigenomics/laplacian.ts
@@ -0,0 +1,14 @@
+/** epigenomics laplacian module — tsb analytics library. */
+export interface EpigenomicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsLaplacian(data: number[], opts: EpigenomicsLaplacianOptions = {}): EpigenomicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsLaplacian };
diff --git a/src/epigenomics/learning.ts b/src/epigenomics/learning.ts
new file mode 100644
index 000000000..3958ed9e0
--- /dev/null
+++ b/src/epigenomics/learning.ts
@@ -0,0 +1,14 @@
+/** epigenomics learning module — tsb analytics library. */
+export interface EpigenomicsLearningOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsLearningResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsLearning(data: number[], opts: EpigenomicsLearningOptions = {}): EpigenomicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsLearning };
diff --git a/src/epigenomics/linear.ts b/src/epigenomics/linear.ts
new file mode 100644
index 000000000..b0c85ac99
--- /dev/null
+++ b/src/epigenomics/linear.ts
@@ -0,0 +1,14 @@
+/** epigenomics linear module — tsb analytics library. */
+export interface EpigenomicsLinearOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsLinearResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsLinear(data: number[], opts: EpigenomicsLinearOptions = {}): EpigenomicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsLinear };
diff --git a/src/epigenomics/manifold.ts b/src/epigenomics/manifold.ts
new file mode 100644
index 000000000..8f30fb45f
--- /dev/null
+++ b/src/epigenomics/manifold.ts
@@ -0,0 +1,14 @@
+/** epigenomics manifold module — tsb analytics library. */
+export interface EpigenomicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsManifoldResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsManifold(data: number[], opts: EpigenomicsManifoldOptions = {}): EpigenomicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsManifold };
diff --git a/src/epigenomics/matching.ts b/src/epigenomics/matching.ts
new file mode 100644
index 000000000..ba9b65d4c
--- /dev/null
+++ b/src/epigenomics/matching.ts
@@ -0,0 +1,14 @@
+/** epigenomics matching module — tsb analytics library. */
+export interface EpigenomicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsMatchingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsMatching(data: number[], opts: EpigenomicsMatchingOptions = {}): EpigenomicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsMatching };
diff --git a/src/epigenomics/measurement.ts b/src/epigenomics/measurement.ts
new file mode 100644
index 000000000..584517eec
--- /dev/null
+++ b/src/epigenomics/measurement.ts
@@ -0,0 +1,14 @@
+/** epigenomics measurement module — tsb analytics library. */
+export interface EpigenomicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsMeasurement(data: number[], opts: EpigenomicsMeasurementOptions = {}): EpigenomicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsMeasurement };
diff --git a/src/epigenomics/metrics.ts b/src/epigenomics/metrics.ts
new file mode 100644
index 000000000..04f1daca7
--- /dev/null
+++ b/src/epigenomics/metrics.ts
@@ -0,0 +1,14 @@
+/** epigenomics metrics module — tsb analytics library. */
+export interface EpigenomicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsMetricsResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsMetrics(data: number[], opts: EpigenomicsMetricsOptions = {}): EpigenomicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsMetrics };
diff --git a/src/epigenomics/modeling.ts b/src/epigenomics/modeling.ts
new file mode 100644
index 000000000..db5467d00
--- /dev/null
+++ b/src/epigenomics/modeling.ts
@@ -0,0 +1,14 @@
+/** epigenomics modeling module — tsb analytics library. */
+export interface EpigenomicsModelingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsModelingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsModeling(data: number[], opts: EpigenomicsModelingOptions = {}): EpigenomicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsModeling };
diff --git a/src/epigenomics/monitoring.ts b/src/epigenomics/monitoring.ts
new file mode 100644
index 000000000..27a049ee7
--- /dev/null
+++ b/src/epigenomics/monitoring.ts
@@ -0,0 +1,14 @@
+/** epigenomics monitoring module — tsb analytics library. */
+export interface EpigenomicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsMonitoring(data: number[], opts: EpigenomicsMonitoringOptions = {}): EpigenomicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsMonitoring };
diff --git a/src/epigenomics/nonlinear.ts b/src/epigenomics/nonlinear.ts
new file mode 100644
index 000000000..02da327db
--- /dev/null
+++ b/src/epigenomics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** epigenomics nonlinear module — tsb analytics library. */
+export interface EpigenomicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsNonlinear(data: number[], opts: EpigenomicsNonlinearOptions = {}): EpigenomicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsNonlinear };
diff --git a/src/epigenomics/normalization.ts b/src/epigenomics/normalization.ts
new file mode 100644
index 000000000..92809b99d
--- /dev/null
+++ b/src/epigenomics/normalization.ts
@@ -0,0 +1,14 @@
+/** epigenomics normalization module — tsb analytics library. */
+export interface EpigenomicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsNormalization(data: number[], opts: EpigenomicsNormalizationOptions = {}): EpigenomicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsNormalization };
diff --git a/src/epigenomics/optimization.ts b/src/epigenomics/optimization.ts
new file mode 100644
index 000000000..29d7d635c
--- /dev/null
+++ b/src/epigenomics/optimization.ts
@@ -0,0 +1,14 @@
+/** epigenomics optimization module — tsb analytics library. */
+export interface EpigenomicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsOptimization(data: number[], opts: EpigenomicsOptimizationOptions = {}): EpigenomicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsOptimization };
diff --git a/src/epigenomics/patterns.ts b/src/epigenomics/patterns.ts
new file mode 100644
index 000000000..02aca0ec9
--- /dev/null
+++ b/src/epigenomics/patterns.ts
@@ -0,0 +1,14 @@
+/** epigenomics patterns module — tsb analytics library. */
+export interface EpigenomicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsPatternsResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsPatterns(data: number[], opts: EpigenomicsPatternsOptions = {}): EpigenomicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsPatterns };
diff --git a/src/epigenomics/permutation.ts b/src/epigenomics/permutation.ts
new file mode 100644
index 000000000..d53b1b6a3
--- /dev/null
+++ b/src/epigenomics/permutation.ts
@@ -0,0 +1,14 @@
+/** epigenomics permutation module — tsb analytics library. */
+export interface EpigenomicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsPermutationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsPermutation(data: number[], opts: EpigenomicsPermutationOptions = {}): EpigenomicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsPermutation };
diff --git a/src/epigenomics/prediction.ts b/src/epigenomics/prediction.ts
new file mode 100644
index 000000000..539c26025
--- /dev/null
+++ b/src/epigenomics/prediction.ts
@@ -0,0 +1,14 @@
+/** epigenomics prediction module — tsb analytics library. */
+export interface EpigenomicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsPredictionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsPrediction(data: number[], opts: EpigenomicsPredictionOptions = {}): EpigenomicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsPrediction };
diff --git a/src/epigenomics/processing.ts b/src/epigenomics/processing.ts
new file mode 100644
index 000000000..93f3b8e14
--- /dev/null
+++ b/src/epigenomics/processing.ts
@@ -0,0 +1,14 @@
+/** epigenomics processing module — tsb analytics library. */
+export interface EpigenomicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsProcessingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsProcessing(data: number[], opts: EpigenomicsProcessingOptions = {}): EpigenomicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsProcessing };
diff --git a/src/epigenomics/profiling.ts b/src/epigenomics/profiling.ts
new file mode 100644
index 000000000..f2e5a4810
--- /dev/null
+++ b/src/epigenomics/profiling.ts
@@ -0,0 +1,14 @@
+/** epigenomics profiling module — tsb analytics library. */
+export interface EpigenomicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsProfilingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsProfiling(data: number[], opts: EpigenomicsProfilingOptions = {}): EpigenomicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsProfiling };
diff --git a/src/epigenomics/projection.ts b/src/epigenomics/projection.ts
new file mode 100644
index 000000000..31c712e43
--- /dev/null
+++ b/src/epigenomics/projection.ts
@@ -0,0 +1,14 @@
+/** epigenomics projection module — tsb analytics library. */
+export interface EpigenomicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsProjectionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsProjection(data: number[], opts: EpigenomicsProjectionOptions = {}): EpigenomicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsProjection };
diff --git a/src/epigenomics/ranking.ts b/src/epigenomics/ranking.ts
new file mode 100644
index 000000000..fa0ff1e1d
--- /dev/null
+++ b/src/epigenomics/ranking.ts
@@ -0,0 +1,14 @@
+/** epigenomics ranking module — tsb analytics library. */
+export interface EpigenomicsRankingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsRankingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsRanking(data: number[], opts: EpigenomicsRankingOptions = {}): EpigenomicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsRanking };
diff --git a/src/epigenomics/reconstruction.ts b/src/epigenomics/reconstruction.ts
new file mode 100644
index 000000000..76e306036
--- /dev/null
+++ b/src/epigenomics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** epigenomics reconstruction module — tsb analytics library. */
+export interface EpigenomicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsReconstruction(data: number[], opts: EpigenomicsReconstructionOptions = {}): EpigenomicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsReconstruction };
diff --git a/src/epigenomics/registration.ts b/src/epigenomics/registration.ts
new file mode 100644
index 000000000..ff7b2756c
--- /dev/null
+++ b/src/epigenomics/registration.ts
@@ -0,0 +1,14 @@
+/** epigenomics registration module — tsb analytics library. */
+export interface EpigenomicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsRegistration(data: number[], opts: EpigenomicsRegistrationOptions = {}): EpigenomicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsRegistration };
diff --git a/src/epigenomics/regression.ts b/src/epigenomics/regression.ts
new file mode 100644
index 000000000..e8d0e20af
--- /dev/null
+++ b/src/epigenomics/regression.ts
@@ -0,0 +1,14 @@
+/** epigenomics regression module — tsb analytics library. */
+export interface EpigenomicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsRegressionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsRegression(data: number[], opts: EpigenomicsRegressionOptions = {}): EpigenomicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsRegression };
diff --git a/src/epigenomics/regularization.ts b/src/epigenomics/regularization.ts
new file mode 100644
index 000000000..f00876471
--- /dev/null
+++ b/src/epigenomics/regularization.ts
@@ -0,0 +1,14 @@
+/** epigenomics regularization module — tsb analytics library. */
+export interface EpigenomicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsRegularization(data: number[], opts: EpigenomicsRegularizationOptions = {}): EpigenomicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsRegularization };
diff --git a/src/epigenomics/robustness.ts b/src/epigenomics/robustness.ts
new file mode 100644
index 000000000..bb366b086
--- /dev/null
+++ b/src/epigenomics/robustness.ts
@@ -0,0 +1,14 @@
+/** epigenomics robustness module — tsb analytics library. */
+export interface EpigenomicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsRobustness(data: number[], opts: EpigenomicsRobustnessOptions = {}): EpigenomicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsRobustness };
diff --git a/src/epigenomics/sampling.ts b/src/epigenomics/sampling.ts
new file mode 100644
index 000000000..a65a34c63
--- /dev/null
+++ b/src/epigenomics/sampling.ts
@@ -0,0 +1,14 @@
+/** epigenomics sampling module — tsb analytics library. */
+export interface EpigenomicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsSamplingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsSampling(data: number[], opts: EpigenomicsSamplingOptions = {}): EpigenomicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsSampling };
diff --git a/src/epigenomics/sampling2.ts b/src/epigenomics/sampling2.ts
new file mode 100644
index 000000000..bde57bcdb
--- /dev/null
+++ b/src/epigenomics/sampling2.ts
@@ -0,0 +1,14 @@
+/** epigenomics sampling2 module — tsb analytics library. */
+export interface EpigenomicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsSamplingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsSampling(data: number[], opts: EpigenomicsSamplingOptions = {}): EpigenomicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsSampling };
diff --git a/src/epigenomics/scaling.ts b/src/epigenomics/scaling.ts
new file mode 100644
index 000000000..51e230cc4
--- /dev/null
+++ b/src/epigenomics/scaling.ts
@@ -0,0 +1,14 @@
+/** epigenomics scaling module — tsb analytics library. */
+export interface EpigenomicsScalingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsScalingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsScaling(data: number[], opts: EpigenomicsScalingOptions = {}): EpigenomicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsScaling };
diff --git a/src/epigenomics/scoring.ts b/src/epigenomics/scoring.ts
new file mode 100644
index 000000000..ad8dc9611
--- /dev/null
+++ b/src/epigenomics/scoring.ts
@@ -0,0 +1,14 @@
+/** epigenomics scoring module — tsb analytics library. */
+export interface EpigenomicsScoringOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsScoringResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsScoring(data: number[], opts: EpigenomicsScoringOptions = {}): EpigenomicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsScoring };
diff --git a/src/epigenomics/segmentation.ts b/src/epigenomics/segmentation.ts
new file mode 100644
index 000000000..042d29ce7
--- /dev/null
+++ b/src/epigenomics/segmentation.ts
@@ -0,0 +1,14 @@
+/** epigenomics segmentation module — tsb analytics library. */
+export interface EpigenomicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsSegmentation(data: number[], opts: EpigenomicsSegmentationOptions = {}): EpigenomicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsSegmentation };
diff --git a/src/epigenomics/selection.ts b/src/epigenomics/selection.ts
new file mode 100644
index 000000000..774b71296
--- /dev/null
+++ b/src/epigenomics/selection.ts
@@ -0,0 +1,14 @@
+/** epigenomics selection module — tsb analytics library. */
+export interface EpigenomicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsSelectionResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsSelection(data: number[], opts: EpigenomicsSelectionOptions = {}): EpigenomicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsSelection };
diff --git a/src/epigenomics/sensitivity.ts b/src/epigenomics/sensitivity.ts
new file mode 100644
index 000000000..6b166ca2c
--- /dev/null
+++ b/src/epigenomics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** epigenomics sensitivity module — tsb analytics library. */
+export interface EpigenomicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsSensitivity(data: number[], opts: EpigenomicsSensitivityOptions = {}): EpigenomicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsSensitivity };
diff --git a/src/epigenomics/simulation.ts b/src/epigenomics/simulation.ts
new file mode 100644
index 000000000..4e004f482
--- /dev/null
+++ b/src/epigenomics/simulation.ts
@@ -0,0 +1,14 @@
+/** epigenomics simulation module — tsb analytics library. */
+export interface EpigenomicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsSimulationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsSimulation(data: number[], opts: EpigenomicsSimulationOptions = {}): EpigenomicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsSimulation };
diff --git a/src/epigenomics/smoothing.ts b/src/epigenomics/smoothing.ts
new file mode 100644
index 000000000..6899360c2
--- /dev/null
+++ b/src/epigenomics/smoothing.ts
@@ -0,0 +1,14 @@
+/** epigenomics smoothing module — tsb analytics library. */
+export interface EpigenomicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsSmoothing(data: number[], opts: EpigenomicsSmoothingOptions = {}): EpigenomicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsSmoothing };
diff --git a/src/epigenomics/stability.ts b/src/epigenomics/stability.ts
new file mode 100644
index 000000000..5942edef1
--- /dev/null
+++ b/src/epigenomics/stability.ts
@@ -0,0 +1,14 @@
+/** epigenomics stability module — tsb analytics library. */
+export interface EpigenomicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsStabilityResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsStability(data: number[], opts: EpigenomicsStabilityOptions = {}): EpigenomicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsStability };
diff --git a/src/epigenomics/stacking.ts b/src/epigenomics/stacking.ts
new file mode 100644
index 000000000..e8f1490cb
--- /dev/null
+++ b/src/epigenomics/stacking.ts
@@ -0,0 +1,14 @@
+/** epigenomics stacking module — tsb analytics library. */
+export interface EpigenomicsStackingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsStackingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsStacking(data: number[], opts: EpigenomicsStackingOptions = {}): EpigenomicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsStacking };
diff --git a/src/epigenomics/standardization.ts b/src/epigenomics/standardization.ts
new file mode 100644
index 000000000..b937e0e7f
--- /dev/null
+++ b/src/epigenomics/standardization.ts
@@ -0,0 +1,14 @@
+/** epigenomics standardization module — tsb analytics library. */
+export interface EpigenomicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsStandardization(data: number[], opts: EpigenomicsStandardizationOptions = {}): EpigenomicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsStandardization };
diff --git a/src/epigenomics/static.ts b/src/epigenomics/static.ts
new file mode 100644
index 000000000..ad0821dd0
--- /dev/null
+++ b/src/epigenomics/static.ts
@@ -0,0 +1,14 @@
+/** epigenomics static module — tsb analytics library. */
+export interface EpigenomicsStaticOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsStaticResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsStatic(data: number[], opts: EpigenomicsStaticOptions = {}): EpigenomicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsStatic };
diff --git a/src/epigenomics/stochastic.ts b/src/epigenomics/stochastic.ts
new file mode 100644
index 000000000..a6f076ddd
--- /dev/null
+++ b/src/epigenomics/stochastic.ts
@@ -0,0 +1,14 @@
+/** epigenomics stochastic module — tsb analytics library. */
+export interface EpigenomicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsStochasticResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsStochastic(data: number[], opts: EpigenomicsStochasticOptions = {}): EpigenomicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsStochastic };
diff --git a/src/epigenomics/synthesis.ts b/src/epigenomics/synthesis.ts
new file mode 100644
index 000000000..8a023bd01
--- /dev/null
+++ b/src/epigenomics/synthesis.ts
@@ -0,0 +1,14 @@
+/** epigenomics synthesis module — tsb analytics library. */
+export interface EpigenomicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsSynthesis(data: number[], opts: EpigenomicsSynthesisOptions = {}): EpigenomicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsSynthesis };
diff --git a/src/epigenomics/topology.ts b/src/epigenomics/topology.ts
new file mode 100644
index 000000000..d54e5db4a
--- /dev/null
+++ b/src/epigenomics/topology.ts
@@ -0,0 +1,14 @@
+/** epigenomics topology module — tsb analytics library. */
+export interface EpigenomicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsTopologyResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsTopology(data: number[], opts: EpigenomicsTopologyOptions = {}): EpigenomicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsTopology };
diff --git a/src/epigenomics/tracking.ts b/src/epigenomics/tracking.ts
new file mode 100644
index 000000000..8ccee62d8
--- /dev/null
+++ b/src/epigenomics/tracking.ts
@@ -0,0 +1,14 @@
+/** epigenomics tracking module — tsb analytics library. */
+export interface EpigenomicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsTrackingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsTracking(data: number[], opts: EpigenomicsTrackingOptions = {}): EpigenomicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsTracking };
diff --git a/src/epigenomics/transform.ts b/src/epigenomics/transform.ts
new file mode 100644
index 000000000..037f54abb
--- /dev/null
+++ b/src/epigenomics/transform.ts
@@ -0,0 +1,14 @@
+/** epigenomics transform module — tsb analytics library. */
+export interface EpigenomicsTransformOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsTransformResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsTransform(data: number[], opts: EpigenomicsTransformOptions = {}): EpigenomicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsTransform };
diff --git a/src/epigenomics/uncertainty.ts b/src/epigenomics/uncertainty.ts
new file mode 100644
index 000000000..85a824769
--- /dev/null
+++ b/src/epigenomics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** epigenomics uncertainty module — tsb analytics library. */
+export interface EpigenomicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsUncertainty(data: number[], opts: EpigenomicsUncertaintyOptions = {}): EpigenomicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsUncertainty };
diff --git a/src/epigenomics/validation.ts b/src/epigenomics/validation.ts
new file mode 100644
index 000000000..e6c0be364
--- /dev/null
+++ b/src/epigenomics/validation.ts
@@ -0,0 +1,14 @@
+/** epigenomics validation module — tsb analytics library. */
+export interface EpigenomicsValidationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsValidationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsValidation(data: number[], opts: EpigenomicsValidationOptions = {}): EpigenomicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsValidation };
diff --git a/src/epigenomics/verification.ts b/src/epigenomics/verification.ts
new file mode 100644
index 000000000..950a5ef8e
--- /dev/null
+++ b/src/epigenomics/verification.ts
@@ -0,0 +1,14 @@
+/** epigenomics verification module — tsb analytics library. */
+export interface EpigenomicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsVerificationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsVerification(data: number[], opts: EpigenomicsVerificationOptions = {}): EpigenomicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsVerification };
diff --git a/src/epigenomics/visualization.ts b/src/epigenomics/visualization.ts
new file mode 100644
index 000000000..5cf87c0dc
--- /dev/null
+++ b/src/epigenomics/visualization.ts
@@ -0,0 +1,14 @@
+/** epigenomics visualization module — tsb analytics library. */
+export interface EpigenomicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsVisualization(data: number[], opts: EpigenomicsVisualizationOptions = {}): EpigenomicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsVisualization };
diff --git a/src/epigenomics/voting.ts b/src/epigenomics/voting.ts
new file mode 100644
index 000000000..fdba549fe
--- /dev/null
+++ b/src/epigenomics/voting.ts
@@ -0,0 +1,14 @@
+/** epigenomics voting module — tsb analytics library. */
+export interface EpigenomicsVotingOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsVotingResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsVoting(data: number[], opts: EpigenomicsVotingOptions = {}): EpigenomicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsVoting };
diff --git a/src/epigenomics/wavelet.ts b/src/epigenomics/wavelet.ts
new file mode 100644
index 000000000..429a0e87c
--- /dev/null
+++ b/src/epigenomics/wavelet.ts
@@ -0,0 +1,14 @@
+/** epigenomics wavelet module — tsb analytics library. */
+export interface EpigenomicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface EpigenomicsWaveletResult { values: number[]; converged: boolean; }
+export function computeEpigenomicsWavelet(data: number[], opts: EpigenomicsWaveletOptions = {}): EpigenomicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEpigenomicsWavelet };
diff --git a/src/evolutionary_bio/adaptation.ts b/src/evolutionary_bio/adaptation.ts
new file mode 100644
index 000000000..42d702247
--- /dev/null
+++ b/src/evolutionary_bio/adaptation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio adaptation module — tsb analytics library. */
+export interface EvolutionaryBioAdaptationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioAdaptationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioAdaptation(data: number[], opts: EvolutionaryBioAdaptationOptions = {}): EvolutionaryBioAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioAdaptation };
diff --git a/src/evolutionary_bio/aggregation.ts b/src/evolutionary_bio/aggregation.ts
new file mode 100644
index 000000000..c1d553c0d
--- /dev/null
+++ b/src/evolutionary_bio/aggregation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio aggregation module — tsb analytics library. */
+export interface EvolutionaryBioAggregationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioAggregationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioAggregation(data: number[], opts: EvolutionaryBioAggregationOptions = {}): EvolutionaryBioAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioAggregation };
diff --git a/src/evolutionary_bio/algebra.ts b/src/evolutionary_bio/algebra.ts
new file mode 100644
index 000000000..7310f9182
--- /dev/null
+++ b/src/evolutionary_bio/algebra.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio algebra module — tsb analytics library. */
+export interface EvolutionaryBioAlgebraOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioAlgebraResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioAlgebra(data: number[], opts: EvolutionaryBioAlgebraOptions = {}): EvolutionaryBioAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioAlgebra };
diff --git a/src/evolutionary_bio/alignment.ts b/src/evolutionary_bio/alignment.ts
new file mode 100644
index 000000000..3ce8259a9
--- /dev/null
+++ b/src/evolutionary_bio/alignment.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio alignment module — tsb analytics library. */
+export interface EvolutionaryBioAlignmentOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioAlignmentResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioAlignment(data: number[], opts: EvolutionaryBioAlignmentOptions = {}): EvolutionaryBioAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioAlignment };
diff --git a/src/evolutionary_bio/analysis.ts b/src/evolutionary_bio/analysis.ts
new file mode 100644
index 000000000..981942684
--- /dev/null
+++ b/src/evolutionary_bio/analysis.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio analysis module — tsb analytics library. */
+export interface EvolutionaryBioAnalysisOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioAnalysisResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioAnalysis(data: number[], opts: EvolutionaryBioAnalysisOptions = {}): EvolutionaryBioAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioAnalysis };
diff --git a/src/evolutionary_bio/augmentation.ts b/src/evolutionary_bio/augmentation.ts
new file mode 100644
index 000000000..acabe2faf
--- /dev/null
+++ b/src/evolutionary_bio/augmentation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio augmentation module — tsb analytics library. */
+export interface EvolutionaryBioAugmentationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioAugmentationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioAugmentation(data: number[], opts: EvolutionaryBioAugmentationOptions = {}): EvolutionaryBioAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioAugmentation };
diff --git a/src/evolutionary_bio/bagging.ts b/src/evolutionary_bio/bagging.ts
new file mode 100644
index 000000000..2e5611cea
--- /dev/null
+++ b/src/evolutionary_bio/bagging.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio bagging module — tsb analytics library. */
+export interface EvolutionaryBioBaggingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioBaggingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioBagging(data: number[], opts: EvolutionaryBioBaggingOptions = {}): EvolutionaryBioBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioBagging };
diff --git a/src/evolutionary_bio/basis.ts b/src/evolutionary_bio/basis.ts
new file mode 100644
index 000000000..7d6d2ac71
--- /dev/null
+++ b/src/evolutionary_bio/basis.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio basis module — tsb analytics library. */
+export interface EvolutionaryBioBasisOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioBasisResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioBasis(data: number[], opts: EvolutionaryBioBasisOptions = {}): EvolutionaryBioBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioBasis };
diff --git a/src/evolutionary_bio/benchmarking.ts b/src/evolutionary_bio/benchmarking.ts
new file mode 100644
index 000000000..cc4939e2f
--- /dev/null
+++ b/src/evolutionary_bio/benchmarking.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio benchmarking module — tsb analytics library. */
+export interface EvolutionaryBioBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioBenchmarking(data: number[], opts: EvolutionaryBioBenchmarkingOptions = {}): EvolutionaryBioBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioBenchmarking };
diff --git a/src/evolutionary_bio/blending.ts b/src/evolutionary_bio/blending.ts
new file mode 100644
index 000000000..7dc9d191e
--- /dev/null
+++ b/src/evolutionary_bio/blending.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio blending module — tsb analytics library. */
+export interface EvolutionaryBioBlendingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioBlendingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioBlending(data: number[], opts: EvolutionaryBioBlendingOptions = {}): EvolutionaryBioBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioBlending };
diff --git a/src/evolutionary_bio/boosting.ts b/src/evolutionary_bio/boosting.ts
new file mode 100644
index 000000000..2b4434c94
--- /dev/null
+++ b/src/evolutionary_bio/boosting.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio boosting module — tsb analytics library. */
+export interface EvolutionaryBioBoostingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioBoostingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioBoosting(data: number[], opts: EvolutionaryBioBoostingOptions = {}): EvolutionaryBioBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioBoosting };
diff --git a/src/evolutionary_bio/bootstrap.ts b/src/evolutionary_bio/bootstrap.ts
new file mode 100644
index 000000000..41c020179
--- /dev/null
+++ b/src/evolutionary_bio/bootstrap.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio bootstrap module — tsb analytics library. */
+export interface EvolutionaryBioBootstrapOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioBootstrapResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioBootstrap(data: number[], opts: EvolutionaryBioBootstrapOptions = {}): EvolutionaryBioBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioBootstrap };
diff --git a/src/evolutionary_bio/calculus.ts b/src/evolutionary_bio/calculus.ts
new file mode 100644
index 000000000..31b0d36f3
--- /dev/null
+++ b/src/evolutionary_bio/calculus.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio calculus module — tsb analytics library. */
+export interface EvolutionaryBioCalculusOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioCalculusResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioCalculus(data: number[], opts: EvolutionaryBioCalculusOptions = {}): EvolutionaryBioCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioCalculus };
diff --git a/src/evolutionary_bio/calibration.ts b/src/evolutionary_bio/calibration.ts
new file mode 100644
index 000000000..51b816af1
--- /dev/null
+++ b/src/evolutionary_bio/calibration.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio calibration module — tsb analytics library. */
+export interface EvolutionaryBioCalibrationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioCalibrationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioCalibration(data: number[], opts: EvolutionaryBioCalibrationOptions = {}): EvolutionaryBioCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioCalibration };
diff --git a/src/evolutionary_bio/characterization.ts b/src/evolutionary_bio/characterization.ts
new file mode 100644
index 000000000..bac8b5d25
--- /dev/null
+++ b/src/evolutionary_bio/characterization.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio characterization module — tsb analytics library. */
+export interface EvolutionaryBioCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioCharacterizationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioCharacterization(data: number[], opts: EvolutionaryBioCharacterizationOptions = {}): EvolutionaryBioCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioCharacterization };
diff --git a/src/evolutionary_bio/classification.ts b/src/evolutionary_bio/classification.ts
new file mode 100644
index 000000000..23cf8e032
--- /dev/null
+++ b/src/evolutionary_bio/classification.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio classification module — tsb analytics library. */
+export interface EvolutionaryBioClassificationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioClassificationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioClassification(data: number[], opts: EvolutionaryBioClassificationOptions = {}): EvolutionaryBioClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioClassification };
diff --git a/src/evolutionary_bio/clustering.ts b/src/evolutionary_bio/clustering.ts
new file mode 100644
index 000000000..52885ab45
--- /dev/null
+++ b/src/evolutionary_bio/clustering.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio clustering module — tsb analytics library. */
+export interface EvolutionaryBioClusteringOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioClusteringResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioClustering(data: number[], opts: EvolutionaryBioClusteringOptions = {}): EvolutionaryBioClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioClustering };
diff --git a/src/evolutionary_bio/compression.ts b/src/evolutionary_bio/compression.ts
new file mode 100644
index 000000000..3d5df8d81
--- /dev/null
+++ b/src/evolutionary_bio/compression.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio compression module — tsb analytics library. */
+export interface EvolutionaryBioCompressionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioCompressionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioCompression(data: number[], opts: EvolutionaryBioCompressionOptions = {}): EvolutionaryBioCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioCompression };
diff --git a/src/evolutionary_bio/continuous.ts b/src/evolutionary_bio/continuous.ts
new file mode 100644
index 000000000..c61c2997e
--- /dev/null
+++ b/src/evolutionary_bio/continuous.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio continuous module — tsb analytics library. */
+export interface EvolutionaryBioContinuousOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioContinuousResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioContinuous(data: number[], opts: EvolutionaryBioContinuousOptions = {}): EvolutionaryBioContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioContinuous };
diff --git a/src/evolutionary_bio/control.ts b/src/evolutionary_bio/control.ts
new file mode 100644
index 000000000..6f2f44038
--- /dev/null
+++ b/src/evolutionary_bio/control.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio control module — tsb analytics library. */
+export interface EvolutionaryBioControlOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioControlResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioControl(data: number[], opts: EvolutionaryBioControlOptions = {}): EvolutionaryBioControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioControl };
diff --git a/src/evolutionary_bio/convergence.ts b/src/evolutionary_bio/convergence.ts
new file mode 100644
index 000000000..c86c76330
--- /dev/null
+++ b/src/evolutionary_bio/convergence.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio convergence module — tsb analytics library. */
+export interface EvolutionaryBioConvergenceOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioConvergenceResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioConvergence(data: number[], opts: EvolutionaryBioConvergenceOptions = {}): EvolutionaryBioConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioConvergence };
diff --git a/src/evolutionary_bio/convex.ts b/src/evolutionary_bio/convex.ts
new file mode 100644
index 000000000..88d91a7f6
--- /dev/null
+++ b/src/evolutionary_bio/convex.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio convex module — tsb analytics library. */
+export interface EvolutionaryBioConvexOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioConvexResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioConvex(data: number[], opts: EvolutionaryBioConvexOptions = {}): EvolutionaryBioConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioConvex };
diff --git a/src/evolutionary_bio/correlation.ts b/src/evolutionary_bio/correlation.ts
new file mode 100644
index 000000000..45df7ee50
--- /dev/null
+++ b/src/evolutionary_bio/correlation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio correlation module — tsb analytics library. */
+export interface EvolutionaryBioCorrelationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioCorrelationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioCorrelation(data: number[], opts: EvolutionaryBioCorrelationOptions = {}): EvolutionaryBioCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioCorrelation };
diff --git a/src/evolutionary_bio/covariance.ts b/src/evolutionary_bio/covariance.ts
new file mode 100644
index 000000000..57f6f5cda
--- /dev/null
+++ b/src/evolutionary_bio/covariance.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio covariance module — tsb analytics library. */
+export interface EvolutionaryBioCovarianceOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioCovarianceResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioCovariance(data: number[], opts: EvolutionaryBioCovarianceOptions = {}): EvolutionaryBioCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioCovariance };
diff --git a/src/evolutionary_bio/cross_validation.ts b/src/evolutionary_bio/cross_validation.ts
new file mode 100644
index 000000000..3ff6cd264
--- /dev/null
+++ b/src/evolutionary_bio/cross_validation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio cross_validation module — tsb analytics library. */
+export interface EvolutionaryBioCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioCrossValidationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioCrossValidation(data: number[], opts: EvolutionaryBioCrossValidationOptions = {}): EvolutionaryBioCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioCrossValidation };
diff --git a/src/evolutionary_bio/decoding.ts b/src/evolutionary_bio/decoding.ts
new file mode 100644
index 000000000..641364032
--- /dev/null
+++ b/src/evolutionary_bio/decoding.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio decoding module — tsb analytics library. */
+export interface EvolutionaryBioDecodingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDecodingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDecoding(data: number[], opts: EvolutionaryBioDecodingOptions = {}): EvolutionaryBioDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDecoding };
diff --git a/src/evolutionary_bio/decomposition.ts b/src/evolutionary_bio/decomposition.ts
new file mode 100644
index 000000000..6f52b9f1e
--- /dev/null
+++ b/src/evolutionary_bio/decomposition.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio decomposition module — tsb analytics library. */
+export interface EvolutionaryBioDecompositionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDecompositionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDecomposition(data: number[], opts: EvolutionaryBioDecompositionOptions = {}): EvolutionaryBioDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDecomposition };
diff --git a/src/evolutionary_bio/detection.ts b/src/evolutionary_bio/detection.ts
new file mode 100644
index 000000000..b414cdf64
--- /dev/null
+++ b/src/evolutionary_bio/detection.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio detection module — tsb analytics library. */
+export interface EvolutionaryBioDetectionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDetectionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDetection(data: number[], opts: EvolutionaryBioDetectionOptions = {}): EvolutionaryBioDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDetection };
diff --git a/src/evolutionary_bio/deterministic.ts b/src/evolutionary_bio/deterministic.ts
new file mode 100644
index 000000000..c775c715d
--- /dev/null
+++ b/src/evolutionary_bio/deterministic.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio deterministic module — tsb analytics library. */
+export interface EvolutionaryBioDeterministicOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDeterministicResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDeterministic(data: number[], opts: EvolutionaryBioDeterministicOptions = {}): EvolutionaryBioDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDeterministic };
diff --git a/src/evolutionary_bio/diagnostics.ts b/src/evolutionary_bio/diagnostics.ts
new file mode 100644
index 000000000..b9b65f46a
--- /dev/null
+++ b/src/evolutionary_bio/diagnostics.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio diagnostics module — tsb analytics library. */
+export interface EvolutionaryBioDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDiagnostics(data: number[], opts: EvolutionaryBioDiagnosticsOptions = {}): EvolutionaryBioDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDiagnostics };
diff --git a/src/evolutionary_bio/differential.ts b/src/evolutionary_bio/differential.ts
new file mode 100644
index 000000000..2c38b67cd
--- /dev/null
+++ b/src/evolutionary_bio/differential.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio differential module — tsb analytics library. */
+export interface EvolutionaryBioDifferentialOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDifferentialResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDifferential(data: number[], opts: EvolutionaryBioDifferentialOptions = {}): EvolutionaryBioDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDifferential };
diff --git a/src/evolutionary_bio/discrete.ts b/src/evolutionary_bio/discrete.ts
new file mode 100644
index 000000000..41f56affa
--- /dev/null
+++ b/src/evolutionary_bio/discrete.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio discrete module — tsb analytics library. */
+export interface EvolutionaryBioDiscreteOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDiscreteResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDiscrete(data: number[], opts: EvolutionaryBioDiscreteOptions = {}): EvolutionaryBioDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDiscrete };
diff --git a/src/evolutionary_bio/distribution.ts b/src/evolutionary_bio/distribution.ts
new file mode 100644
index 000000000..22806783f
--- /dev/null
+++ b/src/evolutionary_bio/distribution.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio distribution module — tsb analytics library. */
+export interface EvolutionaryBioDistributionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDistributionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDistribution(data: number[], opts: EvolutionaryBioDistributionOptions = {}): EvolutionaryBioDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDistribution };
diff --git a/src/evolutionary_bio/dynamic.ts b/src/evolutionary_bio/dynamic.ts
new file mode 100644
index 000000000..b0be9d948
--- /dev/null
+++ b/src/evolutionary_bio/dynamic.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio dynamic module — tsb analytics library. */
+export interface EvolutionaryBioDynamicOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioDynamicResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioDynamic(data: number[], opts: EvolutionaryBioDynamicOptions = {}): EvolutionaryBioDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioDynamic };
diff --git a/src/evolutionary_bio/embedding.ts b/src/evolutionary_bio/embedding.ts
new file mode 100644
index 000000000..da33ea24f
--- /dev/null
+++ b/src/evolutionary_bio/embedding.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio embedding module — tsb analytics library. */
+export interface EvolutionaryBioEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioEmbeddingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioEmbedding(data: number[], opts: EvolutionaryBioEmbeddingOptions = {}): EvolutionaryBioEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioEmbedding };
diff --git a/src/evolutionary_bio/encoding.ts b/src/evolutionary_bio/encoding.ts
new file mode 100644
index 000000000..bb0c8fbf1
--- /dev/null
+++ b/src/evolutionary_bio/encoding.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio encoding module — tsb analytics library. */
+export interface EvolutionaryBioEncodingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioEncodingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioEncoding(data: number[], opts: EvolutionaryBioEncodingOptions = {}): EvolutionaryBioEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioEncoding };
diff --git a/src/evolutionary_bio/ensemble.ts b/src/evolutionary_bio/ensemble.ts
new file mode 100644
index 000000000..91fc81315
--- /dev/null
+++ b/src/evolutionary_bio/ensemble.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio ensemble module — tsb analytics library. */
+export interface EvolutionaryBioEnsembleOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioEnsembleResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioEnsemble(data: number[], opts: EvolutionaryBioEnsembleOptions = {}): EvolutionaryBioEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioEnsemble };
diff --git a/src/evolutionary_bio/estimation.ts b/src/evolutionary_bio/estimation.ts
new file mode 100644
index 000000000..c2dd32dab
--- /dev/null
+++ b/src/evolutionary_bio/estimation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio estimation module — tsb analytics library. */
+export interface EvolutionaryBioEstimationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioEstimationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioEstimation(data: number[], opts: EvolutionaryBioEstimationOptions = {}): EvolutionaryBioEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioEstimation };
diff --git a/src/evolutionary_bio/evaluation.ts b/src/evolutionary_bio/evaluation.ts
new file mode 100644
index 000000000..b87b74478
--- /dev/null
+++ b/src/evolutionary_bio/evaluation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio evaluation module — tsb analytics library. */
+export interface EvolutionaryBioEvaluationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioEvaluationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioEvaluation(data: number[], opts: EvolutionaryBioEvaluationOptions = {}): EvolutionaryBioEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioEvaluation };
diff --git a/src/evolutionary_bio/extrapolation.ts b/src/evolutionary_bio/extrapolation.ts
new file mode 100644
index 000000000..dd6de4c5a
--- /dev/null
+++ b/src/evolutionary_bio/extrapolation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio extrapolation module — tsb analytics library. */
+export interface EvolutionaryBioExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioExtrapolationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioExtrapolation(data: number[], opts: EvolutionaryBioExtrapolationOptions = {}): EvolutionaryBioExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioExtrapolation };
diff --git a/src/evolutionary_bio/features.ts b/src/evolutionary_bio/features.ts
new file mode 100644
index 000000000..16437ebaf
--- /dev/null
+++ b/src/evolutionary_bio/features.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio features module — tsb analytics library. */
+export interface EvolutionaryBioFeaturesOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioFeaturesResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioFeatures(data: number[], opts: EvolutionaryBioFeaturesOptions = {}): EvolutionaryBioFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioFeatures };
diff --git a/src/evolutionary_bio/feedback.ts b/src/evolutionary_bio/feedback.ts
new file mode 100644
index 000000000..2db768923
--- /dev/null
+++ b/src/evolutionary_bio/feedback.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio feedback module — tsb analytics library. */
+export interface EvolutionaryBioFeedbackOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioFeedbackResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioFeedback(data: number[], opts: EvolutionaryBioFeedbackOptions = {}): EvolutionaryBioFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioFeedback };
diff --git a/src/evolutionary_bio/filtering.ts b/src/evolutionary_bio/filtering.ts
new file mode 100644
index 000000000..31f775132
--- /dev/null
+++ b/src/evolutionary_bio/filtering.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio filtering module — tsb analytics library. */
+export interface EvolutionaryBioFilteringOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioFilteringResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioFiltering(data: number[], opts: EvolutionaryBioFilteringOptions = {}): EvolutionaryBioFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioFiltering };
diff --git a/src/evolutionary_bio/fourier.ts b/src/evolutionary_bio/fourier.ts
new file mode 100644
index 000000000..5e7c2250f
--- /dev/null
+++ b/src/evolutionary_bio/fourier.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio fourier module — tsb analytics library. */
+export interface EvolutionaryBioFourierOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioFourierResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioFourier(data: number[], opts: EvolutionaryBioFourierOptions = {}): EvolutionaryBioFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioFourier };
diff --git a/src/evolutionary_bio/fusion.ts b/src/evolutionary_bio/fusion.ts
new file mode 100644
index 000000000..46592505c
--- /dev/null
+++ b/src/evolutionary_bio/fusion.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio fusion module — tsb analytics library. */
+export interface EvolutionaryBioFusionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioFusionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioFusion(data: number[], opts: EvolutionaryBioFusionOptions = {}): EvolutionaryBioFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioFusion };
diff --git a/src/evolutionary_bio/generation.ts b/src/evolutionary_bio/generation.ts
new file mode 100644
index 000000000..f07c93ad5
--- /dev/null
+++ b/src/evolutionary_bio/generation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio generation module — tsb analytics library. */
+export interface EvolutionaryBioGenerationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioGenerationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioGeneration(data: number[], opts: EvolutionaryBioGenerationOptions = {}): EvolutionaryBioGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioGeneration };
diff --git a/src/evolutionary_bio/geometry.ts b/src/evolutionary_bio/geometry.ts
new file mode 100644
index 000000000..aaa9e46b6
--- /dev/null
+++ b/src/evolutionary_bio/geometry.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio geometry module — tsb analytics library. */
+export interface EvolutionaryBioGeometryOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioGeometryResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioGeometry(data: number[], opts: EvolutionaryBioGeometryOptions = {}): EvolutionaryBioGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioGeometry };
diff --git a/src/evolutionary_bio/gradient.ts b/src/evolutionary_bio/gradient.ts
new file mode 100644
index 000000000..3a12e7317
--- /dev/null
+++ b/src/evolutionary_bio/gradient.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio gradient module — tsb analytics library. */
+export interface EvolutionaryBioGradientOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioGradientResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioGradient(data: number[], opts: EvolutionaryBioGradientOptions = {}): EvolutionaryBioGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioGradient };
diff --git a/src/evolutionary_bio/hessian.ts b/src/evolutionary_bio/hessian.ts
new file mode 100644
index 000000000..1b4fd0590
--- /dev/null
+++ b/src/evolutionary_bio/hessian.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio hessian module — tsb analytics library. */
+export interface EvolutionaryBioHessianOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioHessianResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioHessian(data: number[], opts: EvolutionaryBioHessianOptions = {}): EvolutionaryBioHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioHessian };
diff --git a/src/evolutionary_bio/hypothesis.ts b/src/evolutionary_bio/hypothesis.ts
new file mode 100644
index 000000000..863c204fc
--- /dev/null
+++ b/src/evolutionary_bio/hypothesis.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio hypothesis module — tsb analytics library. */
+export interface EvolutionaryBioHypothesisOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioHypothesisResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioHypothesis(data: number[], opts: EvolutionaryBioHypothesisOptions = {}): EvolutionaryBioHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioHypothesis };
diff --git a/src/evolutionary_bio/inference.ts b/src/evolutionary_bio/inference.ts
new file mode 100644
index 000000000..358a62fdb
--- /dev/null
+++ b/src/evolutionary_bio/inference.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio inference module — tsb analytics library. */
+export interface EvolutionaryBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioInferenceResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioInference(data: number[], opts: EvolutionaryBioInferenceOptions = {}): EvolutionaryBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioInference };
diff --git a/src/evolutionary_bio/inference2.ts b/src/evolutionary_bio/inference2.ts
new file mode 100644
index 000000000..816bb6fca
--- /dev/null
+++ b/src/evolutionary_bio/inference2.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio inference2 module — tsb analytics library. */
+export interface EvolutionaryBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioInferenceResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioInference(data: number[], opts: EvolutionaryBioInferenceOptions = {}): EvolutionaryBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioInference };
diff --git a/src/evolutionary_bio/integral.ts b/src/evolutionary_bio/integral.ts
new file mode 100644
index 000000000..1cb15fcc6
--- /dev/null
+++ b/src/evolutionary_bio/integral.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio integral module — tsb analytics library. */
+export interface EvolutionaryBioIntegralOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioIntegralResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioIntegral(data: number[], opts: EvolutionaryBioIntegralOptions = {}): EvolutionaryBioIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioIntegral };
diff --git a/src/evolutionary_bio/integration.ts b/src/evolutionary_bio/integration.ts
new file mode 100644
index 000000000..cfb6e6504
--- /dev/null
+++ b/src/evolutionary_bio/integration.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio integration module — tsb analytics library. */
+export interface EvolutionaryBioIntegrationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioIntegrationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioIntegration(data: number[], opts: EvolutionaryBioIntegrationOptions = {}): EvolutionaryBioIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioIntegration };
diff --git a/src/evolutionary_bio/interpolation.ts b/src/evolutionary_bio/interpolation.ts
new file mode 100644
index 000000000..b2d09d9af
--- /dev/null
+++ b/src/evolutionary_bio/interpolation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio interpolation module — tsb analytics library. */
+export interface EvolutionaryBioInterpolationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioInterpolationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioInterpolation(data: number[], opts: EvolutionaryBioInterpolationOptions = {}): EvolutionaryBioInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioInterpolation };
diff --git a/src/evolutionary_bio/jacobian.ts b/src/evolutionary_bio/jacobian.ts
new file mode 100644
index 000000000..6a4100338
--- /dev/null
+++ b/src/evolutionary_bio/jacobian.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio jacobian module — tsb analytics library. */
+export interface EvolutionaryBioJacobianOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioJacobianResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioJacobian(data: number[], opts: EvolutionaryBioJacobianOptions = {}): EvolutionaryBioJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioJacobian };
diff --git a/src/evolutionary_bio/kernel.ts b/src/evolutionary_bio/kernel.ts
new file mode 100644
index 000000000..4bf97e355
--- /dev/null
+++ b/src/evolutionary_bio/kernel.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio kernel module — tsb analytics library. */
+export interface EvolutionaryBioKernelOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioKernelResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioKernel(data: number[], opts: EvolutionaryBioKernelOptions = {}): EvolutionaryBioKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioKernel };
diff --git a/src/evolutionary_bio/laplacian.ts b/src/evolutionary_bio/laplacian.ts
new file mode 100644
index 000000000..4ce92c552
--- /dev/null
+++ b/src/evolutionary_bio/laplacian.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio laplacian module — tsb analytics library. */
+export interface EvolutionaryBioLaplacianOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioLaplacianResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioLaplacian(data: number[], opts: EvolutionaryBioLaplacianOptions = {}): EvolutionaryBioLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioLaplacian };
diff --git a/src/evolutionary_bio/learning.ts b/src/evolutionary_bio/learning.ts
new file mode 100644
index 000000000..bf52cbab5
--- /dev/null
+++ b/src/evolutionary_bio/learning.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio learning module — tsb analytics library. */
+export interface EvolutionaryBioLearningOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioLearningResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioLearning(data: number[], opts: EvolutionaryBioLearningOptions = {}): EvolutionaryBioLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioLearning };
diff --git a/src/evolutionary_bio/linear.ts b/src/evolutionary_bio/linear.ts
new file mode 100644
index 000000000..c4efd4798
--- /dev/null
+++ b/src/evolutionary_bio/linear.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio linear module — tsb analytics library. */
+export interface EvolutionaryBioLinearOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioLinearResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioLinear(data: number[], opts: EvolutionaryBioLinearOptions = {}): EvolutionaryBioLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioLinear };
diff --git a/src/evolutionary_bio/manifold.ts b/src/evolutionary_bio/manifold.ts
new file mode 100644
index 000000000..d6c8df942
--- /dev/null
+++ b/src/evolutionary_bio/manifold.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio manifold module — tsb analytics library. */
+export interface EvolutionaryBioManifoldOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioManifoldResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioManifold(data: number[], opts: EvolutionaryBioManifoldOptions = {}): EvolutionaryBioManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioManifold };
diff --git a/src/evolutionary_bio/matching.ts b/src/evolutionary_bio/matching.ts
new file mode 100644
index 000000000..dbf91ac26
--- /dev/null
+++ b/src/evolutionary_bio/matching.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio matching module — tsb analytics library. */
+export interface EvolutionaryBioMatchingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioMatchingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioMatching(data: number[], opts: EvolutionaryBioMatchingOptions = {}): EvolutionaryBioMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioMatching };
diff --git a/src/evolutionary_bio/measurement.ts b/src/evolutionary_bio/measurement.ts
new file mode 100644
index 000000000..e5f445608
--- /dev/null
+++ b/src/evolutionary_bio/measurement.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio measurement module — tsb analytics library. */
+export interface EvolutionaryBioMeasurementOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioMeasurementResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioMeasurement(data: number[], opts: EvolutionaryBioMeasurementOptions = {}): EvolutionaryBioMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioMeasurement };
diff --git a/src/evolutionary_bio/metrics.ts b/src/evolutionary_bio/metrics.ts
new file mode 100644
index 000000000..dc8b17066
--- /dev/null
+++ b/src/evolutionary_bio/metrics.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio metrics module — tsb analytics library. */
+export interface EvolutionaryBioMetricsOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioMetricsResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioMetrics(data: number[], opts: EvolutionaryBioMetricsOptions = {}): EvolutionaryBioMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioMetrics };
diff --git a/src/evolutionary_bio/modeling.ts b/src/evolutionary_bio/modeling.ts
new file mode 100644
index 000000000..4413c2856
--- /dev/null
+++ b/src/evolutionary_bio/modeling.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio modeling module — tsb analytics library. */
+export interface EvolutionaryBioModelingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioModelingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioModeling(data: number[], opts: EvolutionaryBioModelingOptions = {}): EvolutionaryBioModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioModeling };
diff --git a/src/evolutionary_bio/monitoring.ts b/src/evolutionary_bio/monitoring.ts
new file mode 100644
index 000000000..10993f4e7
--- /dev/null
+++ b/src/evolutionary_bio/monitoring.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio monitoring module — tsb analytics library. */
+export interface EvolutionaryBioMonitoringOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioMonitoringResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioMonitoring(data: number[], opts: EvolutionaryBioMonitoringOptions = {}): EvolutionaryBioMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioMonitoring };
diff --git a/src/evolutionary_bio/nonlinear.ts b/src/evolutionary_bio/nonlinear.ts
new file mode 100644
index 000000000..157f2a276
--- /dev/null
+++ b/src/evolutionary_bio/nonlinear.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio nonlinear module — tsb analytics library. */
+export interface EvolutionaryBioNonlinearOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioNonlinearResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioNonlinear(data: number[], opts: EvolutionaryBioNonlinearOptions = {}): EvolutionaryBioNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioNonlinear };
diff --git a/src/evolutionary_bio/normalization.ts b/src/evolutionary_bio/normalization.ts
new file mode 100644
index 000000000..31dc47b83
--- /dev/null
+++ b/src/evolutionary_bio/normalization.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio normalization module — tsb analytics library. */
+export interface EvolutionaryBioNormalizationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioNormalizationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioNormalization(data: number[], opts: EvolutionaryBioNormalizationOptions = {}): EvolutionaryBioNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioNormalization };
diff --git a/src/evolutionary_bio/optimization.ts b/src/evolutionary_bio/optimization.ts
new file mode 100644
index 000000000..332029b53
--- /dev/null
+++ b/src/evolutionary_bio/optimization.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio optimization module — tsb analytics library. */
+export interface EvolutionaryBioOptimizationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioOptimizationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioOptimization(data: number[], opts: EvolutionaryBioOptimizationOptions = {}): EvolutionaryBioOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioOptimization };
diff --git a/src/evolutionary_bio/patterns.ts b/src/evolutionary_bio/patterns.ts
new file mode 100644
index 000000000..d8e8629b5
--- /dev/null
+++ b/src/evolutionary_bio/patterns.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio patterns module — tsb analytics library. */
+export interface EvolutionaryBioPatternsOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioPatternsResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioPatterns(data: number[], opts: EvolutionaryBioPatternsOptions = {}): EvolutionaryBioPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioPatterns };
diff --git a/src/evolutionary_bio/permutation.ts b/src/evolutionary_bio/permutation.ts
new file mode 100644
index 000000000..fb51e57c2
--- /dev/null
+++ b/src/evolutionary_bio/permutation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio permutation module — tsb analytics library. */
+export interface EvolutionaryBioPermutationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioPermutationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioPermutation(data: number[], opts: EvolutionaryBioPermutationOptions = {}): EvolutionaryBioPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioPermutation };
diff --git a/src/evolutionary_bio/prediction.ts b/src/evolutionary_bio/prediction.ts
new file mode 100644
index 000000000..751bb2bb7
--- /dev/null
+++ b/src/evolutionary_bio/prediction.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio prediction module — tsb analytics library. */
+export interface EvolutionaryBioPredictionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioPredictionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioPrediction(data: number[], opts: EvolutionaryBioPredictionOptions = {}): EvolutionaryBioPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioPrediction };
diff --git a/src/evolutionary_bio/processing.ts b/src/evolutionary_bio/processing.ts
new file mode 100644
index 000000000..65f1acd5c
--- /dev/null
+++ b/src/evolutionary_bio/processing.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio processing module — tsb analytics library. */
+export interface EvolutionaryBioProcessingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioProcessingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioProcessing(data: number[], opts: EvolutionaryBioProcessingOptions = {}): EvolutionaryBioProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioProcessing };
diff --git a/src/evolutionary_bio/profiling.ts b/src/evolutionary_bio/profiling.ts
new file mode 100644
index 000000000..d0ad4c236
--- /dev/null
+++ b/src/evolutionary_bio/profiling.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio profiling module — tsb analytics library. */
+export interface EvolutionaryBioProfilingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioProfilingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioProfiling(data: number[], opts: EvolutionaryBioProfilingOptions = {}): EvolutionaryBioProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioProfiling };
diff --git a/src/evolutionary_bio/projection.ts b/src/evolutionary_bio/projection.ts
new file mode 100644
index 000000000..54fe20ad3
--- /dev/null
+++ b/src/evolutionary_bio/projection.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio projection module — tsb analytics library. */
+export interface EvolutionaryBioProjectionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioProjectionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioProjection(data: number[], opts: EvolutionaryBioProjectionOptions = {}): EvolutionaryBioProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioProjection };
diff --git a/src/evolutionary_bio/ranking.ts b/src/evolutionary_bio/ranking.ts
new file mode 100644
index 000000000..2ab599079
--- /dev/null
+++ b/src/evolutionary_bio/ranking.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio ranking module — tsb analytics library. */
+export interface EvolutionaryBioRankingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioRankingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioRanking(data: number[], opts: EvolutionaryBioRankingOptions = {}): EvolutionaryBioRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioRanking };
diff --git a/src/evolutionary_bio/reconstruction.ts b/src/evolutionary_bio/reconstruction.ts
new file mode 100644
index 000000000..5b810c52d
--- /dev/null
+++ b/src/evolutionary_bio/reconstruction.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio reconstruction module — tsb analytics library. */
+export interface EvolutionaryBioReconstructionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioReconstructionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioReconstruction(data: number[], opts: EvolutionaryBioReconstructionOptions = {}): EvolutionaryBioReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioReconstruction };
diff --git a/src/evolutionary_bio/registration.ts b/src/evolutionary_bio/registration.ts
new file mode 100644
index 000000000..30ca714d0
--- /dev/null
+++ b/src/evolutionary_bio/registration.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio registration module — tsb analytics library. */
+export interface EvolutionaryBioRegistrationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioRegistrationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioRegistration(data: number[], opts: EvolutionaryBioRegistrationOptions = {}): EvolutionaryBioRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioRegistration };
diff --git a/src/evolutionary_bio/regression.ts b/src/evolutionary_bio/regression.ts
new file mode 100644
index 000000000..6862123e6
--- /dev/null
+++ b/src/evolutionary_bio/regression.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio regression module — tsb analytics library. */
+export interface EvolutionaryBioRegressionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioRegressionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioRegression(data: number[], opts: EvolutionaryBioRegressionOptions = {}): EvolutionaryBioRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioRegression };
diff --git a/src/evolutionary_bio/regularization.ts b/src/evolutionary_bio/regularization.ts
new file mode 100644
index 000000000..dde3981fa
--- /dev/null
+++ b/src/evolutionary_bio/regularization.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio regularization module — tsb analytics library. */
+export interface EvolutionaryBioRegularizationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioRegularizationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioRegularization(data: number[], opts: EvolutionaryBioRegularizationOptions = {}): EvolutionaryBioRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioRegularization };
diff --git a/src/evolutionary_bio/robustness.ts b/src/evolutionary_bio/robustness.ts
new file mode 100644
index 000000000..ecffcc962
--- /dev/null
+++ b/src/evolutionary_bio/robustness.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio robustness module — tsb analytics library. */
+export interface EvolutionaryBioRobustnessOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioRobustnessResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioRobustness(data: number[], opts: EvolutionaryBioRobustnessOptions = {}): EvolutionaryBioRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioRobustness };
diff --git a/src/evolutionary_bio/sampling.ts b/src/evolutionary_bio/sampling.ts
new file mode 100644
index 000000000..82c69de14
--- /dev/null
+++ b/src/evolutionary_bio/sampling.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio sampling module — tsb analytics library. */
+export interface EvolutionaryBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioSamplingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioSampling(data: number[], opts: EvolutionaryBioSamplingOptions = {}): EvolutionaryBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioSampling };
diff --git a/src/evolutionary_bio/sampling2.ts b/src/evolutionary_bio/sampling2.ts
new file mode 100644
index 000000000..ffd88dcf4
--- /dev/null
+++ b/src/evolutionary_bio/sampling2.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio sampling2 module — tsb analytics library. */
+export interface EvolutionaryBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioSamplingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioSampling(data: number[], opts: EvolutionaryBioSamplingOptions = {}): EvolutionaryBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioSampling };
diff --git a/src/evolutionary_bio/scaling.ts b/src/evolutionary_bio/scaling.ts
new file mode 100644
index 000000000..54a6ff7e8
--- /dev/null
+++ b/src/evolutionary_bio/scaling.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio scaling module — tsb analytics library. */
+export interface EvolutionaryBioScalingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioScalingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioScaling(data: number[], opts: EvolutionaryBioScalingOptions = {}): EvolutionaryBioScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioScaling };
diff --git a/src/evolutionary_bio/scoring.ts b/src/evolutionary_bio/scoring.ts
new file mode 100644
index 000000000..4adf10ab2
--- /dev/null
+++ b/src/evolutionary_bio/scoring.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio scoring module — tsb analytics library. */
+export interface EvolutionaryBioScoringOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioScoringResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioScoring(data: number[], opts: EvolutionaryBioScoringOptions = {}): EvolutionaryBioScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioScoring };
diff --git a/src/evolutionary_bio/segmentation.ts b/src/evolutionary_bio/segmentation.ts
new file mode 100644
index 000000000..74f29d54f
--- /dev/null
+++ b/src/evolutionary_bio/segmentation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio segmentation module — tsb analytics library. */
+export interface EvolutionaryBioSegmentationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioSegmentationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioSegmentation(data: number[], opts: EvolutionaryBioSegmentationOptions = {}): EvolutionaryBioSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioSegmentation };
diff --git a/src/evolutionary_bio/selection.ts b/src/evolutionary_bio/selection.ts
new file mode 100644
index 000000000..7fc7a8f7d
--- /dev/null
+++ b/src/evolutionary_bio/selection.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio selection module — tsb analytics library. */
+export interface EvolutionaryBioSelectionOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioSelectionResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioSelection(data: number[], opts: EvolutionaryBioSelectionOptions = {}): EvolutionaryBioSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioSelection };
diff --git a/src/evolutionary_bio/sensitivity.ts b/src/evolutionary_bio/sensitivity.ts
new file mode 100644
index 000000000..d91e598ac
--- /dev/null
+++ b/src/evolutionary_bio/sensitivity.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio sensitivity module — tsb analytics library. */
+export interface EvolutionaryBioSensitivityOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioSensitivityResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioSensitivity(data: number[], opts: EvolutionaryBioSensitivityOptions = {}): EvolutionaryBioSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioSensitivity };
diff --git a/src/evolutionary_bio/simulation.ts b/src/evolutionary_bio/simulation.ts
new file mode 100644
index 000000000..8512c76e1
--- /dev/null
+++ b/src/evolutionary_bio/simulation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio simulation module — tsb analytics library. */
+export interface EvolutionaryBioSimulationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioSimulationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioSimulation(data: number[], opts: EvolutionaryBioSimulationOptions = {}): EvolutionaryBioSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioSimulation };
diff --git a/src/evolutionary_bio/smoothing.ts b/src/evolutionary_bio/smoothing.ts
new file mode 100644
index 000000000..cbec267dc
--- /dev/null
+++ b/src/evolutionary_bio/smoothing.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio smoothing module — tsb analytics library. */
+export interface EvolutionaryBioSmoothingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioSmoothingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioSmoothing(data: number[], opts: EvolutionaryBioSmoothingOptions = {}): EvolutionaryBioSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioSmoothing };
diff --git a/src/evolutionary_bio/stability.ts b/src/evolutionary_bio/stability.ts
new file mode 100644
index 000000000..cf1eb3961
--- /dev/null
+++ b/src/evolutionary_bio/stability.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio stability module — tsb analytics library. */
+export interface EvolutionaryBioStabilityOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioStabilityResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioStability(data: number[], opts: EvolutionaryBioStabilityOptions = {}): EvolutionaryBioStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioStability };
diff --git a/src/evolutionary_bio/stacking.ts b/src/evolutionary_bio/stacking.ts
new file mode 100644
index 000000000..9b2aff6c5
--- /dev/null
+++ b/src/evolutionary_bio/stacking.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio stacking module — tsb analytics library. */
+export interface EvolutionaryBioStackingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioStackingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioStacking(data: number[], opts: EvolutionaryBioStackingOptions = {}): EvolutionaryBioStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioStacking };
diff --git a/src/evolutionary_bio/standardization.ts b/src/evolutionary_bio/standardization.ts
new file mode 100644
index 000000000..a7a52cb81
--- /dev/null
+++ b/src/evolutionary_bio/standardization.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio standardization module — tsb analytics library. */
+export interface EvolutionaryBioStandardizationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioStandardizationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioStandardization(data: number[], opts: EvolutionaryBioStandardizationOptions = {}): EvolutionaryBioStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioStandardization };
diff --git a/src/evolutionary_bio/static.ts b/src/evolutionary_bio/static.ts
new file mode 100644
index 000000000..39b6458d5
--- /dev/null
+++ b/src/evolutionary_bio/static.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio static module — tsb analytics library. */
+export interface EvolutionaryBioStaticOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioStaticResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioStatic(data: number[], opts: EvolutionaryBioStaticOptions = {}): EvolutionaryBioStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioStatic };
diff --git a/src/evolutionary_bio/stochastic.ts b/src/evolutionary_bio/stochastic.ts
new file mode 100644
index 000000000..af09fa6f3
--- /dev/null
+++ b/src/evolutionary_bio/stochastic.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio stochastic module — tsb analytics library. */
+export interface EvolutionaryBioStochasticOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioStochasticResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioStochastic(data: number[], opts: EvolutionaryBioStochasticOptions = {}): EvolutionaryBioStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioStochastic };
diff --git a/src/evolutionary_bio/synthesis.ts b/src/evolutionary_bio/synthesis.ts
new file mode 100644
index 000000000..5d48ddb8c
--- /dev/null
+++ b/src/evolutionary_bio/synthesis.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio synthesis module — tsb analytics library. */
+export interface EvolutionaryBioSynthesisOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioSynthesisResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioSynthesis(data: number[], opts: EvolutionaryBioSynthesisOptions = {}): EvolutionaryBioSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioSynthesis };
diff --git a/src/evolutionary_bio/topology.ts b/src/evolutionary_bio/topology.ts
new file mode 100644
index 000000000..0a3995ad2
--- /dev/null
+++ b/src/evolutionary_bio/topology.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio topology module — tsb analytics library. */
+export interface EvolutionaryBioTopologyOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioTopologyResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioTopology(data: number[], opts: EvolutionaryBioTopologyOptions = {}): EvolutionaryBioTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioTopology };
diff --git a/src/evolutionary_bio/tracking.ts b/src/evolutionary_bio/tracking.ts
new file mode 100644
index 000000000..91758f322
--- /dev/null
+++ b/src/evolutionary_bio/tracking.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio tracking module — tsb analytics library. */
+export interface EvolutionaryBioTrackingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioTrackingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioTracking(data: number[], opts: EvolutionaryBioTrackingOptions = {}): EvolutionaryBioTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioTracking };
diff --git a/src/evolutionary_bio/transform.ts b/src/evolutionary_bio/transform.ts
new file mode 100644
index 000000000..275aa1e4a
--- /dev/null
+++ b/src/evolutionary_bio/transform.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio transform module — tsb analytics library. */
+export interface EvolutionaryBioTransformOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioTransformResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioTransform(data: number[], opts: EvolutionaryBioTransformOptions = {}): EvolutionaryBioTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioTransform };
diff --git a/src/evolutionary_bio/uncertainty.ts b/src/evolutionary_bio/uncertainty.ts
new file mode 100644
index 000000000..a2dd46eec
--- /dev/null
+++ b/src/evolutionary_bio/uncertainty.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio uncertainty module — tsb analytics library. */
+export interface EvolutionaryBioUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioUncertaintyResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioUncertainty(data: number[], opts: EvolutionaryBioUncertaintyOptions = {}): EvolutionaryBioUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioUncertainty };
diff --git a/src/evolutionary_bio/validation.ts b/src/evolutionary_bio/validation.ts
new file mode 100644
index 000000000..9e1d2d132
--- /dev/null
+++ b/src/evolutionary_bio/validation.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio validation module — tsb analytics library. */
+export interface EvolutionaryBioValidationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioValidationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioValidation(data: number[], opts: EvolutionaryBioValidationOptions = {}): EvolutionaryBioValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioValidation };
diff --git a/src/evolutionary_bio/verification.ts b/src/evolutionary_bio/verification.ts
new file mode 100644
index 000000000..c3fef3ea8
--- /dev/null
+++ b/src/evolutionary_bio/verification.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio verification module — tsb analytics library. */
+export interface EvolutionaryBioVerificationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioVerificationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioVerification(data: number[], opts: EvolutionaryBioVerificationOptions = {}): EvolutionaryBioVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioVerification };
diff --git a/src/evolutionary_bio/visualization.ts b/src/evolutionary_bio/visualization.ts
new file mode 100644
index 000000000..d42541831
--- /dev/null
+++ b/src/evolutionary_bio/visualization.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio visualization module — tsb analytics library. */
+export interface EvolutionaryBioVisualizationOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioVisualizationResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioVisualization(data: number[], opts: EvolutionaryBioVisualizationOptions = {}): EvolutionaryBioVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioVisualization };
diff --git a/src/evolutionary_bio/voting.ts b/src/evolutionary_bio/voting.ts
new file mode 100644
index 000000000..05ff3a132
--- /dev/null
+++ b/src/evolutionary_bio/voting.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio voting module — tsb analytics library. */
+export interface EvolutionaryBioVotingOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioVotingResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioVoting(data: number[], opts: EvolutionaryBioVotingOptions = {}): EvolutionaryBioVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioVoting };
diff --git a/src/evolutionary_bio/wavelet.ts b/src/evolutionary_bio/wavelet.ts
new file mode 100644
index 000000000..6107c642d
--- /dev/null
+++ b/src/evolutionary_bio/wavelet.ts
@@ -0,0 +1,14 @@
+/** evolutionary_bio wavelet module — tsb analytics library. */
+export interface EvolutionaryBioWaveletOptions { tol?: number; maxIter?: number; }
+export interface EvolutionaryBioWaveletResult { values: number[]; converged: boolean; }
+export function computeEvolutionaryBioWavelet(data: number[], opts: EvolutionaryBioWaveletOptions = {}): EvolutionaryBioWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeEvolutionaryBioWavelet };
diff --git a/src/fatigue_sci/adaptation.ts b/src/fatigue_sci/adaptation.ts
new file mode 100644
index 000000000..5dbfa30d7
--- /dev/null
+++ b/src/fatigue_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci adaptation module — tsb analytics library. */
+export interface FatigueSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciAdaptation(data: number[], opts: FatigueSciAdaptationOptions = {}): FatigueSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciAdaptation };
diff --git a/src/fatigue_sci/aggregation.ts b/src/fatigue_sci/aggregation.ts
new file mode 100644
index 000000000..415c01162
--- /dev/null
+++ b/src/fatigue_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci aggregation module — tsb analytics library. */
+export interface FatigueSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciAggregationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciAggregation(data: number[], opts: FatigueSciAggregationOptions = {}): FatigueSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciAggregation };
diff --git a/src/fatigue_sci/algebra.ts b/src/fatigue_sci/algebra.ts
new file mode 100644
index 000000000..dfd393ef5
--- /dev/null
+++ b/src/fatigue_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci algebra module — tsb analytics library. */
+export interface FatigueSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeFatigueSciAlgebra(data: number[], opts: FatigueSciAlgebraOptions = {}): FatigueSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciAlgebra };
diff --git a/src/fatigue_sci/alignment.ts b/src/fatigue_sci/alignment.ts
new file mode 100644
index 000000000..cee007fa3
--- /dev/null
+++ b/src/fatigue_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci alignment module — tsb analytics library. */
+export interface FatigueSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeFatigueSciAlignment(data: number[], opts: FatigueSciAlignmentOptions = {}): FatigueSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciAlignment };
diff --git a/src/fatigue_sci/analysis.ts b/src/fatigue_sci/analysis.ts
new file mode 100644
index 000000000..76ac9ed5a
--- /dev/null
+++ b/src/fatigue_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci analysis module — tsb analytics library. */
+export interface FatigueSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeFatigueSciAnalysis(data: number[], opts: FatigueSciAnalysisOptions = {}): FatigueSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciAnalysis };
diff --git a/src/fatigue_sci/augmentation.ts b/src/fatigue_sci/augmentation.ts
new file mode 100644
index 000000000..65bffd4ee
--- /dev/null
+++ b/src/fatigue_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci augmentation module — tsb analytics library. */
+export interface FatigueSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciAugmentation(data: number[], opts: FatigueSciAugmentationOptions = {}): FatigueSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciAugmentation };
diff --git a/src/fatigue_sci/bagging.ts b/src/fatigue_sci/bagging.ts
new file mode 100644
index 000000000..76d5c78e8
--- /dev/null
+++ b/src/fatigue_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci bagging module — tsb analytics library. */
+export interface FatigueSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciBaggingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciBagging(data: number[], opts: FatigueSciBaggingOptions = {}): FatigueSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciBagging };
diff --git a/src/fatigue_sci/basis.ts b/src/fatigue_sci/basis.ts
new file mode 100644
index 000000000..630ab600e
--- /dev/null
+++ b/src/fatigue_sci/basis.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci basis module — tsb analytics library. */
+export interface FatigueSciBasisOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciBasisResult { values: number[]; converged: boolean; }
+export function computeFatigueSciBasis(data: number[], opts: FatigueSciBasisOptions = {}): FatigueSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciBasis };
diff --git a/src/fatigue_sci/benchmarking.ts b/src/fatigue_sci/benchmarking.ts
new file mode 100644
index 000000000..ce8a61f93
--- /dev/null
+++ b/src/fatigue_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci benchmarking module — tsb analytics library. */
+export interface FatigueSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciBenchmarking(data: number[], opts: FatigueSciBenchmarkingOptions = {}): FatigueSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciBenchmarking };
diff --git a/src/fatigue_sci/blending.ts b/src/fatigue_sci/blending.ts
new file mode 100644
index 000000000..39d55139a
--- /dev/null
+++ b/src/fatigue_sci/blending.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci blending module — tsb analytics library. */
+export interface FatigueSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciBlendingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciBlending(data: number[], opts: FatigueSciBlendingOptions = {}): FatigueSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciBlending };
diff --git a/src/fatigue_sci/boosting.ts b/src/fatigue_sci/boosting.ts
new file mode 100644
index 000000000..37ddbd9d7
--- /dev/null
+++ b/src/fatigue_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci boosting module — tsb analytics library. */
+export interface FatigueSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciBoostingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciBoosting(data: number[], opts: FatigueSciBoostingOptions = {}): FatigueSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciBoosting };
diff --git a/src/fatigue_sci/bootstrap.ts b/src/fatigue_sci/bootstrap.ts
new file mode 100644
index 000000000..e73dc5b41
--- /dev/null
+++ b/src/fatigue_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci bootstrap module — tsb analytics library. */
+export interface FatigueSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeFatigueSciBootstrap(data: number[], opts: FatigueSciBootstrapOptions = {}): FatigueSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciBootstrap };
diff --git a/src/fatigue_sci/calculus.ts b/src/fatigue_sci/calculus.ts
new file mode 100644
index 000000000..42dd162bb
--- /dev/null
+++ b/src/fatigue_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci calculus module — tsb analytics library. */
+export interface FatigueSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciCalculusResult { values: number[]; converged: boolean; }
+export function computeFatigueSciCalculus(data: number[], opts: FatigueSciCalculusOptions = {}): FatigueSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciCalculus };
diff --git a/src/fatigue_sci/calibration.ts b/src/fatigue_sci/calibration.ts
new file mode 100644
index 000000000..d8b6028b7
--- /dev/null
+++ b/src/fatigue_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci calibration module — tsb analytics library. */
+export interface FatigueSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciCalibration(data: number[], opts: FatigueSciCalibrationOptions = {}): FatigueSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciCalibration };
diff --git a/src/fatigue_sci/characterization.ts b/src/fatigue_sci/characterization.ts
new file mode 100644
index 000000000..452ef5d10
--- /dev/null
+++ b/src/fatigue_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci characterization module — tsb analytics library. */
+export interface FatigueSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciCharacterization(data: number[], opts: FatigueSciCharacterizationOptions = {}): FatigueSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciCharacterization };
diff --git a/src/fatigue_sci/classification.ts b/src/fatigue_sci/classification.ts
new file mode 100644
index 000000000..d83a2c17d
--- /dev/null
+++ b/src/fatigue_sci/classification.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci classification module — tsb analytics library. */
+export interface FatigueSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciClassificationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciClassification(data: number[], opts: FatigueSciClassificationOptions = {}): FatigueSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciClassification };
diff --git a/src/fatigue_sci/clustering.ts b/src/fatigue_sci/clustering.ts
new file mode 100644
index 000000000..bc162630b
--- /dev/null
+++ b/src/fatigue_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci clustering module — tsb analytics library. */
+export interface FatigueSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciClusteringResult { values: number[]; converged: boolean; }
+export function computeFatigueSciClustering(data: number[], opts: FatigueSciClusteringOptions = {}): FatigueSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciClustering };
diff --git a/src/fatigue_sci/compression.ts b/src/fatigue_sci/compression.ts
new file mode 100644
index 000000000..3cc186bae
--- /dev/null
+++ b/src/fatigue_sci/compression.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci compression module — tsb analytics library. */
+export interface FatigueSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciCompressionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciCompression(data: number[], opts: FatigueSciCompressionOptions = {}): FatigueSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciCompression };
diff --git a/src/fatigue_sci/continuous.ts b/src/fatigue_sci/continuous.ts
new file mode 100644
index 000000000..64a95baf3
--- /dev/null
+++ b/src/fatigue_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci continuous module — tsb analytics library. */
+export interface FatigueSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciContinuousResult { values: number[]; converged: boolean; }
+export function computeFatigueSciContinuous(data: number[], opts: FatigueSciContinuousOptions = {}): FatigueSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciContinuous };
diff --git a/src/fatigue_sci/control.ts b/src/fatigue_sci/control.ts
new file mode 100644
index 000000000..6d741394e
--- /dev/null
+++ b/src/fatigue_sci/control.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci control module — tsb analytics library. */
+export interface FatigueSciControlOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciControlResult { values: number[]; converged: boolean; }
+export function computeFatigueSciControl(data: number[], opts: FatigueSciControlOptions = {}): FatigueSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciControl };
diff --git a/src/fatigue_sci/convergence.ts b/src/fatigue_sci/convergence.ts
new file mode 100644
index 000000000..05a79c6d3
--- /dev/null
+++ b/src/fatigue_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci convergence module — tsb analytics library. */
+export interface FatigueSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeFatigueSciConvergence(data: number[], opts: FatigueSciConvergenceOptions = {}): FatigueSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciConvergence };
diff --git a/src/fatigue_sci/convex.ts b/src/fatigue_sci/convex.ts
new file mode 100644
index 000000000..e434bec93
--- /dev/null
+++ b/src/fatigue_sci/convex.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci convex module — tsb analytics library. */
+export interface FatigueSciConvexOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciConvexResult { values: number[]; converged: boolean; }
+export function computeFatigueSciConvex(data: number[], opts: FatigueSciConvexOptions = {}): FatigueSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciConvex };
diff --git a/src/fatigue_sci/correlation.ts b/src/fatigue_sci/correlation.ts
new file mode 100644
index 000000000..41a8a5134
--- /dev/null
+++ b/src/fatigue_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci correlation module — tsb analytics library. */
+export interface FatigueSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciCorrelation(data: number[], opts: FatigueSciCorrelationOptions = {}): FatigueSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciCorrelation };
diff --git a/src/fatigue_sci/covariance.ts b/src/fatigue_sci/covariance.ts
new file mode 100644
index 000000000..d7d953301
--- /dev/null
+++ b/src/fatigue_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci covariance module — tsb analytics library. */
+export interface FatigueSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeFatigueSciCovariance(data: number[], opts: FatigueSciCovarianceOptions = {}): FatigueSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciCovariance };
diff --git a/src/fatigue_sci/cross_validation.ts b/src/fatigue_sci/cross_validation.ts
new file mode 100644
index 000000000..95c536ec9
--- /dev/null
+++ b/src/fatigue_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci cross_validation module — tsb analytics library. */
+export interface FatigueSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciCrossValidation(data: number[], opts: FatigueSciCrossValidationOptions = {}): FatigueSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciCrossValidation };
diff --git a/src/fatigue_sci/decoding.ts b/src/fatigue_sci/decoding.ts
new file mode 100644
index 000000000..dbf7d176e
--- /dev/null
+++ b/src/fatigue_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci decoding module — tsb analytics library. */
+export interface FatigueSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDecodingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDecoding(data: number[], opts: FatigueSciDecodingOptions = {}): FatigueSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDecoding };
diff --git a/src/fatigue_sci/decomposition.ts b/src/fatigue_sci/decomposition.ts
new file mode 100644
index 000000000..5066c8943
--- /dev/null
+++ b/src/fatigue_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci decomposition module — tsb analytics library. */
+export interface FatigueSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDecomposition(data: number[], opts: FatigueSciDecompositionOptions = {}): FatigueSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDecomposition };
diff --git a/src/fatigue_sci/detection.ts b/src/fatigue_sci/detection.ts
new file mode 100644
index 000000000..735316b64
--- /dev/null
+++ b/src/fatigue_sci/detection.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci detection module — tsb analytics library. */
+export interface FatigueSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDetectionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDetection(data: number[], opts: FatigueSciDetectionOptions = {}): FatigueSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDetection };
diff --git a/src/fatigue_sci/deterministic.ts b/src/fatigue_sci/deterministic.ts
new file mode 100644
index 000000000..4abae83b0
--- /dev/null
+++ b/src/fatigue_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci deterministic module — tsb analytics library. */
+export interface FatigueSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDeterministic(data: number[], opts: FatigueSciDeterministicOptions = {}): FatigueSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDeterministic };
diff --git a/src/fatigue_sci/diagnostics.ts b/src/fatigue_sci/diagnostics.ts
new file mode 100644
index 000000000..eb07a30fa
--- /dev/null
+++ b/src/fatigue_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci diagnostics module — tsb analytics library. */
+export interface FatigueSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDiagnostics(data: number[], opts: FatigueSciDiagnosticsOptions = {}): FatigueSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDiagnostics };
diff --git a/src/fatigue_sci/differential.ts b/src/fatigue_sci/differential.ts
new file mode 100644
index 000000000..116c27f13
--- /dev/null
+++ b/src/fatigue_sci/differential.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci differential module — tsb analytics library. */
+export interface FatigueSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDifferential(data: number[], opts: FatigueSciDifferentialOptions = {}): FatigueSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDifferential };
diff --git a/src/fatigue_sci/discrete.ts b/src/fatigue_sci/discrete.ts
new file mode 100644
index 000000000..555680ef1
--- /dev/null
+++ b/src/fatigue_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci discrete module — tsb analytics library. */
+export interface FatigueSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDiscrete(data: number[], opts: FatigueSciDiscreteOptions = {}): FatigueSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDiscrete };
diff --git a/src/fatigue_sci/distribution.ts b/src/fatigue_sci/distribution.ts
new file mode 100644
index 000000000..7e919fe0d
--- /dev/null
+++ b/src/fatigue_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci distribution module — tsb analytics library. */
+export interface FatigueSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDistributionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDistribution(data: number[], opts: FatigueSciDistributionOptions = {}): FatigueSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDistribution };
diff --git a/src/fatigue_sci/dynamic.ts b/src/fatigue_sci/dynamic.ts
new file mode 100644
index 000000000..15da0461e
--- /dev/null
+++ b/src/fatigue_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci dynamic module — tsb analytics library. */
+export interface FatigueSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciDynamicResult { values: number[]; converged: boolean; }
+export function computeFatigueSciDynamic(data: number[], opts: FatigueSciDynamicOptions = {}): FatigueSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciDynamic };
diff --git a/src/fatigue_sci/embedding.ts b/src/fatigue_sci/embedding.ts
new file mode 100644
index 000000000..061c47bbc
--- /dev/null
+++ b/src/fatigue_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci embedding module — tsb analytics library. */
+export interface FatigueSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciEmbedding(data: number[], opts: FatigueSciEmbeddingOptions = {}): FatigueSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciEmbedding };
diff --git a/src/fatigue_sci/encoding.ts b/src/fatigue_sci/encoding.ts
new file mode 100644
index 000000000..904a7f7ce
--- /dev/null
+++ b/src/fatigue_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci encoding module — tsb analytics library. */
+export interface FatigueSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciEncodingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciEncoding(data: number[], opts: FatigueSciEncodingOptions = {}): FatigueSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciEncoding };
diff --git a/src/fatigue_sci/ensemble.ts b/src/fatigue_sci/ensemble.ts
new file mode 100644
index 000000000..a79e71d10
--- /dev/null
+++ b/src/fatigue_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci ensemble module — tsb analytics library. */
+export interface FatigueSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeFatigueSciEnsemble(data: number[], opts: FatigueSciEnsembleOptions = {}): FatigueSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciEnsemble };
diff --git a/src/fatigue_sci/estimation.ts b/src/fatigue_sci/estimation.ts
new file mode 100644
index 000000000..38b410a1a
--- /dev/null
+++ b/src/fatigue_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci estimation module — tsb analytics library. */
+export interface FatigueSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciEstimationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciEstimation(data: number[], opts: FatigueSciEstimationOptions = {}): FatigueSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciEstimation };
diff --git a/src/fatigue_sci/evaluation.ts b/src/fatigue_sci/evaluation.ts
new file mode 100644
index 000000000..201c36b98
--- /dev/null
+++ b/src/fatigue_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci evaluation module — tsb analytics library. */
+export interface FatigueSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciEvaluation(data: number[], opts: FatigueSciEvaluationOptions = {}): FatigueSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciEvaluation };
diff --git a/src/fatigue_sci/extrapolation.ts b/src/fatigue_sci/extrapolation.ts
new file mode 100644
index 000000000..4cfc0f64a
--- /dev/null
+++ b/src/fatigue_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci extrapolation module — tsb analytics library. */
+export interface FatigueSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciExtrapolation(data: number[], opts: FatigueSciExtrapolationOptions = {}): FatigueSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciExtrapolation };
diff --git a/src/fatigue_sci/features.ts b/src/fatigue_sci/features.ts
new file mode 100644
index 000000000..8c993a2e9
--- /dev/null
+++ b/src/fatigue_sci/features.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci features module — tsb analytics library. */
+export interface FatigueSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeFatigueSciFeatures(data: number[], opts: FatigueSciFeaturesOptions = {}): FatigueSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciFeatures };
diff --git a/src/fatigue_sci/feedback.ts b/src/fatigue_sci/feedback.ts
new file mode 100644
index 000000000..dbed44196
--- /dev/null
+++ b/src/fatigue_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci feedback module — tsb analytics library. */
+export interface FatigueSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeFatigueSciFeedback(data: number[], opts: FatigueSciFeedbackOptions = {}): FatigueSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciFeedback };
diff --git a/src/fatigue_sci/filtering.ts b/src/fatigue_sci/filtering.ts
new file mode 100644
index 000000000..460211ccf
--- /dev/null
+++ b/src/fatigue_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci filtering module — tsb analytics library. */
+export interface FatigueSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciFilteringResult { values: number[]; converged: boolean; }
+export function computeFatigueSciFiltering(data: number[], opts: FatigueSciFilteringOptions = {}): FatigueSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciFiltering };
diff --git a/src/fatigue_sci/fourier.ts b/src/fatigue_sci/fourier.ts
new file mode 100644
index 000000000..650b1b1d5
--- /dev/null
+++ b/src/fatigue_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci fourier module — tsb analytics library. */
+export interface FatigueSciFourierOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciFourierResult { values: number[]; converged: boolean; }
+export function computeFatigueSciFourier(data: number[], opts: FatigueSciFourierOptions = {}): FatigueSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciFourier };
diff --git a/src/fatigue_sci/fusion.ts b/src/fatigue_sci/fusion.ts
new file mode 100644
index 000000000..6c063b4e1
--- /dev/null
+++ b/src/fatigue_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci fusion module — tsb analytics library. */
+export interface FatigueSciFusionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciFusionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciFusion(data: number[], opts: FatigueSciFusionOptions = {}): FatigueSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciFusion };
diff --git a/src/fatigue_sci/generation.ts b/src/fatigue_sci/generation.ts
new file mode 100644
index 000000000..af8aaaa8e
--- /dev/null
+++ b/src/fatigue_sci/generation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci generation module — tsb analytics library. */
+export interface FatigueSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciGenerationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciGeneration(data: number[], opts: FatigueSciGenerationOptions = {}): FatigueSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciGeneration };
diff --git a/src/fatigue_sci/geometry.ts b/src/fatigue_sci/geometry.ts
new file mode 100644
index 000000000..c5a21c79d
--- /dev/null
+++ b/src/fatigue_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci geometry module — tsb analytics library. */
+export interface FatigueSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciGeometryResult { values: number[]; converged: boolean; }
+export function computeFatigueSciGeometry(data: number[], opts: FatigueSciGeometryOptions = {}): FatigueSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciGeometry };
diff --git a/src/fatigue_sci/gradient.ts b/src/fatigue_sci/gradient.ts
new file mode 100644
index 000000000..d82cdf679
--- /dev/null
+++ b/src/fatigue_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci gradient module — tsb analytics library. */
+export interface FatigueSciGradientOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciGradientResult { values: number[]; converged: boolean; }
+export function computeFatigueSciGradient(data: number[], opts: FatigueSciGradientOptions = {}): FatigueSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciGradient };
diff --git a/src/fatigue_sci/hessian.ts b/src/fatigue_sci/hessian.ts
new file mode 100644
index 000000000..34b28f22d
--- /dev/null
+++ b/src/fatigue_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci hessian module — tsb analytics library. */
+export interface FatigueSciHessianOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciHessianResult { values: number[]; converged: boolean; }
+export function computeFatigueSciHessian(data: number[], opts: FatigueSciHessianOptions = {}): FatigueSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciHessian };
diff --git a/src/fatigue_sci/hypothesis.ts b/src/fatigue_sci/hypothesis.ts
new file mode 100644
index 000000000..6b417e7fb
--- /dev/null
+++ b/src/fatigue_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci hypothesis module — tsb analytics library. */
+export interface FatigueSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeFatigueSciHypothesis(data: number[], opts: FatigueSciHypothesisOptions = {}): FatigueSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciHypothesis };
diff --git a/src/fatigue_sci/inference.ts b/src/fatigue_sci/inference.ts
new file mode 100644
index 000000000..48fbf435a
--- /dev/null
+++ b/src/fatigue_sci/inference.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci inference module — tsb analytics library. */
+export interface FatigueSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciInferenceResult { values: number[]; converged: boolean; }
+export function computeFatigueSciInference(data: number[], opts: FatigueSciInferenceOptions = {}): FatigueSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciInference };
diff --git a/src/fatigue_sci/inference2.ts b/src/fatigue_sci/inference2.ts
new file mode 100644
index 000000000..128d4cc6e
--- /dev/null
+++ b/src/fatigue_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci inference2 module — tsb analytics library. */
+export interface FatigueSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciInferenceResult { values: number[]; converged: boolean; }
+export function computeFatigueSciInference(data: number[], opts: FatigueSciInferenceOptions = {}): FatigueSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciInference };
diff --git a/src/fatigue_sci/integral.ts b/src/fatigue_sci/integral.ts
new file mode 100644
index 000000000..391270173
--- /dev/null
+++ b/src/fatigue_sci/integral.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci integral module — tsb analytics library. */
+export interface FatigueSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciIntegralResult { values: number[]; converged: boolean; }
+export function computeFatigueSciIntegral(data: number[], opts: FatigueSciIntegralOptions = {}): FatigueSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciIntegral };
diff --git a/src/fatigue_sci/integration.ts b/src/fatigue_sci/integration.ts
new file mode 100644
index 000000000..a0b9d571a
--- /dev/null
+++ b/src/fatigue_sci/integration.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci integration module — tsb analytics library. */
+export interface FatigueSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciIntegration(data: number[], opts: FatigueSciIntegrationOptions = {}): FatigueSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciIntegration };
diff --git a/src/fatigue_sci/interpolation.ts b/src/fatigue_sci/interpolation.ts
new file mode 100644
index 000000000..6d43a2b1d
--- /dev/null
+++ b/src/fatigue_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci interpolation module — tsb analytics library. */
+export interface FatigueSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciInterpolation(data: number[], opts: FatigueSciInterpolationOptions = {}): FatigueSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciInterpolation };
diff --git a/src/fatigue_sci/jacobian.ts b/src/fatigue_sci/jacobian.ts
new file mode 100644
index 000000000..8de3f1f41
--- /dev/null
+++ b/src/fatigue_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci jacobian module — tsb analytics library. */
+export interface FatigueSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciJacobianResult { values: number[]; converged: boolean; }
+export function computeFatigueSciJacobian(data: number[], opts: FatigueSciJacobianOptions = {}): FatigueSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciJacobian };
diff --git a/src/fatigue_sci/kernel.ts b/src/fatigue_sci/kernel.ts
new file mode 100644
index 000000000..ce2fc2006
--- /dev/null
+++ b/src/fatigue_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci kernel module — tsb analytics library. */
+export interface FatigueSciKernelOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciKernelResult { values: number[]; converged: boolean; }
+export function computeFatigueSciKernel(data: number[], opts: FatigueSciKernelOptions = {}): FatigueSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciKernel };
diff --git a/src/fatigue_sci/laplacian.ts b/src/fatigue_sci/laplacian.ts
new file mode 100644
index 000000000..765652726
--- /dev/null
+++ b/src/fatigue_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci laplacian module — tsb analytics library. */
+export interface FatigueSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeFatigueSciLaplacian(data: number[], opts: FatigueSciLaplacianOptions = {}): FatigueSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciLaplacian };
diff --git a/src/fatigue_sci/learning.ts b/src/fatigue_sci/learning.ts
new file mode 100644
index 000000000..9c85769cb
--- /dev/null
+++ b/src/fatigue_sci/learning.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci learning module — tsb analytics library. */
+export interface FatigueSciLearningOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciLearningResult { values: number[]; converged: boolean; }
+export function computeFatigueSciLearning(data: number[], opts: FatigueSciLearningOptions = {}): FatigueSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciLearning };
diff --git a/src/fatigue_sci/linear.ts b/src/fatigue_sci/linear.ts
new file mode 100644
index 000000000..c08f4d541
--- /dev/null
+++ b/src/fatigue_sci/linear.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci linear module — tsb analytics library. */
+export interface FatigueSciLinearOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciLinearResult { values: number[]; converged: boolean; }
+export function computeFatigueSciLinear(data: number[], opts: FatigueSciLinearOptions = {}): FatigueSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciLinear };
diff --git a/src/fatigue_sci/manifold.ts b/src/fatigue_sci/manifold.ts
new file mode 100644
index 000000000..f116cdf4e
--- /dev/null
+++ b/src/fatigue_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci manifold module — tsb analytics library. */
+export interface FatigueSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciManifoldResult { values: number[]; converged: boolean; }
+export function computeFatigueSciManifold(data: number[], opts: FatigueSciManifoldOptions = {}): FatigueSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciManifold };
diff --git a/src/fatigue_sci/matching.ts b/src/fatigue_sci/matching.ts
new file mode 100644
index 000000000..e3d8e06f1
--- /dev/null
+++ b/src/fatigue_sci/matching.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci matching module — tsb analytics library. */
+export interface FatigueSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciMatchingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciMatching(data: number[], opts: FatigueSciMatchingOptions = {}): FatigueSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciMatching };
diff --git a/src/fatigue_sci/measurement.ts b/src/fatigue_sci/measurement.ts
new file mode 100644
index 000000000..db0fb6609
--- /dev/null
+++ b/src/fatigue_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci measurement module — tsb analytics library. */
+export interface FatigueSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeFatigueSciMeasurement(data: number[], opts: FatigueSciMeasurementOptions = {}): FatigueSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciMeasurement };
diff --git a/src/fatigue_sci/metrics.ts b/src/fatigue_sci/metrics.ts
new file mode 100644
index 000000000..53b194fee
--- /dev/null
+++ b/src/fatigue_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci metrics module — tsb analytics library. */
+export interface FatigueSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciMetricsResult { values: number[]; converged: boolean; }
+export function computeFatigueSciMetrics(data: number[], opts: FatigueSciMetricsOptions = {}): FatigueSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciMetrics };
diff --git a/src/fatigue_sci/modeling.ts b/src/fatigue_sci/modeling.ts
new file mode 100644
index 000000000..1ccc25f44
--- /dev/null
+++ b/src/fatigue_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci modeling module — tsb analytics library. */
+export interface FatigueSciModelingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciModelingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciModeling(data: number[], opts: FatigueSciModelingOptions = {}): FatigueSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciModeling };
diff --git a/src/fatigue_sci/monitoring.ts b/src/fatigue_sci/monitoring.ts
new file mode 100644
index 000000000..fb1f7e5f5
--- /dev/null
+++ b/src/fatigue_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci monitoring module — tsb analytics library. */
+export interface FatigueSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeFatigueSciMonitoring(data: number[], opts: FatigueSciMonitoringOptions = {}): FatigueSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciMonitoring };
diff --git a/src/fatigue_sci/nonlinear.ts b/src/fatigue_sci/nonlinear.ts
new file mode 100644
index 000000000..b2044b93d
--- /dev/null
+++ b/src/fatigue_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci nonlinear module — tsb analytics library. */
+export interface FatigueSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeFatigueSciNonlinear(data: number[], opts: FatigueSciNonlinearOptions = {}): FatigueSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciNonlinear };
diff --git a/src/fatigue_sci/normalization.ts b/src/fatigue_sci/normalization.ts
new file mode 100644
index 000000000..ab22ac74a
--- /dev/null
+++ b/src/fatigue_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci normalization module — tsb analytics library. */
+export interface FatigueSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciNormalization(data: number[], opts: FatigueSciNormalizationOptions = {}): FatigueSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciNormalization };
diff --git a/src/fatigue_sci/optimization.ts b/src/fatigue_sci/optimization.ts
new file mode 100644
index 000000000..780fbf886
--- /dev/null
+++ b/src/fatigue_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci optimization module — tsb analytics library. */
+export interface FatigueSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciOptimization(data: number[], opts: FatigueSciOptimizationOptions = {}): FatigueSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciOptimization };
diff --git a/src/fatigue_sci/patterns.ts b/src/fatigue_sci/patterns.ts
new file mode 100644
index 000000000..4542fef6e
--- /dev/null
+++ b/src/fatigue_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci patterns module — tsb analytics library. */
+export interface FatigueSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciPatternsResult { values: number[]; converged: boolean; }
+export function computeFatigueSciPatterns(data: number[], opts: FatigueSciPatternsOptions = {}): FatigueSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciPatterns };
diff --git a/src/fatigue_sci/permutation.ts b/src/fatigue_sci/permutation.ts
new file mode 100644
index 000000000..e85fab813
--- /dev/null
+++ b/src/fatigue_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci permutation module — tsb analytics library. */
+export interface FatigueSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciPermutationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciPermutation(data: number[], opts: FatigueSciPermutationOptions = {}): FatigueSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciPermutation };
diff --git a/src/fatigue_sci/prediction.ts b/src/fatigue_sci/prediction.ts
new file mode 100644
index 000000000..23b1f2286
--- /dev/null
+++ b/src/fatigue_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci prediction module — tsb analytics library. */
+export interface FatigueSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciPredictionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciPrediction(data: number[], opts: FatigueSciPredictionOptions = {}): FatigueSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciPrediction };
diff --git a/src/fatigue_sci/processing.ts b/src/fatigue_sci/processing.ts
new file mode 100644
index 000000000..3b3ebd0c1
--- /dev/null
+++ b/src/fatigue_sci/processing.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci processing module — tsb analytics library. */
+export interface FatigueSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciProcessingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciProcessing(data: number[], opts: FatigueSciProcessingOptions = {}): FatigueSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciProcessing };
diff --git a/src/fatigue_sci/profiling.ts b/src/fatigue_sci/profiling.ts
new file mode 100644
index 000000000..db306627d
--- /dev/null
+++ b/src/fatigue_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci profiling module — tsb analytics library. */
+export interface FatigueSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciProfilingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciProfiling(data: number[], opts: FatigueSciProfilingOptions = {}): FatigueSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciProfiling };
diff --git a/src/fatigue_sci/projection.ts b/src/fatigue_sci/projection.ts
new file mode 100644
index 000000000..bcefefec8
--- /dev/null
+++ b/src/fatigue_sci/projection.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci projection module — tsb analytics library. */
+export interface FatigueSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciProjectionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciProjection(data: number[], opts: FatigueSciProjectionOptions = {}): FatigueSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciProjection };
diff --git a/src/fatigue_sci/ranking.ts b/src/fatigue_sci/ranking.ts
new file mode 100644
index 000000000..adaee9c70
--- /dev/null
+++ b/src/fatigue_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci ranking module — tsb analytics library. */
+export interface FatigueSciRankingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciRankingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciRanking(data: number[], opts: FatigueSciRankingOptions = {}): FatigueSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciRanking };
diff --git a/src/fatigue_sci/reconstruction.ts b/src/fatigue_sci/reconstruction.ts
new file mode 100644
index 000000000..48860babf
--- /dev/null
+++ b/src/fatigue_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci reconstruction module — tsb analytics library. */
+export interface FatigueSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciReconstruction(data: number[], opts: FatigueSciReconstructionOptions = {}): FatigueSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciReconstruction };
diff --git a/src/fatigue_sci/registration.ts b/src/fatigue_sci/registration.ts
new file mode 100644
index 000000000..42ec96b48
--- /dev/null
+++ b/src/fatigue_sci/registration.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci registration module — tsb analytics library. */
+export interface FatigueSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciRegistration(data: number[], opts: FatigueSciRegistrationOptions = {}): FatigueSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciRegistration };
diff --git a/src/fatigue_sci/regression.ts b/src/fatigue_sci/regression.ts
new file mode 100644
index 000000000..8b7974409
--- /dev/null
+++ b/src/fatigue_sci/regression.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci regression module — tsb analytics library. */
+export interface FatigueSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciRegressionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciRegression(data: number[], opts: FatigueSciRegressionOptions = {}): FatigueSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciRegression };
diff --git a/src/fatigue_sci/regularization.ts b/src/fatigue_sci/regularization.ts
new file mode 100644
index 000000000..7af0df782
--- /dev/null
+++ b/src/fatigue_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci regularization module — tsb analytics library. */
+export interface FatigueSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciRegularization(data: number[], opts: FatigueSciRegularizationOptions = {}): FatigueSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciRegularization };
diff --git a/src/fatigue_sci/robustness.ts b/src/fatigue_sci/robustness.ts
new file mode 100644
index 000000000..def254191
--- /dev/null
+++ b/src/fatigue_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci robustness module — tsb analytics library. */
+export interface FatigueSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeFatigueSciRobustness(data: number[], opts: FatigueSciRobustnessOptions = {}): FatigueSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciRobustness };
diff --git a/src/fatigue_sci/sampling.ts b/src/fatigue_sci/sampling.ts
new file mode 100644
index 000000000..cc5c7b608
--- /dev/null
+++ b/src/fatigue_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci sampling module — tsb analytics library. */
+export interface FatigueSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciSamplingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciSampling(data: number[], opts: FatigueSciSamplingOptions = {}): FatigueSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciSampling };
diff --git a/src/fatigue_sci/sampling2.ts b/src/fatigue_sci/sampling2.ts
new file mode 100644
index 000000000..ee1578df3
--- /dev/null
+++ b/src/fatigue_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci sampling2 module — tsb analytics library. */
+export interface FatigueSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciSamplingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciSampling(data: number[], opts: FatigueSciSamplingOptions = {}): FatigueSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciSampling };
diff --git a/src/fatigue_sci/scaling.ts b/src/fatigue_sci/scaling.ts
new file mode 100644
index 000000000..13bed85d0
--- /dev/null
+++ b/src/fatigue_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci scaling module — tsb analytics library. */
+export interface FatigueSciScalingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciScalingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciScaling(data: number[], opts: FatigueSciScalingOptions = {}): FatigueSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciScaling };
diff --git a/src/fatigue_sci/scoring.ts b/src/fatigue_sci/scoring.ts
new file mode 100644
index 000000000..5e2941a43
--- /dev/null
+++ b/src/fatigue_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci scoring module — tsb analytics library. */
+export interface FatigueSciScoringOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciScoringResult { values: number[]; converged: boolean; }
+export function computeFatigueSciScoring(data: number[], opts: FatigueSciScoringOptions = {}): FatigueSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciScoring };
diff --git a/src/fatigue_sci/segmentation.ts b/src/fatigue_sci/segmentation.ts
new file mode 100644
index 000000000..2a246cc7a
--- /dev/null
+++ b/src/fatigue_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci segmentation module — tsb analytics library. */
+export interface FatigueSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciSegmentation(data: number[], opts: FatigueSciSegmentationOptions = {}): FatigueSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciSegmentation };
diff --git a/src/fatigue_sci/selection.ts b/src/fatigue_sci/selection.ts
new file mode 100644
index 000000000..3da4f9bb4
--- /dev/null
+++ b/src/fatigue_sci/selection.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci selection module — tsb analytics library. */
+export interface FatigueSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciSelectionResult { values: number[]; converged: boolean; }
+export function computeFatigueSciSelection(data: number[], opts: FatigueSciSelectionOptions = {}): FatigueSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciSelection };
diff --git a/src/fatigue_sci/sensitivity.ts b/src/fatigue_sci/sensitivity.ts
new file mode 100644
index 000000000..3036c07bd
--- /dev/null
+++ b/src/fatigue_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci sensitivity module — tsb analytics library. */
+export interface FatigueSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeFatigueSciSensitivity(data: number[], opts: FatigueSciSensitivityOptions = {}): FatigueSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciSensitivity };
diff --git a/src/fatigue_sci/simulation.ts b/src/fatigue_sci/simulation.ts
new file mode 100644
index 000000000..8f42d1064
--- /dev/null
+++ b/src/fatigue_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci simulation module — tsb analytics library. */
+export interface FatigueSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciSimulationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciSimulation(data: number[], opts: FatigueSciSimulationOptions = {}): FatigueSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciSimulation };
diff --git a/src/fatigue_sci/smoothing.ts b/src/fatigue_sci/smoothing.ts
new file mode 100644
index 000000000..4978f5fc4
--- /dev/null
+++ b/src/fatigue_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci smoothing module — tsb analytics library. */
+export interface FatigueSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciSmoothing(data: number[], opts: FatigueSciSmoothingOptions = {}): FatigueSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciSmoothing };
diff --git a/src/fatigue_sci/stability.ts b/src/fatigue_sci/stability.ts
new file mode 100644
index 000000000..2da276e0c
--- /dev/null
+++ b/src/fatigue_sci/stability.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci stability module — tsb analytics library. */
+export interface FatigueSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciStabilityResult { values: number[]; converged: boolean; }
+export function computeFatigueSciStability(data: number[], opts: FatigueSciStabilityOptions = {}): FatigueSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciStability };
diff --git a/src/fatigue_sci/stacking.ts b/src/fatigue_sci/stacking.ts
new file mode 100644
index 000000000..19699075f
--- /dev/null
+++ b/src/fatigue_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci stacking module — tsb analytics library. */
+export interface FatigueSciStackingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciStackingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciStacking(data: number[], opts: FatigueSciStackingOptions = {}): FatigueSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciStacking };
diff --git a/src/fatigue_sci/standardization.ts b/src/fatigue_sci/standardization.ts
new file mode 100644
index 000000000..cf90013e8
--- /dev/null
+++ b/src/fatigue_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci standardization module — tsb analytics library. */
+export interface FatigueSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciStandardization(data: number[], opts: FatigueSciStandardizationOptions = {}): FatigueSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciStandardization };
diff --git a/src/fatigue_sci/static.ts b/src/fatigue_sci/static.ts
new file mode 100644
index 000000000..ce3c15520
--- /dev/null
+++ b/src/fatigue_sci/static.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci static module — tsb analytics library. */
+export interface FatigueSciStaticOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciStaticResult { values: number[]; converged: boolean; }
+export function computeFatigueSciStatic(data: number[], opts: FatigueSciStaticOptions = {}): FatigueSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciStatic };
diff --git a/src/fatigue_sci/stochastic.ts b/src/fatigue_sci/stochastic.ts
new file mode 100644
index 000000000..f65b9ecfa
--- /dev/null
+++ b/src/fatigue_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci stochastic module — tsb analytics library. */
+export interface FatigueSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciStochasticResult { values: number[]; converged: boolean; }
+export function computeFatigueSciStochastic(data: number[], opts: FatigueSciStochasticOptions = {}): FatigueSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciStochastic };
diff --git a/src/fatigue_sci/synthesis.ts b/src/fatigue_sci/synthesis.ts
new file mode 100644
index 000000000..956d24647
--- /dev/null
+++ b/src/fatigue_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci synthesis module — tsb analytics library. */
+export interface FatigueSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeFatigueSciSynthesis(data: number[], opts: FatigueSciSynthesisOptions = {}): FatigueSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciSynthesis };
diff --git a/src/fatigue_sci/topology.ts b/src/fatigue_sci/topology.ts
new file mode 100644
index 000000000..4ae234812
--- /dev/null
+++ b/src/fatigue_sci/topology.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci topology module — tsb analytics library. */
+export interface FatigueSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciTopologyResult { values: number[]; converged: boolean; }
+export function computeFatigueSciTopology(data: number[], opts: FatigueSciTopologyOptions = {}): FatigueSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciTopology };
diff --git a/src/fatigue_sci/tracking.ts b/src/fatigue_sci/tracking.ts
new file mode 100644
index 000000000..b9c25f957
--- /dev/null
+++ b/src/fatigue_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci tracking module — tsb analytics library. */
+export interface FatigueSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciTrackingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciTracking(data: number[], opts: FatigueSciTrackingOptions = {}): FatigueSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciTracking };
diff --git a/src/fatigue_sci/transform.ts b/src/fatigue_sci/transform.ts
new file mode 100644
index 000000000..7505e4428
--- /dev/null
+++ b/src/fatigue_sci/transform.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci transform module — tsb analytics library. */
+export interface FatigueSciTransformOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciTransformResult { values: number[]; converged: boolean; }
+export function computeFatigueSciTransform(data: number[], opts: FatigueSciTransformOptions = {}): FatigueSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciTransform };
diff --git a/src/fatigue_sci/uncertainty.ts b/src/fatigue_sci/uncertainty.ts
new file mode 100644
index 000000000..cb831a3d2
--- /dev/null
+++ b/src/fatigue_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci uncertainty module — tsb analytics library. */
+export interface FatigueSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeFatigueSciUncertainty(data: number[], opts: FatigueSciUncertaintyOptions = {}): FatigueSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciUncertainty };
diff --git a/src/fatigue_sci/validation.ts b/src/fatigue_sci/validation.ts
new file mode 100644
index 000000000..d257e2a87
--- /dev/null
+++ b/src/fatigue_sci/validation.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci validation module — tsb analytics library. */
+export interface FatigueSciValidationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciValidationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciValidation(data: number[], opts: FatigueSciValidationOptions = {}): FatigueSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciValidation };
diff --git a/src/fatigue_sci/verification.ts b/src/fatigue_sci/verification.ts
new file mode 100644
index 000000000..cb72fde65
--- /dev/null
+++ b/src/fatigue_sci/verification.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci verification module — tsb analytics library. */
+export interface FatigueSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciVerificationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciVerification(data: number[], opts: FatigueSciVerificationOptions = {}): FatigueSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciVerification };
diff --git a/src/fatigue_sci/visualization.ts b/src/fatigue_sci/visualization.ts
new file mode 100644
index 000000000..2e1b2c371
--- /dev/null
+++ b/src/fatigue_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci visualization module — tsb analytics library. */
+export interface FatigueSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeFatigueSciVisualization(data: number[], opts: FatigueSciVisualizationOptions = {}): FatigueSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciVisualization };
diff --git a/src/fatigue_sci/voting.ts b/src/fatigue_sci/voting.ts
new file mode 100644
index 000000000..ee1581ce5
--- /dev/null
+++ b/src/fatigue_sci/voting.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci voting module — tsb analytics library. */
+export interface FatigueSciVotingOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciVotingResult { values: number[]; converged: boolean; }
+export function computeFatigueSciVoting(data: number[], opts: FatigueSciVotingOptions = {}): FatigueSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciVoting };
diff --git a/src/fatigue_sci/wavelet.ts b/src/fatigue_sci/wavelet.ts
new file mode 100644
index 000000000..fd51703c9
--- /dev/null
+++ b/src/fatigue_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** fatigue_sci wavelet module — tsb analytics library. */
+export interface FatigueSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface FatigueSciWaveletResult { values: number[]; converged: boolean; }
+export function computeFatigueSciWavelet(data: number[], opts: FatigueSciWaveletOptions = {}): FatigueSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFatigueSciWavelet };
diff --git a/src/finance/advanced.ts b/src/finance/advanced.ts
new file mode 100644
index 000000000..8b34d5a2c
--- /dev/null
+++ b/src/finance/advanced.ts
@@ -0,0 +1,15 @@
+/** Finance Advanced module — tsb analytics library. */
+export interface Finance advancedOptions { tol?: number; maxIter?: number; }
+export interface Finance advancedResult { values: number[]; converged: boolean; }
+export function computeFinance advanced(data: number[], opts: Finance advancedOptions = {}): Finance advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance advanced };
diff --git a/src/finance/alpha.ts b/src/finance/alpha.ts
new file mode 100644
index 000000000..90a9c2534
--- /dev/null
+++ b/src/finance/alpha.ts
@@ -0,0 +1,22 @@
+/** Alpha module — tsb analytics library. */
+
+/** Options for Alpha. */
+export interface AlphaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Alpha. */
+export interface AlphaResult { values: number[]; converged: boolean; }
+
+/** Compute Alpha. */
+export function computeAlpha(data: number[], opts: AlphaOptions = {}): AlphaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAlpha };
diff --git a/src/finance/arbitrage.ts b/src/finance/arbitrage.ts
new file mode 100644
index 000000000..14f406b61
--- /dev/null
+++ b/src/finance/arbitrage.ts
@@ -0,0 +1,22 @@
+/** Arbitrage module — tsb analytics library. */
+
+/** Options for Arbitrage. */
+export interface ArbitrageOptions { tol?: number; maxIter?: number; }
+
+/** Result from Arbitrage. */
+export interface ArbitrageResult { values: number[]; converged: boolean; }
+
+/** Compute Arbitrage. */
+export function computeArbitrage(data: number[], opts: ArbitrageOptions = {}): ArbitrageResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeArbitrage };
diff --git a/src/finance/backtesting.ts b/src/finance/backtesting.ts
new file mode 100644
index 000000000..16933d86c
--- /dev/null
+++ b/src/finance/backtesting.ts
@@ -0,0 +1,22 @@
+/** Backtesting module — tsb analytics library. */
+
+/** Options for Backtesting. */
+export interface BacktestingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Backtesting. */
+export interface BacktestingResult { values: number[]; converged: boolean; }
+
+/** Compute Backtesting. */
+export function computeBacktesting(data: number[], opts: BacktestingOptions = {}): BacktestingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBacktesting };
diff --git a/src/finance/base2.ts b/src/finance/base2.ts
new file mode 100644
index 000000000..076f3a580
--- /dev/null
+++ b/src/finance/base2.ts
@@ -0,0 +1,15 @@
+/** Finance Base2 module — tsb analytics library. */
+export interface Finance base2Options { tol?: number; maxIter?: number; }
+export interface Finance base2Result { values: number[]; converged: boolean; }
+export function computeFinance base2(data: number[], opts: Finance base2Options = {}): Finance base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance base2 };
diff --git a/src/finance/batch.ts b/src/finance/batch.ts
new file mode 100644
index 000000000..ee40b42da
--- /dev/null
+++ b/src/finance/batch.ts
@@ -0,0 +1,15 @@
+/** Finance Batch module — tsb analytics library. */
+export interface Finance batchOptions { tol?: number; maxIter?: number; }
+export interface Finance batchResult { values: number[]; converged: boolean; }
+export function computeFinance batch(data: number[], opts: Finance batchOptions = {}): Finance batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance batch };
diff --git a/src/finance/beta.ts b/src/finance/beta.ts
new file mode 100644
index 000000000..5310086e3
--- /dev/null
+++ b/src/finance/beta.ts
@@ -0,0 +1,22 @@
+/** Beta module — tsb analytics library. */
+
+/** Options for Beta. */
+export interface BetaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Beta. */
+export interface BetaResult { values: number[]; converged: boolean; }
+
+/** Compute Beta. */
+export function computeBeta(data: number[], opts: BetaOptions = {}): BetaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBeta };
diff --git a/src/finance/bonds.ts b/src/finance/bonds.ts
new file mode 100644
index 000000000..d5da170b8
--- /dev/null
+++ b/src/finance/bonds.ts
@@ -0,0 +1,22 @@
+/** Bonds module — tsb analytics library. */
+
+/** Options for Bonds. */
+export interface BondsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bonds. */
+export interface BondsResult { values: number[]; converged: boolean; }
+
+/** Compute Bonds. */
+export function computeBonds(data: number[], opts: BondsOptions = {}): BondsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBonds };
diff --git a/src/finance/commodities.ts b/src/finance/commodities.ts
new file mode 100644
index 000000000..a3c8a1d10
--- /dev/null
+++ b/src/finance/commodities.ts
@@ -0,0 +1,22 @@
+/** Commodities module — tsb analytics library. */
+
+/** Options for Commodities. */
+export interface CommoditiesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Commodities. */
+export interface CommoditiesResult { values: number[]; converged: boolean; }
+
+/** Compute Commodities. */
+export function computeCommodities(data: number[], opts: CommoditiesOptions = {}): CommoditiesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCommodities };
diff --git a/src/finance/cpu.ts b/src/finance/cpu.ts
new file mode 100644
index 000000000..d2a16d086
--- /dev/null
+++ b/src/finance/cpu.ts
@@ -0,0 +1,15 @@
+/** Finance Cpu module — tsb analytics library. */
+export interface Finance cpuOptions { tol?: number; maxIter?: number; }
+export interface Finance cpuResult { values: number[]; converged: boolean; }
+export function computeFinance cpu(data: number[], opts: Finance cpuOptions = {}): Finance cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance cpu };
diff --git a/src/finance/credit.ts b/src/finance/credit.ts
new file mode 100644
index 000000000..16a38d2f8
--- /dev/null
+++ b/src/finance/credit.ts
@@ -0,0 +1,22 @@
+/** Credit module — tsb analytics library. */
+
+/** Options for Credit. */
+export interface CreditOptions { tol?: number; maxIter?: number; }
+
+/** Result from Credit. */
+export interface CreditResult { values: number[]; converged: boolean; }
+
+/** Compute Credit. */
+export function computeCredit(data: number[], opts: CreditOptions = {}): CreditResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCredit };
diff --git a/src/finance/cvar.ts b/src/finance/cvar.ts
new file mode 100644
index 000000000..e885874e7
--- /dev/null
+++ b/src/finance/cvar.ts
@@ -0,0 +1,22 @@
+/** Cvar module — tsb analytics library. */
+
+/** Options for Cvar. */
+export interface CvarOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cvar. */
+export interface CvarResult { values: number[]; converged: boolean; }
+
+/** Compute Cvar. */
+export function computeCvar(data: number[], opts: CvarOptions = {}): CvarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCvar };
diff --git a/src/finance/dense.ts b/src/finance/dense.ts
new file mode 100644
index 000000000..270b05f90
--- /dev/null
+++ b/src/finance/dense.ts
@@ -0,0 +1,15 @@
+/** Finance Dense module — tsb analytics library. */
+export interface Finance denseOptions { tol?: number; maxIter?: number; }
+export interface Finance denseResult { values: number[]; converged: boolean; }
+export function computeFinance dense(data: number[], opts: Finance denseOptions = {}): Finance denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance dense };
diff --git a/src/finance/derivatives.ts b/src/finance/derivatives.ts
new file mode 100644
index 000000000..7694b7b7b
--- /dev/null
+++ b/src/finance/derivatives.ts
@@ -0,0 +1,22 @@
+/** Derivatives module — tsb analytics library. */
+
+/** Options for Derivatives. */
+export interface DerivativesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Derivatives. */
+export interface DerivativesResult { values: number[]; converged: boolean; }
+
+/** Compute Derivatives. */
+export function computeDerivatives(data: number[], opts: DerivativesOptions = {}): DerivativesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDerivatives };
diff --git a/src/finance/distributed.ts b/src/finance/distributed.ts
new file mode 100644
index 000000000..3136c5665
--- /dev/null
+++ b/src/finance/distributed.ts
@@ -0,0 +1,15 @@
+/** Finance Distributed module — tsb analytics library. */
+export interface Finance distributedOptions { tol?: number; maxIter?: number; }
+export interface Finance distributedResult { values: number[]; converged: boolean; }
+export function computeFinance distributed(data: number[], opts: Finance distributedOptions = {}): Finance distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance distributed };
diff --git a/src/finance/drawdown.ts b/src/finance/drawdown.ts
new file mode 100644
index 000000000..24d9747f2
--- /dev/null
+++ b/src/finance/drawdown.ts
@@ -0,0 +1,22 @@
+/** Drawdown module — tsb analytics library. */
+
+/** Options for Drawdown. */
+export interface DrawdownOptions { tol?: number; maxIter?: number; }
+
+/** Result from Drawdown. */
+export interface DrawdownResult { values: number[]; converged: boolean; }
+
+/** Compute Drawdown. */
+export function computeDrawdown(data: number[], opts: DrawdownOptions = {}): DrawdownResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDrawdown };
diff --git a/src/finance/equity.ts b/src/finance/equity.ts
new file mode 100644
index 000000000..b8f2761f3
--- /dev/null
+++ b/src/finance/equity.ts
@@ -0,0 +1,22 @@
+/** Equity module — tsb analytics library. */
+
+/** Options for Equity. */
+export interface EquityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Equity. */
+export interface EquityResult { values: number[]; converged: boolean; }
+
+/** Compute Equity. */
+export function computeEquity(data: number[], opts: EquityOptions = {}): EquityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEquity };
diff --git a/src/finance/execution.ts b/src/finance/execution.ts
new file mode 100644
index 000000000..ea7ea1881
--- /dev/null
+++ b/src/finance/execution.ts
@@ -0,0 +1,22 @@
+/** Execution module — tsb analytics library. */
+
+/** Options for Execution. */
+export interface ExecutionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Execution. */
+export interface ExecutionResult { values: number[]; converged: boolean; }
+
+/** Compute Execution. */
+export function computeExecution(data: number[], opts: ExecutionOptions = {}): ExecutionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExecution };
diff --git a/src/finance/experimental.ts b/src/finance/experimental.ts
new file mode 100644
index 000000000..4c701f4d8
--- /dev/null
+++ b/src/finance/experimental.ts
@@ -0,0 +1,15 @@
+/** Finance Experimental module — tsb analytics library. */
+export interface Finance experimentalOptions { tol?: number; maxIter?: number; }
+export interface Finance experimentalResult { values: number[]; converged: boolean; }
+export function computeFinance experimental(data: number[], opts: Finance experimentalOptions = {}): Finance experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance experimental };
diff --git a/src/finance/fast.ts b/src/finance/fast.ts
new file mode 100644
index 000000000..f7b5668d2
--- /dev/null
+++ b/src/finance/fast.ts
@@ -0,0 +1,15 @@
+/** Finance Fast module — tsb analytics library. */
+export interface Finance fastOptions { tol?: number; maxIter?: number; }
+export interface Finance fastResult { values: number[]; converged: boolean; }
+export function computeFinance fast(data: number[], opts: Finance fastOptions = {}): Finance fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance fast };
diff --git a/src/finance/forex.ts b/src/finance/forex.ts
new file mode 100644
index 000000000..c573e99a6
--- /dev/null
+++ b/src/finance/forex.ts
@@ -0,0 +1,22 @@
+/** Forex module — tsb analytics library. */
+
+/** Options for Forex. */
+export interface ForexOptions { tol?: number; maxIter?: number; }
+
+/** Result from Forex. */
+export interface ForexResult { values: number[]; converged: boolean; }
+
+/** Compute Forex. */
+export function computeForex(data: number[], opts: ForexOptions = {}): ForexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeForex };
diff --git a/src/finance/future.ts b/src/finance/future.ts
new file mode 100644
index 000000000..0e1535c35
--- /dev/null
+++ b/src/finance/future.ts
@@ -0,0 +1,15 @@
+/** Finance Future module — tsb analytics library. */
+export interface Finance futureOptions { tol?: number; maxIter?: number; }
+export interface Finance futureResult { values: number[]; converged: boolean; }
+export function computeFinance future(data: number[], opts: Finance futureOptions = {}): Finance futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance future };
diff --git a/src/finance/futures.ts b/src/finance/futures.ts
new file mode 100644
index 000000000..3a6ba5c5d
--- /dev/null
+++ b/src/finance/futures.ts
@@ -0,0 +1,22 @@
+/** Futures module — tsb analytics library. */
+
+/** Options for Futures. */
+export interface FuturesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Futures. */
+export interface FuturesResult { values: number[]; converged: boolean; }
+
+/** Compute Futures. */
+export function computeFutures(data: number[], opts: FuturesOptions = {}): FuturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFutures };
diff --git a/src/finance/gpu.ts b/src/finance/gpu.ts
new file mode 100644
index 000000000..6f4a0d8de
--- /dev/null
+++ b/src/finance/gpu.ts
@@ -0,0 +1,15 @@
+/** Finance Gpu module — tsb analytics library. */
+export interface Finance gpuOptions { tol?: number; maxIter?: number; }
+export interface Finance gpuResult { values: number[]; converged: boolean; }
+export function computeFinance gpu(data: number[], opts: Finance gpuOptions = {}): Finance gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance gpu };
diff --git a/src/finance/hedging.ts b/src/finance/hedging.ts
new file mode 100644
index 000000000..06b699afb
--- /dev/null
+++ b/src/finance/hedging.ts
@@ -0,0 +1,22 @@
+/** Hedging module — tsb analytics library. */
+
+/** Options for Hedging. */
+export interface HedgingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hedging. */
+export interface HedgingResult { values: number[]; converged: boolean; }
+
+/** Compute Hedging. */
+export function computeHedging(data: number[], opts: HedgingOptions = {}): HedgingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHedging };
diff --git a/src/finance/large.ts b/src/finance/large.ts
new file mode 100644
index 000000000..828aa1465
--- /dev/null
+++ b/src/finance/large.ts
@@ -0,0 +1,15 @@
+/** Finance Large module — tsb analytics library. */
+export interface Finance largeOptions { tol?: number; maxIter?: number; }
+export interface Finance largeResult { values: number[]; converged: boolean; }
+export function computeFinance large(data: number[], opts: Finance largeOptions = {}): Finance largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance large };
diff --git a/src/finance/legacy.ts b/src/finance/legacy.ts
new file mode 100644
index 000000000..2c3989be4
--- /dev/null
+++ b/src/finance/legacy.ts
@@ -0,0 +1,15 @@
+/** Finance Legacy module — tsb analytics library. */
+export interface Finance legacyOptions { tol?: number; maxIter?: number; }
+export interface Finance legacyResult { values: number[]; converged: boolean; }
+export function computeFinance legacy(data: number[], opts: Finance legacyOptions = {}): Finance legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance legacy };
diff --git a/src/finance/lite.ts b/src/finance/lite.ts
new file mode 100644
index 000000000..f17c26de2
--- /dev/null
+++ b/src/finance/lite.ts
@@ -0,0 +1,15 @@
+/** Finance Lite module — tsb analytics library. */
+export interface Finance liteOptions { tol?: number; maxIter?: number; }
+export interface Finance liteResult { values: number[]; converged: boolean; }
+export function computeFinance lite(data: number[], opts: Finance liteOptions = {}): Finance liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance lite };
diff --git a/src/finance/mean_reversion.ts b/src/finance/mean_reversion.ts
new file mode 100644
index 000000000..3569788aa
--- /dev/null
+++ b/src/finance/mean_reversion.ts
@@ -0,0 +1,22 @@
+/** Mean Reversion module — tsb analytics library. */
+
+/** Options for Mean Reversion. */
+export interface MeanReversionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mean Reversion. */
+export interface MeanReversionResult { values: number[]; converged: boolean; }
+
+/** Compute Mean Reversion. */
+export function computeMeanReversion(data: number[], opts: MeanReversionOptions = {}): MeanReversionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMeanReversion };
diff --git a/src/finance/mini.ts b/src/finance/mini.ts
new file mode 100644
index 000000000..a3e20ba91
--- /dev/null
+++ b/src/finance/mini.ts
@@ -0,0 +1,15 @@
+/** Finance Mini module — tsb analytics library. */
+export interface Finance miniOptions { tol?: number; maxIter?: number; }
+export interface Finance miniResult { values: number[]; converged: boolean; }
+export function computeFinance mini(data: number[], opts: Finance miniOptions = {}): Finance miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance mini };
diff --git a/src/finance/momentum.ts b/src/finance/momentum.ts
new file mode 100644
index 000000000..fdd4f501f
--- /dev/null
+++ b/src/finance/momentum.ts
@@ -0,0 +1,22 @@
+/** Momentum module — tsb analytics library. */
+
+/** Options for Momentum. */
+export interface MomentumOptions { tol?: number; maxIter?: number; }
+
+/** Result from Momentum. */
+export interface MomentumResult { values: number[]; converged: boolean; }
+
+/** Compute Momentum. */
+export function computeMomentum(data: number[], opts: MomentumOptions = {}): MomentumResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMomentum };
diff --git a/src/finance/next.ts b/src/finance/next.ts
new file mode 100644
index 000000000..91ec2e107
--- /dev/null
+++ b/src/finance/next.ts
@@ -0,0 +1,15 @@
+/** Finance Next module — tsb analytics library. */
+export interface Finance nextOptions { tol?: number; maxIter?: number; }
+export interface Finance nextResult { values: number[]; converged: boolean; }
+export function computeFinance next(data: number[], opts: Finance nextOptions = {}): Finance nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance next };
diff --git a/src/finance/online.ts b/src/finance/online.ts
new file mode 100644
index 000000000..05739d4b8
--- /dev/null
+++ b/src/finance/online.ts
@@ -0,0 +1,15 @@
+/** Finance Online module — tsb analytics library. */
+export interface Finance onlineOptions { tol?: number; maxIter?: number; }
+export interface Finance onlineResult { values: number[]; converged: boolean; }
+export function computeFinance online(data: number[], opts: Finance onlineOptions = {}): Finance onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance online };
diff --git a/src/finance/options.ts b/src/finance/options.ts
new file mode 100644
index 000000000..dd147af5b
--- /dev/null
+++ b/src/finance/options.ts
@@ -0,0 +1,22 @@
+/** Options module — tsb analytics library. */
+
+/** Options for Options. */
+export interface OptionsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Options. */
+export interface OptionsResult { values: number[]; converged: boolean; }
+
+/** Compute Options. */
+export function computeOptions(data: number[], opts: OptionsOptions = {}): OptionsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOptions };
diff --git a/src/finance/pairs.ts b/src/finance/pairs.ts
new file mode 100644
index 000000000..8661b153e
--- /dev/null
+++ b/src/finance/pairs.ts
@@ -0,0 +1,22 @@
+/** Pairs module — tsb analytics library. */
+
+/** Options for Pairs. */
+export interface PairsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pairs. */
+export interface PairsResult { values: number[]; converged: boolean; }
+
+/** Compute Pairs. */
+export function computePairs(data: number[], opts: PairsOptions = {}): PairsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePairs };
diff --git a/src/finance/parallel.ts b/src/finance/parallel.ts
new file mode 100644
index 000000000..acf34bca6
--- /dev/null
+++ b/src/finance/parallel.ts
@@ -0,0 +1,15 @@
+/** Finance Parallel module — tsb analytics library. */
+export interface Finance parallelOptions { tol?: number; maxIter?: number; }
+export interface Finance parallelResult { values: number[]; converged: boolean; }
+export function computeFinance parallel(data: number[], opts: Finance parallelOptions = {}): Finance parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance parallel };
diff --git a/src/finance/plus.ts b/src/finance/plus.ts
new file mode 100644
index 000000000..b40208252
--- /dev/null
+++ b/src/finance/plus.ts
@@ -0,0 +1,15 @@
+/** Finance Plus module — tsb analytics library. */
+export interface Finance plusOptions { tol?: number; maxIter?: number; }
+export interface Finance plusResult { values: number[]; converged: boolean; }
+export function computeFinance plus(data: number[], opts: Finance plusOptions = {}): Finance plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance plus };
diff --git a/src/finance/portfolio.ts b/src/finance/portfolio.ts
new file mode 100644
index 000000000..ebb8e3558
--- /dev/null
+++ b/src/finance/portfolio.ts
@@ -0,0 +1,22 @@
+/** Portfolio module — tsb analytics library. */
+
+/** Options for Portfolio. */
+export interface PortfolioOptions { tol?: number; maxIter?: number; }
+
+/** Result from Portfolio. */
+export interface PortfolioResult { values: number[]; converged: boolean; }
+
+/** Compute Portfolio. */
+export function computePortfolio(data: number[], opts: PortfolioOptions = {}): PortfolioResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePortfolio };
diff --git a/src/finance/pricing.ts b/src/finance/pricing.ts
new file mode 100644
index 000000000..9e2ed9353
--- /dev/null
+++ b/src/finance/pricing.ts
@@ -0,0 +1,22 @@
+/** Pricing module — tsb analytics library. */
+
+/** Options for Pricing. */
+export interface PricingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pricing. */
+export interface PricingResult { values: number[]; converged: boolean; }
+
+/** Compute Pricing. */
+export function computePricing(data: number[], opts: PricingOptions = {}): PricingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePricing };
diff --git a/src/finance/pro.ts b/src/finance/pro.ts
new file mode 100644
index 000000000..4ee88dd9e
--- /dev/null
+++ b/src/finance/pro.ts
@@ -0,0 +1,15 @@
+/** Finance Pro module — tsb analytics library. */
+export interface Finance proOptions { tol?: number; maxIter?: number; }
+export interface Finance proResult { values: number[]; converged: boolean; }
+export function computeFinance pro(data: number[], opts: Finance proOptions = {}): Finance proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance pro };
diff --git a/src/finance/rates.ts b/src/finance/rates.ts
new file mode 100644
index 000000000..5d35dba72
--- /dev/null
+++ b/src/finance/rates.ts
@@ -0,0 +1,22 @@
+/** Rates module — tsb analytics library. */
+
+/** Options for Rates. */
+export interface RatesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rates. */
+export interface RatesResult { values: number[]; converged: boolean; }
+
+/** Compute Rates. */
+export function computeRates(data: number[], opts: RatesOptions = {}): RatesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRates };
diff --git a/src/finance/risk.ts b/src/finance/risk.ts
new file mode 100644
index 000000000..5dffec3f7
--- /dev/null
+++ b/src/finance/risk.ts
@@ -0,0 +1,22 @@
+/** Risk module — tsb analytics library. */
+
+/** Options for Risk. */
+export interface RiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Risk. */
+export interface RiskResult { values: number[]; converged: boolean; }
+
+/** Compute Risk. */
+export function computeRisk(data: number[], opts: RiskOptions = {}): RiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRisk };
diff --git a/src/finance/robust.ts b/src/finance/robust.ts
new file mode 100644
index 000000000..2033b0c99
--- /dev/null
+++ b/src/finance/robust.ts
@@ -0,0 +1,15 @@
+/** Finance Robust module — tsb analytics library. */
+export interface Finance robustOptions { tol?: number; maxIter?: number; }
+export interface Finance robustResult { values: number[]; converged: boolean; }
+export function computeFinance robust(data: number[], opts: Finance robustOptions = {}): Finance robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance robust };
diff --git a/src/finance/scenario.ts b/src/finance/scenario.ts
new file mode 100644
index 000000000..6dfafa8b9
--- /dev/null
+++ b/src/finance/scenario.ts
@@ -0,0 +1,22 @@
+/** Scenario module — tsb analytics library. */
+
+/** Options for Scenario. */
+export interface ScenarioOptions { tol?: number; maxIter?: number; }
+
+/** Result from Scenario. */
+export interface ScenarioResult { values: number[]; converged: boolean; }
+
+/** Compute Scenario. */
+export function computeScenario(data: number[], opts: ScenarioOptions = {}): ScenarioResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeScenario };
diff --git a/src/finance/sharpe.ts b/src/finance/sharpe.ts
new file mode 100644
index 000000000..830dc7ca7
--- /dev/null
+++ b/src/finance/sharpe.ts
@@ -0,0 +1,22 @@
+/** Sharpe module — tsb analytics library. */
+
+/** Options for Sharpe. */
+export interface SharpeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sharpe. */
+export interface SharpeResult { values: number[]; converged: boolean; }
+
+/** Compute Sharpe. */
+export function computeSharpe(data: number[], opts: SharpeOptions = {}): SharpeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSharpe };
diff --git a/src/finance/small.ts b/src/finance/small.ts
new file mode 100644
index 000000000..43e24c0d2
--- /dev/null
+++ b/src/finance/small.ts
@@ -0,0 +1,15 @@
+/** Finance Small module — tsb analytics library. */
+export interface Finance smallOptions { tol?: number; maxIter?: number; }
+export interface Finance smallResult { values: number[]; converged: boolean; }
+export function computeFinance small(data: number[], opts: Finance smallOptions = {}): Finance smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance small };
diff --git a/src/finance/sortino.ts b/src/finance/sortino.ts
new file mode 100644
index 000000000..74d23c8d1
--- /dev/null
+++ b/src/finance/sortino.ts
@@ -0,0 +1,22 @@
+/** Sortino module — tsb analytics library. */
+
+/** Options for Sortino. */
+export interface SortinoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sortino. */
+export interface SortinoResult { values: number[]; converged: boolean; }
+
+/** Compute Sortino. */
+export function computeSortino(data: number[], opts: SortinoOptions = {}): SortinoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSortino };
diff --git a/src/finance/sparse.ts b/src/finance/sparse.ts
new file mode 100644
index 000000000..828a88bcb
--- /dev/null
+++ b/src/finance/sparse.ts
@@ -0,0 +1,15 @@
+/** Finance Sparse module — tsb analytics library. */
+export interface Finance sparseOptions { tol?: number; maxIter?: number; }
+export interface Finance sparseResult { values: number[]; converged: boolean; }
+export function computeFinance sparse(data: number[], opts: Finance sparseOptions = {}): Finance sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance sparse };
diff --git a/src/finance/stable.ts b/src/finance/stable.ts
new file mode 100644
index 000000000..08de1b375
--- /dev/null
+++ b/src/finance/stable.ts
@@ -0,0 +1,15 @@
+/** Finance Stable module — tsb analytics library. */
+export interface Finance stableOptions { tol?: number; maxIter?: number; }
+export interface Finance stableResult { values: number[]; converged: boolean; }
+export function computeFinance stable(data: number[], opts: Finance stableOptions = {}): Finance stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance stable };
diff --git a/src/finance/streaming.ts b/src/finance/streaming.ts
new file mode 100644
index 000000000..312b82935
--- /dev/null
+++ b/src/finance/streaming.ts
@@ -0,0 +1,15 @@
+/** Finance Streaming module — tsb analytics library. */
+export interface Finance streamingOptions { tol?: number; maxIter?: number; }
+export interface Finance streamingResult { values: number[]; converged: boolean; }
+export function computeFinance streaming(data: number[], opts: Finance streamingOptions = {}): Finance streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance streaming };
diff --git a/src/finance/stress_test.ts b/src/finance/stress_test.ts
new file mode 100644
index 000000000..5faf11688
--- /dev/null
+++ b/src/finance/stress_test.ts
@@ -0,0 +1,22 @@
+/** Stress Test module — tsb analytics library. */
+
+/** Options for Stress Test. */
+export interface StressTestOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stress Test. */
+export interface StressTestResult { values: number[]; converged: boolean; }
+
+/** Compute Stress Test. */
+export function computeStressTest(data: number[], opts: StressTestOptions = {}): StressTestResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStressTest };
diff --git a/src/finance/v2.ts b/src/finance/v2.ts
new file mode 100644
index 000000000..f669727d4
--- /dev/null
+++ b/src/finance/v2.ts
@@ -0,0 +1,15 @@
+/** Finance V2 module — tsb analytics library. */
+export interface Finance v2Options { tol?: number; maxIter?: number; }
+export interface Finance v2Result { values: number[]; converged: boolean; }
+export function computeFinance v2(data: number[], opts: Finance v2Options = {}): Finance v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance v2 };
diff --git a/src/finance/v3.ts b/src/finance/v3.ts
new file mode 100644
index 000000000..71e90815f
--- /dev/null
+++ b/src/finance/v3.ts
@@ -0,0 +1,15 @@
+/** Finance V3 module — tsb analytics library. */
+export interface Finance v3Options { tol?: number; maxIter?: number; }
+export interface Finance v3Result { values: number[]; converged: boolean; }
+export function computeFinance v3(data: number[], opts: Finance v3Options = {}): Finance v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance v3 };
diff --git a/src/finance/var.ts b/src/finance/var.ts
new file mode 100644
index 000000000..0377e36cf
--- /dev/null
+++ b/src/finance/var.ts
@@ -0,0 +1,22 @@
+/** Var module — tsb analytics library. */
+
+/** Options for Var. */
+export interface VarOptions { tol?: number; maxIter?: number; }
+
+/** Result from Var. */
+export interface VarResult { values: number[]; converged: boolean; }
+
+/** Compute Var. */
+export function computeVar(data: number[], opts: VarOptions = {}): VarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVar };
diff --git a/src/finance/volatility.ts b/src/finance/volatility.ts
new file mode 100644
index 000000000..4978c8aa8
--- /dev/null
+++ b/src/finance/volatility.ts
@@ -0,0 +1,22 @@
+/** Volatility module — tsb analytics library. */
+
+/** Options for Volatility. */
+export interface VolatilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Volatility. */
+export interface VolatilityResult { values: number[]; converged: boolean; }
+
+/** Compute Volatility. */
+export function computeVolatility(data: number[], opts: VolatilityOptions = {}): VolatilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVolatility };
diff --git a/src/finance/wasm.ts b/src/finance/wasm.ts
new file mode 100644
index 000000000..0df06e552
--- /dev/null
+++ b/src/finance/wasm.ts
@@ -0,0 +1,15 @@
+/** Finance Wasm module — tsb analytics library. */
+export interface Finance wasmOptions { tol?: number; maxIter?: number; }
+export interface Finance wasmResult { values: number[]; converged: boolean; }
+export function computeFinance wasm(data: number[], opts: Finance wasmOptions = {}): Finance wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance wasm };
diff --git a/src/finance/xlarge.ts b/src/finance/xlarge.ts
new file mode 100644
index 000000000..fae36abea
--- /dev/null
+++ b/src/finance/xlarge.ts
@@ -0,0 +1,15 @@
+/** Finance Xlarge module — tsb analytics library. */
+export interface Finance xlargeOptions { tol?: number; maxIter?: number; }
+export interface Finance xlargeResult { values: number[]; converged: boolean; }
+export function computeFinance xlarge(data: number[], opts: Finance xlargeOptions = {}): Finance xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFinance xlarge };
diff --git a/src/finance/yield_curve.ts b/src/finance/yield_curve.ts
new file mode 100644
index 000000000..6e8382964
--- /dev/null
+++ b/src/finance/yield_curve.ts
@@ -0,0 +1,22 @@
+/** Yield Curve module — tsb analytics library. */
+
+/** Options for Yield Curve. */
+export interface YieldCurveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Yield Curve. */
+export interface YieldCurveResult { values: number[]; converged: boolean; }
+
+/** Compute Yield Curve. */
+export function computeYieldCurve(data: number[], opts: YieldCurveOptions = {}): YieldCurveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeYieldCurve };
diff --git a/src/fluid_dynamics/adaptation.ts b/src/fluid_dynamics/adaptation.ts
new file mode 100644
index 000000000..63399e341
--- /dev/null
+++ b/src/fluid_dynamics/adaptation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics adaptation module — tsb analytics library. */
+export interface FluidDynamicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsAdaptation(data: number[], opts: FluidDynamicsAdaptationOptions = {}): FluidDynamicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsAdaptation };
diff --git a/src/fluid_dynamics/aggregation.ts b/src/fluid_dynamics/aggregation.ts
new file mode 100644
index 000000000..18189cea5
--- /dev/null
+++ b/src/fluid_dynamics/aggregation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics aggregation module — tsb analytics library. */
+export interface FluidDynamicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsAggregationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsAggregation(data: number[], opts: FluidDynamicsAggregationOptions = {}): FluidDynamicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsAggregation };
diff --git a/src/fluid_dynamics/algebra.ts b/src/fluid_dynamics/algebra.ts
new file mode 100644
index 000000000..1b1d82b0a
--- /dev/null
+++ b/src/fluid_dynamics/algebra.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics algebra module — tsb analytics library. */
+export interface FluidDynamicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsAlgebra(data: number[], opts: FluidDynamicsAlgebraOptions = {}): FluidDynamicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsAlgebra };
diff --git a/src/fluid_dynamics/alignment.ts b/src/fluid_dynamics/alignment.ts
new file mode 100644
index 000000000..c13e5ae9b
--- /dev/null
+++ b/src/fluid_dynamics/alignment.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics alignment module — tsb analytics library. */
+export interface FluidDynamicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsAlignment(data: number[], opts: FluidDynamicsAlignmentOptions = {}): FluidDynamicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsAlignment };
diff --git a/src/fluid_dynamics/analysis.ts b/src/fluid_dynamics/analysis.ts
new file mode 100644
index 000000000..3ad886efd
--- /dev/null
+++ b/src/fluid_dynamics/analysis.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics analysis module — tsb analytics library. */
+export interface FluidDynamicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsAnalysis(data: number[], opts: FluidDynamicsAnalysisOptions = {}): FluidDynamicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsAnalysis };
diff --git a/src/fluid_dynamics/augmentation.ts b/src/fluid_dynamics/augmentation.ts
new file mode 100644
index 000000000..a48c2bc65
--- /dev/null
+++ b/src/fluid_dynamics/augmentation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics augmentation module — tsb analytics library. */
+export interface FluidDynamicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsAugmentation(data: number[], opts: FluidDynamicsAugmentationOptions = {}): FluidDynamicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsAugmentation };
diff --git a/src/fluid_dynamics/bagging.ts b/src/fluid_dynamics/bagging.ts
new file mode 100644
index 000000000..ec78aade9
--- /dev/null
+++ b/src/fluid_dynamics/bagging.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics bagging module — tsb analytics library. */
+export interface FluidDynamicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsBaggingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsBagging(data: number[], opts: FluidDynamicsBaggingOptions = {}): FluidDynamicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsBagging };
diff --git a/src/fluid_dynamics/basis.ts b/src/fluid_dynamics/basis.ts
new file mode 100644
index 000000000..07dab8470
--- /dev/null
+++ b/src/fluid_dynamics/basis.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics basis module — tsb analytics library. */
+export interface FluidDynamicsBasisOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsBasisResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsBasis(data: number[], opts: FluidDynamicsBasisOptions = {}): FluidDynamicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsBasis };
diff --git a/src/fluid_dynamics/benchmarking.ts b/src/fluid_dynamics/benchmarking.ts
new file mode 100644
index 000000000..c74a5d163
--- /dev/null
+++ b/src/fluid_dynamics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics benchmarking module — tsb analytics library. */
+export interface FluidDynamicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsBenchmarking(data: number[], opts: FluidDynamicsBenchmarkingOptions = {}): FluidDynamicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsBenchmarking };
diff --git a/src/fluid_dynamics/blending.ts b/src/fluid_dynamics/blending.ts
new file mode 100644
index 000000000..eb30f4369
--- /dev/null
+++ b/src/fluid_dynamics/blending.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics blending module — tsb analytics library. */
+export interface FluidDynamicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsBlendingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsBlending(data: number[], opts: FluidDynamicsBlendingOptions = {}): FluidDynamicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsBlending };
diff --git a/src/fluid_dynamics/boosting.ts b/src/fluid_dynamics/boosting.ts
new file mode 100644
index 000000000..93ad81275
--- /dev/null
+++ b/src/fluid_dynamics/boosting.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics boosting module — tsb analytics library. */
+export interface FluidDynamicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsBoostingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsBoosting(data: number[], opts: FluidDynamicsBoostingOptions = {}): FluidDynamicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsBoosting };
diff --git a/src/fluid_dynamics/bootstrap.ts b/src/fluid_dynamics/bootstrap.ts
new file mode 100644
index 000000000..2f775718a
--- /dev/null
+++ b/src/fluid_dynamics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics bootstrap module — tsb analytics library. */
+export interface FluidDynamicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsBootstrap(data: number[], opts: FluidDynamicsBootstrapOptions = {}): FluidDynamicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsBootstrap };
diff --git a/src/fluid_dynamics/calculus.ts b/src/fluid_dynamics/calculus.ts
new file mode 100644
index 000000000..8c49f4d7f
--- /dev/null
+++ b/src/fluid_dynamics/calculus.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics calculus module — tsb analytics library. */
+export interface FluidDynamicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsCalculusResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsCalculus(data: number[], opts: FluidDynamicsCalculusOptions = {}): FluidDynamicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsCalculus };
diff --git a/src/fluid_dynamics/calibration.ts b/src/fluid_dynamics/calibration.ts
new file mode 100644
index 000000000..b02a63ef3
--- /dev/null
+++ b/src/fluid_dynamics/calibration.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics calibration module — tsb analytics library. */
+export interface FluidDynamicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsCalibration(data: number[], opts: FluidDynamicsCalibrationOptions = {}): FluidDynamicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsCalibration };
diff --git a/src/fluid_dynamics/characterization.ts b/src/fluid_dynamics/characterization.ts
new file mode 100644
index 000000000..a8230267f
--- /dev/null
+++ b/src/fluid_dynamics/characterization.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics characterization module — tsb analytics library. */
+export interface FluidDynamicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsCharacterization(data: number[], opts: FluidDynamicsCharacterizationOptions = {}): FluidDynamicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsCharacterization };
diff --git a/src/fluid_dynamics/classification.ts b/src/fluid_dynamics/classification.ts
new file mode 100644
index 000000000..21ca7b65a
--- /dev/null
+++ b/src/fluid_dynamics/classification.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics classification module — tsb analytics library. */
+export interface FluidDynamicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsClassificationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsClassification(data: number[], opts: FluidDynamicsClassificationOptions = {}): FluidDynamicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsClassification };
diff --git a/src/fluid_dynamics/clustering.ts b/src/fluid_dynamics/clustering.ts
new file mode 100644
index 000000000..c507c55e4
--- /dev/null
+++ b/src/fluid_dynamics/clustering.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics clustering module — tsb analytics library. */
+export interface FluidDynamicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsClusteringResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsClustering(data: number[], opts: FluidDynamicsClusteringOptions = {}): FluidDynamicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsClustering };
diff --git a/src/fluid_dynamics/compression.ts b/src/fluid_dynamics/compression.ts
new file mode 100644
index 000000000..b826cec76
--- /dev/null
+++ b/src/fluid_dynamics/compression.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics compression module — tsb analytics library. */
+export interface FluidDynamicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsCompressionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsCompression(data: number[], opts: FluidDynamicsCompressionOptions = {}): FluidDynamicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsCompression };
diff --git a/src/fluid_dynamics/continuous.ts b/src/fluid_dynamics/continuous.ts
new file mode 100644
index 000000000..91dce67ee
--- /dev/null
+++ b/src/fluid_dynamics/continuous.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics continuous module — tsb analytics library. */
+export interface FluidDynamicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsContinuousResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsContinuous(data: number[], opts: FluidDynamicsContinuousOptions = {}): FluidDynamicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsContinuous };
diff --git a/src/fluid_dynamics/control.ts b/src/fluid_dynamics/control.ts
new file mode 100644
index 000000000..b5c68ce21
--- /dev/null
+++ b/src/fluid_dynamics/control.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics control module — tsb analytics library. */
+export interface FluidDynamicsControlOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsControlResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsControl(data: number[], opts: FluidDynamicsControlOptions = {}): FluidDynamicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsControl };
diff --git a/src/fluid_dynamics/convergence.ts b/src/fluid_dynamics/convergence.ts
new file mode 100644
index 000000000..c7a45ab32
--- /dev/null
+++ b/src/fluid_dynamics/convergence.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics convergence module — tsb analytics library. */
+export interface FluidDynamicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsConvergence(data: number[], opts: FluidDynamicsConvergenceOptions = {}): FluidDynamicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsConvergence };
diff --git a/src/fluid_dynamics/convex.ts b/src/fluid_dynamics/convex.ts
new file mode 100644
index 000000000..edb771341
--- /dev/null
+++ b/src/fluid_dynamics/convex.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics convex module — tsb analytics library. */
+export interface FluidDynamicsConvexOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsConvexResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsConvex(data: number[], opts: FluidDynamicsConvexOptions = {}): FluidDynamicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsConvex };
diff --git a/src/fluid_dynamics/correlation.ts b/src/fluid_dynamics/correlation.ts
new file mode 100644
index 000000000..26c2e25f7
--- /dev/null
+++ b/src/fluid_dynamics/correlation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics correlation module — tsb analytics library. */
+export interface FluidDynamicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsCorrelation(data: number[], opts: FluidDynamicsCorrelationOptions = {}): FluidDynamicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsCorrelation };
diff --git a/src/fluid_dynamics/covariance.ts b/src/fluid_dynamics/covariance.ts
new file mode 100644
index 000000000..e2dd415eb
--- /dev/null
+++ b/src/fluid_dynamics/covariance.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics covariance module — tsb analytics library. */
+export interface FluidDynamicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsCovariance(data: number[], opts: FluidDynamicsCovarianceOptions = {}): FluidDynamicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsCovariance };
diff --git a/src/fluid_dynamics/cross_validation.ts b/src/fluid_dynamics/cross_validation.ts
new file mode 100644
index 000000000..dec477725
--- /dev/null
+++ b/src/fluid_dynamics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics cross_validation module — tsb analytics library. */
+export interface FluidDynamicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsCrossValidation(data: number[], opts: FluidDynamicsCrossValidationOptions = {}): FluidDynamicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsCrossValidation };
diff --git a/src/fluid_dynamics/decoding.ts b/src/fluid_dynamics/decoding.ts
new file mode 100644
index 000000000..243ba06ad
--- /dev/null
+++ b/src/fluid_dynamics/decoding.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics decoding module — tsb analytics library. */
+export interface FluidDynamicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDecodingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDecoding(data: number[], opts: FluidDynamicsDecodingOptions = {}): FluidDynamicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDecoding };
diff --git a/src/fluid_dynamics/decomposition.ts b/src/fluid_dynamics/decomposition.ts
new file mode 100644
index 000000000..572578961
--- /dev/null
+++ b/src/fluid_dynamics/decomposition.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics decomposition module — tsb analytics library. */
+export interface FluidDynamicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDecomposition(data: number[], opts: FluidDynamicsDecompositionOptions = {}): FluidDynamicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDecomposition };
diff --git a/src/fluid_dynamics/detection.ts b/src/fluid_dynamics/detection.ts
new file mode 100644
index 000000000..a1e1ceb2c
--- /dev/null
+++ b/src/fluid_dynamics/detection.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics detection module — tsb analytics library. */
+export interface FluidDynamicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDetectionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDetection(data: number[], opts: FluidDynamicsDetectionOptions = {}): FluidDynamicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDetection };
diff --git a/src/fluid_dynamics/deterministic.ts b/src/fluid_dynamics/deterministic.ts
new file mode 100644
index 000000000..8977cece2
--- /dev/null
+++ b/src/fluid_dynamics/deterministic.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics deterministic module — tsb analytics library. */
+export interface FluidDynamicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDeterministic(data: number[], opts: FluidDynamicsDeterministicOptions = {}): FluidDynamicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDeterministic };
diff --git a/src/fluid_dynamics/diagnostics.ts b/src/fluid_dynamics/diagnostics.ts
new file mode 100644
index 000000000..33c6db04d
--- /dev/null
+++ b/src/fluid_dynamics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics diagnostics module — tsb analytics library. */
+export interface FluidDynamicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDiagnostics(data: number[], opts: FluidDynamicsDiagnosticsOptions = {}): FluidDynamicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDiagnostics };
diff --git a/src/fluid_dynamics/differential.ts b/src/fluid_dynamics/differential.ts
new file mode 100644
index 000000000..3914e7cdb
--- /dev/null
+++ b/src/fluid_dynamics/differential.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics differential module — tsb analytics library. */
+export interface FluidDynamicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDifferential(data: number[], opts: FluidDynamicsDifferentialOptions = {}): FluidDynamicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDifferential };
diff --git a/src/fluid_dynamics/discrete.ts b/src/fluid_dynamics/discrete.ts
new file mode 100644
index 000000000..ad87592e5
--- /dev/null
+++ b/src/fluid_dynamics/discrete.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics discrete module — tsb analytics library. */
+export interface FluidDynamicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDiscrete(data: number[], opts: FluidDynamicsDiscreteOptions = {}): FluidDynamicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDiscrete };
diff --git a/src/fluid_dynamics/distribution.ts b/src/fluid_dynamics/distribution.ts
new file mode 100644
index 000000000..74d16d844
--- /dev/null
+++ b/src/fluid_dynamics/distribution.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics distribution module — tsb analytics library. */
+export interface FluidDynamicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDistributionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDistribution(data: number[], opts: FluidDynamicsDistributionOptions = {}): FluidDynamicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDistribution };
diff --git a/src/fluid_dynamics/dynamic.ts b/src/fluid_dynamics/dynamic.ts
new file mode 100644
index 000000000..84838fc5f
--- /dev/null
+++ b/src/fluid_dynamics/dynamic.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics dynamic module — tsb analytics library. */
+export interface FluidDynamicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsDynamicResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsDynamic(data: number[], opts: FluidDynamicsDynamicOptions = {}): FluidDynamicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsDynamic };
diff --git a/src/fluid_dynamics/embedding.ts b/src/fluid_dynamics/embedding.ts
new file mode 100644
index 000000000..e19fd7a08
--- /dev/null
+++ b/src/fluid_dynamics/embedding.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics embedding module — tsb analytics library. */
+export interface FluidDynamicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsEmbedding(data: number[], opts: FluidDynamicsEmbeddingOptions = {}): FluidDynamicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsEmbedding };
diff --git a/src/fluid_dynamics/encoding.ts b/src/fluid_dynamics/encoding.ts
new file mode 100644
index 000000000..b0fec5a3e
--- /dev/null
+++ b/src/fluid_dynamics/encoding.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics encoding module — tsb analytics library. */
+export interface FluidDynamicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsEncodingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsEncoding(data: number[], opts: FluidDynamicsEncodingOptions = {}): FluidDynamicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsEncoding };
diff --git a/src/fluid_dynamics/ensemble.ts b/src/fluid_dynamics/ensemble.ts
new file mode 100644
index 000000000..7adb2ebbf
--- /dev/null
+++ b/src/fluid_dynamics/ensemble.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics ensemble module — tsb analytics library. */
+export interface FluidDynamicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsEnsemble(data: number[], opts: FluidDynamicsEnsembleOptions = {}): FluidDynamicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsEnsemble };
diff --git a/src/fluid_dynamics/estimation.ts b/src/fluid_dynamics/estimation.ts
new file mode 100644
index 000000000..07c19cb0b
--- /dev/null
+++ b/src/fluid_dynamics/estimation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics estimation module — tsb analytics library. */
+export interface FluidDynamicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsEstimationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsEstimation(data: number[], opts: FluidDynamicsEstimationOptions = {}): FluidDynamicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsEstimation };
diff --git a/src/fluid_dynamics/evaluation.ts b/src/fluid_dynamics/evaluation.ts
new file mode 100644
index 000000000..285178fd3
--- /dev/null
+++ b/src/fluid_dynamics/evaluation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics evaluation module — tsb analytics library. */
+export interface FluidDynamicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsEvaluation(data: number[], opts: FluidDynamicsEvaluationOptions = {}): FluidDynamicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsEvaluation };
diff --git a/src/fluid_dynamics/extrapolation.ts b/src/fluid_dynamics/extrapolation.ts
new file mode 100644
index 000000000..5d691269f
--- /dev/null
+++ b/src/fluid_dynamics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics extrapolation module — tsb analytics library. */
+export interface FluidDynamicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsExtrapolation(data: number[], opts: FluidDynamicsExtrapolationOptions = {}): FluidDynamicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsExtrapolation };
diff --git a/src/fluid_dynamics/features.ts b/src/fluid_dynamics/features.ts
new file mode 100644
index 000000000..b157e8075
--- /dev/null
+++ b/src/fluid_dynamics/features.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics features module — tsb analytics library. */
+export interface FluidDynamicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsFeatures(data: number[], opts: FluidDynamicsFeaturesOptions = {}): FluidDynamicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsFeatures };
diff --git a/src/fluid_dynamics/feedback.ts b/src/fluid_dynamics/feedback.ts
new file mode 100644
index 000000000..a616cb920
--- /dev/null
+++ b/src/fluid_dynamics/feedback.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics feedback module — tsb analytics library. */
+export interface FluidDynamicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsFeedback(data: number[], opts: FluidDynamicsFeedbackOptions = {}): FluidDynamicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsFeedback };
diff --git a/src/fluid_dynamics/filtering.ts b/src/fluid_dynamics/filtering.ts
new file mode 100644
index 000000000..d5266bb12
--- /dev/null
+++ b/src/fluid_dynamics/filtering.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics filtering module — tsb analytics library. */
+export interface FluidDynamicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsFilteringResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsFiltering(data: number[], opts: FluidDynamicsFilteringOptions = {}): FluidDynamicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsFiltering };
diff --git a/src/fluid_dynamics/fourier.ts b/src/fluid_dynamics/fourier.ts
new file mode 100644
index 000000000..7a0d12be1
--- /dev/null
+++ b/src/fluid_dynamics/fourier.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics fourier module — tsb analytics library. */
+export interface FluidDynamicsFourierOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsFourierResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsFourier(data: number[], opts: FluidDynamicsFourierOptions = {}): FluidDynamicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsFourier };
diff --git a/src/fluid_dynamics/fusion.ts b/src/fluid_dynamics/fusion.ts
new file mode 100644
index 000000000..84d223334
--- /dev/null
+++ b/src/fluid_dynamics/fusion.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics fusion module — tsb analytics library. */
+export interface FluidDynamicsFusionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsFusionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsFusion(data: number[], opts: FluidDynamicsFusionOptions = {}): FluidDynamicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsFusion };
diff --git a/src/fluid_dynamics/generation.ts b/src/fluid_dynamics/generation.ts
new file mode 100644
index 000000000..8873d8042
--- /dev/null
+++ b/src/fluid_dynamics/generation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics generation module — tsb analytics library. */
+export interface FluidDynamicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsGenerationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsGeneration(data: number[], opts: FluidDynamicsGenerationOptions = {}): FluidDynamicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsGeneration };
diff --git a/src/fluid_dynamics/geometry.ts b/src/fluid_dynamics/geometry.ts
new file mode 100644
index 000000000..057bf432b
--- /dev/null
+++ b/src/fluid_dynamics/geometry.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics geometry module — tsb analytics library. */
+export interface FluidDynamicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsGeometryResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsGeometry(data: number[], opts: FluidDynamicsGeometryOptions = {}): FluidDynamicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsGeometry };
diff --git a/src/fluid_dynamics/gradient.ts b/src/fluid_dynamics/gradient.ts
new file mode 100644
index 000000000..29cb8bd85
--- /dev/null
+++ b/src/fluid_dynamics/gradient.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics gradient module — tsb analytics library. */
+export interface FluidDynamicsGradientOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsGradientResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsGradient(data: number[], opts: FluidDynamicsGradientOptions = {}): FluidDynamicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsGradient };
diff --git a/src/fluid_dynamics/hessian.ts b/src/fluid_dynamics/hessian.ts
new file mode 100644
index 000000000..38ffa0c1c
--- /dev/null
+++ b/src/fluid_dynamics/hessian.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics hessian module — tsb analytics library. */
+export interface FluidDynamicsHessianOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsHessianResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsHessian(data: number[], opts: FluidDynamicsHessianOptions = {}): FluidDynamicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsHessian };
diff --git a/src/fluid_dynamics/hypothesis.ts b/src/fluid_dynamics/hypothesis.ts
new file mode 100644
index 000000000..b521ca938
--- /dev/null
+++ b/src/fluid_dynamics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics hypothesis module — tsb analytics library. */
+export interface FluidDynamicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsHypothesis(data: number[], opts: FluidDynamicsHypothesisOptions = {}): FluidDynamicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsHypothesis };
diff --git a/src/fluid_dynamics/inference.ts b/src/fluid_dynamics/inference.ts
new file mode 100644
index 000000000..3e5c877f1
--- /dev/null
+++ b/src/fluid_dynamics/inference.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics inference module — tsb analytics library. */
+export interface FluidDynamicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsInferenceResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsInference(data: number[], opts: FluidDynamicsInferenceOptions = {}): FluidDynamicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsInference };
diff --git a/src/fluid_dynamics/inference2.ts b/src/fluid_dynamics/inference2.ts
new file mode 100644
index 000000000..2ab2a32b7
--- /dev/null
+++ b/src/fluid_dynamics/inference2.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics inference2 module — tsb analytics library. */
+export interface FluidDynamicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsInferenceResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsInference(data: number[], opts: FluidDynamicsInferenceOptions = {}): FluidDynamicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsInference };
diff --git a/src/fluid_dynamics/integral.ts b/src/fluid_dynamics/integral.ts
new file mode 100644
index 000000000..fad329ce7
--- /dev/null
+++ b/src/fluid_dynamics/integral.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics integral module — tsb analytics library. */
+export interface FluidDynamicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsIntegralResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsIntegral(data: number[], opts: FluidDynamicsIntegralOptions = {}): FluidDynamicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsIntegral };
diff --git a/src/fluid_dynamics/integration.ts b/src/fluid_dynamics/integration.ts
new file mode 100644
index 000000000..ec244f30a
--- /dev/null
+++ b/src/fluid_dynamics/integration.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics integration module — tsb analytics library. */
+export interface FluidDynamicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsIntegration(data: number[], opts: FluidDynamicsIntegrationOptions = {}): FluidDynamicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsIntegration };
diff --git a/src/fluid_dynamics/interpolation.ts b/src/fluid_dynamics/interpolation.ts
new file mode 100644
index 000000000..d50492e23
--- /dev/null
+++ b/src/fluid_dynamics/interpolation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics interpolation module — tsb analytics library. */
+export interface FluidDynamicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsInterpolation(data: number[], opts: FluidDynamicsInterpolationOptions = {}): FluidDynamicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsInterpolation };
diff --git a/src/fluid_dynamics/jacobian.ts b/src/fluid_dynamics/jacobian.ts
new file mode 100644
index 000000000..5f556d1ec
--- /dev/null
+++ b/src/fluid_dynamics/jacobian.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics jacobian module — tsb analytics library. */
+export interface FluidDynamicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsJacobianResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsJacobian(data: number[], opts: FluidDynamicsJacobianOptions = {}): FluidDynamicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsJacobian };
diff --git a/src/fluid_dynamics/kernel.ts b/src/fluid_dynamics/kernel.ts
new file mode 100644
index 000000000..9d8f4283b
--- /dev/null
+++ b/src/fluid_dynamics/kernel.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics kernel module — tsb analytics library. */
+export interface FluidDynamicsKernelOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsKernelResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsKernel(data: number[], opts: FluidDynamicsKernelOptions = {}): FluidDynamicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsKernel };
diff --git a/src/fluid_dynamics/laplacian.ts b/src/fluid_dynamics/laplacian.ts
new file mode 100644
index 000000000..a7f82fa75
--- /dev/null
+++ b/src/fluid_dynamics/laplacian.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics laplacian module — tsb analytics library. */
+export interface FluidDynamicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsLaplacian(data: number[], opts: FluidDynamicsLaplacianOptions = {}): FluidDynamicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsLaplacian };
diff --git a/src/fluid_dynamics/learning.ts b/src/fluid_dynamics/learning.ts
new file mode 100644
index 000000000..caf426ee3
--- /dev/null
+++ b/src/fluid_dynamics/learning.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics learning module — tsb analytics library. */
+export interface FluidDynamicsLearningOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsLearningResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsLearning(data: number[], opts: FluidDynamicsLearningOptions = {}): FluidDynamicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsLearning };
diff --git a/src/fluid_dynamics/linear.ts b/src/fluid_dynamics/linear.ts
new file mode 100644
index 000000000..4f7dabd04
--- /dev/null
+++ b/src/fluid_dynamics/linear.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics linear module — tsb analytics library. */
+export interface FluidDynamicsLinearOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsLinearResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsLinear(data: number[], opts: FluidDynamicsLinearOptions = {}): FluidDynamicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsLinear };
diff --git a/src/fluid_dynamics/manifold.ts b/src/fluid_dynamics/manifold.ts
new file mode 100644
index 000000000..ce08c35c4
--- /dev/null
+++ b/src/fluid_dynamics/manifold.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics manifold module — tsb analytics library. */
+export interface FluidDynamicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsManifoldResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsManifold(data: number[], opts: FluidDynamicsManifoldOptions = {}): FluidDynamicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsManifold };
diff --git a/src/fluid_dynamics/matching.ts b/src/fluid_dynamics/matching.ts
new file mode 100644
index 000000000..94cfd7077
--- /dev/null
+++ b/src/fluid_dynamics/matching.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics matching module — tsb analytics library. */
+export interface FluidDynamicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsMatchingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsMatching(data: number[], opts: FluidDynamicsMatchingOptions = {}): FluidDynamicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsMatching };
diff --git a/src/fluid_dynamics/measurement.ts b/src/fluid_dynamics/measurement.ts
new file mode 100644
index 000000000..6d52d2479
--- /dev/null
+++ b/src/fluid_dynamics/measurement.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics measurement module — tsb analytics library. */
+export interface FluidDynamicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsMeasurement(data: number[], opts: FluidDynamicsMeasurementOptions = {}): FluidDynamicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsMeasurement };
diff --git a/src/fluid_dynamics/metrics.ts b/src/fluid_dynamics/metrics.ts
new file mode 100644
index 000000000..f2fe105ed
--- /dev/null
+++ b/src/fluid_dynamics/metrics.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics metrics module — tsb analytics library. */
+export interface FluidDynamicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsMetricsResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsMetrics(data: number[], opts: FluidDynamicsMetricsOptions = {}): FluidDynamicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsMetrics };
diff --git a/src/fluid_dynamics/modeling.ts b/src/fluid_dynamics/modeling.ts
new file mode 100644
index 000000000..b25d73690
--- /dev/null
+++ b/src/fluid_dynamics/modeling.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics modeling module — tsb analytics library. */
+export interface FluidDynamicsModelingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsModelingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsModeling(data: number[], opts: FluidDynamicsModelingOptions = {}): FluidDynamicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsModeling };
diff --git a/src/fluid_dynamics/monitoring.ts b/src/fluid_dynamics/monitoring.ts
new file mode 100644
index 000000000..bd103f6bb
--- /dev/null
+++ b/src/fluid_dynamics/monitoring.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics monitoring module — tsb analytics library. */
+export interface FluidDynamicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsMonitoring(data: number[], opts: FluidDynamicsMonitoringOptions = {}): FluidDynamicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsMonitoring };
diff --git a/src/fluid_dynamics/nonlinear.ts b/src/fluid_dynamics/nonlinear.ts
new file mode 100644
index 000000000..1b02d7677
--- /dev/null
+++ b/src/fluid_dynamics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics nonlinear module — tsb analytics library. */
+export interface FluidDynamicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsNonlinear(data: number[], opts: FluidDynamicsNonlinearOptions = {}): FluidDynamicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsNonlinear };
diff --git a/src/fluid_dynamics/normalization.ts b/src/fluid_dynamics/normalization.ts
new file mode 100644
index 000000000..a6ffd7957
--- /dev/null
+++ b/src/fluid_dynamics/normalization.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics normalization module — tsb analytics library. */
+export interface FluidDynamicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsNormalization(data: number[], opts: FluidDynamicsNormalizationOptions = {}): FluidDynamicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsNormalization };
diff --git a/src/fluid_dynamics/optimization.ts b/src/fluid_dynamics/optimization.ts
new file mode 100644
index 000000000..d14c98844
--- /dev/null
+++ b/src/fluid_dynamics/optimization.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics optimization module — tsb analytics library. */
+export interface FluidDynamicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsOptimization(data: number[], opts: FluidDynamicsOptimizationOptions = {}): FluidDynamicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsOptimization };
diff --git a/src/fluid_dynamics/patterns.ts b/src/fluid_dynamics/patterns.ts
new file mode 100644
index 000000000..a709818b7
--- /dev/null
+++ b/src/fluid_dynamics/patterns.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics patterns module — tsb analytics library. */
+export interface FluidDynamicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsPatternsResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsPatterns(data: number[], opts: FluidDynamicsPatternsOptions = {}): FluidDynamicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsPatterns };
diff --git a/src/fluid_dynamics/permutation.ts b/src/fluid_dynamics/permutation.ts
new file mode 100644
index 000000000..d8892a080
--- /dev/null
+++ b/src/fluid_dynamics/permutation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics permutation module — tsb analytics library. */
+export interface FluidDynamicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsPermutationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsPermutation(data: number[], opts: FluidDynamicsPermutationOptions = {}): FluidDynamicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsPermutation };
diff --git a/src/fluid_dynamics/prediction.ts b/src/fluid_dynamics/prediction.ts
new file mode 100644
index 000000000..9276299fa
--- /dev/null
+++ b/src/fluid_dynamics/prediction.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics prediction module — tsb analytics library. */
+export interface FluidDynamicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsPredictionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsPrediction(data: number[], opts: FluidDynamicsPredictionOptions = {}): FluidDynamicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsPrediction };
diff --git a/src/fluid_dynamics/processing.ts b/src/fluid_dynamics/processing.ts
new file mode 100644
index 000000000..f71d87099
--- /dev/null
+++ b/src/fluid_dynamics/processing.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics processing module — tsb analytics library. */
+export interface FluidDynamicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsProcessingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsProcessing(data: number[], opts: FluidDynamicsProcessingOptions = {}): FluidDynamicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsProcessing };
diff --git a/src/fluid_dynamics/profiling.ts b/src/fluid_dynamics/profiling.ts
new file mode 100644
index 000000000..794098e81
--- /dev/null
+++ b/src/fluid_dynamics/profiling.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics profiling module — tsb analytics library. */
+export interface FluidDynamicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsProfilingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsProfiling(data: number[], opts: FluidDynamicsProfilingOptions = {}): FluidDynamicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsProfiling };
diff --git a/src/fluid_dynamics/projection.ts b/src/fluid_dynamics/projection.ts
new file mode 100644
index 000000000..ba097c399
--- /dev/null
+++ b/src/fluid_dynamics/projection.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics projection module — tsb analytics library. */
+export interface FluidDynamicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsProjectionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsProjection(data: number[], opts: FluidDynamicsProjectionOptions = {}): FluidDynamicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsProjection };
diff --git a/src/fluid_dynamics/ranking.ts b/src/fluid_dynamics/ranking.ts
new file mode 100644
index 000000000..1e43ffb69
--- /dev/null
+++ b/src/fluid_dynamics/ranking.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics ranking module — tsb analytics library. */
+export interface FluidDynamicsRankingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsRankingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsRanking(data: number[], opts: FluidDynamicsRankingOptions = {}): FluidDynamicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsRanking };
diff --git a/src/fluid_dynamics/reconstruction.ts b/src/fluid_dynamics/reconstruction.ts
new file mode 100644
index 000000000..fc874a808
--- /dev/null
+++ b/src/fluid_dynamics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics reconstruction module — tsb analytics library. */
+export interface FluidDynamicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsReconstruction(data: number[], opts: FluidDynamicsReconstructionOptions = {}): FluidDynamicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsReconstruction };
diff --git a/src/fluid_dynamics/registration.ts b/src/fluid_dynamics/registration.ts
new file mode 100644
index 000000000..d9b5cd754
--- /dev/null
+++ b/src/fluid_dynamics/registration.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics registration module — tsb analytics library. */
+export interface FluidDynamicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsRegistration(data: number[], opts: FluidDynamicsRegistrationOptions = {}): FluidDynamicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsRegistration };
diff --git a/src/fluid_dynamics/regression.ts b/src/fluid_dynamics/regression.ts
new file mode 100644
index 000000000..e16cf7804
--- /dev/null
+++ b/src/fluid_dynamics/regression.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics regression module — tsb analytics library. */
+export interface FluidDynamicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsRegressionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsRegression(data: number[], opts: FluidDynamicsRegressionOptions = {}): FluidDynamicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsRegression };
diff --git a/src/fluid_dynamics/regularization.ts b/src/fluid_dynamics/regularization.ts
new file mode 100644
index 000000000..b94e6e411
--- /dev/null
+++ b/src/fluid_dynamics/regularization.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics regularization module — tsb analytics library. */
+export interface FluidDynamicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsRegularization(data: number[], opts: FluidDynamicsRegularizationOptions = {}): FluidDynamicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsRegularization };
diff --git a/src/fluid_dynamics/robustness.ts b/src/fluid_dynamics/robustness.ts
new file mode 100644
index 000000000..14b61d248
--- /dev/null
+++ b/src/fluid_dynamics/robustness.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics robustness module — tsb analytics library. */
+export interface FluidDynamicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsRobustness(data: number[], opts: FluidDynamicsRobustnessOptions = {}): FluidDynamicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsRobustness };
diff --git a/src/fluid_dynamics/sampling.ts b/src/fluid_dynamics/sampling.ts
new file mode 100644
index 000000000..7e2951127
--- /dev/null
+++ b/src/fluid_dynamics/sampling.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics sampling module — tsb analytics library. */
+export interface FluidDynamicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsSamplingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsSampling(data: number[], opts: FluidDynamicsSamplingOptions = {}): FluidDynamicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsSampling };
diff --git a/src/fluid_dynamics/sampling2.ts b/src/fluid_dynamics/sampling2.ts
new file mode 100644
index 000000000..e7628ae31
--- /dev/null
+++ b/src/fluid_dynamics/sampling2.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics sampling2 module — tsb analytics library. */
+export interface FluidDynamicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsSamplingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsSampling(data: number[], opts: FluidDynamicsSamplingOptions = {}): FluidDynamicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsSampling };
diff --git a/src/fluid_dynamics/scaling.ts b/src/fluid_dynamics/scaling.ts
new file mode 100644
index 000000000..a5ff57fc2
--- /dev/null
+++ b/src/fluid_dynamics/scaling.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics scaling module — tsb analytics library. */
+export interface FluidDynamicsScalingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsScalingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsScaling(data: number[], opts: FluidDynamicsScalingOptions = {}): FluidDynamicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsScaling };
diff --git a/src/fluid_dynamics/scoring.ts b/src/fluid_dynamics/scoring.ts
new file mode 100644
index 000000000..2a2557204
--- /dev/null
+++ b/src/fluid_dynamics/scoring.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics scoring module — tsb analytics library. */
+export interface FluidDynamicsScoringOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsScoringResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsScoring(data: number[], opts: FluidDynamicsScoringOptions = {}): FluidDynamicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsScoring };
diff --git a/src/fluid_dynamics/segmentation.ts b/src/fluid_dynamics/segmentation.ts
new file mode 100644
index 000000000..a65fe5d46
--- /dev/null
+++ b/src/fluid_dynamics/segmentation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics segmentation module — tsb analytics library. */
+export interface FluidDynamicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsSegmentation(data: number[], opts: FluidDynamicsSegmentationOptions = {}): FluidDynamicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsSegmentation };
diff --git a/src/fluid_dynamics/selection.ts b/src/fluid_dynamics/selection.ts
new file mode 100644
index 000000000..14185869a
--- /dev/null
+++ b/src/fluid_dynamics/selection.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics selection module — tsb analytics library. */
+export interface FluidDynamicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsSelectionResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsSelection(data: number[], opts: FluidDynamicsSelectionOptions = {}): FluidDynamicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsSelection };
diff --git a/src/fluid_dynamics/sensitivity.ts b/src/fluid_dynamics/sensitivity.ts
new file mode 100644
index 000000000..1530042b3
--- /dev/null
+++ b/src/fluid_dynamics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics sensitivity module — tsb analytics library. */
+export interface FluidDynamicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsSensitivity(data: number[], opts: FluidDynamicsSensitivityOptions = {}): FluidDynamicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsSensitivity };
diff --git a/src/fluid_dynamics/simulation.ts b/src/fluid_dynamics/simulation.ts
new file mode 100644
index 000000000..43a298eac
--- /dev/null
+++ b/src/fluid_dynamics/simulation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics simulation module — tsb analytics library. */
+export interface FluidDynamicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsSimulationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsSimulation(data: number[], opts: FluidDynamicsSimulationOptions = {}): FluidDynamicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsSimulation };
diff --git a/src/fluid_dynamics/smoothing.ts b/src/fluid_dynamics/smoothing.ts
new file mode 100644
index 000000000..157ce340d
--- /dev/null
+++ b/src/fluid_dynamics/smoothing.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics smoothing module — tsb analytics library. */
+export interface FluidDynamicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsSmoothing(data: number[], opts: FluidDynamicsSmoothingOptions = {}): FluidDynamicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsSmoothing };
diff --git a/src/fluid_dynamics/stability.ts b/src/fluid_dynamics/stability.ts
new file mode 100644
index 000000000..0a42e18d6
--- /dev/null
+++ b/src/fluid_dynamics/stability.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics stability module — tsb analytics library. */
+export interface FluidDynamicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsStabilityResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsStability(data: number[], opts: FluidDynamicsStabilityOptions = {}): FluidDynamicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsStability };
diff --git a/src/fluid_dynamics/stacking.ts b/src/fluid_dynamics/stacking.ts
new file mode 100644
index 000000000..aee3ac409
--- /dev/null
+++ b/src/fluid_dynamics/stacking.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics stacking module — tsb analytics library. */
+export interface FluidDynamicsStackingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsStackingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsStacking(data: number[], opts: FluidDynamicsStackingOptions = {}): FluidDynamicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsStacking };
diff --git a/src/fluid_dynamics/standardization.ts b/src/fluid_dynamics/standardization.ts
new file mode 100644
index 000000000..deb8b81fb
--- /dev/null
+++ b/src/fluid_dynamics/standardization.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics standardization module — tsb analytics library. */
+export interface FluidDynamicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsStandardization(data: number[], opts: FluidDynamicsStandardizationOptions = {}): FluidDynamicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsStandardization };
diff --git a/src/fluid_dynamics/static.ts b/src/fluid_dynamics/static.ts
new file mode 100644
index 000000000..36608465e
--- /dev/null
+++ b/src/fluid_dynamics/static.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics static module — tsb analytics library. */
+export interface FluidDynamicsStaticOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsStaticResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsStatic(data: number[], opts: FluidDynamicsStaticOptions = {}): FluidDynamicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsStatic };
diff --git a/src/fluid_dynamics/stochastic.ts b/src/fluid_dynamics/stochastic.ts
new file mode 100644
index 000000000..aeb12a366
--- /dev/null
+++ b/src/fluid_dynamics/stochastic.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics stochastic module — tsb analytics library. */
+export interface FluidDynamicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsStochasticResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsStochastic(data: number[], opts: FluidDynamicsStochasticOptions = {}): FluidDynamicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsStochastic };
diff --git a/src/fluid_dynamics/synthesis.ts b/src/fluid_dynamics/synthesis.ts
new file mode 100644
index 000000000..74905aa19
--- /dev/null
+++ b/src/fluid_dynamics/synthesis.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics synthesis module — tsb analytics library. */
+export interface FluidDynamicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsSynthesis(data: number[], opts: FluidDynamicsSynthesisOptions = {}): FluidDynamicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsSynthesis };
diff --git a/src/fluid_dynamics/topology.ts b/src/fluid_dynamics/topology.ts
new file mode 100644
index 000000000..4229f0bd6
--- /dev/null
+++ b/src/fluid_dynamics/topology.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics topology module — tsb analytics library. */
+export interface FluidDynamicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsTopologyResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsTopology(data: number[], opts: FluidDynamicsTopologyOptions = {}): FluidDynamicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsTopology };
diff --git a/src/fluid_dynamics/tracking.ts b/src/fluid_dynamics/tracking.ts
new file mode 100644
index 000000000..f8ee30859
--- /dev/null
+++ b/src/fluid_dynamics/tracking.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics tracking module — tsb analytics library. */
+export interface FluidDynamicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsTrackingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsTracking(data: number[], opts: FluidDynamicsTrackingOptions = {}): FluidDynamicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsTracking };
diff --git a/src/fluid_dynamics/transform.ts b/src/fluid_dynamics/transform.ts
new file mode 100644
index 000000000..3becf7991
--- /dev/null
+++ b/src/fluid_dynamics/transform.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics transform module — tsb analytics library. */
+export interface FluidDynamicsTransformOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsTransformResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsTransform(data: number[], opts: FluidDynamicsTransformOptions = {}): FluidDynamicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsTransform };
diff --git a/src/fluid_dynamics/uncertainty.ts b/src/fluid_dynamics/uncertainty.ts
new file mode 100644
index 000000000..5abe09217
--- /dev/null
+++ b/src/fluid_dynamics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics uncertainty module — tsb analytics library. */
+export interface FluidDynamicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsUncertainty(data: number[], opts: FluidDynamicsUncertaintyOptions = {}): FluidDynamicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsUncertainty };
diff --git a/src/fluid_dynamics/validation.ts b/src/fluid_dynamics/validation.ts
new file mode 100644
index 000000000..669350be6
--- /dev/null
+++ b/src/fluid_dynamics/validation.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics validation module — tsb analytics library. */
+export interface FluidDynamicsValidationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsValidationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsValidation(data: number[], opts: FluidDynamicsValidationOptions = {}): FluidDynamicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsValidation };
diff --git a/src/fluid_dynamics/verification.ts b/src/fluid_dynamics/verification.ts
new file mode 100644
index 000000000..a63e51c5d
--- /dev/null
+++ b/src/fluid_dynamics/verification.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics verification module — tsb analytics library. */
+export interface FluidDynamicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsVerificationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsVerification(data: number[], opts: FluidDynamicsVerificationOptions = {}): FluidDynamicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsVerification };
diff --git a/src/fluid_dynamics/visualization.ts b/src/fluid_dynamics/visualization.ts
new file mode 100644
index 000000000..21c473cd7
--- /dev/null
+++ b/src/fluid_dynamics/visualization.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics visualization module — tsb analytics library. */
+export interface FluidDynamicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsVisualization(data: number[], opts: FluidDynamicsVisualizationOptions = {}): FluidDynamicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsVisualization };
diff --git a/src/fluid_dynamics/voting.ts b/src/fluid_dynamics/voting.ts
new file mode 100644
index 000000000..6243635ce
--- /dev/null
+++ b/src/fluid_dynamics/voting.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics voting module — tsb analytics library. */
+export interface FluidDynamicsVotingOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsVotingResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsVoting(data: number[], opts: FluidDynamicsVotingOptions = {}): FluidDynamicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsVoting };
diff --git a/src/fluid_dynamics/wavelet.ts b/src/fluid_dynamics/wavelet.ts
new file mode 100644
index 000000000..3f092601e
--- /dev/null
+++ b/src/fluid_dynamics/wavelet.ts
@@ -0,0 +1,14 @@
+/** fluid_dynamics wavelet module — tsb analytics library. */
+export interface FluidDynamicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface FluidDynamicsWaveletResult { values: number[]; converged: boolean; }
+export function computeFluidDynamicsWavelet(data: number[], opts: FluidDynamicsWaveletOptions = {}): FluidDynamicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFluidDynamicsWavelet };
diff --git a/src/food_sci/adaptation.ts b/src/food_sci/adaptation.ts
new file mode 100644
index 000000000..af4d75d62
--- /dev/null
+++ b/src/food_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** food_sci adaptation module — tsb analytics library. */
+export interface FoodSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeFoodSciAdaptation(data: number[], opts: FoodSciAdaptationOptions = {}): FoodSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciAdaptation };
diff --git a/src/food_sci/aggregation.ts b/src/food_sci/aggregation.ts
new file mode 100644
index 000000000..bc9cf6335
--- /dev/null
+++ b/src/food_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** food_sci aggregation module — tsb analytics library. */
+export interface FoodSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciAggregationResult { values: number[]; converged: boolean; }
+export function computeFoodSciAggregation(data: number[], opts: FoodSciAggregationOptions = {}): FoodSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciAggregation };
diff --git a/src/food_sci/algebra.ts b/src/food_sci/algebra.ts
new file mode 100644
index 000000000..784c2d507
--- /dev/null
+++ b/src/food_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** food_sci algebra module — tsb analytics library. */
+export interface FoodSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface FoodSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeFoodSciAlgebra(data: number[], opts: FoodSciAlgebraOptions = {}): FoodSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciAlgebra };
diff --git a/src/food_sci/alignment.ts b/src/food_sci/alignment.ts
new file mode 100644
index 000000000..e6d64396f
--- /dev/null
+++ b/src/food_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** food_sci alignment module — tsb analytics library. */
+export interface FoodSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface FoodSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeFoodSciAlignment(data: number[], opts: FoodSciAlignmentOptions = {}): FoodSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciAlignment };
diff --git a/src/food_sci/analysis.ts b/src/food_sci/analysis.ts
new file mode 100644
index 000000000..41930387e
--- /dev/null
+++ b/src/food_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** food_sci analysis module — tsb analytics library. */
+export interface FoodSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface FoodSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeFoodSciAnalysis(data: number[], opts: FoodSciAnalysisOptions = {}): FoodSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciAnalysis };
diff --git a/src/food_sci/augmentation.ts b/src/food_sci/augmentation.ts
new file mode 100644
index 000000000..ab59ac24e
--- /dev/null
+++ b/src/food_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** food_sci augmentation module — tsb analytics library. */
+export interface FoodSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeFoodSciAugmentation(data: number[], opts: FoodSciAugmentationOptions = {}): FoodSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciAugmentation };
diff --git a/src/food_sci/bagging.ts b/src/food_sci/bagging.ts
new file mode 100644
index 000000000..35b8f1d10
--- /dev/null
+++ b/src/food_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** food_sci bagging module — tsb analytics library. */
+export interface FoodSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciBaggingResult { values: number[]; converged: boolean; }
+export function computeFoodSciBagging(data: number[], opts: FoodSciBaggingOptions = {}): FoodSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciBagging };
diff --git a/src/food_sci/basis.ts b/src/food_sci/basis.ts
new file mode 100644
index 000000000..256b36079
--- /dev/null
+++ b/src/food_sci/basis.ts
@@ -0,0 +1,14 @@
+/** food_sci basis module — tsb analytics library. */
+export interface FoodSciBasisOptions { tol?: number; maxIter?: number; }
+export interface FoodSciBasisResult { values: number[]; converged: boolean; }
+export function computeFoodSciBasis(data: number[], opts: FoodSciBasisOptions = {}): FoodSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciBasis };
diff --git a/src/food_sci/benchmarking.ts b/src/food_sci/benchmarking.ts
new file mode 100644
index 000000000..7a03841f4
--- /dev/null
+++ b/src/food_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** food_sci benchmarking module — tsb analytics library. */
+export interface FoodSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeFoodSciBenchmarking(data: number[], opts: FoodSciBenchmarkingOptions = {}): FoodSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciBenchmarking };
diff --git a/src/food_sci/blending.ts b/src/food_sci/blending.ts
new file mode 100644
index 000000000..089596af2
--- /dev/null
+++ b/src/food_sci/blending.ts
@@ -0,0 +1,14 @@
+/** food_sci blending module — tsb analytics library. */
+export interface FoodSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciBlendingResult { values: number[]; converged: boolean; }
+export function computeFoodSciBlending(data: number[], opts: FoodSciBlendingOptions = {}): FoodSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciBlending };
diff --git a/src/food_sci/boosting.ts b/src/food_sci/boosting.ts
new file mode 100644
index 000000000..99fbbe8f3
--- /dev/null
+++ b/src/food_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** food_sci boosting module — tsb analytics library. */
+export interface FoodSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciBoostingResult { values: number[]; converged: boolean; }
+export function computeFoodSciBoosting(data: number[], opts: FoodSciBoostingOptions = {}): FoodSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciBoosting };
diff --git a/src/food_sci/bootstrap.ts b/src/food_sci/bootstrap.ts
new file mode 100644
index 000000000..43ec6e5e0
--- /dev/null
+++ b/src/food_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** food_sci bootstrap module — tsb analytics library. */
+export interface FoodSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface FoodSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeFoodSciBootstrap(data: number[], opts: FoodSciBootstrapOptions = {}): FoodSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciBootstrap };
diff --git a/src/food_sci/calculus.ts b/src/food_sci/calculus.ts
new file mode 100644
index 000000000..a552edf22
--- /dev/null
+++ b/src/food_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** food_sci calculus module — tsb analytics library. */
+export interface FoodSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface FoodSciCalculusResult { values: number[]; converged: boolean; }
+export function computeFoodSciCalculus(data: number[], opts: FoodSciCalculusOptions = {}): FoodSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciCalculus };
diff --git a/src/food_sci/calibration.ts b/src/food_sci/calibration.ts
new file mode 100644
index 000000000..5a5ffd633
--- /dev/null
+++ b/src/food_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** food_sci calibration module — tsb analytics library. */
+export interface FoodSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeFoodSciCalibration(data: number[], opts: FoodSciCalibrationOptions = {}): FoodSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciCalibration };
diff --git a/src/food_sci/characterization.ts b/src/food_sci/characterization.ts
new file mode 100644
index 000000000..31f3cf835
--- /dev/null
+++ b/src/food_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** food_sci characterization module — tsb analytics library. */
+export interface FoodSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeFoodSciCharacterization(data: number[], opts: FoodSciCharacterizationOptions = {}): FoodSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciCharacterization };
diff --git a/src/food_sci/classification.ts b/src/food_sci/classification.ts
new file mode 100644
index 000000000..283799bce
--- /dev/null
+++ b/src/food_sci/classification.ts
@@ -0,0 +1,14 @@
+/** food_sci classification module — tsb analytics library. */
+export interface FoodSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciClassificationResult { values: number[]; converged: boolean; }
+export function computeFoodSciClassification(data: number[], opts: FoodSciClassificationOptions = {}): FoodSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciClassification };
diff --git a/src/food_sci/clustering.ts b/src/food_sci/clustering.ts
new file mode 100644
index 000000000..c51e04750
--- /dev/null
+++ b/src/food_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** food_sci clustering module — tsb analytics library. */
+export interface FoodSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface FoodSciClusteringResult { values: number[]; converged: boolean; }
+export function computeFoodSciClustering(data: number[], opts: FoodSciClusteringOptions = {}): FoodSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciClustering };
diff --git a/src/food_sci/compression.ts b/src/food_sci/compression.ts
new file mode 100644
index 000000000..c07ce8e04
--- /dev/null
+++ b/src/food_sci/compression.ts
@@ -0,0 +1,14 @@
+/** food_sci compression module — tsb analytics library. */
+export interface FoodSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciCompressionResult { values: number[]; converged: boolean; }
+export function computeFoodSciCompression(data: number[], opts: FoodSciCompressionOptions = {}): FoodSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciCompression };
diff --git a/src/food_sci/continuous.ts b/src/food_sci/continuous.ts
new file mode 100644
index 000000000..d3b53eb76
--- /dev/null
+++ b/src/food_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** food_sci continuous module — tsb analytics library. */
+export interface FoodSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface FoodSciContinuousResult { values: number[]; converged: boolean; }
+export function computeFoodSciContinuous(data: number[], opts: FoodSciContinuousOptions = {}): FoodSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciContinuous };
diff --git a/src/food_sci/control.ts b/src/food_sci/control.ts
new file mode 100644
index 000000000..9e81bbc0e
--- /dev/null
+++ b/src/food_sci/control.ts
@@ -0,0 +1,14 @@
+/** food_sci control module — tsb analytics library. */
+export interface FoodSciControlOptions { tol?: number; maxIter?: number; }
+export interface FoodSciControlResult { values: number[]; converged: boolean; }
+export function computeFoodSciControl(data: number[], opts: FoodSciControlOptions = {}): FoodSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciControl };
diff --git a/src/food_sci/convergence.ts b/src/food_sci/convergence.ts
new file mode 100644
index 000000000..b2a37e05c
--- /dev/null
+++ b/src/food_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** food_sci convergence module — tsb analytics library. */
+export interface FoodSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface FoodSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeFoodSciConvergence(data: number[], opts: FoodSciConvergenceOptions = {}): FoodSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciConvergence };
diff --git a/src/food_sci/convex.ts b/src/food_sci/convex.ts
new file mode 100644
index 000000000..d7ff6c9e7
--- /dev/null
+++ b/src/food_sci/convex.ts
@@ -0,0 +1,14 @@
+/** food_sci convex module — tsb analytics library. */
+export interface FoodSciConvexOptions { tol?: number; maxIter?: number; }
+export interface FoodSciConvexResult { values: number[]; converged: boolean; }
+export function computeFoodSciConvex(data: number[], opts: FoodSciConvexOptions = {}): FoodSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciConvex };
diff --git a/src/food_sci/correlation.ts b/src/food_sci/correlation.ts
new file mode 100644
index 000000000..dd613986c
--- /dev/null
+++ b/src/food_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** food_sci correlation module — tsb analytics library. */
+export interface FoodSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeFoodSciCorrelation(data: number[], opts: FoodSciCorrelationOptions = {}): FoodSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciCorrelation };
diff --git a/src/food_sci/covariance.ts b/src/food_sci/covariance.ts
new file mode 100644
index 000000000..94753ab95
--- /dev/null
+++ b/src/food_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** food_sci covariance module — tsb analytics library. */
+export interface FoodSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface FoodSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeFoodSciCovariance(data: number[], opts: FoodSciCovarianceOptions = {}): FoodSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciCovariance };
diff --git a/src/food_sci/cross_validation.ts b/src/food_sci/cross_validation.ts
new file mode 100644
index 000000000..934b04afd
--- /dev/null
+++ b/src/food_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** food_sci cross_validation module — tsb analytics library. */
+export interface FoodSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeFoodSciCrossValidation(data: number[], opts: FoodSciCrossValidationOptions = {}): FoodSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciCrossValidation };
diff --git a/src/food_sci/decoding.ts b/src/food_sci/decoding.ts
new file mode 100644
index 000000000..63055e869
--- /dev/null
+++ b/src/food_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** food_sci decoding module — tsb analytics library. */
+export interface FoodSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDecodingResult { values: number[]; converged: boolean; }
+export function computeFoodSciDecoding(data: number[], opts: FoodSciDecodingOptions = {}): FoodSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDecoding };
diff --git a/src/food_sci/decomposition.ts b/src/food_sci/decomposition.ts
new file mode 100644
index 000000000..708b7bf24
--- /dev/null
+++ b/src/food_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** food_sci decomposition module — tsb analytics library. */
+export interface FoodSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeFoodSciDecomposition(data: number[], opts: FoodSciDecompositionOptions = {}): FoodSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDecomposition };
diff --git a/src/food_sci/detection.ts b/src/food_sci/detection.ts
new file mode 100644
index 000000000..8df87aabb
--- /dev/null
+++ b/src/food_sci/detection.ts
@@ -0,0 +1,14 @@
+/** food_sci detection module — tsb analytics library. */
+export interface FoodSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDetectionResult { values: number[]; converged: boolean; }
+export function computeFoodSciDetection(data: number[], opts: FoodSciDetectionOptions = {}): FoodSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDetection };
diff --git a/src/food_sci/deterministic.ts b/src/food_sci/deterministic.ts
new file mode 100644
index 000000000..aaf5a7f53
--- /dev/null
+++ b/src/food_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** food_sci deterministic module — tsb analytics library. */
+export interface FoodSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeFoodSciDeterministic(data: number[], opts: FoodSciDeterministicOptions = {}): FoodSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDeterministic };
diff --git a/src/food_sci/diagnostics.ts b/src/food_sci/diagnostics.ts
new file mode 100644
index 000000000..1edf019c2
--- /dev/null
+++ b/src/food_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** food_sci diagnostics module — tsb analytics library. */
+export interface FoodSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeFoodSciDiagnostics(data: number[], opts: FoodSciDiagnosticsOptions = {}): FoodSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDiagnostics };
diff --git a/src/food_sci/differential.ts b/src/food_sci/differential.ts
new file mode 100644
index 000000000..9a92c2e59
--- /dev/null
+++ b/src/food_sci/differential.ts
@@ -0,0 +1,14 @@
+/** food_sci differential module — tsb analytics library. */
+export interface FoodSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeFoodSciDifferential(data: number[], opts: FoodSciDifferentialOptions = {}): FoodSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDifferential };
diff --git a/src/food_sci/discrete.ts b/src/food_sci/discrete.ts
new file mode 100644
index 000000000..4eb82c746
--- /dev/null
+++ b/src/food_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** food_sci discrete module — tsb analytics library. */
+export interface FoodSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeFoodSciDiscrete(data: number[], opts: FoodSciDiscreteOptions = {}): FoodSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDiscrete };
diff --git a/src/food_sci/distribution.ts b/src/food_sci/distribution.ts
new file mode 100644
index 000000000..1bc3c6368
--- /dev/null
+++ b/src/food_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** food_sci distribution module — tsb analytics library. */
+export interface FoodSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDistributionResult { values: number[]; converged: boolean; }
+export function computeFoodSciDistribution(data: number[], opts: FoodSciDistributionOptions = {}): FoodSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDistribution };
diff --git a/src/food_sci/dynamic.ts b/src/food_sci/dynamic.ts
new file mode 100644
index 000000000..51b7725be
--- /dev/null
+++ b/src/food_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** food_sci dynamic module — tsb analytics library. */
+export interface FoodSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface FoodSciDynamicResult { values: number[]; converged: boolean; }
+export function computeFoodSciDynamic(data: number[], opts: FoodSciDynamicOptions = {}): FoodSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciDynamic };
diff --git a/src/food_sci/embedding.ts b/src/food_sci/embedding.ts
new file mode 100644
index 000000000..bbb3b9307
--- /dev/null
+++ b/src/food_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** food_sci embedding module — tsb analytics library. */
+export interface FoodSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeFoodSciEmbedding(data: number[], opts: FoodSciEmbeddingOptions = {}): FoodSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciEmbedding };
diff --git a/src/food_sci/encoding.ts b/src/food_sci/encoding.ts
new file mode 100644
index 000000000..fe245a9c5
--- /dev/null
+++ b/src/food_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** food_sci encoding module — tsb analytics library. */
+export interface FoodSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciEncodingResult { values: number[]; converged: boolean; }
+export function computeFoodSciEncoding(data: number[], opts: FoodSciEncodingOptions = {}): FoodSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciEncoding };
diff --git a/src/food_sci/ensemble.ts b/src/food_sci/ensemble.ts
new file mode 100644
index 000000000..b0ebab520
--- /dev/null
+++ b/src/food_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** food_sci ensemble module — tsb analytics library. */
+export interface FoodSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface FoodSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeFoodSciEnsemble(data: number[], opts: FoodSciEnsembleOptions = {}): FoodSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciEnsemble };
diff --git a/src/food_sci/estimation.ts b/src/food_sci/estimation.ts
new file mode 100644
index 000000000..32297f8e6
--- /dev/null
+++ b/src/food_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** food_sci estimation module — tsb analytics library. */
+export interface FoodSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciEstimationResult { values: number[]; converged: boolean; }
+export function computeFoodSciEstimation(data: number[], opts: FoodSciEstimationOptions = {}): FoodSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciEstimation };
diff --git a/src/food_sci/evaluation.ts b/src/food_sci/evaluation.ts
new file mode 100644
index 000000000..648166df0
--- /dev/null
+++ b/src/food_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** food_sci evaluation module — tsb analytics library. */
+export interface FoodSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeFoodSciEvaluation(data: number[], opts: FoodSciEvaluationOptions = {}): FoodSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciEvaluation };
diff --git a/src/food_sci/extrapolation.ts b/src/food_sci/extrapolation.ts
new file mode 100644
index 000000000..7b1bf6ac7
--- /dev/null
+++ b/src/food_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** food_sci extrapolation module — tsb analytics library. */
+export interface FoodSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeFoodSciExtrapolation(data: number[], opts: FoodSciExtrapolationOptions = {}): FoodSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciExtrapolation };
diff --git a/src/food_sci/features.ts b/src/food_sci/features.ts
new file mode 100644
index 000000000..a02ac9e2e
--- /dev/null
+++ b/src/food_sci/features.ts
@@ -0,0 +1,14 @@
+/** food_sci features module — tsb analytics library. */
+export interface FoodSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface FoodSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeFoodSciFeatures(data: number[], opts: FoodSciFeaturesOptions = {}): FoodSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciFeatures };
diff --git a/src/food_sci/feedback.ts b/src/food_sci/feedback.ts
new file mode 100644
index 000000000..f5ba157a6
--- /dev/null
+++ b/src/food_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** food_sci feedback module — tsb analytics library. */
+export interface FoodSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface FoodSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeFoodSciFeedback(data: number[], opts: FoodSciFeedbackOptions = {}): FoodSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciFeedback };
diff --git a/src/food_sci/filtering.ts b/src/food_sci/filtering.ts
new file mode 100644
index 000000000..336e5b51c
--- /dev/null
+++ b/src/food_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** food_sci filtering module — tsb analytics library. */
+export interface FoodSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface FoodSciFilteringResult { values: number[]; converged: boolean; }
+export function computeFoodSciFiltering(data: number[], opts: FoodSciFilteringOptions = {}): FoodSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciFiltering };
diff --git a/src/food_sci/fourier.ts b/src/food_sci/fourier.ts
new file mode 100644
index 000000000..47b1de56e
--- /dev/null
+++ b/src/food_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** food_sci fourier module — tsb analytics library. */
+export interface FoodSciFourierOptions { tol?: number; maxIter?: number; }
+export interface FoodSciFourierResult { values: number[]; converged: boolean; }
+export function computeFoodSciFourier(data: number[], opts: FoodSciFourierOptions = {}): FoodSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciFourier };
diff --git a/src/food_sci/fusion.ts b/src/food_sci/fusion.ts
new file mode 100644
index 000000000..056b4e506
--- /dev/null
+++ b/src/food_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** food_sci fusion module — tsb analytics library. */
+export interface FoodSciFusionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciFusionResult { values: number[]; converged: boolean; }
+export function computeFoodSciFusion(data: number[], opts: FoodSciFusionOptions = {}): FoodSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciFusion };
diff --git a/src/food_sci/generation.ts b/src/food_sci/generation.ts
new file mode 100644
index 000000000..2d395f3c1
--- /dev/null
+++ b/src/food_sci/generation.ts
@@ -0,0 +1,14 @@
+/** food_sci generation module — tsb analytics library. */
+export interface FoodSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciGenerationResult { values: number[]; converged: boolean; }
+export function computeFoodSciGeneration(data: number[], opts: FoodSciGenerationOptions = {}): FoodSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciGeneration };
diff --git a/src/food_sci/geometry.ts b/src/food_sci/geometry.ts
new file mode 100644
index 000000000..3eeb5ace3
--- /dev/null
+++ b/src/food_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** food_sci geometry module — tsb analytics library. */
+export interface FoodSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface FoodSciGeometryResult { values: number[]; converged: boolean; }
+export function computeFoodSciGeometry(data: number[], opts: FoodSciGeometryOptions = {}): FoodSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciGeometry };
diff --git a/src/food_sci/gradient.ts b/src/food_sci/gradient.ts
new file mode 100644
index 000000000..d37f5835c
--- /dev/null
+++ b/src/food_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** food_sci gradient module — tsb analytics library. */
+export interface FoodSciGradientOptions { tol?: number; maxIter?: number; }
+export interface FoodSciGradientResult { values: number[]; converged: boolean; }
+export function computeFoodSciGradient(data: number[], opts: FoodSciGradientOptions = {}): FoodSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciGradient };
diff --git a/src/food_sci/hessian.ts b/src/food_sci/hessian.ts
new file mode 100644
index 000000000..816df6a2c
--- /dev/null
+++ b/src/food_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** food_sci hessian module — tsb analytics library. */
+export interface FoodSciHessianOptions { tol?: number; maxIter?: number; }
+export interface FoodSciHessianResult { values: number[]; converged: boolean; }
+export function computeFoodSciHessian(data: number[], opts: FoodSciHessianOptions = {}): FoodSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciHessian };
diff --git a/src/food_sci/hypothesis.ts b/src/food_sci/hypothesis.ts
new file mode 100644
index 000000000..6c2299477
--- /dev/null
+++ b/src/food_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** food_sci hypothesis module — tsb analytics library. */
+export interface FoodSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface FoodSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeFoodSciHypothesis(data: number[], opts: FoodSciHypothesisOptions = {}): FoodSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciHypothesis };
diff --git a/src/food_sci/inference.ts b/src/food_sci/inference.ts
new file mode 100644
index 000000000..4ff57be08
--- /dev/null
+++ b/src/food_sci/inference.ts
@@ -0,0 +1,14 @@
+/** food_sci inference module — tsb analytics library. */
+export interface FoodSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface FoodSciInferenceResult { values: number[]; converged: boolean; }
+export function computeFoodSciInference(data: number[], opts: FoodSciInferenceOptions = {}): FoodSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciInference };
diff --git a/src/food_sci/inference2.ts b/src/food_sci/inference2.ts
new file mode 100644
index 000000000..59ce6d190
--- /dev/null
+++ b/src/food_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** food_sci inference2 module — tsb analytics library. */
+export interface FoodSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface FoodSciInferenceResult { values: number[]; converged: boolean; }
+export function computeFoodSciInference(data: number[], opts: FoodSciInferenceOptions = {}): FoodSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciInference };
diff --git a/src/food_sci/integral.ts b/src/food_sci/integral.ts
new file mode 100644
index 000000000..b186c9e08
--- /dev/null
+++ b/src/food_sci/integral.ts
@@ -0,0 +1,14 @@
+/** food_sci integral module — tsb analytics library. */
+export interface FoodSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface FoodSciIntegralResult { values: number[]; converged: boolean; }
+export function computeFoodSciIntegral(data: number[], opts: FoodSciIntegralOptions = {}): FoodSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciIntegral };
diff --git a/src/food_sci/integration.ts b/src/food_sci/integration.ts
new file mode 100644
index 000000000..849aae2be
--- /dev/null
+++ b/src/food_sci/integration.ts
@@ -0,0 +1,14 @@
+/** food_sci integration module — tsb analytics library. */
+export interface FoodSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeFoodSciIntegration(data: number[], opts: FoodSciIntegrationOptions = {}): FoodSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciIntegration };
diff --git a/src/food_sci/interpolation.ts b/src/food_sci/interpolation.ts
new file mode 100644
index 000000000..ac02415e0
--- /dev/null
+++ b/src/food_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** food_sci interpolation module — tsb analytics library. */
+export interface FoodSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeFoodSciInterpolation(data: number[], opts: FoodSciInterpolationOptions = {}): FoodSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciInterpolation };
diff --git a/src/food_sci/jacobian.ts b/src/food_sci/jacobian.ts
new file mode 100644
index 000000000..e3e6accfc
--- /dev/null
+++ b/src/food_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** food_sci jacobian module — tsb analytics library. */
+export interface FoodSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface FoodSciJacobianResult { values: number[]; converged: boolean; }
+export function computeFoodSciJacobian(data: number[], opts: FoodSciJacobianOptions = {}): FoodSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciJacobian };
diff --git a/src/food_sci/kernel.ts b/src/food_sci/kernel.ts
new file mode 100644
index 000000000..3902e0e27
--- /dev/null
+++ b/src/food_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** food_sci kernel module — tsb analytics library. */
+export interface FoodSciKernelOptions { tol?: number; maxIter?: number; }
+export interface FoodSciKernelResult { values: number[]; converged: boolean; }
+export function computeFoodSciKernel(data: number[], opts: FoodSciKernelOptions = {}): FoodSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciKernel };
diff --git a/src/food_sci/laplacian.ts b/src/food_sci/laplacian.ts
new file mode 100644
index 000000000..090a65328
--- /dev/null
+++ b/src/food_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** food_sci laplacian module — tsb analytics library. */
+export interface FoodSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface FoodSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeFoodSciLaplacian(data: number[], opts: FoodSciLaplacianOptions = {}): FoodSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciLaplacian };
diff --git a/src/food_sci/learning.ts b/src/food_sci/learning.ts
new file mode 100644
index 000000000..efe0f60ad
--- /dev/null
+++ b/src/food_sci/learning.ts
@@ -0,0 +1,14 @@
+/** food_sci learning module — tsb analytics library. */
+export interface FoodSciLearningOptions { tol?: number; maxIter?: number; }
+export interface FoodSciLearningResult { values: number[]; converged: boolean; }
+export function computeFoodSciLearning(data: number[], opts: FoodSciLearningOptions = {}): FoodSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciLearning };
diff --git a/src/food_sci/linear.ts b/src/food_sci/linear.ts
new file mode 100644
index 000000000..768692c99
--- /dev/null
+++ b/src/food_sci/linear.ts
@@ -0,0 +1,14 @@
+/** food_sci linear module — tsb analytics library. */
+export interface FoodSciLinearOptions { tol?: number; maxIter?: number; }
+export interface FoodSciLinearResult { values: number[]; converged: boolean; }
+export function computeFoodSciLinear(data: number[], opts: FoodSciLinearOptions = {}): FoodSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciLinear };
diff --git a/src/food_sci/manifold.ts b/src/food_sci/manifold.ts
new file mode 100644
index 000000000..b9cd98793
--- /dev/null
+++ b/src/food_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** food_sci manifold module — tsb analytics library. */
+export interface FoodSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface FoodSciManifoldResult { values: number[]; converged: boolean; }
+export function computeFoodSciManifold(data: number[], opts: FoodSciManifoldOptions = {}): FoodSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciManifold };
diff --git a/src/food_sci/matching.ts b/src/food_sci/matching.ts
new file mode 100644
index 000000000..29823e204
--- /dev/null
+++ b/src/food_sci/matching.ts
@@ -0,0 +1,14 @@
+/** food_sci matching module — tsb analytics library. */
+export interface FoodSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciMatchingResult { values: number[]; converged: boolean; }
+export function computeFoodSciMatching(data: number[], opts: FoodSciMatchingOptions = {}): FoodSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciMatching };
diff --git a/src/food_sci/measurement.ts b/src/food_sci/measurement.ts
new file mode 100644
index 000000000..0ff6fdf0a
--- /dev/null
+++ b/src/food_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** food_sci measurement module — tsb analytics library. */
+export interface FoodSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface FoodSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeFoodSciMeasurement(data: number[], opts: FoodSciMeasurementOptions = {}): FoodSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciMeasurement };
diff --git a/src/food_sci/metrics.ts b/src/food_sci/metrics.ts
new file mode 100644
index 000000000..2228cc78f
--- /dev/null
+++ b/src/food_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** food_sci metrics module — tsb analytics library. */
+export interface FoodSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface FoodSciMetricsResult { values: number[]; converged: boolean; }
+export function computeFoodSciMetrics(data: number[], opts: FoodSciMetricsOptions = {}): FoodSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciMetrics };
diff --git a/src/food_sci/modeling.ts b/src/food_sci/modeling.ts
new file mode 100644
index 000000000..b17350d00
--- /dev/null
+++ b/src/food_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** food_sci modeling module — tsb analytics library. */
+export interface FoodSciModelingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciModelingResult { values: number[]; converged: boolean; }
+export function computeFoodSciModeling(data: number[], opts: FoodSciModelingOptions = {}): FoodSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciModeling };
diff --git a/src/food_sci/monitoring.ts b/src/food_sci/monitoring.ts
new file mode 100644
index 000000000..32c1e7505
--- /dev/null
+++ b/src/food_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** food_sci monitoring module — tsb analytics library. */
+export interface FoodSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface FoodSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeFoodSciMonitoring(data: number[], opts: FoodSciMonitoringOptions = {}): FoodSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciMonitoring };
diff --git a/src/food_sci/nonlinear.ts b/src/food_sci/nonlinear.ts
new file mode 100644
index 000000000..96845892a
--- /dev/null
+++ b/src/food_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** food_sci nonlinear module — tsb analytics library. */
+export interface FoodSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface FoodSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeFoodSciNonlinear(data: number[], opts: FoodSciNonlinearOptions = {}): FoodSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciNonlinear };
diff --git a/src/food_sci/normalization.ts b/src/food_sci/normalization.ts
new file mode 100644
index 000000000..e20b94169
--- /dev/null
+++ b/src/food_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** food_sci normalization module — tsb analytics library. */
+export interface FoodSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeFoodSciNormalization(data: number[], opts: FoodSciNormalizationOptions = {}): FoodSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciNormalization };
diff --git a/src/food_sci/optimization.ts b/src/food_sci/optimization.ts
new file mode 100644
index 000000000..917cced5f
--- /dev/null
+++ b/src/food_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** food_sci optimization module — tsb analytics library. */
+export interface FoodSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeFoodSciOptimization(data: number[], opts: FoodSciOptimizationOptions = {}): FoodSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciOptimization };
diff --git a/src/food_sci/patterns.ts b/src/food_sci/patterns.ts
new file mode 100644
index 000000000..af3283ce2
--- /dev/null
+++ b/src/food_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** food_sci patterns module — tsb analytics library. */
+export interface FoodSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface FoodSciPatternsResult { values: number[]; converged: boolean; }
+export function computeFoodSciPatterns(data: number[], opts: FoodSciPatternsOptions = {}): FoodSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciPatterns };
diff --git a/src/food_sci/permutation.ts b/src/food_sci/permutation.ts
new file mode 100644
index 000000000..f2ca620ac
--- /dev/null
+++ b/src/food_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** food_sci permutation module — tsb analytics library. */
+export interface FoodSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciPermutationResult { values: number[]; converged: boolean; }
+export function computeFoodSciPermutation(data: number[], opts: FoodSciPermutationOptions = {}): FoodSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciPermutation };
diff --git a/src/food_sci/prediction.ts b/src/food_sci/prediction.ts
new file mode 100644
index 000000000..8ecedc9cf
--- /dev/null
+++ b/src/food_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** food_sci prediction module — tsb analytics library. */
+export interface FoodSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciPredictionResult { values: number[]; converged: boolean; }
+export function computeFoodSciPrediction(data: number[], opts: FoodSciPredictionOptions = {}): FoodSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciPrediction };
diff --git a/src/food_sci/processing.ts b/src/food_sci/processing.ts
new file mode 100644
index 000000000..3039aa451
--- /dev/null
+++ b/src/food_sci/processing.ts
@@ -0,0 +1,14 @@
+/** food_sci processing module — tsb analytics library. */
+export interface FoodSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciProcessingResult { values: number[]; converged: boolean; }
+export function computeFoodSciProcessing(data: number[], opts: FoodSciProcessingOptions = {}): FoodSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciProcessing };
diff --git a/src/food_sci/profiling.ts b/src/food_sci/profiling.ts
new file mode 100644
index 000000000..b1dc39888
--- /dev/null
+++ b/src/food_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** food_sci profiling module — tsb analytics library. */
+export interface FoodSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciProfilingResult { values: number[]; converged: boolean; }
+export function computeFoodSciProfiling(data: number[], opts: FoodSciProfilingOptions = {}): FoodSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciProfiling };
diff --git a/src/food_sci/projection.ts b/src/food_sci/projection.ts
new file mode 100644
index 000000000..c0edb2969
--- /dev/null
+++ b/src/food_sci/projection.ts
@@ -0,0 +1,14 @@
+/** food_sci projection module — tsb analytics library. */
+export interface FoodSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciProjectionResult { values: number[]; converged: boolean; }
+export function computeFoodSciProjection(data: number[], opts: FoodSciProjectionOptions = {}): FoodSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciProjection };
diff --git a/src/food_sci/ranking.ts b/src/food_sci/ranking.ts
new file mode 100644
index 000000000..7743723f9
--- /dev/null
+++ b/src/food_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** food_sci ranking module — tsb analytics library. */
+export interface FoodSciRankingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciRankingResult { values: number[]; converged: boolean; }
+export function computeFoodSciRanking(data: number[], opts: FoodSciRankingOptions = {}): FoodSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciRanking };
diff --git a/src/food_sci/reconstruction.ts b/src/food_sci/reconstruction.ts
new file mode 100644
index 000000000..bd79867b5
--- /dev/null
+++ b/src/food_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** food_sci reconstruction module — tsb analytics library. */
+export interface FoodSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeFoodSciReconstruction(data: number[], opts: FoodSciReconstructionOptions = {}): FoodSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciReconstruction };
diff --git a/src/food_sci/registration.ts b/src/food_sci/registration.ts
new file mode 100644
index 000000000..ea21b79f3
--- /dev/null
+++ b/src/food_sci/registration.ts
@@ -0,0 +1,14 @@
+/** food_sci registration module — tsb analytics library. */
+export interface FoodSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeFoodSciRegistration(data: number[], opts: FoodSciRegistrationOptions = {}): FoodSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciRegistration };
diff --git a/src/food_sci/regression.ts b/src/food_sci/regression.ts
new file mode 100644
index 000000000..828624e42
--- /dev/null
+++ b/src/food_sci/regression.ts
@@ -0,0 +1,14 @@
+/** food_sci regression module — tsb analytics library. */
+export interface FoodSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciRegressionResult { values: number[]; converged: boolean; }
+export function computeFoodSciRegression(data: number[], opts: FoodSciRegressionOptions = {}): FoodSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciRegression };
diff --git a/src/food_sci/regularization.ts b/src/food_sci/regularization.ts
new file mode 100644
index 000000000..0ba865172
--- /dev/null
+++ b/src/food_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** food_sci regularization module — tsb analytics library. */
+export interface FoodSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeFoodSciRegularization(data: number[], opts: FoodSciRegularizationOptions = {}): FoodSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciRegularization };
diff --git a/src/food_sci/robustness.ts b/src/food_sci/robustness.ts
new file mode 100644
index 000000000..74001691f
--- /dev/null
+++ b/src/food_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** food_sci robustness module — tsb analytics library. */
+export interface FoodSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface FoodSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeFoodSciRobustness(data: number[], opts: FoodSciRobustnessOptions = {}): FoodSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciRobustness };
diff --git a/src/food_sci/sampling.ts b/src/food_sci/sampling.ts
new file mode 100644
index 000000000..e514bb4c0
--- /dev/null
+++ b/src/food_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** food_sci sampling module — tsb analytics library. */
+export interface FoodSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciSamplingResult { values: number[]; converged: boolean; }
+export function computeFoodSciSampling(data: number[], opts: FoodSciSamplingOptions = {}): FoodSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciSampling };
diff --git a/src/food_sci/sampling2.ts b/src/food_sci/sampling2.ts
new file mode 100644
index 000000000..941346a92
--- /dev/null
+++ b/src/food_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** food_sci sampling2 module — tsb analytics library. */
+export interface FoodSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciSamplingResult { values: number[]; converged: boolean; }
+export function computeFoodSciSampling(data: number[], opts: FoodSciSamplingOptions = {}): FoodSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciSampling };
diff --git a/src/food_sci/scaling.ts b/src/food_sci/scaling.ts
new file mode 100644
index 000000000..340860ef4
--- /dev/null
+++ b/src/food_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** food_sci scaling module — tsb analytics library. */
+export interface FoodSciScalingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciScalingResult { values: number[]; converged: boolean; }
+export function computeFoodSciScaling(data: number[], opts: FoodSciScalingOptions = {}): FoodSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciScaling };
diff --git a/src/food_sci/scoring.ts b/src/food_sci/scoring.ts
new file mode 100644
index 000000000..7f499d77f
--- /dev/null
+++ b/src/food_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** food_sci scoring module — tsb analytics library. */
+export interface FoodSciScoringOptions { tol?: number; maxIter?: number; }
+export interface FoodSciScoringResult { values: number[]; converged: boolean; }
+export function computeFoodSciScoring(data: number[], opts: FoodSciScoringOptions = {}): FoodSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciScoring };
diff --git a/src/food_sci/segmentation.ts b/src/food_sci/segmentation.ts
new file mode 100644
index 000000000..4b1ace759
--- /dev/null
+++ b/src/food_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** food_sci segmentation module — tsb analytics library. */
+export interface FoodSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeFoodSciSegmentation(data: number[], opts: FoodSciSegmentationOptions = {}): FoodSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciSegmentation };
diff --git a/src/food_sci/selection.ts b/src/food_sci/selection.ts
new file mode 100644
index 000000000..5e7a25db5
--- /dev/null
+++ b/src/food_sci/selection.ts
@@ -0,0 +1,14 @@
+/** food_sci selection module — tsb analytics library. */
+export interface FoodSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface FoodSciSelectionResult { values: number[]; converged: boolean; }
+export function computeFoodSciSelection(data: number[], opts: FoodSciSelectionOptions = {}): FoodSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciSelection };
diff --git a/src/food_sci/sensitivity.ts b/src/food_sci/sensitivity.ts
new file mode 100644
index 000000000..a31ca1dee
--- /dev/null
+++ b/src/food_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** food_sci sensitivity module — tsb analytics library. */
+export interface FoodSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface FoodSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeFoodSciSensitivity(data: number[], opts: FoodSciSensitivityOptions = {}): FoodSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciSensitivity };
diff --git a/src/food_sci/simulation.ts b/src/food_sci/simulation.ts
new file mode 100644
index 000000000..9b6d39d3a
--- /dev/null
+++ b/src/food_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** food_sci simulation module — tsb analytics library. */
+export interface FoodSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciSimulationResult { values: number[]; converged: boolean; }
+export function computeFoodSciSimulation(data: number[], opts: FoodSciSimulationOptions = {}): FoodSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciSimulation };
diff --git a/src/food_sci/smoothing.ts b/src/food_sci/smoothing.ts
new file mode 100644
index 000000000..2b073042f
--- /dev/null
+++ b/src/food_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** food_sci smoothing module — tsb analytics library. */
+export interface FoodSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeFoodSciSmoothing(data: number[], opts: FoodSciSmoothingOptions = {}): FoodSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciSmoothing };
diff --git a/src/food_sci/stability.ts b/src/food_sci/stability.ts
new file mode 100644
index 000000000..67ee99d05
--- /dev/null
+++ b/src/food_sci/stability.ts
@@ -0,0 +1,14 @@
+/** food_sci stability module — tsb analytics library. */
+export interface FoodSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface FoodSciStabilityResult { values: number[]; converged: boolean; }
+export function computeFoodSciStability(data: number[], opts: FoodSciStabilityOptions = {}): FoodSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciStability };
diff --git a/src/food_sci/stacking.ts b/src/food_sci/stacking.ts
new file mode 100644
index 000000000..a2ae1e1f2
--- /dev/null
+++ b/src/food_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** food_sci stacking module — tsb analytics library. */
+export interface FoodSciStackingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciStackingResult { values: number[]; converged: boolean; }
+export function computeFoodSciStacking(data: number[], opts: FoodSciStackingOptions = {}): FoodSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciStacking };
diff --git a/src/food_sci/standardization.ts b/src/food_sci/standardization.ts
new file mode 100644
index 000000000..23ce79006
--- /dev/null
+++ b/src/food_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** food_sci standardization module — tsb analytics library. */
+export interface FoodSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeFoodSciStandardization(data: number[], opts: FoodSciStandardizationOptions = {}): FoodSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciStandardization };
diff --git a/src/food_sci/static.ts b/src/food_sci/static.ts
new file mode 100644
index 000000000..959f8810c
--- /dev/null
+++ b/src/food_sci/static.ts
@@ -0,0 +1,14 @@
+/** food_sci static module — tsb analytics library. */
+export interface FoodSciStaticOptions { tol?: number; maxIter?: number; }
+export interface FoodSciStaticResult { values: number[]; converged: boolean; }
+export function computeFoodSciStatic(data: number[], opts: FoodSciStaticOptions = {}): FoodSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciStatic };
diff --git a/src/food_sci/stochastic.ts b/src/food_sci/stochastic.ts
new file mode 100644
index 000000000..d5a565920
--- /dev/null
+++ b/src/food_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** food_sci stochastic module — tsb analytics library. */
+export interface FoodSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface FoodSciStochasticResult { values: number[]; converged: boolean; }
+export function computeFoodSciStochastic(data: number[], opts: FoodSciStochasticOptions = {}): FoodSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciStochastic };
diff --git a/src/food_sci/synthesis.ts b/src/food_sci/synthesis.ts
new file mode 100644
index 000000000..39b274d53
--- /dev/null
+++ b/src/food_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** food_sci synthesis module — tsb analytics library. */
+export interface FoodSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface FoodSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeFoodSciSynthesis(data: number[], opts: FoodSciSynthesisOptions = {}): FoodSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciSynthesis };
diff --git a/src/food_sci/topology.ts b/src/food_sci/topology.ts
new file mode 100644
index 000000000..0316705ac
--- /dev/null
+++ b/src/food_sci/topology.ts
@@ -0,0 +1,14 @@
+/** food_sci topology module — tsb analytics library. */
+export interface FoodSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface FoodSciTopologyResult { values: number[]; converged: boolean; }
+export function computeFoodSciTopology(data: number[], opts: FoodSciTopologyOptions = {}): FoodSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciTopology };
diff --git a/src/food_sci/tracking.ts b/src/food_sci/tracking.ts
new file mode 100644
index 000000000..36b410a26
--- /dev/null
+++ b/src/food_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** food_sci tracking module — tsb analytics library. */
+export interface FoodSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciTrackingResult { values: number[]; converged: boolean; }
+export function computeFoodSciTracking(data: number[], opts: FoodSciTrackingOptions = {}): FoodSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciTracking };
diff --git a/src/food_sci/transform.ts b/src/food_sci/transform.ts
new file mode 100644
index 000000000..e32ab9cc2
--- /dev/null
+++ b/src/food_sci/transform.ts
@@ -0,0 +1,14 @@
+/** food_sci transform module — tsb analytics library. */
+export interface FoodSciTransformOptions { tol?: number; maxIter?: number; }
+export interface FoodSciTransformResult { values: number[]; converged: boolean; }
+export function computeFoodSciTransform(data: number[], opts: FoodSciTransformOptions = {}): FoodSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciTransform };
diff --git a/src/food_sci/uncertainty.ts b/src/food_sci/uncertainty.ts
new file mode 100644
index 000000000..bf65a8072
--- /dev/null
+++ b/src/food_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** food_sci uncertainty module — tsb analytics library. */
+export interface FoodSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface FoodSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeFoodSciUncertainty(data: number[], opts: FoodSciUncertaintyOptions = {}): FoodSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciUncertainty };
diff --git a/src/food_sci/validation.ts b/src/food_sci/validation.ts
new file mode 100644
index 000000000..9e3349bdf
--- /dev/null
+++ b/src/food_sci/validation.ts
@@ -0,0 +1,14 @@
+/** food_sci validation module — tsb analytics library. */
+export interface FoodSciValidationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciValidationResult { values: number[]; converged: boolean; }
+export function computeFoodSciValidation(data: number[], opts: FoodSciValidationOptions = {}): FoodSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciValidation };
diff --git a/src/food_sci/verification.ts b/src/food_sci/verification.ts
new file mode 100644
index 000000000..4b11bdd98
--- /dev/null
+++ b/src/food_sci/verification.ts
@@ -0,0 +1,14 @@
+/** food_sci verification module — tsb analytics library. */
+export interface FoodSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciVerificationResult { values: number[]; converged: boolean; }
+export function computeFoodSciVerification(data: number[], opts: FoodSciVerificationOptions = {}): FoodSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciVerification };
diff --git a/src/food_sci/visualization.ts b/src/food_sci/visualization.ts
new file mode 100644
index 000000000..83a2df75b
--- /dev/null
+++ b/src/food_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** food_sci visualization module — tsb analytics library. */
+export interface FoodSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface FoodSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeFoodSciVisualization(data: number[], opts: FoodSciVisualizationOptions = {}): FoodSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciVisualization };
diff --git a/src/food_sci/voting.ts b/src/food_sci/voting.ts
new file mode 100644
index 000000000..80fee2448
--- /dev/null
+++ b/src/food_sci/voting.ts
@@ -0,0 +1,14 @@
+/** food_sci voting module — tsb analytics library. */
+export interface FoodSciVotingOptions { tol?: number; maxIter?: number; }
+export interface FoodSciVotingResult { values: number[]; converged: boolean; }
+export function computeFoodSciVoting(data: number[], opts: FoodSciVotingOptions = {}): FoodSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciVoting };
diff --git a/src/food_sci/wavelet.ts b/src/food_sci/wavelet.ts
new file mode 100644
index 000000000..39398d2fa
--- /dev/null
+++ b/src/food_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** food_sci wavelet module — tsb analytics library. */
+export interface FoodSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface FoodSciWaveletResult { values: number[]; converged: boolean; }
+export function computeFoodSciWavelet(data: number[], opts: FoodSciWaveletOptions = {}): FoodSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFoodSciWavelet };
diff --git a/src/forensic_sci/adaptation.ts b/src/forensic_sci/adaptation.ts
new file mode 100644
index 000000000..81ba568f2
--- /dev/null
+++ b/src/forensic_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci adaptation module — tsb analytics library. */
+export interface ForensicSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeForensicSciAdaptation(data: number[], opts: ForensicSciAdaptationOptions = {}): ForensicSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciAdaptation };
diff --git a/src/forensic_sci/aggregation.ts b/src/forensic_sci/aggregation.ts
new file mode 100644
index 000000000..434325b4b
--- /dev/null
+++ b/src/forensic_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci aggregation module — tsb analytics library. */
+export interface ForensicSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciAggregationResult { values: number[]; converged: boolean; }
+export function computeForensicSciAggregation(data: number[], opts: ForensicSciAggregationOptions = {}): ForensicSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciAggregation };
diff --git a/src/forensic_sci/algebra.ts b/src/forensic_sci/algebra.ts
new file mode 100644
index 000000000..48ec3f4af
--- /dev/null
+++ b/src/forensic_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** forensic_sci algebra module — tsb analytics library. */
+export interface ForensicSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeForensicSciAlgebra(data: number[], opts: ForensicSciAlgebraOptions = {}): ForensicSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciAlgebra };
diff --git a/src/forensic_sci/alignment.ts b/src/forensic_sci/alignment.ts
new file mode 100644
index 000000000..5f5e5ef54
--- /dev/null
+++ b/src/forensic_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** forensic_sci alignment module — tsb analytics library. */
+export interface ForensicSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeForensicSciAlignment(data: number[], opts: ForensicSciAlignmentOptions = {}): ForensicSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciAlignment };
diff --git a/src/forensic_sci/analysis.ts b/src/forensic_sci/analysis.ts
new file mode 100644
index 000000000..ce5494e0a
--- /dev/null
+++ b/src/forensic_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** forensic_sci analysis module — tsb analytics library. */
+export interface ForensicSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeForensicSciAnalysis(data: number[], opts: ForensicSciAnalysisOptions = {}): ForensicSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciAnalysis };
diff --git a/src/forensic_sci/augmentation.ts b/src/forensic_sci/augmentation.ts
new file mode 100644
index 000000000..5d02d899f
--- /dev/null
+++ b/src/forensic_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci augmentation module — tsb analytics library. */
+export interface ForensicSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeForensicSciAugmentation(data: number[], opts: ForensicSciAugmentationOptions = {}): ForensicSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciAugmentation };
diff --git a/src/forensic_sci/bagging.ts b/src/forensic_sci/bagging.ts
new file mode 100644
index 000000000..377b3aab6
--- /dev/null
+++ b/src/forensic_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** forensic_sci bagging module — tsb analytics library. */
+export interface ForensicSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciBaggingResult { values: number[]; converged: boolean; }
+export function computeForensicSciBagging(data: number[], opts: ForensicSciBaggingOptions = {}): ForensicSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciBagging };
diff --git a/src/forensic_sci/basis.ts b/src/forensic_sci/basis.ts
new file mode 100644
index 000000000..3e353c832
--- /dev/null
+++ b/src/forensic_sci/basis.ts
@@ -0,0 +1,14 @@
+/** forensic_sci basis module — tsb analytics library. */
+export interface ForensicSciBasisOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciBasisResult { values: number[]; converged: boolean; }
+export function computeForensicSciBasis(data: number[], opts: ForensicSciBasisOptions = {}): ForensicSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciBasis };
diff --git a/src/forensic_sci/benchmarking.ts b/src/forensic_sci/benchmarking.ts
new file mode 100644
index 000000000..5252e6cc5
--- /dev/null
+++ b/src/forensic_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** forensic_sci benchmarking module — tsb analytics library. */
+export interface ForensicSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeForensicSciBenchmarking(data: number[], opts: ForensicSciBenchmarkingOptions = {}): ForensicSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciBenchmarking };
diff --git a/src/forensic_sci/blending.ts b/src/forensic_sci/blending.ts
new file mode 100644
index 000000000..3cee35564
--- /dev/null
+++ b/src/forensic_sci/blending.ts
@@ -0,0 +1,14 @@
+/** forensic_sci blending module — tsb analytics library. */
+export interface ForensicSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciBlendingResult { values: number[]; converged: boolean; }
+export function computeForensicSciBlending(data: number[], opts: ForensicSciBlendingOptions = {}): ForensicSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciBlending };
diff --git a/src/forensic_sci/boosting.ts b/src/forensic_sci/boosting.ts
new file mode 100644
index 000000000..b4149dc05
--- /dev/null
+++ b/src/forensic_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** forensic_sci boosting module — tsb analytics library. */
+export interface ForensicSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciBoostingResult { values: number[]; converged: boolean; }
+export function computeForensicSciBoosting(data: number[], opts: ForensicSciBoostingOptions = {}): ForensicSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciBoosting };
diff --git a/src/forensic_sci/bootstrap.ts b/src/forensic_sci/bootstrap.ts
new file mode 100644
index 000000000..659d0f33a
--- /dev/null
+++ b/src/forensic_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** forensic_sci bootstrap module — tsb analytics library. */
+export interface ForensicSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeForensicSciBootstrap(data: number[], opts: ForensicSciBootstrapOptions = {}): ForensicSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciBootstrap };
diff --git a/src/forensic_sci/calculus.ts b/src/forensic_sci/calculus.ts
new file mode 100644
index 000000000..04d162c8c
--- /dev/null
+++ b/src/forensic_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** forensic_sci calculus module — tsb analytics library. */
+export interface ForensicSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciCalculusResult { values: number[]; converged: boolean; }
+export function computeForensicSciCalculus(data: number[], opts: ForensicSciCalculusOptions = {}): ForensicSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciCalculus };
diff --git a/src/forensic_sci/calibration.ts b/src/forensic_sci/calibration.ts
new file mode 100644
index 000000000..5628d29a7
--- /dev/null
+++ b/src/forensic_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** forensic_sci calibration module — tsb analytics library. */
+export interface ForensicSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeForensicSciCalibration(data: number[], opts: ForensicSciCalibrationOptions = {}): ForensicSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciCalibration };
diff --git a/src/forensic_sci/characterization.ts b/src/forensic_sci/characterization.ts
new file mode 100644
index 000000000..0e14916ba
--- /dev/null
+++ b/src/forensic_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** forensic_sci characterization module — tsb analytics library. */
+export interface ForensicSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeForensicSciCharacterization(data: number[], opts: ForensicSciCharacterizationOptions = {}): ForensicSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciCharacterization };
diff --git a/src/forensic_sci/classification.ts b/src/forensic_sci/classification.ts
new file mode 100644
index 000000000..efcab4071
--- /dev/null
+++ b/src/forensic_sci/classification.ts
@@ -0,0 +1,14 @@
+/** forensic_sci classification module — tsb analytics library. */
+export interface ForensicSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciClassificationResult { values: number[]; converged: boolean; }
+export function computeForensicSciClassification(data: number[], opts: ForensicSciClassificationOptions = {}): ForensicSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciClassification };
diff --git a/src/forensic_sci/clustering.ts b/src/forensic_sci/clustering.ts
new file mode 100644
index 000000000..7d8b5d1d7
--- /dev/null
+++ b/src/forensic_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** forensic_sci clustering module — tsb analytics library. */
+export interface ForensicSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciClusteringResult { values: number[]; converged: boolean; }
+export function computeForensicSciClustering(data: number[], opts: ForensicSciClusteringOptions = {}): ForensicSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciClustering };
diff --git a/src/forensic_sci/compression.ts b/src/forensic_sci/compression.ts
new file mode 100644
index 000000000..73f63e599
--- /dev/null
+++ b/src/forensic_sci/compression.ts
@@ -0,0 +1,14 @@
+/** forensic_sci compression module — tsb analytics library. */
+export interface ForensicSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciCompressionResult { values: number[]; converged: boolean; }
+export function computeForensicSciCompression(data: number[], opts: ForensicSciCompressionOptions = {}): ForensicSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciCompression };
diff --git a/src/forensic_sci/continuous.ts b/src/forensic_sci/continuous.ts
new file mode 100644
index 000000000..9111f84f9
--- /dev/null
+++ b/src/forensic_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** forensic_sci continuous module — tsb analytics library. */
+export interface ForensicSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciContinuousResult { values: number[]; converged: boolean; }
+export function computeForensicSciContinuous(data: number[], opts: ForensicSciContinuousOptions = {}): ForensicSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciContinuous };
diff --git a/src/forensic_sci/control.ts b/src/forensic_sci/control.ts
new file mode 100644
index 000000000..e812ca8ce
--- /dev/null
+++ b/src/forensic_sci/control.ts
@@ -0,0 +1,14 @@
+/** forensic_sci control module — tsb analytics library. */
+export interface ForensicSciControlOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciControlResult { values: number[]; converged: boolean; }
+export function computeForensicSciControl(data: number[], opts: ForensicSciControlOptions = {}): ForensicSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciControl };
diff --git a/src/forensic_sci/convergence.ts b/src/forensic_sci/convergence.ts
new file mode 100644
index 000000000..daf5d752a
--- /dev/null
+++ b/src/forensic_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** forensic_sci convergence module — tsb analytics library. */
+export interface ForensicSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeForensicSciConvergence(data: number[], opts: ForensicSciConvergenceOptions = {}): ForensicSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciConvergence };
diff --git a/src/forensic_sci/convex.ts b/src/forensic_sci/convex.ts
new file mode 100644
index 000000000..d1cc22e45
--- /dev/null
+++ b/src/forensic_sci/convex.ts
@@ -0,0 +1,14 @@
+/** forensic_sci convex module — tsb analytics library. */
+export interface ForensicSciConvexOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciConvexResult { values: number[]; converged: boolean; }
+export function computeForensicSciConvex(data: number[], opts: ForensicSciConvexOptions = {}): ForensicSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciConvex };
diff --git a/src/forensic_sci/correlation.ts b/src/forensic_sci/correlation.ts
new file mode 100644
index 000000000..e2ab3e83b
--- /dev/null
+++ b/src/forensic_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci correlation module — tsb analytics library. */
+export interface ForensicSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeForensicSciCorrelation(data: number[], opts: ForensicSciCorrelationOptions = {}): ForensicSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciCorrelation };
diff --git a/src/forensic_sci/covariance.ts b/src/forensic_sci/covariance.ts
new file mode 100644
index 000000000..2cb255c98
--- /dev/null
+++ b/src/forensic_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** forensic_sci covariance module — tsb analytics library. */
+export interface ForensicSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeForensicSciCovariance(data: number[], opts: ForensicSciCovarianceOptions = {}): ForensicSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciCovariance };
diff --git a/src/forensic_sci/cross_validation.ts b/src/forensic_sci/cross_validation.ts
new file mode 100644
index 000000000..d2e7c2b4f
--- /dev/null
+++ b/src/forensic_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci cross_validation module — tsb analytics library. */
+export interface ForensicSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeForensicSciCrossValidation(data: number[], opts: ForensicSciCrossValidationOptions = {}): ForensicSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciCrossValidation };
diff --git a/src/forensic_sci/decoding.ts b/src/forensic_sci/decoding.ts
new file mode 100644
index 000000000..31b96e8ea
--- /dev/null
+++ b/src/forensic_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** forensic_sci decoding module — tsb analytics library. */
+export interface ForensicSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDecodingResult { values: number[]; converged: boolean; }
+export function computeForensicSciDecoding(data: number[], opts: ForensicSciDecodingOptions = {}): ForensicSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDecoding };
diff --git a/src/forensic_sci/decomposition.ts b/src/forensic_sci/decomposition.ts
new file mode 100644
index 000000000..93410c3f8
--- /dev/null
+++ b/src/forensic_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** forensic_sci decomposition module — tsb analytics library. */
+export interface ForensicSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeForensicSciDecomposition(data: number[], opts: ForensicSciDecompositionOptions = {}): ForensicSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDecomposition };
diff --git a/src/forensic_sci/detection.ts b/src/forensic_sci/detection.ts
new file mode 100644
index 000000000..c963371ab
--- /dev/null
+++ b/src/forensic_sci/detection.ts
@@ -0,0 +1,14 @@
+/** forensic_sci detection module — tsb analytics library. */
+export interface ForensicSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDetectionResult { values: number[]; converged: boolean; }
+export function computeForensicSciDetection(data: number[], opts: ForensicSciDetectionOptions = {}): ForensicSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDetection };
diff --git a/src/forensic_sci/deterministic.ts b/src/forensic_sci/deterministic.ts
new file mode 100644
index 000000000..69d22773d
--- /dev/null
+++ b/src/forensic_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** forensic_sci deterministic module — tsb analytics library. */
+export interface ForensicSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeForensicSciDeterministic(data: number[], opts: ForensicSciDeterministicOptions = {}): ForensicSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDeterministic };
diff --git a/src/forensic_sci/diagnostics.ts b/src/forensic_sci/diagnostics.ts
new file mode 100644
index 000000000..dc9fa1725
--- /dev/null
+++ b/src/forensic_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** forensic_sci diagnostics module — tsb analytics library. */
+export interface ForensicSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeForensicSciDiagnostics(data: number[], opts: ForensicSciDiagnosticsOptions = {}): ForensicSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDiagnostics };
diff --git a/src/forensic_sci/differential.ts b/src/forensic_sci/differential.ts
new file mode 100644
index 000000000..d9be7f213
--- /dev/null
+++ b/src/forensic_sci/differential.ts
@@ -0,0 +1,14 @@
+/** forensic_sci differential module — tsb analytics library. */
+export interface ForensicSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeForensicSciDifferential(data: number[], opts: ForensicSciDifferentialOptions = {}): ForensicSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDifferential };
diff --git a/src/forensic_sci/discrete.ts b/src/forensic_sci/discrete.ts
new file mode 100644
index 000000000..0c42bb893
--- /dev/null
+++ b/src/forensic_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** forensic_sci discrete module — tsb analytics library. */
+export interface ForensicSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeForensicSciDiscrete(data: number[], opts: ForensicSciDiscreteOptions = {}): ForensicSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDiscrete };
diff --git a/src/forensic_sci/distribution.ts b/src/forensic_sci/distribution.ts
new file mode 100644
index 000000000..757bf3f8a
--- /dev/null
+++ b/src/forensic_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** forensic_sci distribution module — tsb analytics library. */
+export interface ForensicSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDistributionResult { values: number[]; converged: boolean; }
+export function computeForensicSciDistribution(data: number[], opts: ForensicSciDistributionOptions = {}): ForensicSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDistribution };
diff --git a/src/forensic_sci/dynamic.ts b/src/forensic_sci/dynamic.ts
new file mode 100644
index 000000000..9a4447bca
--- /dev/null
+++ b/src/forensic_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** forensic_sci dynamic module — tsb analytics library. */
+export interface ForensicSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciDynamicResult { values: number[]; converged: boolean; }
+export function computeForensicSciDynamic(data: number[], opts: ForensicSciDynamicOptions = {}): ForensicSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciDynamic };
diff --git a/src/forensic_sci/embedding.ts b/src/forensic_sci/embedding.ts
new file mode 100644
index 000000000..48d3a12de
--- /dev/null
+++ b/src/forensic_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** forensic_sci embedding module — tsb analytics library. */
+export interface ForensicSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeForensicSciEmbedding(data: number[], opts: ForensicSciEmbeddingOptions = {}): ForensicSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciEmbedding };
diff --git a/src/forensic_sci/encoding.ts b/src/forensic_sci/encoding.ts
new file mode 100644
index 000000000..10338f328
--- /dev/null
+++ b/src/forensic_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** forensic_sci encoding module — tsb analytics library. */
+export interface ForensicSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciEncodingResult { values: number[]; converged: boolean; }
+export function computeForensicSciEncoding(data: number[], opts: ForensicSciEncodingOptions = {}): ForensicSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciEncoding };
diff --git a/src/forensic_sci/ensemble.ts b/src/forensic_sci/ensemble.ts
new file mode 100644
index 000000000..4b65f82ea
--- /dev/null
+++ b/src/forensic_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** forensic_sci ensemble module — tsb analytics library. */
+export interface ForensicSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeForensicSciEnsemble(data: number[], opts: ForensicSciEnsembleOptions = {}): ForensicSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciEnsemble };
diff --git a/src/forensic_sci/estimation.ts b/src/forensic_sci/estimation.ts
new file mode 100644
index 000000000..feb698b0a
--- /dev/null
+++ b/src/forensic_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci estimation module — tsb analytics library. */
+export interface ForensicSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciEstimationResult { values: number[]; converged: boolean; }
+export function computeForensicSciEstimation(data: number[], opts: ForensicSciEstimationOptions = {}): ForensicSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciEstimation };
diff --git a/src/forensic_sci/evaluation.ts b/src/forensic_sci/evaluation.ts
new file mode 100644
index 000000000..905afae48
--- /dev/null
+++ b/src/forensic_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci evaluation module — tsb analytics library. */
+export interface ForensicSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeForensicSciEvaluation(data: number[], opts: ForensicSciEvaluationOptions = {}): ForensicSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciEvaluation };
diff --git a/src/forensic_sci/extrapolation.ts b/src/forensic_sci/extrapolation.ts
new file mode 100644
index 000000000..dd705d4dd
--- /dev/null
+++ b/src/forensic_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci extrapolation module — tsb analytics library. */
+export interface ForensicSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeForensicSciExtrapolation(data: number[], opts: ForensicSciExtrapolationOptions = {}): ForensicSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciExtrapolation };
diff --git a/src/forensic_sci/features.ts b/src/forensic_sci/features.ts
new file mode 100644
index 000000000..d69043463
--- /dev/null
+++ b/src/forensic_sci/features.ts
@@ -0,0 +1,14 @@
+/** forensic_sci features module — tsb analytics library. */
+export interface ForensicSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeForensicSciFeatures(data: number[], opts: ForensicSciFeaturesOptions = {}): ForensicSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciFeatures };
diff --git a/src/forensic_sci/feedback.ts b/src/forensic_sci/feedback.ts
new file mode 100644
index 000000000..804b94030
--- /dev/null
+++ b/src/forensic_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** forensic_sci feedback module — tsb analytics library. */
+export interface ForensicSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeForensicSciFeedback(data: number[], opts: ForensicSciFeedbackOptions = {}): ForensicSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciFeedback };
diff --git a/src/forensic_sci/filtering.ts b/src/forensic_sci/filtering.ts
new file mode 100644
index 000000000..d944a95b6
--- /dev/null
+++ b/src/forensic_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** forensic_sci filtering module — tsb analytics library. */
+export interface ForensicSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciFilteringResult { values: number[]; converged: boolean; }
+export function computeForensicSciFiltering(data: number[], opts: ForensicSciFilteringOptions = {}): ForensicSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciFiltering };
diff --git a/src/forensic_sci/fourier.ts b/src/forensic_sci/fourier.ts
new file mode 100644
index 000000000..502e50fc2
--- /dev/null
+++ b/src/forensic_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** forensic_sci fourier module — tsb analytics library. */
+export interface ForensicSciFourierOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciFourierResult { values: number[]; converged: boolean; }
+export function computeForensicSciFourier(data: number[], opts: ForensicSciFourierOptions = {}): ForensicSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciFourier };
diff --git a/src/forensic_sci/fusion.ts b/src/forensic_sci/fusion.ts
new file mode 100644
index 000000000..0fab28239
--- /dev/null
+++ b/src/forensic_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** forensic_sci fusion module — tsb analytics library. */
+export interface ForensicSciFusionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciFusionResult { values: number[]; converged: boolean; }
+export function computeForensicSciFusion(data: number[], opts: ForensicSciFusionOptions = {}): ForensicSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciFusion };
diff --git a/src/forensic_sci/generation.ts b/src/forensic_sci/generation.ts
new file mode 100644
index 000000000..6e009f80e
--- /dev/null
+++ b/src/forensic_sci/generation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci generation module — tsb analytics library. */
+export interface ForensicSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciGenerationResult { values: number[]; converged: boolean; }
+export function computeForensicSciGeneration(data: number[], opts: ForensicSciGenerationOptions = {}): ForensicSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciGeneration };
diff --git a/src/forensic_sci/geometry.ts b/src/forensic_sci/geometry.ts
new file mode 100644
index 000000000..57d7700fc
--- /dev/null
+++ b/src/forensic_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** forensic_sci geometry module — tsb analytics library. */
+export interface ForensicSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciGeometryResult { values: number[]; converged: boolean; }
+export function computeForensicSciGeometry(data: number[], opts: ForensicSciGeometryOptions = {}): ForensicSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciGeometry };
diff --git a/src/forensic_sci/gradient.ts b/src/forensic_sci/gradient.ts
new file mode 100644
index 000000000..835f3c9ce
--- /dev/null
+++ b/src/forensic_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** forensic_sci gradient module — tsb analytics library. */
+export interface ForensicSciGradientOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciGradientResult { values: number[]; converged: boolean; }
+export function computeForensicSciGradient(data: number[], opts: ForensicSciGradientOptions = {}): ForensicSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciGradient };
diff --git a/src/forensic_sci/hessian.ts b/src/forensic_sci/hessian.ts
new file mode 100644
index 000000000..c4db6f542
--- /dev/null
+++ b/src/forensic_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** forensic_sci hessian module — tsb analytics library. */
+export interface ForensicSciHessianOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciHessianResult { values: number[]; converged: boolean; }
+export function computeForensicSciHessian(data: number[], opts: ForensicSciHessianOptions = {}): ForensicSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciHessian };
diff --git a/src/forensic_sci/hypothesis.ts b/src/forensic_sci/hypothesis.ts
new file mode 100644
index 000000000..9deede477
--- /dev/null
+++ b/src/forensic_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** forensic_sci hypothesis module — tsb analytics library. */
+export interface ForensicSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeForensicSciHypothesis(data: number[], opts: ForensicSciHypothesisOptions = {}): ForensicSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciHypothesis };
diff --git a/src/forensic_sci/inference.ts b/src/forensic_sci/inference.ts
new file mode 100644
index 000000000..01797c15c
--- /dev/null
+++ b/src/forensic_sci/inference.ts
@@ -0,0 +1,14 @@
+/** forensic_sci inference module — tsb analytics library. */
+export interface ForensicSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciInferenceResult { values: number[]; converged: boolean; }
+export function computeForensicSciInference(data: number[], opts: ForensicSciInferenceOptions = {}): ForensicSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciInference };
diff --git a/src/forensic_sci/inference2.ts b/src/forensic_sci/inference2.ts
new file mode 100644
index 000000000..926b7cc7f
--- /dev/null
+++ b/src/forensic_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** forensic_sci inference2 module — tsb analytics library. */
+export interface ForensicSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciInferenceResult { values: number[]; converged: boolean; }
+export function computeForensicSciInference(data: number[], opts: ForensicSciInferenceOptions = {}): ForensicSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciInference };
diff --git a/src/forensic_sci/integral.ts b/src/forensic_sci/integral.ts
new file mode 100644
index 000000000..f3b4772c0
--- /dev/null
+++ b/src/forensic_sci/integral.ts
@@ -0,0 +1,14 @@
+/** forensic_sci integral module — tsb analytics library. */
+export interface ForensicSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciIntegralResult { values: number[]; converged: boolean; }
+export function computeForensicSciIntegral(data: number[], opts: ForensicSciIntegralOptions = {}): ForensicSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciIntegral };
diff --git a/src/forensic_sci/integration.ts b/src/forensic_sci/integration.ts
new file mode 100644
index 000000000..df0f3fe60
--- /dev/null
+++ b/src/forensic_sci/integration.ts
@@ -0,0 +1,14 @@
+/** forensic_sci integration module — tsb analytics library. */
+export interface ForensicSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeForensicSciIntegration(data: number[], opts: ForensicSciIntegrationOptions = {}): ForensicSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciIntegration };
diff --git a/src/forensic_sci/interpolation.ts b/src/forensic_sci/interpolation.ts
new file mode 100644
index 000000000..47c37f4cf
--- /dev/null
+++ b/src/forensic_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci interpolation module — tsb analytics library. */
+export interface ForensicSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeForensicSciInterpolation(data: number[], opts: ForensicSciInterpolationOptions = {}): ForensicSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciInterpolation };
diff --git a/src/forensic_sci/jacobian.ts b/src/forensic_sci/jacobian.ts
new file mode 100644
index 000000000..cbcf89078
--- /dev/null
+++ b/src/forensic_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** forensic_sci jacobian module — tsb analytics library. */
+export interface ForensicSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciJacobianResult { values: number[]; converged: boolean; }
+export function computeForensicSciJacobian(data: number[], opts: ForensicSciJacobianOptions = {}): ForensicSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciJacobian };
diff --git a/src/forensic_sci/kernel.ts b/src/forensic_sci/kernel.ts
new file mode 100644
index 000000000..a29a205a8
--- /dev/null
+++ b/src/forensic_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** forensic_sci kernel module — tsb analytics library. */
+export interface ForensicSciKernelOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciKernelResult { values: number[]; converged: boolean; }
+export function computeForensicSciKernel(data: number[], opts: ForensicSciKernelOptions = {}): ForensicSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciKernel };
diff --git a/src/forensic_sci/laplacian.ts b/src/forensic_sci/laplacian.ts
new file mode 100644
index 000000000..d7a618e1d
--- /dev/null
+++ b/src/forensic_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** forensic_sci laplacian module — tsb analytics library. */
+export interface ForensicSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeForensicSciLaplacian(data: number[], opts: ForensicSciLaplacianOptions = {}): ForensicSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciLaplacian };
diff --git a/src/forensic_sci/learning.ts b/src/forensic_sci/learning.ts
new file mode 100644
index 000000000..86ec13ce2
--- /dev/null
+++ b/src/forensic_sci/learning.ts
@@ -0,0 +1,14 @@
+/** forensic_sci learning module — tsb analytics library. */
+export interface ForensicSciLearningOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciLearningResult { values: number[]; converged: boolean; }
+export function computeForensicSciLearning(data: number[], opts: ForensicSciLearningOptions = {}): ForensicSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciLearning };
diff --git a/src/forensic_sci/linear.ts b/src/forensic_sci/linear.ts
new file mode 100644
index 000000000..75014f082
--- /dev/null
+++ b/src/forensic_sci/linear.ts
@@ -0,0 +1,14 @@
+/** forensic_sci linear module — tsb analytics library. */
+export interface ForensicSciLinearOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciLinearResult { values: number[]; converged: boolean; }
+export function computeForensicSciLinear(data: number[], opts: ForensicSciLinearOptions = {}): ForensicSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciLinear };
diff --git a/src/forensic_sci/manifold.ts b/src/forensic_sci/manifold.ts
new file mode 100644
index 000000000..3bcbbda41
--- /dev/null
+++ b/src/forensic_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** forensic_sci manifold module — tsb analytics library. */
+export interface ForensicSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciManifoldResult { values: number[]; converged: boolean; }
+export function computeForensicSciManifold(data: number[], opts: ForensicSciManifoldOptions = {}): ForensicSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciManifold };
diff --git a/src/forensic_sci/matching.ts b/src/forensic_sci/matching.ts
new file mode 100644
index 000000000..36e43cea7
--- /dev/null
+++ b/src/forensic_sci/matching.ts
@@ -0,0 +1,14 @@
+/** forensic_sci matching module — tsb analytics library. */
+export interface ForensicSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciMatchingResult { values: number[]; converged: boolean; }
+export function computeForensicSciMatching(data: number[], opts: ForensicSciMatchingOptions = {}): ForensicSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciMatching };
diff --git a/src/forensic_sci/measurement.ts b/src/forensic_sci/measurement.ts
new file mode 100644
index 000000000..620039cc6
--- /dev/null
+++ b/src/forensic_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** forensic_sci measurement module — tsb analytics library. */
+export interface ForensicSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeForensicSciMeasurement(data: number[], opts: ForensicSciMeasurementOptions = {}): ForensicSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciMeasurement };
diff --git a/src/forensic_sci/metrics.ts b/src/forensic_sci/metrics.ts
new file mode 100644
index 000000000..febc091be
--- /dev/null
+++ b/src/forensic_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** forensic_sci metrics module — tsb analytics library. */
+export interface ForensicSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciMetricsResult { values: number[]; converged: boolean; }
+export function computeForensicSciMetrics(data: number[], opts: ForensicSciMetricsOptions = {}): ForensicSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciMetrics };
diff --git a/src/forensic_sci/modeling.ts b/src/forensic_sci/modeling.ts
new file mode 100644
index 000000000..bf29fc689
--- /dev/null
+++ b/src/forensic_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** forensic_sci modeling module — tsb analytics library. */
+export interface ForensicSciModelingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciModelingResult { values: number[]; converged: boolean; }
+export function computeForensicSciModeling(data: number[], opts: ForensicSciModelingOptions = {}): ForensicSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciModeling };
diff --git a/src/forensic_sci/monitoring.ts b/src/forensic_sci/monitoring.ts
new file mode 100644
index 000000000..40a979b8b
--- /dev/null
+++ b/src/forensic_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** forensic_sci monitoring module — tsb analytics library. */
+export interface ForensicSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeForensicSciMonitoring(data: number[], opts: ForensicSciMonitoringOptions = {}): ForensicSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciMonitoring };
diff --git a/src/forensic_sci/nonlinear.ts b/src/forensic_sci/nonlinear.ts
new file mode 100644
index 000000000..c749f26da
--- /dev/null
+++ b/src/forensic_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** forensic_sci nonlinear module — tsb analytics library. */
+export interface ForensicSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeForensicSciNonlinear(data: number[], opts: ForensicSciNonlinearOptions = {}): ForensicSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciNonlinear };
diff --git a/src/forensic_sci/normalization.ts b/src/forensic_sci/normalization.ts
new file mode 100644
index 000000000..6ec8dcfe4
--- /dev/null
+++ b/src/forensic_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** forensic_sci normalization module — tsb analytics library. */
+export interface ForensicSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeForensicSciNormalization(data: number[], opts: ForensicSciNormalizationOptions = {}): ForensicSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciNormalization };
diff --git a/src/forensic_sci/optimization.ts b/src/forensic_sci/optimization.ts
new file mode 100644
index 000000000..2f882b386
--- /dev/null
+++ b/src/forensic_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** forensic_sci optimization module — tsb analytics library. */
+export interface ForensicSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeForensicSciOptimization(data: number[], opts: ForensicSciOptimizationOptions = {}): ForensicSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciOptimization };
diff --git a/src/forensic_sci/patterns.ts b/src/forensic_sci/patterns.ts
new file mode 100644
index 000000000..d6e77f530
--- /dev/null
+++ b/src/forensic_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** forensic_sci patterns module — tsb analytics library. */
+export interface ForensicSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciPatternsResult { values: number[]; converged: boolean; }
+export function computeForensicSciPatterns(data: number[], opts: ForensicSciPatternsOptions = {}): ForensicSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciPatterns };
diff --git a/src/forensic_sci/permutation.ts b/src/forensic_sci/permutation.ts
new file mode 100644
index 000000000..fdeb9fa90
--- /dev/null
+++ b/src/forensic_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci permutation module — tsb analytics library. */
+export interface ForensicSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciPermutationResult { values: number[]; converged: boolean; }
+export function computeForensicSciPermutation(data: number[], opts: ForensicSciPermutationOptions = {}): ForensicSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciPermutation };
diff --git a/src/forensic_sci/prediction.ts b/src/forensic_sci/prediction.ts
new file mode 100644
index 000000000..ffc6a6c75
--- /dev/null
+++ b/src/forensic_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** forensic_sci prediction module — tsb analytics library. */
+export interface ForensicSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciPredictionResult { values: number[]; converged: boolean; }
+export function computeForensicSciPrediction(data: number[], opts: ForensicSciPredictionOptions = {}): ForensicSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciPrediction };
diff --git a/src/forensic_sci/processing.ts b/src/forensic_sci/processing.ts
new file mode 100644
index 000000000..bfc31af93
--- /dev/null
+++ b/src/forensic_sci/processing.ts
@@ -0,0 +1,14 @@
+/** forensic_sci processing module — tsb analytics library. */
+export interface ForensicSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciProcessingResult { values: number[]; converged: boolean; }
+export function computeForensicSciProcessing(data: number[], opts: ForensicSciProcessingOptions = {}): ForensicSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciProcessing };
diff --git a/src/forensic_sci/profiling.ts b/src/forensic_sci/profiling.ts
new file mode 100644
index 000000000..7cbac0786
--- /dev/null
+++ b/src/forensic_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** forensic_sci profiling module — tsb analytics library. */
+export interface ForensicSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciProfilingResult { values: number[]; converged: boolean; }
+export function computeForensicSciProfiling(data: number[], opts: ForensicSciProfilingOptions = {}): ForensicSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciProfiling };
diff --git a/src/forensic_sci/projection.ts b/src/forensic_sci/projection.ts
new file mode 100644
index 000000000..940ed0f63
--- /dev/null
+++ b/src/forensic_sci/projection.ts
@@ -0,0 +1,14 @@
+/** forensic_sci projection module — tsb analytics library. */
+export interface ForensicSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciProjectionResult { values: number[]; converged: boolean; }
+export function computeForensicSciProjection(data: number[], opts: ForensicSciProjectionOptions = {}): ForensicSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciProjection };
diff --git a/src/forensic_sci/ranking.ts b/src/forensic_sci/ranking.ts
new file mode 100644
index 000000000..920e332b9
--- /dev/null
+++ b/src/forensic_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** forensic_sci ranking module — tsb analytics library. */
+export interface ForensicSciRankingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciRankingResult { values: number[]; converged: boolean; }
+export function computeForensicSciRanking(data: number[], opts: ForensicSciRankingOptions = {}): ForensicSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciRanking };
diff --git a/src/forensic_sci/reconstruction.ts b/src/forensic_sci/reconstruction.ts
new file mode 100644
index 000000000..7db440120
--- /dev/null
+++ b/src/forensic_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** forensic_sci reconstruction module — tsb analytics library. */
+export interface ForensicSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeForensicSciReconstruction(data: number[], opts: ForensicSciReconstructionOptions = {}): ForensicSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciReconstruction };
diff --git a/src/forensic_sci/registration.ts b/src/forensic_sci/registration.ts
new file mode 100644
index 000000000..6484f247a
--- /dev/null
+++ b/src/forensic_sci/registration.ts
@@ -0,0 +1,14 @@
+/** forensic_sci registration module — tsb analytics library. */
+export interface ForensicSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeForensicSciRegistration(data: number[], opts: ForensicSciRegistrationOptions = {}): ForensicSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciRegistration };
diff --git a/src/forensic_sci/regression.ts b/src/forensic_sci/regression.ts
new file mode 100644
index 000000000..04972b303
--- /dev/null
+++ b/src/forensic_sci/regression.ts
@@ -0,0 +1,14 @@
+/** forensic_sci regression module — tsb analytics library. */
+export interface ForensicSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciRegressionResult { values: number[]; converged: boolean; }
+export function computeForensicSciRegression(data: number[], opts: ForensicSciRegressionOptions = {}): ForensicSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciRegression };
diff --git a/src/forensic_sci/regularization.ts b/src/forensic_sci/regularization.ts
new file mode 100644
index 000000000..9cc58895f
--- /dev/null
+++ b/src/forensic_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** forensic_sci regularization module — tsb analytics library. */
+export interface ForensicSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeForensicSciRegularization(data: number[], opts: ForensicSciRegularizationOptions = {}): ForensicSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciRegularization };
diff --git a/src/forensic_sci/robustness.ts b/src/forensic_sci/robustness.ts
new file mode 100644
index 000000000..f9f543058
--- /dev/null
+++ b/src/forensic_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** forensic_sci robustness module — tsb analytics library. */
+export interface ForensicSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeForensicSciRobustness(data: number[], opts: ForensicSciRobustnessOptions = {}): ForensicSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciRobustness };
diff --git a/src/forensic_sci/sampling.ts b/src/forensic_sci/sampling.ts
new file mode 100644
index 000000000..a9e04989b
--- /dev/null
+++ b/src/forensic_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** forensic_sci sampling module — tsb analytics library. */
+export interface ForensicSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciSamplingResult { values: number[]; converged: boolean; }
+export function computeForensicSciSampling(data: number[], opts: ForensicSciSamplingOptions = {}): ForensicSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciSampling };
diff --git a/src/forensic_sci/sampling2.ts b/src/forensic_sci/sampling2.ts
new file mode 100644
index 000000000..3bdd936cd
--- /dev/null
+++ b/src/forensic_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** forensic_sci sampling2 module — tsb analytics library. */
+export interface ForensicSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciSamplingResult { values: number[]; converged: boolean; }
+export function computeForensicSciSampling(data: number[], opts: ForensicSciSamplingOptions = {}): ForensicSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciSampling };
diff --git a/src/forensic_sci/scaling.ts b/src/forensic_sci/scaling.ts
new file mode 100644
index 000000000..93d0ebca4
--- /dev/null
+++ b/src/forensic_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** forensic_sci scaling module — tsb analytics library. */
+export interface ForensicSciScalingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciScalingResult { values: number[]; converged: boolean; }
+export function computeForensicSciScaling(data: number[], opts: ForensicSciScalingOptions = {}): ForensicSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciScaling };
diff --git a/src/forensic_sci/scoring.ts b/src/forensic_sci/scoring.ts
new file mode 100644
index 000000000..22c78040b
--- /dev/null
+++ b/src/forensic_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** forensic_sci scoring module — tsb analytics library. */
+export interface ForensicSciScoringOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciScoringResult { values: number[]; converged: boolean; }
+export function computeForensicSciScoring(data: number[], opts: ForensicSciScoringOptions = {}): ForensicSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciScoring };
diff --git a/src/forensic_sci/segmentation.ts b/src/forensic_sci/segmentation.ts
new file mode 100644
index 000000000..256f8b8a6
--- /dev/null
+++ b/src/forensic_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci segmentation module — tsb analytics library. */
+export interface ForensicSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeForensicSciSegmentation(data: number[], opts: ForensicSciSegmentationOptions = {}): ForensicSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciSegmentation };
diff --git a/src/forensic_sci/selection.ts b/src/forensic_sci/selection.ts
new file mode 100644
index 000000000..d7cb01162
--- /dev/null
+++ b/src/forensic_sci/selection.ts
@@ -0,0 +1,14 @@
+/** forensic_sci selection module — tsb analytics library. */
+export interface ForensicSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciSelectionResult { values: number[]; converged: boolean; }
+export function computeForensicSciSelection(data: number[], opts: ForensicSciSelectionOptions = {}): ForensicSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciSelection };
diff --git a/src/forensic_sci/sensitivity.ts b/src/forensic_sci/sensitivity.ts
new file mode 100644
index 000000000..2b5d63250
--- /dev/null
+++ b/src/forensic_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** forensic_sci sensitivity module — tsb analytics library. */
+export interface ForensicSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeForensicSciSensitivity(data: number[], opts: ForensicSciSensitivityOptions = {}): ForensicSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciSensitivity };
diff --git a/src/forensic_sci/simulation.ts b/src/forensic_sci/simulation.ts
new file mode 100644
index 000000000..9d38535b2
--- /dev/null
+++ b/src/forensic_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci simulation module — tsb analytics library. */
+export interface ForensicSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciSimulationResult { values: number[]; converged: boolean; }
+export function computeForensicSciSimulation(data: number[], opts: ForensicSciSimulationOptions = {}): ForensicSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciSimulation };
diff --git a/src/forensic_sci/smoothing.ts b/src/forensic_sci/smoothing.ts
new file mode 100644
index 000000000..a3f589660
--- /dev/null
+++ b/src/forensic_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** forensic_sci smoothing module — tsb analytics library. */
+export interface ForensicSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeForensicSciSmoothing(data: number[], opts: ForensicSciSmoothingOptions = {}): ForensicSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciSmoothing };
diff --git a/src/forensic_sci/stability.ts b/src/forensic_sci/stability.ts
new file mode 100644
index 000000000..dc5f89e0b
--- /dev/null
+++ b/src/forensic_sci/stability.ts
@@ -0,0 +1,14 @@
+/** forensic_sci stability module — tsb analytics library. */
+export interface ForensicSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciStabilityResult { values: number[]; converged: boolean; }
+export function computeForensicSciStability(data: number[], opts: ForensicSciStabilityOptions = {}): ForensicSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciStability };
diff --git a/src/forensic_sci/stacking.ts b/src/forensic_sci/stacking.ts
new file mode 100644
index 000000000..7f178cc13
--- /dev/null
+++ b/src/forensic_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** forensic_sci stacking module — tsb analytics library. */
+export interface ForensicSciStackingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciStackingResult { values: number[]; converged: boolean; }
+export function computeForensicSciStacking(data: number[], opts: ForensicSciStackingOptions = {}): ForensicSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciStacking };
diff --git a/src/forensic_sci/standardization.ts b/src/forensic_sci/standardization.ts
new file mode 100644
index 000000000..3ea505538
--- /dev/null
+++ b/src/forensic_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** forensic_sci standardization module — tsb analytics library. */
+export interface ForensicSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeForensicSciStandardization(data: number[], opts: ForensicSciStandardizationOptions = {}): ForensicSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciStandardization };
diff --git a/src/forensic_sci/static.ts b/src/forensic_sci/static.ts
new file mode 100644
index 000000000..3f570687b
--- /dev/null
+++ b/src/forensic_sci/static.ts
@@ -0,0 +1,14 @@
+/** forensic_sci static module — tsb analytics library. */
+export interface ForensicSciStaticOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciStaticResult { values: number[]; converged: boolean; }
+export function computeForensicSciStatic(data: number[], opts: ForensicSciStaticOptions = {}): ForensicSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciStatic };
diff --git a/src/forensic_sci/stochastic.ts b/src/forensic_sci/stochastic.ts
new file mode 100644
index 000000000..992bf3bc5
--- /dev/null
+++ b/src/forensic_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** forensic_sci stochastic module — tsb analytics library. */
+export interface ForensicSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciStochasticResult { values: number[]; converged: boolean; }
+export function computeForensicSciStochastic(data: number[], opts: ForensicSciStochasticOptions = {}): ForensicSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciStochastic };
diff --git a/src/forensic_sci/synthesis.ts b/src/forensic_sci/synthesis.ts
new file mode 100644
index 000000000..5d68ccfcc
--- /dev/null
+++ b/src/forensic_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** forensic_sci synthesis module — tsb analytics library. */
+export interface ForensicSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeForensicSciSynthesis(data: number[], opts: ForensicSciSynthesisOptions = {}): ForensicSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciSynthesis };
diff --git a/src/forensic_sci/topology.ts b/src/forensic_sci/topology.ts
new file mode 100644
index 000000000..3ae30bbf3
--- /dev/null
+++ b/src/forensic_sci/topology.ts
@@ -0,0 +1,14 @@
+/** forensic_sci topology module — tsb analytics library. */
+export interface ForensicSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciTopologyResult { values: number[]; converged: boolean; }
+export function computeForensicSciTopology(data: number[], opts: ForensicSciTopologyOptions = {}): ForensicSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciTopology };
diff --git a/src/forensic_sci/tracking.ts b/src/forensic_sci/tracking.ts
new file mode 100644
index 000000000..a09ab539f
--- /dev/null
+++ b/src/forensic_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** forensic_sci tracking module — tsb analytics library. */
+export interface ForensicSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciTrackingResult { values: number[]; converged: boolean; }
+export function computeForensicSciTracking(data: number[], opts: ForensicSciTrackingOptions = {}): ForensicSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciTracking };
diff --git a/src/forensic_sci/transform.ts b/src/forensic_sci/transform.ts
new file mode 100644
index 000000000..0d11e99e8
--- /dev/null
+++ b/src/forensic_sci/transform.ts
@@ -0,0 +1,14 @@
+/** forensic_sci transform module — tsb analytics library. */
+export interface ForensicSciTransformOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciTransformResult { values: number[]; converged: boolean; }
+export function computeForensicSciTransform(data: number[], opts: ForensicSciTransformOptions = {}): ForensicSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciTransform };
diff --git a/src/forensic_sci/uncertainty.ts b/src/forensic_sci/uncertainty.ts
new file mode 100644
index 000000000..bed9eb72d
--- /dev/null
+++ b/src/forensic_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** forensic_sci uncertainty module — tsb analytics library. */
+export interface ForensicSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeForensicSciUncertainty(data: number[], opts: ForensicSciUncertaintyOptions = {}): ForensicSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciUncertainty };
diff --git a/src/forensic_sci/validation.ts b/src/forensic_sci/validation.ts
new file mode 100644
index 000000000..6ede0c70d
--- /dev/null
+++ b/src/forensic_sci/validation.ts
@@ -0,0 +1,14 @@
+/** forensic_sci validation module — tsb analytics library. */
+export interface ForensicSciValidationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciValidationResult { values: number[]; converged: boolean; }
+export function computeForensicSciValidation(data: number[], opts: ForensicSciValidationOptions = {}): ForensicSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciValidation };
diff --git a/src/forensic_sci/verification.ts b/src/forensic_sci/verification.ts
new file mode 100644
index 000000000..cbdb73b47
--- /dev/null
+++ b/src/forensic_sci/verification.ts
@@ -0,0 +1,14 @@
+/** forensic_sci verification module — tsb analytics library. */
+export interface ForensicSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciVerificationResult { values: number[]; converged: boolean; }
+export function computeForensicSciVerification(data: number[], opts: ForensicSciVerificationOptions = {}): ForensicSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciVerification };
diff --git a/src/forensic_sci/visualization.ts b/src/forensic_sci/visualization.ts
new file mode 100644
index 000000000..a94a72764
--- /dev/null
+++ b/src/forensic_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** forensic_sci visualization module — tsb analytics library. */
+export interface ForensicSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeForensicSciVisualization(data: number[], opts: ForensicSciVisualizationOptions = {}): ForensicSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciVisualization };
diff --git a/src/forensic_sci/voting.ts b/src/forensic_sci/voting.ts
new file mode 100644
index 000000000..fb0bfb0bf
--- /dev/null
+++ b/src/forensic_sci/voting.ts
@@ -0,0 +1,14 @@
+/** forensic_sci voting module — tsb analytics library. */
+export interface ForensicSciVotingOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciVotingResult { values: number[]; converged: boolean; }
+export function computeForensicSciVoting(data: number[], opts: ForensicSciVotingOptions = {}): ForensicSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciVoting };
diff --git a/src/forensic_sci/wavelet.ts b/src/forensic_sci/wavelet.ts
new file mode 100644
index 000000000..751ddd9df
--- /dev/null
+++ b/src/forensic_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** forensic_sci wavelet module — tsb analytics library. */
+export interface ForensicSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface ForensicSciWaveletResult { values: number[]; converged: boolean; }
+export function computeForensicSciWavelet(data: number[], opts: ForensicSciWaveletOptions = {}): ForensicSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForensicSciWavelet };
diff --git a/src/forestry_sci/adaptation.ts b/src/forestry_sci/adaptation.ts
new file mode 100644
index 000000000..e9c4a0ff5
--- /dev/null
+++ b/src/forestry_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci adaptation module — tsb analytics library. */
+export interface ForestrySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeForestrySciAdaptation(data: number[], opts: ForestrySciAdaptationOptions = {}): ForestrySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciAdaptation };
diff --git a/src/forestry_sci/aggregation.ts b/src/forestry_sci/aggregation.ts
new file mode 100644
index 000000000..9681279c3
--- /dev/null
+++ b/src/forestry_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci aggregation module — tsb analytics library. */
+export interface ForestrySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciAggregationResult { values: number[]; converged: boolean; }
+export function computeForestrySciAggregation(data: number[], opts: ForestrySciAggregationOptions = {}): ForestrySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciAggregation };
diff --git a/src/forestry_sci/algebra.ts b/src/forestry_sci/algebra.ts
new file mode 100644
index 000000000..8fd653b0e
--- /dev/null
+++ b/src/forestry_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** forestry_sci algebra module — tsb analytics library. */
+export interface ForestrySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeForestrySciAlgebra(data: number[], opts: ForestrySciAlgebraOptions = {}): ForestrySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciAlgebra };
diff --git a/src/forestry_sci/alignment.ts b/src/forestry_sci/alignment.ts
new file mode 100644
index 000000000..07f52cbff
--- /dev/null
+++ b/src/forestry_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** forestry_sci alignment module — tsb analytics library. */
+export interface ForestrySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeForestrySciAlignment(data: number[], opts: ForestrySciAlignmentOptions = {}): ForestrySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciAlignment };
diff --git a/src/forestry_sci/analysis.ts b/src/forestry_sci/analysis.ts
new file mode 100644
index 000000000..7cf06622b
--- /dev/null
+++ b/src/forestry_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** forestry_sci analysis module — tsb analytics library. */
+export interface ForestrySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeForestrySciAnalysis(data: number[], opts: ForestrySciAnalysisOptions = {}): ForestrySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciAnalysis };
diff --git a/src/forestry_sci/augmentation.ts b/src/forestry_sci/augmentation.ts
new file mode 100644
index 000000000..c39333528
--- /dev/null
+++ b/src/forestry_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci augmentation module — tsb analytics library. */
+export interface ForestrySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeForestrySciAugmentation(data: number[], opts: ForestrySciAugmentationOptions = {}): ForestrySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciAugmentation };
diff --git a/src/forestry_sci/bagging.ts b/src/forestry_sci/bagging.ts
new file mode 100644
index 000000000..22d7f128a
--- /dev/null
+++ b/src/forestry_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** forestry_sci bagging module — tsb analytics library. */
+export interface ForestrySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciBaggingResult { values: number[]; converged: boolean; }
+export function computeForestrySciBagging(data: number[], opts: ForestrySciBaggingOptions = {}): ForestrySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciBagging };
diff --git a/src/forestry_sci/basis.ts b/src/forestry_sci/basis.ts
new file mode 100644
index 000000000..814a7a8f9
--- /dev/null
+++ b/src/forestry_sci/basis.ts
@@ -0,0 +1,14 @@
+/** forestry_sci basis module — tsb analytics library. */
+export interface ForestrySciBasisOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciBasisResult { values: number[]; converged: boolean; }
+export function computeForestrySciBasis(data: number[], opts: ForestrySciBasisOptions = {}): ForestrySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciBasis };
diff --git a/src/forestry_sci/benchmarking.ts b/src/forestry_sci/benchmarking.ts
new file mode 100644
index 000000000..0257a559f
--- /dev/null
+++ b/src/forestry_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** forestry_sci benchmarking module — tsb analytics library. */
+export interface ForestrySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeForestrySciBenchmarking(data: number[], opts: ForestrySciBenchmarkingOptions = {}): ForestrySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciBenchmarking };
diff --git a/src/forestry_sci/blending.ts b/src/forestry_sci/blending.ts
new file mode 100644
index 000000000..b18af4da5
--- /dev/null
+++ b/src/forestry_sci/blending.ts
@@ -0,0 +1,14 @@
+/** forestry_sci blending module — tsb analytics library. */
+export interface ForestrySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciBlendingResult { values: number[]; converged: boolean; }
+export function computeForestrySciBlending(data: number[], opts: ForestrySciBlendingOptions = {}): ForestrySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciBlending };
diff --git a/src/forestry_sci/boosting.ts b/src/forestry_sci/boosting.ts
new file mode 100644
index 000000000..89e40e0ee
--- /dev/null
+++ b/src/forestry_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** forestry_sci boosting module — tsb analytics library. */
+export interface ForestrySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciBoostingResult { values: number[]; converged: boolean; }
+export function computeForestrySciBoosting(data: number[], opts: ForestrySciBoostingOptions = {}): ForestrySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciBoosting };
diff --git a/src/forestry_sci/bootstrap.ts b/src/forestry_sci/bootstrap.ts
new file mode 100644
index 000000000..89a88b609
--- /dev/null
+++ b/src/forestry_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** forestry_sci bootstrap module — tsb analytics library. */
+export interface ForestrySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeForestrySciBootstrap(data: number[], opts: ForestrySciBootstrapOptions = {}): ForestrySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciBootstrap };
diff --git a/src/forestry_sci/calculus.ts b/src/forestry_sci/calculus.ts
new file mode 100644
index 000000000..55f8ddb6c
--- /dev/null
+++ b/src/forestry_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** forestry_sci calculus module — tsb analytics library. */
+export interface ForestrySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciCalculusResult { values: number[]; converged: boolean; }
+export function computeForestrySciCalculus(data: number[], opts: ForestrySciCalculusOptions = {}): ForestrySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciCalculus };
diff --git a/src/forestry_sci/calibration.ts b/src/forestry_sci/calibration.ts
new file mode 100644
index 000000000..1a4d8b9f0
--- /dev/null
+++ b/src/forestry_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** forestry_sci calibration module — tsb analytics library. */
+export interface ForestrySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeForestrySciCalibration(data: number[], opts: ForestrySciCalibrationOptions = {}): ForestrySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciCalibration };
diff --git a/src/forestry_sci/characterization.ts b/src/forestry_sci/characterization.ts
new file mode 100644
index 000000000..f1ebfa3f0
--- /dev/null
+++ b/src/forestry_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** forestry_sci characterization module — tsb analytics library. */
+export interface ForestrySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeForestrySciCharacterization(data: number[], opts: ForestrySciCharacterizationOptions = {}): ForestrySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciCharacterization };
diff --git a/src/forestry_sci/classification.ts b/src/forestry_sci/classification.ts
new file mode 100644
index 000000000..ecf373c5b
--- /dev/null
+++ b/src/forestry_sci/classification.ts
@@ -0,0 +1,14 @@
+/** forestry_sci classification module — tsb analytics library. */
+export interface ForestrySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciClassificationResult { values: number[]; converged: boolean; }
+export function computeForestrySciClassification(data: number[], opts: ForestrySciClassificationOptions = {}): ForestrySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciClassification };
diff --git a/src/forestry_sci/clustering.ts b/src/forestry_sci/clustering.ts
new file mode 100644
index 000000000..e0d398eda
--- /dev/null
+++ b/src/forestry_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** forestry_sci clustering module — tsb analytics library. */
+export interface ForestrySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciClusteringResult { values: number[]; converged: boolean; }
+export function computeForestrySciClustering(data: number[], opts: ForestrySciClusteringOptions = {}): ForestrySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciClustering };
diff --git a/src/forestry_sci/compression.ts b/src/forestry_sci/compression.ts
new file mode 100644
index 000000000..14d8b7612
--- /dev/null
+++ b/src/forestry_sci/compression.ts
@@ -0,0 +1,14 @@
+/** forestry_sci compression module — tsb analytics library. */
+export interface ForestrySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciCompressionResult { values: number[]; converged: boolean; }
+export function computeForestrySciCompression(data: number[], opts: ForestrySciCompressionOptions = {}): ForestrySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciCompression };
diff --git a/src/forestry_sci/continuous.ts b/src/forestry_sci/continuous.ts
new file mode 100644
index 000000000..3226a375b
--- /dev/null
+++ b/src/forestry_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** forestry_sci continuous module — tsb analytics library. */
+export interface ForestrySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciContinuousResult { values: number[]; converged: boolean; }
+export function computeForestrySciContinuous(data: number[], opts: ForestrySciContinuousOptions = {}): ForestrySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciContinuous };
diff --git a/src/forestry_sci/control.ts b/src/forestry_sci/control.ts
new file mode 100644
index 000000000..f949b32e6
--- /dev/null
+++ b/src/forestry_sci/control.ts
@@ -0,0 +1,14 @@
+/** forestry_sci control module — tsb analytics library. */
+export interface ForestrySciControlOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciControlResult { values: number[]; converged: boolean; }
+export function computeForestrySciControl(data: number[], opts: ForestrySciControlOptions = {}): ForestrySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciControl };
diff --git a/src/forestry_sci/convergence.ts b/src/forestry_sci/convergence.ts
new file mode 100644
index 000000000..5a9d8daf7
--- /dev/null
+++ b/src/forestry_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** forestry_sci convergence module — tsb analytics library. */
+export interface ForestrySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeForestrySciConvergence(data: number[], opts: ForestrySciConvergenceOptions = {}): ForestrySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciConvergence };
diff --git a/src/forestry_sci/convex.ts b/src/forestry_sci/convex.ts
new file mode 100644
index 000000000..cdc5bd23a
--- /dev/null
+++ b/src/forestry_sci/convex.ts
@@ -0,0 +1,14 @@
+/** forestry_sci convex module — tsb analytics library. */
+export interface ForestrySciConvexOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciConvexResult { values: number[]; converged: boolean; }
+export function computeForestrySciConvex(data: number[], opts: ForestrySciConvexOptions = {}): ForestrySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciConvex };
diff --git a/src/forestry_sci/correlation.ts b/src/forestry_sci/correlation.ts
new file mode 100644
index 000000000..171410b36
--- /dev/null
+++ b/src/forestry_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci correlation module — tsb analytics library. */
+export interface ForestrySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeForestrySciCorrelation(data: number[], opts: ForestrySciCorrelationOptions = {}): ForestrySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciCorrelation };
diff --git a/src/forestry_sci/covariance.ts b/src/forestry_sci/covariance.ts
new file mode 100644
index 000000000..2111ebb5c
--- /dev/null
+++ b/src/forestry_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** forestry_sci covariance module — tsb analytics library. */
+export interface ForestrySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeForestrySciCovariance(data: number[], opts: ForestrySciCovarianceOptions = {}): ForestrySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciCovariance };
diff --git a/src/forestry_sci/cross_validation.ts b/src/forestry_sci/cross_validation.ts
new file mode 100644
index 000000000..7f987961a
--- /dev/null
+++ b/src/forestry_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci cross_validation module — tsb analytics library. */
+export interface ForestrySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeForestrySciCrossValidation(data: number[], opts: ForestrySciCrossValidationOptions = {}): ForestrySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciCrossValidation };
diff --git a/src/forestry_sci/decoding.ts b/src/forestry_sci/decoding.ts
new file mode 100644
index 000000000..46952fdfe
--- /dev/null
+++ b/src/forestry_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** forestry_sci decoding module — tsb analytics library. */
+export interface ForestrySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDecodingResult { values: number[]; converged: boolean; }
+export function computeForestrySciDecoding(data: number[], opts: ForestrySciDecodingOptions = {}): ForestrySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDecoding };
diff --git a/src/forestry_sci/decomposition.ts b/src/forestry_sci/decomposition.ts
new file mode 100644
index 000000000..79b1c0bd2
--- /dev/null
+++ b/src/forestry_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** forestry_sci decomposition module — tsb analytics library. */
+export interface ForestrySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeForestrySciDecomposition(data: number[], opts: ForestrySciDecompositionOptions = {}): ForestrySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDecomposition };
diff --git a/src/forestry_sci/detection.ts b/src/forestry_sci/detection.ts
new file mode 100644
index 000000000..c50286680
--- /dev/null
+++ b/src/forestry_sci/detection.ts
@@ -0,0 +1,14 @@
+/** forestry_sci detection module — tsb analytics library. */
+export interface ForestrySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDetectionResult { values: number[]; converged: boolean; }
+export function computeForestrySciDetection(data: number[], opts: ForestrySciDetectionOptions = {}): ForestrySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDetection };
diff --git a/src/forestry_sci/deterministic.ts b/src/forestry_sci/deterministic.ts
new file mode 100644
index 000000000..170c632d7
--- /dev/null
+++ b/src/forestry_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** forestry_sci deterministic module — tsb analytics library. */
+export interface ForestrySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeForestrySciDeterministic(data: number[], opts: ForestrySciDeterministicOptions = {}): ForestrySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDeterministic };
diff --git a/src/forestry_sci/diagnostics.ts b/src/forestry_sci/diagnostics.ts
new file mode 100644
index 000000000..1b50798a2
--- /dev/null
+++ b/src/forestry_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** forestry_sci diagnostics module — tsb analytics library. */
+export interface ForestrySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeForestrySciDiagnostics(data: number[], opts: ForestrySciDiagnosticsOptions = {}): ForestrySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDiagnostics };
diff --git a/src/forestry_sci/differential.ts b/src/forestry_sci/differential.ts
new file mode 100644
index 000000000..4d5196c2f
--- /dev/null
+++ b/src/forestry_sci/differential.ts
@@ -0,0 +1,14 @@
+/** forestry_sci differential module — tsb analytics library. */
+export interface ForestrySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeForestrySciDifferential(data: number[], opts: ForestrySciDifferentialOptions = {}): ForestrySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDifferential };
diff --git a/src/forestry_sci/discrete.ts b/src/forestry_sci/discrete.ts
new file mode 100644
index 000000000..e1f97302d
--- /dev/null
+++ b/src/forestry_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** forestry_sci discrete module — tsb analytics library. */
+export interface ForestrySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeForestrySciDiscrete(data: number[], opts: ForestrySciDiscreteOptions = {}): ForestrySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDiscrete };
diff --git a/src/forestry_sci/distribution.ts b/src/forestry_sci/distribution.ts
new file mode 100644
index 000000000..1307f6f5e
--- /dev/null
+++ b/src/forestry_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** forestry_sci distribution module — tsb analytics library. */
+export interface ForestrySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDistributionResult { values: number[]; converged: boolean; }
+export function computeForestrySciDistribution(data: number[], opts: ForestrySciDistributionOptions = {}): ForestrySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDistribution };
diff --git a/src/forestry_sci/dynamic.ts b/src/forestry_sci/dynamic.ts
new file mode 100644
index 000000000..01c4b53fb
--- /dev/null
+++ b/src/forestry_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** forestry_sci dynamic module — tsb analytics library. */
+export interface ForestrySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciDynamicResult { values: number[]; converged: boolean; }
+export function computeForestrySciDynamic(data: number[], opts: ForestrySciDynamicOptions = {}): ForestrySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciDynamic };
diff --git a/src/forestry_sci/embedding.ts b/src/forestry_sci/embedding.ts
new file mode 100644
index 000000000..1040d31cc
--- /dev/null
+++ b/src/forestry_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** forestry_sci embedding module — tsb analytics library. */
+export interface ForestrySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeForestrySciEmbedding(data: number[], opts: ForestrySciEmbeddingOptions = {}): ForestrySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciEmbedding };
diff --git a/src/forestry_sci/encoding.ts b/src/forestry_sci/encoding.ts
new file mode 100644
index 000000000..d85b080e7
--- /dev/null
+++ b/src/forestry_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** forestry_sci encoding module — tsb analytics library. */
+export interface ForestrySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciEncodingResult { values: number[]; converged: boolean; }
+export function computeForestrySciEncoding(data: number[], opts: ForestrySciEncodingOptions = {}): ForestrySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciEncoding };
diff --git a/src/forestry_sci/ensemble.ts b/src/forestry_sci/ensemble.ts
new file mode 100644
index 000000000..6b3f0e56f
--- /dev/null
+++ b/src/forestry_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** forestry_sci ensemble module — tsb analytics library. */
+export interface ForestrySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeForestrySciEnsemble(data: number[], opts: ForestrySciEnsembleOptions = {}): ForestrySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciEnsemble };
diff --git a/src/forestry_sci/estimation.ts b/src/forestry_sci/estimation.ts
new file mode 100644
index 000000000..6683427e5
--- /dev/null
+++ b/src/forestry_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci estimation module — tsb analytics library. */
+export interface ForestrySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciEstimationResult { values: number[]; converged: boolean; }
+export function computeForestrySciEstimation(data: number[], opts: ForestrySciEstimationOptions = {}): ForestrySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciEstimation };
diff --git a/src/forestry_sci/evaluation.ts b/src/forestry_sci/evaluation.ts
new file mode 100644
index 000000000..04782f713
--- /dev/null
+++ b/src/forestry_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci evaluation module — tsb analytics library. */
+export interface ForestrySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeForestrySciEvaluation(data: number[], opts: ForestrySciEvaluationOptions = {}): ForestrySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciEvaluation };
diff --git a/src/forestry_sci/extrapolation.ts b/src/forestry_sci/extrapolation.ts
new file mode 100644
index 000000000..12cc49d2a
--- /dev/null
+++ b/src/forestry_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci extrapolation module — tsb analytics library. */
+export interface ForestrySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeForestrySciExtrapolation(data: number[], opts: ForestrySciExtrapolationOptions = {}): ForestrySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciExtrapolation };
diff --git a/src/forestry_sci/features.ts b/src/forestry_sci/features.ts
new file mode 100644
index 000000000..e3ba650d7
--- /dev/null
+++ b/src/forestry_sci/features.ts
@@ -0,0 +1,14 @@
+/** forestry_sci features module — tsb analytics library. */
+export interface ForestrySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeForestrySciFeatures(data: number[], opts: ForestrySciFeaturesOptions = {}): ForestrySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciFeatures };
diff --git a/src/forestry_sci/feedback.ts b/src/forestry_sci/feedback.ts
new file mode 100644
index 000000000..d786a93a8
--- /dev/null
+++ b/src/forestry_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** forestry_sci feedback module — tsb analytics library. */
+export interface ForestrySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeForestrySciFeedback(data: number[], opts: ForestrySciFeedbackOptions = {}): ForestrySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciFeedback };
diff --git a/src/forestry_sci/filtering.ts b/src/forestry_sci/filtering.ts
new file mode 100644
index 000000000..285481215
--- /dev/null
+++ b/src/forestry_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** forestry_sci filtering module — tsb analytics library. */
+export interface ForestrySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciFilteringResult { values: number[]; converged: boolean; }
+export function computeForestrySciFiltering(data: number[], opts: ForestrySciFilteringOptions = {}): ForestrySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciFiltering };
diff --git a/src/forestry_sci/fourier.ts b/src/forestry_sci/fourier.ts
new file mode 100644
index 000000000..91c573700
--- /dev/null
+++ b/src/forestry_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** forestry_sci fourier module — tsb analytics library. */
+export interface ForestrySciFourierOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciFourierResult { values: number[]; converged: boolean; }
+export function computeForestrySciFourier(data: number[], opts: ForestrySciFourierOptions = {}): ForestrySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciFourier };
diff --git a/src/forestry_sci/fusion.ts b/src/forestry_sci/fusion.ts
new file mode 100644
index 000000000..85e5fc02c
--- /dev/null
+++ b/src/forestry_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** forestry_sci fusion module — tsb analytics library. */
+export interface ForestrySciFusionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciFusionResult { values: number[]; converged: boolean; }
+export function computeForestrySciFusion(data: number[], opts: ForestrySciFusionOptions = {}): ForestrySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciFusion };
diff --git a/src/forestry_sci/generation.ts b/src/forestry_sci/generation.ts
new file mode 100644
index 000000000..e6582dfd8
--- /dev/null
+++ b/src/forestry_sci/generation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci generation module — tsb analytics library. */
+export interface ForestrySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciGenerationResult { values: number[]; converged: boolean; }
+export function computeForestrySciGeneration(data: number[], opts: ForestrySciGenerationOptions = {}): ForestrySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciGeneration };
diff --git a/src/forestry_sci/geometry.ts b/src/forestry_sci/geometry.ts
new file mode 100644
index 000000000..c2bfbbfe1
--- /dev/null
+++ b/src/forestry_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** forestry_sci geometry module — tsb analytics library. */
+export interface ForestrySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciGeometryResult { values: number[]; converged: boolean; }
+export function computeForestrySciGeometry(data: number[], opts: ForestrySciGeometryOptions = {}): ForestrySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciGeometry };
diff --git a/src/forestry_sci/gradient.ts b/src/forestry_sci/gradient.ts
new file mode 100644
index 000000000..4006cdf73
--- /dev/null
+++ b/src/forestry_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** forestry_sci gradient module — tsb analytics library. */
+export interface ForestrySciGradientOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciGradientResult { values: number[]; converged: boolean; }
+export function computeForestrySciGradient(data: number[], opts: ForestrySciGradientOptions = {}): ForestrySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciGradient };
diff --git a/src/forestry_sci/hessian.ts b/src/forestry_sci/hessian.ts
new file mode 100644
index 000000000..8cca8fcd1
--- /dev/null
+++ b/src/forestry_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** forestry_sci hessian module — tsb analytics library. */
+export interface ForestrySciHessianOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciHessianResult { values: number[]; converged: boolean; }
+export function computeForestrySciHessian(data: number[], opts: ForestrySciHessianOptions = {}): ForestrySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciHessian };
diff --git a/src/forestry_sci/hypothesis.ts b/src/forestry_sci/hypothesis.ts
new file mode 100644
index 000000000..80eabd1ae
--- /dev/null
+++ b/src/forestry_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** forestry_sci hypothesis module — tsb analytics library. */
+export interface ForestrySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeForestrySciHypothesis(data: number[], opts: ForestrySciHypothesisOptions = {}): ForestrySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciHypothesis };
diff --git a/src/forestry_sci/inference.ts b/src/forestry_sci/inference.ts
new file mode 100644
index 000000000..9306180e7
--- /dev/null
+++ b/src/forestry_sci/inference.ts
@@ -0,0 +1,14 @@
+/** forestry_sci inference module — tsb analytics library. */
+export interface ForestrySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciInferenceResult { values: number[]; converged: boolean; }
+export function computeForestrySciInference(data: number[], opts: ForestrySciInferenceOptions = {}): ForestrySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciInference };
diff --git a/src/forestry_sci/inference2.ts b/src/forestry_sci/inference2.ts
new file mode 100644
index 000000000..9eeece2c0
--- /dev/null
+++ b/src/forestry_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** forestry_sci inference2 module — tsb analytics library. */
+export interface ForestrySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciInferenceResult { values: number[]; converged: boolean; }
+export function computeForestrySciInference(data: number[], opts: ForestrySciInferenceOptions = {}): ForestrySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciInference };
diff --git a/src/forestry_sci/integral.ts b/src/forestry_sci/integral.ts
new file mode 100644
index 000000000..c71e0207a
--- /dev/null
+++ b/src/forestry_sci/integral.ts
@@ -0,0 +1,14 @@
+/** forestry_sci integral module — tsb analytics library. */
+export interface ForestrySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciIntegralResult { values: number[]; converged: boolean; }
+export function computeForestrySciIntegral(data: number[], opts: ForestrySciIntegralOptions = {}): ForestrySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciIntegral };
diff --git a/src/forestry_sci/integration.ts b/src/forestry_sci/integration.ts
new file mode 100644
index 000000000..520047c91
--- /dev/null
+++ b/src/forestry_sci/integration.ts
@@ -0,0 +1,14 @@
+/** forestry_sci integration module — tsb analytics library. */
+export interface ForestrySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeForestrySciIntegration(data: number[], opts: ForestrySciIntegrationOptions = {}): ForestrySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciIntegration };
diff --git a/src/forestry_sci/interpolation.ts b/src/forestry_sci/interpolation.ts
new file mode 100644
index 000000000..449c958ba
--- /dev/null
+++ b/src/forestry_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci interpolation module — tsb analytics library. */
+export interface ForestrySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeForestrySciInterpolation(data: number[], opts: ForestrySciInterpolationOptions = {}): ForestrySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciInterpolation };
diff --git a/src/forestry_sci/jacobian.ts b/src/forestry_sci/jacobian.ts
new file mode 100644
index 000000000..d721a5f7a
--- /dev/null
+++ b/src/forestry_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** forestry_sci jacobian module — tsb analytics library. */
+export interface ForestrySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciJacobianResult { values: number[]; converged: boolean; }
+export function computeForestrySciJacobian(data: number[], opts: ForestrySciJacobianOptions = {}): ForestrySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciJacobian };
diff --git a/src/forestry_sci/kernel.ts b/src/forestry_sci/kernel.ts
new file mode 100644
index 000000000..af4d7caff
--- /dev/null
+++ b/src/forestry_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** forestry_sci kernel module — tsb analytics library. */
+export interface ForestrySciKernelOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciKernelResult { values: number[]; converged: boolean; }
+export function computeForestrySciKernel(data: number[], opts: ForestrySciKernelOptions = {}): ForestrySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciKernel };
diff --git a/src/forestry_sci/laplacian.ts b/src/forestry_sci/laplacian.ts
new file mode 100644
index 000000000..237c3bfee
--- /dev/null
+++ b/src/forestry_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** forestry_sci laplacian module — tsb analytics library. */
+export interface ForestrySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeForestrySciLaplacian(data: number[], opts: ForestrySciLaplacianOptions = {}): ForestrySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciLaplacian };
diff --git a/src/forestry_sci/learning.ts b/src/forestry_sci/learning.ts
new file mode 100644
index 000000000..e9834cbe0
--- /dev/null
+++ b/src/forestry_sci/learning.ts
@@ -0,0 +1,14 @@
+/** forestry_sci learning module — tsb analytics library. */
+export interface ForestrySciLearningOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciLearningResult { values: number[]; converged: boolean; }
+export function computeForestrySciLearning(data: number[], opts: ForestrySciLearningOptions = {}): ForestrySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciLearning };
diff --git a/src/forestry_sci/linear.ts b/src/forestry_sci/linear.ts
new file mode 100644
index 000000000..ac75e468e
--- /dev/null
+++ b/src/forestry_sci/linear.ts
@@ -0,0 +1,14 @@
+/** forestry_sci linear module — tsb analytics library. */
+export interface ForestrySciLinearOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciLinearResult { values: number[]; converged: boolean; }
+export function computeForestrySciLinear(data: number[], opts: ForestrySciLinearOptions = {}): ForestrySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciLinear };
diff --git a/src/forestry_sci/manifold.ts b/src/forestry_sci/manifold.ts
new file mode 100644
index 000000000..e5d8c77a3
--- /dev/null
+++ b/src/forestry_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** forestry_sci manifold module — tsb analytics library. */
+export interface ForestrySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciManifoldResult { values: number[]; converged: boolean; }
+export function computeForestrySciManifold(data: number[], opts: ForestrySciManifoldOptions = {}): ForestrySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciManifold };
diff --git a/src/forestry_sci/matching.ts b/src/forestry_sci/matching.ts
new file mode 100644
index 000000000..517bf9779
--- /dev/null
+++ b/src/forestry_sci/matching.ts
@@ -0,0 +1,14 @@
+/** forestry_sci matching module — tsb analytics library. */
+export interface ForestrySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciMatchingResult { values: number[]; converged: boolean; }
+export function computeForestrySciMatching(data: number[], opts: ForestrySciMatchingOptions = {}): ForestrySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciMatching };
diff --git a/src/forestry_sci/measurement.ts b/src/forestry_sci/measurement.ts
new file mode 100644
index 000000000..506b21f05
--- /dev/null
+++ b/src/forestry_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** forestry_sci measurement module — tsb analytics library. */
+export interface ForestrySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeForestrySciMeasurement(data: number[], opts: ForestrySciMeasurementOptions = {}): ForestrySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciMeasurement };
diff --git a/src/forestry_sci/metrics.ts b/src/forestry_sci/metrics.ts
new file mode 100644
index 000000000..9d5327a24
--- /dev/null
+++ b/src/forestry_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** forestry_sci metrics module — tsb analytics library. */
+export interface ForestrySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciMetricsResult { values: number[]; converged: boolean; }
+export function computeForestrySciMetrics(data: number[], opts: ForestrySciMetricsOptions = {}): ForestrySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciMetrics };
diff --git a/src/forestry_sci/modeling.ts b/src/forestry_sci/modeling.ts
new file mode 100644
index 000000000..fc6032127
--- /dev/null
+++ b/src/forestry_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** forestry_sci modeling module — tsb analytics library. */
+export interface ForestrySciModelingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciModelingResult { values: number[]; converged: boolean; }
+export function computeForestrySciModeling(data: number[], opts: ForestrySciModelingOptions = {}): ForestrySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciModeling };
diff --git a/src/forestry_sci/monitoring.ts b/src/forestry_sci/monitoring.ts
new file mode 100644
index 000000000..18a87e586
--- /dev/null
+++ b/src/forestry_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** forestry_sci monitoring module — tsb analytics library. */
+export interface ForestrySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeForestrySciMonitoring(data: number[], opts: ForestrySciMonitoringOptions = {}): ForestrySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciMonitoring };
diff --git a/src/forestry_sci/nonlinear.ts b/src/forestry_sci/nonlinear.ts
new file mode 100644
index 000000000..3e4718575
--- /dev/null
+++ b/src/forestry_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** forestry_sci nonlinear module — tsb analytics library. */
+export interface ForestrySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeForestrySciNonlinear(data: number[], opts: ForestrySciNonlinearOptions = {}): ForestrySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciNonlinear };
diff --git a/src/forestry_sci/normalization.ts b/src/forestry_sci/normalization.ts
new file mode 100644
index 000000000..0f0c4b39f
--- /dev/null
+++ b/src/forestry_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** forestry_sci normalization module — tsb analytics library. */
+export interface ForestrySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeForestrySciNormalization(data: number[], opts: ForestrySciNormalizationOptions = {}): ForestrySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciNormalization };
diff --git a/src/forestry_sci/optimization.ts b/src/forestry_sci/optimization.ts
new file mode 100644
index 000000000..b5ef5fa0f
--- /dev/null
+++ b/src/forestry_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** forestry_sci optimization module — tsb analytics library. */
+export interface ForestrySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeForestrySciOptimization(data: number[], opts: ForestrySciOptimizationOptions = {}): ForestrySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciOptimization };
diff --git a/src/forestry_sci/patterns.ts b/src/forestry_sci/patterns.ts
new file mode 100644
index 000000000..5452a040d
--- /dev/null
+++ b/src/forestry_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** forestry_sci patterns module — tsb analytics library. */
+export interface ForestrySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciPatternsResult { values: number[]; converged: boolean; }
+export function computeForestrySciPatterns(data: number[], opts: ForestrySciPatternsOptions = {}): ForestrySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciPatterns };
diff --git a/src/forestry_sci/permutation.ts b/src/forestry_sci/permutation.ts
new file mode 100644
index 000000000..607d35bd6
--- /dev/null
+++ b/src/forestry_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci permutation module — tsb analytics library. */
+export interface ForestrySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciPermutationResult { values: number[]; converged: boolean; }
+export function computeForestrySciPermutation(data: number[], opts: ForestrySciPermutationOptions = {}): ForestrySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciPermutation };
diff --git a/src/forestry_sci/prediction.ts b/src/forestry_sci/prediction.ts
new file mode 100644
index 000000000..8f9da6456
--- /dev/null
+++ b/src/forestry_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** forestry_sci prediction module — tsb analytics library. */
+export interface ForestrySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciPredictionResult { values: number[]; converged: boolean; }
+export function computeForestrySciPrediction(data: number[], opts: ForestrySciPredictionOptions = {}): ForestrySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciPrediction };
diff --git a/src/forestry_sci/processing.ts b/src/forestry_sci/processing.ts
new file mode 100644
index 000000000..b847faf91
--- /dev/null
+++ b/src/forestry_sci/processing.ts
@@ -0,0 +1,14 @@
+/** forestry_sci processing module — tsb analytics library. */
+export interface ForestrySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciProcessingResult { values: number[]; converged: boolean; }
+export function computeForestrySciProcessing(data: number[], opts: ForestrySciProcessingOptions = {}): ForestrySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciProcessing };
diff --git a/src/forestry_sci/profiling.ts b/src/forestry_sci/profiling.ts
new file mode 100644
index 000000000..8b39df00d
--- /dev/null
+++ b/src/forestry_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** forestry_sci profiling module — tsb analytics library. */
+export interface ForestrySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciProfilingResult { values: number[]; converged: boolean; }
+export function computeForestrySciProfiling(data: number[], opts: ForestrySciProfilingOptions = {}): ForestrySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciProfiling };
diff --git a/src/forestry_sci/projection.ts b/src/forestry_sci/projection.ts
new file mode 100644
index 000000000..4a4e6d9e0
--- /dev/null
+++ b/src/forestry_sci/projection.ts
@@ -0,0 +1,14 @@
+/** forestry_sci projection module — tsb analytics library. */
+export interface ForestrySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciProjectionResult { values: number[]; converged: boolean; }
+export function computeForestrySciProjection(data: number[], opts: ForestrySciProjectionOptions = {}): ForestrySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciProjection };
diff --git a/src/forestry_sci/ranking.ts b/src/forestry_sci/ranking.ts
new file mode 100644
index 000000000..1b16e7b2a
--- /dev/null
+++ b/src/forestry_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** forestry_sci ranking module — tsb analytics library. */
+export interface ForestrySciRankingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciRankingResult { values: number[]; converged: boolean; }
+export function computeForestrySciRanking(data: number[], opts: ForestrySciRankingOptions = {}): ForestrySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciRanking };
diff --git a/src/forestry_sci/reconstruction.ts b/src/forestry_sci/reconstruction.ts
new file mode 100644
index 000000000..2c5b51867
--- /dev/null
+++ b/src/forestry_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** forestry_sci reconstruction module — tsb analytics library. */
+export interface ForestrySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeForestrySciReconstruction(data: number[], opts: ForestrySciReconstructionOptions = {}): ForestrySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciReconstruction };
diff --git a/src/forestry_sci/registration.ts b/src/forestry_sci/registration.ts
new file mode 100644
index 000000000..26c1e3dfe
--- /dev/null
+++ b/src/forestry_sci/registration.ts
@@ -0,0 +1,14 @@
+/** forestry_sci registration module — tsb analytics library. */
+export interface ForestrySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeForestrySciRegistration(data: number[], opts: ForestrySciRegistrationOptions = {}): ForestrySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciRegistration };
diff --git a/src/forestry_sci/regression.ts b/src/forestry_sci/regression.ts
new file mode 100644
index 000000000..8a43b56ff
--- /dev/null
+++ b/src/forestry_sci/regression.ts
@@ -0,0 +1,14 @@
+/** forestry_sci regression module — tsb analytics library. */
+export interface ForestrySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciRegressionResult { values: number[]; converged: boolean; }
+export function computeForestrySciRegression(data: number[], opts: ForestrySciRegressionOptions = {}): ForestrySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciRegression };
diff --git a/src/forestry_sci/regularization.ts b/src/forestry_sci/regularization.ts
new file mode 100644
index 000000000..b2c28b954
--- /dev/null
+++ b/src/forestry_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** forestry_sci regularization module — tsb analytics library. */
+export interface ForestrySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeForestrySciRegularization(data: number[], opts: ForestrySciRegularizationOptions = {}): ForestrySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciRegularization };
diff --git a/src/forestry_sci/robustness.ts b/src/forestry_sci/robustness.ts
new file mode 100644
index 000000000..fe8b0626a
--- /dev/null
+++ b/src/forestry_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** forestry_sci robustness module — tsb analytics library. */
+export interface ForestrySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeForestrySciRobustness(data: number[], opts: ForestrySciRobustnessOptions = {}): ForestrySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciRobustness };
diff --git a/src/forestry_sci/sampling.ts b/src/forestry_sci/sampling.ts
new file mode 100644
index 000000000..d747cbfef
--- /dev/null
+++ b/src/forestry_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** forestry_sci sampling module — tsb analytics library. */
+export interface ForestrySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciSamplingResult { values: number[]; converged: boolean; }
+export function computeForestrySciSampling(data: number[], opts: ForestrySciSamplingOptions = {}): ForestrySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciSampling };
diff --git a/src/forestry_sci/sampling2.ts b/src/forestry_sci/sampling2.ts
new file mode 100644
index 000000000..ffff83401
--- /dev/null
+++ b/src/forestry_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** forestry_sci sampling2 module — tsb analytics library. */
+export interface ForestrySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciSamplingResult { values: number[]; converged: boolean; }
+export function computeForestrySciSampling(data: number[], opts: ForestrySciSamplingOptions = {}): ForestrySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciSampling };
diff --git a/src/forestry_sci/scaling.ts b/src/forestry_sci/scaling.ts
new file mode 100644
index 000000000..74f54a11b
--- /dev/null
+++ b/src/forestry_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** forestry_sci scaling module — tsb analytics library. */
+export interface ForestrySciScalingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciScalingResult { values: number[]; converged: boolean; }
+export function computeForestrySciScaling(data: number[], opts: ForestrySciScalingOptions = {}): ForestrySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciScaling };
diff --git a/src/forestry_sci/scoring.ts b/src/forestry_sci/scoring.ts
new file mode 100644
index 000000000..32e2275a3
--- /dev/null
+++ b/src/forestry_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** forestry_sci scoring module — tsb analytics library. */
+export interface ForestrySciScoringOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciScoringResult { values: number[]; converged: boolean; }
+export function computeForestrySciScoring(data: number[], opts: ForestrySciScoringOptions = {}): ForestrySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciScoring };
diff --git a/src/forestry_sci/segmentation.ts b/src/forestry_sci/segmentation.ts
new file mode 100644
index 000000000..d022916ea
--- /dev/null
+++ b/src/forestry_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci segmentation module — tsb analytics library. */
+export interface ForestrySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeForestrySciSegmentation(data: number[], opts: ForestrySciSegmentationOptions = {}): ForestrySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciSegmentation };
diff --git a/src/forestry_sci/selection.ts b/src/forestry_sci/selection.ts
new file mode 100644
index 000000000..bc115b516
--- /dev/null
+++ b/src/forestry_sci/selection.ts
@@ -0,0 +1,14 @@
+/** forestry_sci selection module — tsb analytics library. */
+export interface ForestrySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciSelectionResult { values: number[]; converged: boolean; }
+export function computeForestrySciSelection(data: number[], opts: ForestrySciSelectionOptions = {}): ForestrySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciSelection };
diff --git a/src/forestry_sci/sensitivity.ts b/src/forestry_sci/sensitivity.ts
new file mode 100644
index 000000000..af437b7c6
--- /dev/null
+++ b/src/forestry_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** forestry_sci sensitivity module — tsb analytics library. */
+export interface ForestrySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeForestrySciSensitivity(data: number[], opts: ForestrySciSensitivityOptions = {}): ForestrySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciSensitivity };
diff --git a/src/forestry_sci/simulation.ts b/src/forestry_sci/simulation.ts
new file mode 100644
index 000000000..c93e4cddc
--- /dev/null
+++ b/src/forestry_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci simulation module — tsb analytics library. */
+export interface ForestrySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciSimulationResult { values: number[]; converged: boolean; }
+export function computeForestrySciSimulation(data: number[], opts: ForestrySciSimulationOptions = {}): ForestrySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciSimulation };
diff --git a/src/forestry_sci/smoothing.ts b/src/forestry_sci/smoothing.ts
new file mode 100644
index 000000000..a94dd5ad0
--- /dev/null
+++ b/src/forestry_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** forestry_sci smoothing module — tsb analytics library. */
+export interface ForestrySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeForestrySciSmoothing(data: number[], opts: ForestrySciSmoothingOptions = {}): ForestrySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciSmoothing };
diff --git a/src/forestry_sci/stability.ts b/src/forestry_sci/stability.ts
new file mode 100644
index 000000000..76e70ddb1
--- /dev/null
+++ b/src/forestry_sci/stability.ts
@@ -0,0 +1,14 @@
+/** forestry_sci stability module — tsb analytics library. */
+export interface ForestrySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciStabilityResult { values: number[]; converged: boolean; }
+export function computeForestrySciStability(data: number[], opts: ForestrySciStabilityOptions = {}): ForestrySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciStability };
diff --git a/src/forestry_sci/stacking.ts b/src/forestry_sci/stacking.ts
new file mode 100644
index 000000000..9592c1787
--- /dev/null
+++ b/src/forestry_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** forestry_sci stacking module — tsb analytics library. */
+export interface ForestrySciStackingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciStackingResult { values: number[]; converged: boolean; }
+export function computeForestrySciStacking(data: number[], opts: ForestrySciStackingOptions = {}): ForestrySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciStacking };
diff --git a/src/forestry_sci/standardization.ts b/src/forestry_sci/standardization.ts
new file mode 100644
index 000000000..78cba6f5d
--- /dev/null
+++ b/src/forestry_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** forestry_sci standardization module — tsb analytics library. */
+export interface ForestrySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeForestrySciStandardization(data: number[], opts: ForestrySciStandardizationOptions = {}): ForestrySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciStandardization };
diff --git a/src/forestry_sci/static.ts b/src/forestry_sci/static.ts
new file mode 100644
index 000000000..1cd225a05
--- /dev/null
+++ b/src/forestry_sci/static.ts
@@ -0,0 +1,14 @@
+/** forestry_sci static module — tsb analytics library. */
+export interface ForestrySciStaticOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciStaticResult { values: number[]; converged: boolean; }
+export function computeForestrySciStatic(data: number[], opts: ForestrySciStaticOptions = {}): ForestrySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciStatic };
diff --git a/src/forestry_sci/stochastic.ts b/src/forestry_sci/stochastic.ts
new file mode 100644
index 000000000..9386ed637
--- /dev/null
+++ b/src/forestry_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** forestry_sci stochastic module — tsb analytics library. */
+export interface ForestrySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciStochasticResult { values: number[]; converged: boolean; }
+export function computeForestrySciStochastic(data: number[], opts: ForestrySciStochasticOptions = {}): ForestrySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciStochastic };
diff --git a/src/forestry_sci/synthesis.ts b/src/forestry_sci/synthesis.ts
new file mode 100644
index 000000000..7b0ad5146
--- /dev/null
+++ b/src/forestry_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** forestry_sci synthesis module — tsb analytics library. */
+export interface ForestrySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeForestrySciSynthesis(data: number[], opts: ForestrySciSynthesisOptions = {}): ForestrySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciSynthesis };
diff --git a/src/forestry_sci/topology.ts b/src/forestry_sci/topology.ts
new file mode 100644
index 000000000..0ac69bf3a
--- /dev/null
+++ b/src/forestry_sci/topology.ts
@@ -0,0 +1,14 @@
+/** forestry_sci topology module — tsb analytics library. */
+export interface ForestrySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciTopologyResult { values: number[]; converged: boolean; }
+export function computeForestrySciTopology(data: number[], opts: ForestrySciTopologyOptions = {}): ForestrySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciTopology };
diff --git a/src/forestry_sci/tracking.ts b/src/forestry_sci/tracking.ts
new file mode 100644
index 000000000..5d7696dcc
--- /dev/null
+++ b/src/forestry_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** forestry_sci tracking module — tsb analytics library. */
+export interface ForestrySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciTrackingResult { values: number[]; converged: boolean; }
+export function computeForestrySciTracking(data: number[], opts: ForestrySciTrackingOptions = {}): ForestrySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciTracking };
diff --git a/src/forestry_sci/transform.ts b/src/forestry_sci/transform.ts
new file mode 100644
index 000000000..1bb7dfdfa
--- /dev/null
+++ b/src/forestry_sci/transform.ts
@@ -0,0 +1,14 @@
+/** forestry_sci transform module — tsb analytics library. */
+export interface ForestrySciTransformOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciTransformResult { values: number[]; converged: boolean; }
+export function computeForestrySciTransform(data: number[], opts: ForestrySciTransformOptions = {}): ForestrySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciTransform };
diff --git a/src/forestry_sci/uncertainty.ts b/src/forestry_sci/uncertainty.ts
new file mode 100644
index 000000000..0a60600ee
--- /dev/null
+++ b/src/forestry_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** forestry_sci uncertainty module — tsb analytics library. */
+export interface ForestrySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeForestrySciUncertainty(data: number[], opts: ForestrySciUncertaintyOptions = {}): ForestrySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciUncertainty };
diff --git a/src/forestry_sci/validation.ts b/src/forestry_sci/validation.ts
new file mode 100644
index 000000000..6e1b70a58
--- /dev/null
+++ b/src/forestry_sci/validation.ts
@@ -0,0 +1,14 @@
+/** forestry_sci validation module — tsb analytics library. */
+export interface ForestrySciValidationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciValidationResult { values: number[]; converged: boolean; }
+export function computeForestrySciValidation(data: number[], opts: ForestrySciValidationOptions = {}): ForestrySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciValidation };
diff --git a/src/forestry_sci/verification.ts b/src/forestry_sci/verification.ts
new file mode 100644
index 000000000..86aaa26e5
--- /dev/null
+++ b/src/forestry_sci/verification.ts
@@ -0,0 +1,14 @@
+/** forestry_sci verification module — tsb analytics library. */
+export interface ForestrySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciVerificationResult { values: number[]; converged: boolean; }
+export function computeForestrySciVerification(data: number[], opts: ForestrySciVerificationOptions = {}): ForestrySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciVerification };
diff --git a/src/forestry_sci/visualization.ts b/src/forestry_sci/visualization.ts
new file mode 100644
index 000000000..3142371aa
--- /dev/null
+++ b/src/forestry_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** forestry_sci visualization module — tsb analytics library. */
+export interface ForestrySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeForestrySciVisualization(data: number[], opts: ForestrySciVisualizationOptions = {}): ForestrySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciVisualization };
diff --git a/src/forestry_sci/voting.ts b/src/forestry_sci/voting.ts
new file mode 100644
index 000000000..06690c107
--- /dev/null
+++ b/src/forestry_sci/voting.ts
@@ -0,0 +1,14 @@
+/** forestry_sci voting module — tsb analytics library. */
+export interface ForestrySciVotingOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciVotingResult { values: number[]; converged: boolean; }
+export function computeForestrySciVoting(data: number[], opts: ForestrySciVotingOptions = {}): ForestrySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciVoting };
diff --git a/src/forestry_sci/wavelet.ts b/src/forestry_sci/wavelet.ts
new file mode 100644
index 000000000..40483cc27
--- /dev/null
+++ b/src/forestry_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** forestry_sci wavelet module — tsb analytics library. */
+export interface ForestrySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface ForestrySciWaveletResult { values: number[]; converged: boolean; }
+export function computeForestrySciWavelet(data: number[], opts: ForestrySciWaveletOptions = {}): ForestrySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeForestrySciWavelet };
diff --git a/src/fracture_mech/adaptation.ts b/src/fracture_mech/adaptation.ts
new file mode 100644
index 000000000..4dbba74ee
--- /dev/null
+++ b/src/fracture_mech/adaptation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech adaptation module — tsb analytics library. */
+export interface FractureMechAdaptationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechAdaptationResult { values: number[]; converged: boolean; }
+export function computeFractureMechAdaptation(data: number[], opts: FractureMechAdaptationOptions = {}): FractureMechAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechAdaptation };
diff --git a/src/fracture_mech/aggregation.ts b/src/fracture_mech/aggregation.ts
new file mode 100644
index 000000000..a1fe128e3
--- /dev/null
+++ b/src/fracture_mech/aggregation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech aggregation module — tsb analytics library. */
+export interface FractureMechAggregationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechAggregationResult { values: number[]; converged: boolean; }
+export function computeFractureMechAggregation(data: number[], opts: FractureMechAggregationOptions = {}): FractureMechAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechAggregation };
diff --git a/src/fracture_mech/algebra.ts b/src/fracture_mech/algebra.ts
new file mode 100644
index 000000000..04dbe1d7a
--- /dev/null
+++ b/src/fracture_mech/algebra.ts
@@ -0,0 +1,14 @@
+/** fracture_mech algebra module — tsb analytics library. */
+export interface FractureMechAlgebraOptions { tol?: number; maxIter?: number; }
+export interface FractureMechAlgebraResult { values: number[]; converged: boolean; }
+export function computeFractureMechAlgebra(data: number[], opts: FractureMechAlgebraOptions = {}): FractureMechAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechAlgebra };
diff --git a/src/fracture_mech/alignment.ts b/src/fracture_mech/alignment.ts
new file mode 100644
index 000000000..7e8180352
--- /dev/null
+++ b/src/fracture_mech/alignment.ts
@@ -0,0 +1,14 @@
+/** fracture_mech alignment module — tsb analytics library. */
+export interface FractureMechAlignmentOptions { tol?: number; maxIter?: number; }
+export interface FractureMechAlignmentResult { values: number[]; converged: boolean; }
+export function computeFractureMechAlignment(data: number[], opts: FractureMechAlignmentOptions = {}): FractureMechAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechAlignment };
diff --git a/src/fracture_mech/analysis.ts b/src/fracture_mech/analysis.ts
new file mode 100644
index 000000000..56589d42a
--- /dev/null
+++ b/src/fracture_mech/analysis.ts
@@ -0,0 +1,14 @@
+/** fracture_mech analysis module — tsb analytics library. */
+export interface FractureMechAnalysisOptions { tol?: number; maxIter?: number; }
+export interface FractureMechAnalysisResult { values: number[]; converged: boolean; }
+export function computeFractureMechAnalysis(data: number[], opts: FractureMechAnalysisOptions = {}): FractureMechAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechAnalysis };
diff --git a/src/fracture_mech/augmentation.ts b/src/fracture_mech/augmentation.ts
new file mode 100644
index 000000000..3ffc1743d
--- /dev/null
+++ b/src/fracture_mech/augmentation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech augmentation module — tsb analytics library. */
+export interface FractureMechAugmentationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechAugmentationResult { values: number[]; converged: boolean; }
+export function computeFractureMechAugmentation(data: number[], opts: FractureMechAugmentationOptions = {}): FractureMechAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechAugmentation };
diff --git a/src/fracture_mech/bagging.ts b/src/fracture_mech/bagging.ts
new file mode 100644
index 000000000..ff594b781
--- /dev/null
+++ b/src/fracture_mech/bagging.ts
@@ -0,0 +1,14 @@
+/** fracture_mech bagging module — tsb analytics library. */
+export interface FractureMechBaggingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechBaggingResult { values: number[]; converged: boolean; }
+export function computeFractureMechBagging(data: number[], opts: FractureMechBaggingOptions = {}): FractureMechBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechBagging };
diff --git a/src/fracture_mech/basis.ts b/src/fracture_mech/basis.ts
new file mode 100644
index 000000000..86910df97
--- /dev/null
+++ b/src/fracture_mech/basis.ts
@@ -0,0 +1,14 @@
+/** fracture_mech basis module — tsb analytics library. */
+export interface FractureMechBasisOptions { tol?: number; maxIter?: number; }
+export interface FractureMechBasisResult { values: number[]; converged: boolean; }
+export function computeFractureMechBasis(data: number[], opts: FractureMechBasisOptions = {}): FractureMechBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechBasis };
diff --git a/src/fracture_mech/benchmarking.ts b/src/fracture_mech/benchmarking.ts
new file mode 100644
index 000000000..a05d1412b
--- /dev/null
+++ b/src/fracture_mech/benchmarking.ts
@@ -0,0 +1,14 @@
+/** fracture_mech benchmarking module — tsb analytics library. */
+export interface FractureMechBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeFractureMechBenchmarking(data: number[], opts: FractureMechBenchmarkingOptions = {}): FractureMechBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechBenchmarking };
diff --git a/src/fracture_mech/blending.ts b/src/fracture_mech/blending.ts
new file mode 100644
index 000000000..25276dcb1
--- /dev/null
+++ b/src/fracture_mech/blending.ts
@@ -0,0 +1,14 @@
+/** fracture_mech blending module — tsb analytics library. */
+export interface FractureMechBlendingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechBlendingResult { values: number[]; converged: boolean; }
+export function computeFractureMechBlending(data: number[], opts: FractureMechBlendingOptions = {}): FractureMechBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechBlending };
diff --git a/src/fracture_mech/boosting.ts b/src/fracture_mech/boosting.ts
new file mode 100644
index 000000000..8dbfc99b2
--- /dev/null
+++ b/src/fracture_mech/boosting.ts
@@ -0,0 +1,14 @@
+/** fracture_mech boosting module — tsb analytics library. */
+export interface FractureMechBoostingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechBoostingResult { values: number[]; converged: boolean; }
+export function computeFractureMechBoosting(data: number[], opts: FractureMechBoostingOptions = {}): FractureMechBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechBoosting };
diff --git a/src/fracture_mech/bootstrap.ts b/src/fracture_mech/bootstrap.ts
new file mode 100644
index 000000000..e11fb4e0a
--- /dev/null
+++ b/src/fracture_mech/bootstrap.ts
@@ -0,0 +1,14 @@
+/** fracture_mech bootstrap module — tsb analytics library. */
+export interface FractureMechBootstrapOptions { tol?: number; maxIter?: number; }
+export interface FractureMechBootstrapResult { values: number[]; converged: boolean; }
+export function computeFractureMechBootstrap(data: number[], opts: FractureMechBootstrapOptions = {}): FractureMechBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechBootstrap };
diff --git a/src/fracture_mech/calculus.ts b/src/fracture_mech/calculus.ts
new file mode 100644
index 000000000..598807ebf
--- /dev/null
+++ b/src/fracture_mech/calculus.ts
@@ -0,0 +1,14 @@
+/** fracture_mech calculus module — tsb analytics library. */
+export interface FractureMechCalculusOptions { tol?: number; maxIter?: number; }
+export interface FractureMechCalculusResult { values: number[]; converged: boolean; }
+export function computeFractureMechCalculus(data: number[], opts: FractureMechCalculusOptions = {}): FractureMechCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechCalculus };
diff --git a/src/fracture_mech/calibration.ts b/src/fracture_mech/calibration.ts
new file mode 100644
index 000000000..674e8c2af
--- /dev/null
+++ b/src/fracture_mech/calibration.ts
@@ -0,0 +1,14 @@
+/** fracture_mech calibration module — tsb analytics library. */
+export interface FractureMechCalibrationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechCalibrationResult { values: number[]; converged: boolean; }
+export function computeFractureMechCalibration(data: number[], opts: FractureMechCalibrationOptions = {}): FractureMechCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechCalibration };
diff --git a/src/fracture_mech/characterization.ts b/src/fracture_mech/characterization.ts
new file mode 100644
index 000000000..63f674486
--- /dev/null
+++ b/src/fracture_mech/characterization.ts
@@ -0,0 +1,14 @@
+/** fracture_mech characterization module — tsb analytics library. */
+export interface FractureMechCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechCharacterizationResult { values: number[]; converged: boolean; }
+export function computeFractureMechCharacterization(data: number[], opts: FractureMechCharacterizationOptions = {}): FractureMechCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechCharacterization };
diff --git a/src/fracture_mech/classification.ts b/src/fracture_mech/classification.ts
new file mode 100644
index 000000000..1ff3072e8
--- /dev/null
+++ b/src/fracture_mech/classification.ts
@@ -0,0 +1,14 @@
+/** fracture_mech classification module — tsb analytics library. */
+export interface FractureMechClassificationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechClassificationResult { values: number[]; converged: boolean; }
+export function computeFractureMechClassification(data: number[], opts: FractureMechClassificationOptions = {}): FractureMechClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechClassification };
diff --git a/src/fracture_mech/clustering.ts b/src/fracture_mech/clustering.ts
new file mode 100644
index 000000000..a68f80d73
--- /dev/null
+++ b/src/fracture_mech/clustering.ts
@@ -0,0 +1,14 @@
+/** fracture_mech clustering module — tsb analytics library. */
+export interface FractureMechClusteringOptions { tol?: number; maxIter?: number; }
+export interface FractureMechClusteringResult { values: number[]; converged: boolean; }
+export function computeFractureMechClustering(data: number[], opts: FractureMechClusteringOptions = {}): FractureMechClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechClustering };
diff --git a/src/fracture_mech/compression.ts b/src/fracture_mech/compression.ts
new file mode 100644
index 000000000..ae054a119
--- /dev/null
+++ b/src/fracture_mech/compression.ts
@@ -0,0 +1,14 @@
+/** fracture_mech compression module — tsb analytics library. */
+export interface FractureMechCompressionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechCompressionResult { values: number[]; converged: boolean; }
+export function computeFractureMechCompression(data: number[], opts: FractureMechCompressionOptions = {}): FractureMechCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechCompression };
diff --git a/src/fracture_mech/continuous.ts b/src/fracture_mech/continuous.ts
new file mode 100644
index 000000000..f7c4cec1d
--- /dev/null
+++ b/src/fracture_mech/continuous.ts
@@ -0,0 +1,14 @@
+/** fracture_mech continuous module — tsb analytics library. */
+export interface FractureMechContinuousOptions { tol?: number; maxIter?: number; }
+export interface FractureMechContinuousResult { values: number[]; converged: boolean; }
+export function computeFractureMechContinuous(data: number[], opts: FractureMechContinuousOptions = {}): FractureMechContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechContinuous };
diff --git a/src/fracture_mech/control.ts b/src/fracture_mech/control.ts
new file mode 100644
index 000000000..ae7e2ba94
--- /dev/null
+++ b/src/fracture_mech/control.ts
@@ -0,0 +1,14 @@
+/** fracture_mech control module — tsb analytics library. */
+export interface FractureMechControlOptions { tol?: number; maxIter?: number; }
+export interface FractureMechControlResult { values: number[]; converged: boolean; }
+export function computeFractureMechControl(data: number[], opts: FractureMechControlOptions = {}): FractureMechControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechControl };
diff --git a/src/fracture_mech/convergence.ts b/src/fracture_mech/convergence.ts
new file mode 100644
index 000000000..b69c5b6c6
--- /dev/null
+++ b/src/fracture_mech/convergence.ts
@@ -0,0 +1,14 @@
+/** fracture_mech convergence module — tsb analytics library. */
+export interface FractureMechConvergenceOptions { tol?: number; maxIter?: number; }
+export interface FractureMechConvergenceResult { values: number[]; converged: boolean; }
+export function computeFractureMechConvergence(data: number[], opts: FractureMechConvergenceOptions = {}): FractureMechConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechConvergence };
diff --git a/src/fracture_mech/convex.ts b/src/fracture_mech/convex.ts
new file mode 100644
index 000000000..cfa61fd46
--- /dev/null
+++ b/src/fracture_mech/convex.ts
@@ -0,0 +1,14 @@
+/** fracture_mech convex module — tsb analytics library. */
+export interface FractureMechConvexOptions { tol?: number; maxIter?: number; }
+export interface FractureMechConvexResult { values: number[]; converged: boolean; }
+export function computeFractureMechConvex(data: number[], opts: FractureMechConvexOptions = {}): FractureMechConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechConvex };
diff --git a/src/fracture_mech/correlation.ts b/src/fracture_mech/correlation.ts
new file mode 100644
index 000000000..ec76fab10
--- /dev/null
+++ b/src/fracture_mech/correlation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech correlation module — tsb analytics library. */
+export interface FractureMechCorrelationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechCorrelationResult { values: number[]; converged: boolean; }
+export function computeFractureMechCorrelation(data: number[], opts: FractureMechCorrelationOptions = {}): FractureMechCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechCorrelation };
diff --git a/src/fracture_mech/covariance.ts b/src/fracture_mech/covariance.ts
new file mode 100644
index 000000000..3adf8671b
--- /dev/null
+++ b/src/fracture_mech/covariance.ts
@@ -0,0 +1,14 @@
+/** fracture_mech covariance module — tsb analytics library. */
+export interface FractureMechCovarianceOptions { tol?: number; maxIter?: number; }
+export interface FractureMechCovarianceResult { values: number[]; converged: boolean; }
+export function computeFractureMechCovariance(data: number[], opts: FractureMechCovarianceOptions = {}): FractureMechCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechCovariance };
diff --git a/src/fracture_mech/cross_validation.ts b/src/fracture_mech/cross_validation.ts
new file mode 100644
index 000000000..273b15c5f
--- /dev/null
+++ b/src/fracture_mech/cross_validation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech cross_validation module — tsb analytics library. */
+export interface FractureMechCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechCrossValidationResult { values: number[]; converged: boolean; }
+export function computeFractureMechCrossValidation(data: number[], opts: FractureMechCrossValidationOptions = {}): FractureMechCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechCrossValidation };
diff --git a/src/fracture_mech/decoding.ts b/src/fracture_mech/decoding.ts
new file mode 100644
index 000000000..a8b613243
--- /dev/null
+++ b/src/fracture_mech/decoding.ts
@@ -0,0 +1,14 @@
+/** fracture_mech decoding module — tsb analytics library. */
+export interface FractureMechDecodingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDecodingResult { values: number[]; converged: boolean; }
+export function computeFractureMechDecoding(data: number[], opts: FractureMechDecodingOptions = {}): FractureMechDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDecoding };
diff --git a/src/fracture_mech/decomposition.ts b/src/fracture_mech/decomposition.ts
new file mode 100644
index 000000000..30bcd2d88
--- /dev/null
+++ b/src/fracture_mech/decomposition.ts
@@ -0,0 +1,14 @@
+/** fracture_mech decomposition module — tsb analytics library. */
+export interface FractureMechDecompositionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDecompositionResult { values: number[]; converged: boolean; }
+export function computeFractureMechDecomposition(data: number[], opts: FractureMechDecompositionOptions = {}): FractureMechDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDecomposition };
diff --git a/src/fracture_mech/detection.ts b/src/fracture_mech/detection.ts
new file mode 100644
index 000000000..fd3af399e
--- /dev/null
+++ b/src/fracture_mech/detection.ts
@@ -0,0 +1,14 @@
+/** fracture_mech detection module — tsb analytics library. */
+export interface FractureMechDetectionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDetectionResult { values: number[]; converged: boolean; }
+export function computeFractureMechDetection(data: number[], opts: FractureMechDetectionOptions = {}): FractureMechDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDetection };
diff --git a/src/fracture_mech/deterministic.ts b/src/fracture_mech/deterministic.ts
new file mode 100644
index 000000000..c196fa247
--- /dev/null
+++ b/src/fracture_mech/deterministic.ts
@@ -0,0 +1,14 @@
+/** fracture_mech deterministic module — tsb analytics library. */
+export interface FractureMechDeterministicOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDeterministicResult { values: number[]; converged: boolean; }
+export function computeFractureMechDeterministic(data: number[], opts: FractureMechDeterministicOptions = {}): FractureMechDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDeterministic };
diff --git a/src/fracture_mech/diagnostics.ts b/src/fracture_mech/diagnostics.ts
new file mode 100644
index 000000000..38d41b0d8
--- /dev/null
+++ b/src/fracture_mech/diagnostics.ts
@@ -0,0 +1,14 @@
+/** fracture_mech diagnostics module — tsb analytics library. */
+export interface FractureMechDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeFractureMechDiagnostics(data: number[], opts: FractureMechDiagnosticsOptions = {}): FractureMechDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDiagnostics };
diff --git a/src/fracture_mech/differential.ts b/src/fracture_mech/differential.ts
new file mode 100644
index 000000000..4cb8d3db3
--- /dev/null
+++ b/src/fracture_mech/differential.ts
@@ -0,0 +1,14 @@
+/** fracture_mech differential module — tsb analytics library. */
+export interface FractureMechDifferentialOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDifferentialResult { values: number[]; converged: boolean; }
+export function computeFractureMechDifferential(data: number[], opts: FractureMechDifferentialOptions = {}): FractureMechDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDifferential };
diff --git a/src/fracture_mech/discrete.ts b/src/fracture_mech/discrete.ts
new file mode 100644
index 000000000..1f866a6fc
--- /dev/null
+++ b/src/fracture_mech/discrete.ts
@@ -0,0 +1,14 @@
+/** fracture_mech discrete module — tsb analytics library. */
+export interface FractureMechDiscreteOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDiscreteResult { values: number[]; converged: boolean; }
+export function computeFractureMechDiscrete(data: number[], opts: FractureMechDiscreteOptions = {}): FractureMechDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDiscrete };
diff --git a/src/fracture_mech/distribution.ts b/src/fracture_mech/distribution.ts
new file mode 100644
index 000000000..995dcb043
--- /dev/null
+++ b/src/fracture_mech/distribution.ts
@@ -0,0 +1,14 @@
+/** fracture_mech distribution module — tsb analytics library. */
+export interface FractureMechDistributionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDistributionResult { values: number[]; converged: boolean; }
+export function computeFractureMechDistribution(data: number[], opts: FractureMechDistributionOptions = {}): FractureMechDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDistribution };
diff --git a/src/fracture_mech/dynamic.ts b/src/fracture_mech/dynamic.ts
new file mode 100644
index 000000000..99191fc26
--- /dev/null
+++ b/src/fracture_mech/dynamic.ts
@@ -0,0 +1,14 @@
+/** fracture_mech dynamic module — tsb analytics library. */
+export interface FractureMechDynamicOptions { tol?: number; maxIter?: number; }
+export interface FractureMechDynamicResult { values: number[]; converged: boolean; }
+export function computeFractureMechDynamic(data: number[], opts: FractureMechDynamicOptions = {}): FractureMechDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechDynamic };
diff --git a/src/fracture_mech/embedding.ts b/src/fracture_mech/embedding.ts
new file mode 100644
index 000000000..ed6432892
--- /dev/null
+++ b/src/fracture_mech/embedding.ts
@@ -0,0 +1,14 @@
+/** fracture_mech embedding module — tsb analytics library. */
+export interface FractureMechEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechEmbeddingResult { values: number[]; converged: boolean; }
+export function computeFractureMechEmbedding(data: number[], opts: FractureMechEmbeddingOptions = {}): FractureMechEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechEmbedding };
diff --git a/src/fracture_mech/encoding.ts b/src/fracture_mech/encoding.ts
new file mode 100644
index 000000000..e0eb93d6a
--- /dev/null
+++ b/src/fracture_mech/encoding.ts
@@ -0,0 +1,14 @@
+/** fracture_mech encoding module — tsb analytics library. */
+export interface FractureMechEncodingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechEncodingResult { values: number[]; converged: boolean; }
+export function computeFractureMechEncoding(data: number[], opts: FractureMechEncodingOptions = {}): FractureMechEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechEncoding };
diff --git a/src/fracture_mech/ensemble.ts b/src/fracture_mech/ensemble.ts
new file mode 100644
index 000000000..729ad5aa9
--- /dev/null
+++ b/src/fracture_mech/ensemble.ts
@@ -0,0 +1,14 @@
+/** fracture_mech ensemble module — tsb analytics library. */
+export interface FractureMechEnsembleOptions { tol?: number; maxIter?: number; }
+export interface FractureMechEnsembleResult { values: number[]; converged: boolean; }
+export function computeFractureMechEnsemble(data: number[], opts: FractureMechEnsembleOptions = {}): FractureMechEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechEnsemble };
diff --git a/src/fracture_mech/estimation.ts b/src/fracture_mech/estimation.ts
new file mode 100644
index 000000000..0e104b2e3
--- /dev/null
+++ b/src/fracture_mech/estimation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech estimation module — tsb analytics library. */
+export interface FractureMechEstimationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechEstimationResult { values: number[]; converged: boolean; }
+export function computeFractureMechEstimation(data: number[], opts: FractureMechEstimationOptions = {}): FractureMechEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechEstimation };
diff --git a/src/fracture_mech/evaluation.ts b/src/fracture_mech/evaluation.ts
new file mode 100644
index 000000000..2b39f4ca1
--- /dev/null
+++ b/src/fracture_mech/evaluation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech evaluation module — tsb analytics library. */
+export interface FractureMechEvaluationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechEvaluationResult { values: number[]; converged: boolean; }
+export function computeFractureMechEvaluation(data: number[], opts: FractureMechEvaluationOptions = {}): FractureMechEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechEvaluation };
diff --git a/src/fracture_mech/extrapolation.ts b/src/fracture_mech/extrapolation.ts
new file mode 100644
index 000000000..23a35b84d
--- /dev/null
+++ b/src/fracture_mech/extrapolation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech extrapolation module — tsb analytics library. */
+export interface FractureMechExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechExtrapolationResult { values: number[]; converged: boolean; }
+export function computeFractureMechExtrapolation(data: number[], opts: FractureMechExtrapolationOptions = {}): FractureMechExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechExtrapolation };
diff --git a/src/fracture_mech/features.ts b/src/fracture_mech/features.ts
new file mode 100644
index 000000000..5117a263f
--- /dev/null
+++ b/src/fracture_mech/features.ts
@@ -0,0 +1,14 @@
+/** fracture_mech features module — tsb analytics library. */
+export interface FractureMechFeaturesOptions { tol?: number; maxIter?: number; }
+export interface FractureMechFeaturesResult { values: number[]; converged: boolean; }
+export function computeFractureMechFeatures(data: number[], opts: FractureMechFeaturesOptions = {}): FractureMechFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechFeatures };
diff --git a/src/fracture_mech/feedback.ts b/src/fracture_mech/feedback.ts
new file mode 100644
index 000000000..b26f0a5b1
--- /dev/null
+++ b/src/fracture_mech/feedback.ts
@@ -0,0 +1,14 @@
+/** fracture_mech feedback module — tsb analytics library. */
+export interface FractureMechFeedbackOptions { tol?: number; maxIter?: number; }
+export interface FractureMechFeedbackResult { values: number[]; converged: boolean; }
+export function computeFractureMechFeedback(data: number[], opts: FractureMechFeedbackOptions = {}): FractureMechFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechFeedback };
diff --git a/src/fracture_mech/filtering.ts b/src/fracture_mech/filtering.ts
new file mode 100644
index 000000000..556c8f058
--- /dev/null
+++ b/src/fracture_mech/filtering.ts
@@ -0,0 +1,14 @@
+/** fracture_mech filtering module — tsb analytics library. */
+export interface FractureMechFilteringOptions { tol?: number; maxIter?: number; }
+export interface FractureMechFilteringResult { values: number[]; converged: boolean; }
+export function computeFractureMechFiltering(data: number[], opts: FractureMechFilteringOptions = {}): FractureMechFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechFiltering };
diff --git a/src/fracture_mech/fourier.ts b/src/fracture_mech/fourier.ts
new file mode 100644
index 000000000..76ccd817d
--- /dev/null
+++ b/src/fracture_mech/fourier.ts
@@ -0,0 +1,14 @@
+/** fracture_mech fourier module — tsb analytics library. */
+export interface FractureMechFourierOptions { tol?: number; maxIter?: number; }
+export interface FractureMechFourierResult { values: number[]; converged: boolean; }
+export function computeFractureMechFourier(data: number[], opts: FractureMechFourierOptions = {}): FractureMechFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechFourier };
diff --git a/src/fracture_mech/fusion.ts b/src/fracture_mech/fusion.ts
new file mode 100644
index 000000000..20e0cdb33
--- /dev/null
+++ b/src/fracture_mech/fusion.ts
@@ -0,0 +1,14 @@
+/** fracture_mech fusion module — tsb analytics library. */
+export interface FractureMechFusionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechFusionResult { values: number[]; converged: boolean; }
+export function computeFractureMechFusion(data: number[], opts: FractureMechFusionOptions = {}): FractureMechFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechFusion };
diff --git a/src/fracture_mech/generation.ts b/src/fracture_mech/generation.ts
new file mode 100644
index 000000000..5a3f5c5f1
--- /dev/null
+++ b/src/fracture_mech/generation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech generation module — tsb analytics library. */
+export interface FractureMechGenerationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechGenerationResult { values: number[]; converged: boolean; }
+export function computeFractureMechGeneration(data: number[], opts: FractureMechGenerationOptions = {}): FractureMechGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechGeneration };
diff --git a/src/fracture_mech/geometry.ts b/src/fracture_mech/geometry.ts
new file mode 100644
index 000000000..a2c120a7a
--- /dev/null
+++ b/src/fracture_mech/geometry.ts
@@ -0,0 +1,14 @@
+/** fracture_mech geometry module — tsb analytics library. */
+export interface FractureMechGeometryOptions { tol?: number; maxIter?: number; }
+export interface FractureMechGeometryResult { values: number[]; converged: boolean; }
+export function computeFractureMechGeometry(data: number[], opts: FractureMechGeometryOptions = {}): FractureMechGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechGeometry };
diff --git a/src/fracture_mech/gradient.ts b/src/fracture_mech/gradient.ts
new file mode 100644
index 000000000..a3715ed1f
--- /dev/null
+++ b/src/fracture_mech/gradient.ts
@@ -0,0 +1,14 @@
+/** fracture_mech gradient module — tsb analytics library. */
+export interface FractureMechGradientOptions { tol?: number; maxIter?: number; }
+export interface FractureMechGradientResult { values: number[]; converged: boolean; }
+export function computeFractureMechGradient(data: number[], opts: FractureMechGradientOptions = {}): FractureMechGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechGradient };
diff --git a/src/fracture_mech/hessian.ts b/src/fracture_mech/hessian.ts
new file mode 100644
index 000000000..7ce46f894
--- /dev/null
+++ b/src/fracture_mech/hessian.ts
@@ -0,0 +1,14 @@
+/** fracture_mech hessian module — tsb analytics library. */
+export interface FractureMechHessianOptions { tol?: number; maxIter?: number; }
+export interface FractureMechHessianResult { values: number[]; converged: boolean; }
+export function computeFractureMechHessian(data: number[], opts: FractureMechHessianOptions = {}): FractureMechHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechHessian };
diff --git a/src/fracture_mech/hypothesis.ts b/src/fracture_mech/hypothesis.ts
new file mode 100644
index 000000000..389c27aaf
--- /dev/null
+++ b/src/fracture_mech/hypothesis.ts
@@ -0,0 +1,14 @@
+/** fracture_mech hypothesis module — tsb analytics library. */
+export interface FractureMechHypothesisOptions { tol?: number; maxIter?: number; }
+export interface FractureMechHypothesisResult { values: number[]; converged: boolean; }
+export function computeFractureMechHypothesis(data: number[], opts: FractureMechHypothesisOptions = {}): FractureMechHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechHypothesis };
diff --git a/src/fracture_mech/inference.ts b/src/fracture_mech/inference.ts
new file mode 100644
index 000000000..6938260e4
--- /dev/null
+++ b/src/fracture_mech/inference.ts
@@ -0,0 +1,14 @@
+/** fracture_mech inference module — tsb analytics library. */
+export interface FractureMechInferenceOptions { tol?: number; maxIter?: number; }
+export interface FractureMechInferenceResult { values: number[]; converged: boolean; }
+export function computeFractureMechInference(data: number[], opts: FractureMechInferenceOptions = {}): FractureMechInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechInference };
diff --git a/src/fracture_mech/inference2.ts b/src/fracture_mech/inference2.ts
new file mode 100644
index 000000000..e49e993ab
--- /dev/null
+++ b/src/fracture_mech/inference2.ts
@@ -0,0 +1,14 @@
+/** fracture_mech inference2 module — tsb analytics library. */
+export interface FractureMechInferenceOptions { tol?: number; maxIter?: number; }
+export interface FractureMechInferenceResult { values: number[]; converged: boolean; }
+export function computeFractureMechInference(data: number[], opts: FractureMechInferenceOptions = {}): FractureMechInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechInference };
diff --git a/src/fracture_mech/integral.ts b/src/fracture_mech/integral.ts
new file mode 100644
index 000000000..671861fb6
--- /dev/null
+++ b/src/fracture_mech/integral.ts
@@ -0,0 +1,14 @@
+/** fracture_mech integral module — tsb analytics library. */
+export interface FractureMechIntegralOptions { tol?: number; maxIter?: number; }
+export interface FractureMechIntegralResult { values: number[]; converged: boolean; }
+export function computeFractureMechIntegral(data: number[], opts: FractureMechIntegralOptions = {}): FractureMechIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechIntegral };
diff --git a/src/fracture_mech/integration.ts b/src/fracture_mech/integration.ts
new file mode 100644
index 000000000..21e7bf443
--- /dev/null
+++ b/src/fracture_mech/integration.ts
@@ -0,0 +1,14 @@
+/** fracture_mech integration module — tsb analytics library. */
+export interface FractureMechIntegrationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechIntegrationResult { values: number[]; converged: boolean; }
+export function computeFractureMechIntegration(data: number[], opts: FractureMechIntegrationOptions = {}): FractureMechIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechIntegration };
diff --git a/src/fracture_mech/interpolation.ts b/src/fracture_mech/interpolation.ts
new file mode 100644
index 000000000..a560f7c08
--- /dev/null
+++ b/src/fracture_mech/interpolation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech interpolation module — tsb analytics library. */
+export interface FractureMechInterpolationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechInterpolationResult { values: number[]; converged: boolean; }
+export function computeFractureMechInterpolation(data: number[], opts: FractureMechInterpolationOptions = {}): FractureMechInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechInterpolation };
diff --git a/src/fracture_mech/jacobian.ts b/src/fracture_mech/jacobian.ts
new file mode 100644
index 000000000..96969d78b
--- /dev/null
+++ b/src/fracture_mech/jacobian.ts
@@ -0,0 +1,14 @@
+/** fracture_mech jacobian module — tsb analytics library. */
+export interface FractureMechJacobianOptions { tol?: number; maxIter?: number; }
+export interface FractureMechJacobianResult { values: number[]; converged: boolean; }
+export function computeFractureMechJacobian(data: number[], opts: FractureMechJacobianOptions = {}): FractureMechJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechJacobian };
diff --git a/src/fracture_mech/kernel.ts b/src/fracture_mech/kernel.ts
new file mode 100644
index 000000000..27a2a8172
--- /dev/null
+++ b/src/fracture_mech/kernel.ts
@@ -0,0 +1,14 @@
+/** fracture_mech kernel module — tsb analytics library. */
+export interface FractureMechKernelOptions { tol?: number; maxIter?: number; }
+export interface FractureMechKernelResult { values: number[]; converged: boolean; }
+export function computeFractureMechKernel(data: number[], opts: FractureMechKernelOptions = {}): FractureMechKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechKernel };
diff --git a/src/fracture_mech/laplacian.ts b/src/fracture_mech/laplacian.ts
new file mode 100644
index 000000000..c947a7942
--- /dev/null
+++ b/src/fracture_mech/laplacian.ts
@@ -0,0 +1,14 @@
+/** fracture_mech laplacian module — tsb analytics library. */
+export interface FractureMechLaplacianOptions { tol?: number; maxIter?: number; }
+export interface FractureMechLaplacianResult { values: number[]; converged: boolean; }
+export function computeFractureMechLaplacian(data: number[], opts: FractureMechLaplacianOptions = {}): FractureMechLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechLaplacian };
diff --git a/src/fracture_mech/learning.ts b/src/fracture_mech/learning.ts
new file mode 100644
index 000000000..6740e5b13
--- /dev/null
+++ b/src/fracture_mech/learning.ts
@@ -0,0 +1,14 @@
+/** fracture_mech learning module — tsb analytics library. */
+export interface FractureMechLearningOptions { tol?: number; maxIter?: number; }
+export interface FractureMechLearningResult { values: number[]; converged: boolean; }
+export function computeFractureMechLearning(data: number[], opts: FractureMechLearningOptions = {}): FractureMechLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechLearning };
diff --git a/src/fracture_mech/linear.ts b/src/fracture_mech/linear.ts
new file mode 100644
index 000000000..618b36af3
--- /dev/null
+++ b/src/fracture_mech/linear.ts
@@ -0,0 +1,14 @@
+/** fracture_mech linear module — tsb analytics library. */
+export interface FractureMechLinearOptions { tol?: number; maxIter?: number; }
+export interface FractureMechLinearResult { values: number[]; converged: boolean; }
+export function computeFractureMechLinear(data: number[], opts: FractureMechLinearOptions = {}): FractureMechLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechLinear };
diff --git a/src/fracture_mech/manifold.ts b/src/fracture_mech/manifold.ts
new file mode 100644
index 000000000..4fcb51fef
--- /dev/null
+++ b/src/fracture_mech/manifold.ts
@@ -0,0 +1,14 @@
+/** fracture_mech manifold module — tsb analytics library. */
+export interface FractureMechManifoldOptions { tol?: number; maxIter?: number; }
+export interface FractureMechManifoldResult { values: number[]; converged: boolean; }
+export function computeFractureMechManifold(data: number[], opts: FractureMechManifoldOptions = {}): FractureMechManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechManifold };
diff --git a/src/fracture_mech/matching.ts b/src/fracture_mech/matching.ts
new file mode 100644
index 000000000..0f9384a80
--- /dev/null
+++ b/src/fracture_mech/matching.ts
@@ -0,0 +1,14 @@
+/** fracture_mech matching module — tsb analytics library. */
+export interface FractureMechMatchingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechMatchingResult { values: number[]; converged: boolean; }
+export function computeFractureMechMatching(data: number[], opts: FractureMechMatchingOptions = {}): FractureMechMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechMatching };
diff --git a/src/fracture_mech/measurement.ts b/src/fracture_mech/measurement.ts
new file mode 100644
index 000000000..45db6abc9
--- /dev/null
+++ b/src/fracture_mech/measurement.ts
@@ -0,0 +1,14 @@
+/** fracture_mech measurement module — tsb analytics library. */
+export interface FractureMechMeasurementOptions { tol?: number; maxIter?: number; }
+export interface FractureMechMeasurementResult { values: number[]; converged: boolean; }
+export function computeFractureMechMeasurement(data: number[], opts: FractureMechMeasurementOptions = {}): FractureMechMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechMeasurement };
diff --git a/src/fracture_mech/metrics.ts b/src/fracture_mech/metrics.ts
new file mode 100644
index 000000000..804861abc
--- /dev/null
+++ b/src/fracture_mech/metrics.ts
@@ -0,0 +1,14 @@
+/** fracture_mech metrics module — tsb analytics library. */
+export interface FractureMechMetricsOptions { tol?: number; maxIter?: number; }
+export interface FractureMechMetricsResult { values: number[]; converged: boolean; }
+export function computeFractureMechMetrics(data: number[], opts: FractureMechMetricsOptions = {}): FractureMechMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechMetrics };
diff --git a/src/fracture_mech/modeling.ts b/src/fracture_mech/modeling.ts
new file mode 100644
index 000000000..d735cb24f
--- /dev/null
+++ b/src/fracture_mech/modeling.ts
@@ -0,0 +1,14 @@
+/** fracture_mech modeling module — tsb analytics library. */
+export interface FractureMechModelingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechModelingResult { values: number[]; converged: boolean; }
+export function computeFractureMechModeling(data: number[], opts: FractureMechModelingOptions = {}): FractureMechModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechModeling };
diff --git a/src/fracture_mech/monitoring.ts b/src/fracture_mech/monitoring.ts
new file mode 100644
index 000000000..0f4501788
--- /dev/null
+++ b/src/fracture_mech/monitoring.ts
@@ -0,0 +1,14 @@
+/** fracture_mech monitoring module — tsb analytics library. */
+export interface FractureMechMonitoringOptions { tol?: number; maxIter?: number; }
+export interface FractureMechMonitoringResult { values: number[]; converged: boolean; }
+export function computeFractureMechMonitoring(data: number[], opts: FractureMechMonitoringOptions = {}): FractureMechMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechMonitoring };
diff --git a/src/fracture_mech/nonlinear.ts b/src/fracture_mech/nonlinear.ts
new file mode 100644
index 000000000..8454f2f06
--- /dev/null
+++ b/src/fracture_mech/nonlinear.ts
@@ -0,0 +1,14 @@
+/** fracture_mech nonlinear module — tsb analytics library. */
+export interface FractureMechNonlinearOptions { tol?: number; maxIter?: number; }
+export interface FractureMechNonlinearResult { values: number[]; converged: boolean; }
+export function computeFractureMechNonlinear(data: number[], opts: FractureMechNonlinearOptions = {}): FractureMechNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechNonlinear };
diff --git a/src/fracture_mech/normalization.ts b/src/fracture_mech/normalization.ts
new file mode 100644
index 000000000..e8d2b46f5
--- /dev/null
+++ b/src/fracture_mech/normalization.ts
@@ -0,0 +1,14 @@
+/** fracture_mech normalization module — tsb analytics library. */
+export interface FractureMechNormalizationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechNormalizationResult { values: number[]; converged: boolean; }
+export function computeFractureMechNormalization(data: number[], opts: FractureMechNormalizationOptions = {}): FractureMechNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechNormalization };
diff --git a/src/fracture_mech/optimization.ts b/src/fracture_mech/optimization.ts
new file mode 100644
index 000000000..b13636d1d
--- /dev/null
+++ b/src/fracture_mech/optimization.ts
@@ -0,0 +1,14 @@
+/** fracture_mech optimization module — tsb analytics library. */
+export interface FractureMechOptimizationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechOptimizationResult { values: number[]; converged: boolean; }
+export function computeFractureMechOptimization(data: number[], opts: FractureMechOptimizationOptions = {}): FractureMechOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechOptimization };
diff --git a/src/fracture_mech/patterns.ts b/src/fracture_mech/patterns.ts
new file mode 100644
index 000000000..d16f11518
--- /dev/null
+++ b/src/fracture_mech/patterns.ts
@@ -0,0 +1,14 @@
+/** fracture_mech patterns module — tsb analytics library. */
+export interface FractureMechPatternsOptions { tol?: number; maxIter?: number; }
+export interface FractureMechPatternsResult { values: number[]; converged: boolean; }
+export function computeFractureMechPatterns(data: number[], opts: FractureMechPatternsOptions = {}): FractureMechPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechPatterns };
diff --git a/src/fracture_mech/permutation.ts b/src/fracture_mech/permutation.ts
new file mode 100644
index 000000000..581d73888
--- /dev/null
+++ b/src/fracture_mech/permutation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech permutation module — tsb analytics library. */
+export interface FractureMechPermutationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechPermutationResult { values: number[]; converged: boolean; }
+export function computeFractureMechPermutation(data: number[], opts: FractureMechPermutationOptions = {}): FractureMechPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechPermutation };
diff --git a/src/fracture_mech/prediction.ts b/src/fracture_mech/prediction.ts
new file mode 100644
index 000000000..6b89587b7
--- /dev/null
+++ b/src/fracture_mech/prediction.ts
@@ -0,0 +1,14 @@
+/** fracture_mech prediction module — tsb analytics library. */
+export interface FractureMechPredictionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechPredictionResult { values: number[]; converged: boolean; }
+export function computeFractureMechPrediction(data: number[], opts: FractureMechPredictionOptions = {}): FractureMechPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechPrediction };
diff --git a/src/fracture_mech/processing.ts b/src/fracture_mech/processing.ts
new file mode 100644
index 000000000..e500c64db
--- /dev/null
+++ b/src/fracture_mech/processing.ts
@@ -0,0 +1,14 @@
+/** fracture_mech processing module — tsb analytics library. */
+export interface FractureMechProcessingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechProcessingResult { values: number[]; converged: boolean; }
+export function computeFractureMechProcessing(data: number[], opts: FractureMechProcessingOptions = {}): FractureMechProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechProcessing };
diff --git a/src/fracture_mech/profiling.ts b/src/fracture_mech/profiling.ts
new file mode 100644
index 000000000..96aefaa1c
--- /dev/null
+++ b/src/fracture_mech/profiling.ts
@@ -0,0 +1,14 @@
+/** fracture_mech profiling module — tsb analytics library. */
+export interface FractureMechProfilingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechProfilingResult { values: number[]; converged: boolean; }
+export function computeFractureMechProfiling(data: number[], opts: FractureMechProfilingOptions = {}): FractureMechProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechProfiling };
diff --git a/src/fracture_mech/projection.ts b/src/fracture_mech/projection.ts
new file mode 100644
index 000000000..6a873a3c6
--- /dev/null
+++ b/src/fracture_mech/projection.ts
@@ -0,0 +1,14 @@
+/** fracture_mech projection module — tsb analytics library. */
+export interface FractureMechProjectionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechProjectionResult { values: number[]; converged: boolean; }
+export function computeFractureMechProjection(data: number[], opts: FractureMechProjectionOptions = {}): FractureMechProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechProjection };
diff --git a/src/fracture_mech/ranking.ts b/src/fracture_mech/ranking.ts
new file mode 100644
index 000000000..d4f632597
--- /dev/null
+++ b/src/fracture_mech/ranking.ts
@@ -0,0 +1,14 @@
+/** fracture_mech ranking module — tsb analytics library. */
+export interface FractureMechRankingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechRankingResult { values: number[]; converged: boolean; }
+export function computeFractureMechRanking(data: number[], opts: FractureMechRankingOptions = {}): FractureMechRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechRanking };
diff --git a/src/fracture_mech/reconstruction.ts b/src/fracture_mech/reconstruction.ts
new file mode 100644
index 000000000..2d7238972
--- /dev/null
+++ b/src/fracture_mech/reconstruction.ts
@@ -0,0 +1,14 @@
+/** fracture_mech reconstruction module — tsb analytics library. */
+export interface FractureMechReconstructionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechReconstructionResult { values: number[]; converged: boolean; }
+export function computeFractureMechReconstruction(data: number[], opts: FractureMechReconstructionOptions = {}): FractureMechReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechReconstruction };
diff --git a/src/fracture_mech/registration.ts b/src/fracture_mech/registration.ts
new file mode 100644
index 000000000..805edd1ff
--- /dev/null
+++ b/src/fracture_mech/registration.ts
@@ -0,0 +1,14 @@
+/** fracture_mech registration module — tsb analytics library. */
+export interface FractureMechRegistrationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechRegistrationResult { values: number[]; converged: boolean; }
+export function computeFractureMechRegistration(data: number[], opts: FractureMechRegistrationOptions = {}): FractureMechRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechRegistration };
diff --git a/src/fracture_mech/regression.ts b/src/fracture_mech/regression.ts
new file mode 100644
index 000000000..8eb651799
--- /dev/null
+++ b/src/fracture_mech/regression.ts
@@ -0,0 +1,14 @@
+/** fracture_mech regression module — tsb analytics library. */
+export interface FractureMechRegressionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechRegressionResult { values: number[]; converged: boolean; }
+export function computeFractureMechRegression(data: number[], opts: FractureMechRegressionOptions = {}): FractureMechRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechRegression };
diff --git a/src/fracture_mech/regularization.ts b/src/fracture_mech/regularization.ts
new file mode 100644
index 000000000..808d403dd
--- /dev/null
+++ b/src/fracture_mech/regularization.ts
@@ -0,0 +1,14 @@
+/** fracture_mech regularization module — tsb analytics library. */
+export interface FractureMechRegularizationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechRegularizationResult { values: number[]; converged: boolean; }
+export function computeFractureMechRegularization(data: number[], opts: FractureMechRegularizationOptions = {}): FractureMechRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechRegularization };
diff --git a/src/fracture_mech/robustness.ts b/src/fracture_mech/robustness.ts
new file mode 100644
index 000000000..0e9552247
--- /dev/null
+++ b/src/fracture_mech/robustness.ts
@@ -0,0 +1,14 @@
+/** fracture_mech robustness module — tsb analytics library. */
+export interface FractureMechRobustnessOptions { tol?: number; maxIter?: number; }
+export interface FractureMechRobustnessResult { values: number[]; converged: boolean; }
+export function computeFractureMechRobustness(data: number[], opts: FractureMechRobustnessOptions = {}): FractureMechRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechRobustness };
diff --git a/src/fracture_mech/sampling.ts b/src/fracture_mech/sampling.ts
new file mode 100644
index 000000000..b58046f62
--- /dev/null
+++ b/src/fracture_mech/sampling.ts
@@ -0,0 +1,14 @@
+/** fracture_mech sampling module — tsb analytics library. */
+export interface FractureMechSamplingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechSamplingResult { values: number[]; converged: boolean; }
+export function computeFractureMechSampling(data: number[], opts: FractureMechSamplingOptions = {}): FractureMechSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechSampling };
diff --git a/src/fracture_mech/sampling2.ts b/src/fracture_mech/sampling2.ts
new file mode 100644
index 000000000..24b97e48c
--- /dev/null
+++ b/src/fracture_mech/sampling2.ts
@@ -0,0 +1,14 @@
+/** fracture_mech sampling2 module — tsb analytics library. */
+export interface FractureMechSamplingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechSamplingResult { values: number[]; converged: boolean; }
+export function computeFractureMechSampling(data: number[], opts: FractureMechSamplingOptions = {}): FractureMechSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechSampling };
diff --git a/src/fracture_mech/scaling.ts b/src/fracture_mech/scaling.ts
new file mode 100644
index 000000000..bb8ec211d
--- /dev/null
+++ b/src/fracture_mech/scaling.ts
@@ -0,0 +1,14 @@
+/** fracture_mech scaling module — tsb analytics library. */
+export interface FractureMechScalingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechScalingResult { values: number[]; converged: boolean; }
+export function computeFractureMechScaling(data: number[], opts: FractureMechScalingOptions = {}): FractureMechScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechScaling };
diff --git a/src/fracture_mech/scoring.ts b/src/fracture_mech/scoring.ts
new file mode 100644
index 000000000..fd1ee6f52
--- /dev/null
+++ b/src/fracture_mech/scoring.ts
@@ -0,0 +1,14 @@
+/** fracture_mech scoring module — tsb analytics library. */
+export interface FractureMechScoringOptions { tol?: number; maxIter?: number; }
+export interface FractureMechScoringResult { values: number[]; converged: boolean; }
+export function computeFractureMechScoring(data: number[], opts: FractureMechScoringOptions = {}): FractureMechScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechScoring };
diff --git a/src/fracture_mech/segmentation.ts b/src/fracture_mech/segmentation.ts
new file mode 100644
index 000000000..4b422093b
--- /dev/null
+++ b/src/fracture_mech/segmentation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech segmentation module — tsb analytics library. */
+export interface FractureMechSegmentationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechSegmentationResult { values: number[]; converged: boolean; }
+export function computeFractureMechSegmentation(data: number[], opts: FractureMechSegmentationOptions = {}): FractureMechSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechSegmentation };
diff --git a/src/fracture_mech/selection.ts b/src/fracture_mech/selection.ts
new file mode 100644
index 000000000..4ae5ebe78
--- /dev/null
+++ b/src/fracture_mech/selection.ts
@@ -0,0 +1,14 @@
+/** fracture_mech selection module — tsb analytics library. */
+export interface FractureMechSelectionOptions { tol?: number; maxIter?: number; }
+export interface FractureMechSelectionResult { values: number[]; converged: boolean; }
+export function computeFractureMechSelection(data: number[], opts: FractureMechSelectionOptions = {}): FractureMechSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechSelection };
diff --git a/src/fracture_mech/sensitivity.ts b/src/fracture_mech/sensitivity.ts
new file mode 100644
index 000000000..580f9de42
--- /dev/null
+++ b/src/fracture_mech/sensitivity.ts
@@ -0,0 +1,14 @@
+/** fracture_mech sensitivity module — tsb analytics library. */
+export interface FractureMechSensitivityOptions { tol?: number; maxIter?: number; }
+export interface FractureMechSensitivityResult { values: number[]; converged: boolean; }
+export function computeFractureMechSensitivity(data: number[], opts: FractureMechSensitivityOptions = {}): FractureMechSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechSensitivity };
diff --git a/src/fracture_mech/simulation.ts b/src/fracture_mech/simulation.ts
new file mode 100644
index 000000000..35b21247b
--- /dev/null
+++ b/src/fracture_mech/simulation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech simulation module — tsb analytics library. */
+export interface FractureMechSimulationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechSimulationResult { values: number[]; converged: boolean; }
+export function computeFractureMechSimulation(data: number[], opts: FractureMechSimulationOptions = {}): FractureMechSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechSimulation };
diff --git a/src/fracture_mech/smoothing.ts b/src/fracture_mech/smoothing.ts
new file mode 100644
index 000000000..9d2f1b6b6
--- /dev/null
+++ b/src/fracture_mech/smoothing.ts
@@ -0,0 +1,14 @@
+/** fracture_mech smoothing module — tsb analytics library. */
+export interface FractureMechSmoothingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechSmoothingResult { values: number[]; converged: boolean; }
+export function computeFractureMechSmoothing(data: number[], opts: FractureMechSmoothingOptions = {}): FractureMechSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechSmoothing };
diff --git a/src/fracture_mech/stability.ts b/src/fracture_mech/stability.ts
new file mode 100644
index 000000000..363f6ee71
--- /dev/null
+++ b/src/fracture_mech/stability.ts
@@ -0,0 +1,14 @@
+/** fracture_mech stability module — tsb analytics library. */
+export interface FractureMechStabilityOptions { tol?: number; maxIter?: number; }
+export interface FractureMechStabilityResult { values: number[]; converged: boolean; }
+export function computeFractureMechStability(data: number[], opts: FractureMechStabilityOptions = {}): FractureMechStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechStability };
diff --git a/src/fracture_mech/stacking.ts b/src/fracture_mech/stacking.ts
new file mode 100644
index 000000000..091711320
--- /dev/null
+++ b/src/fracture_mech/stacking.ts
@@ -0,0 +1,14 @@
+/** fracture_mech stacking module — tsb analytics library. */
+export interface FractureMechStackingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechStackingResult { values: number[]; converged: boolean; }
+export function computeFractureMechStacking(data: number[], opts: FractureMechStackingOptions = {}): FractureMechStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechStacking };
diff --git a/src/fracture_mech/standardization.ts b/src/fracture_mech/standardization.ts
new file mode 100644
index 000000000..f5cff07d7
--- /dev/null
+++ b/src/fracture_mech/standardization.ts
@@ -0,0 +1,14 @@
+/** fracture_mech standardization module — tsb analytics library. */
+export interface FractureMechStandardizationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechStandardizationResult { values: number[]; converged: boolean; }
+export function computeFractureMechStandardization(data: number[], opts: FractureMechStandardizationOptions = {}): FractureMechStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechStandardization };
diff --git a/src/fracture_mech/static.ts b/src/fracture_mech/static.ts
new file mode 100644
index 000000000..b84ea1af4
--- /dev/null
+++ b/src/fracture_mech/static.ts
@@ -0,0 +1,14 @@
+/** fracture_mech static module — tsb analytics library. */
+export interface FractureMechStaticOptions { tol?: number; maxIter?: number; }
+export interface FractureMechStaticResult { values: number[]; converged: boolean; }
+export function computeFractureMechStatic(data: number[], opts: FractureMechStaticOptions = {}): FractureMechStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechStatic };
diff --git a/src/fracture_mech/stochastic.ts b/src/fracture_mech/stochastic.ts
new file mode 100644
index 000000000..fc1abcc58
--- /dev/null
+++ b/src/fracture_mech/stochastic.ts
@@ -0,0 +1,14 @@
+/** fracture_mech stochastic module — tsb analytics library. */
+export interface FractureMechStochasticOptions { tol?: number; maxIter?: number; }
+export interface FractureMechStochasticResult { values: number[]; converged: boolean; }
+export function computeFractureMechStochastic(data: number[], opts: FractureMechStochasticOptions = {}): FractureMechStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechStochastic };
diff --git a/src/fracture_mech/synthesis.ts b/src/fracture_mech/synthesis.ts
new file mode 100644
index 000000000..c771928cb
--- /dev/null
+++ b/src/fracture_mech/synthesis.ts
@@ -0,0 +1,14 @@
+/** fracture_mech synthesis module — tsb analytics library. */
+export interface FractureMechSynthesisOptions { tol?: number; maxIter?: number; }
+export interface FractureMechSynthesisResult { values: number[]; converged: boolean; }
+export function computeFractureMechSynthesis(data: number[], opts: FractureMechSynthesisOptions = {}): FractureMechSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechSynthesis };
diff --git a/src/fracture_mech/topology.ts b/src/fracture_mech/topology.ts
new file mode 100644
index 000000000..7868bf854
--- /dev/null
+++ b/src/fracture_mech/topology.ts
@@ -0,0 +1,14 @@
+/** fracture_mech topology module — tsb analytics library. */
+export interface FractureMechTopologyOptions { tol?: number; maxIter?: number; }
+export interface FractureMechTopologyResult { values: number[]; converged: boolean; }
+export function computeFractureMechTopology(data: number[], opts: FractureMechTopologyOptions = {}): FractureMechTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechTopology };
diff --git a/src/fracture_mech/tracking.ts b/src/fracture_mech/tracking.ts
new file mode 100644
index 000000000..6e0e6bf13
--- /dev/null
+++ b/src/fracture_mech/tracking.ts
@@ -0,0 +1,14 @@
+/** fracture_mech tracking module — tsb analytics library. */
+export interface FractureMechTrackingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechTrackingResult { values: number[]; converged: boolean; }
+export function computeFractureMechTracking(data: number[], opts: FractureMechTrackingOptions = {}): FractureMechTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechTracking };
diff --git a/src/fracture_mech/transform.ts b/src/fracture_mech/transform.ts
new file mode 100644
index 000000000..5c315523e
--- /dev/null
+++ b/src/fracture_mech/transform.ts
@@ -0,0 +1,14 @@
+/** fracture_mech transform module — tsb analytics library. */
+export interface FractureMechTransformOptions { tol?: number; maxIter?: number; }
+export interface FractureMechTransformResult { values: number[]; converged: boolean; }
+export function computeFractureMechTransform(data: number[], opts: FractureMechTransformOptions = {}): FractureMechTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechTransform };
diff --git a/src/fracture_mech/uncertainty.ts b/src/fracture_mech/uncertainty.ts
new file mode 100644
index 000000000..8513c4f4b
--- /dev/null
+++ b/src/fracture_mech/uncertainty.ts
@@ -0,0 +1,14 @@
+/** fracture_mech uncertainty module — tsb analytics library. */
+export interface FractureMechUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface FractureMechUncertaintyResult { values: number[]; converged: boolean; }
+export function computeFractureMechUncertainty(data: number[], opts: FractureMechUncertaintyOptions = {}): FractureMechUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechUncertainty };
diff --git a/src/fracture_mech/validation.ts b/src/fracture_mech/validation.ts
new file mode 100644
index 000000000..d6b29393e
--- /dev/null
+++ b/src/fracture_mech/validation.ts
@@ -0,0 +1,14 @@
+/** fracture_mech validation module — tsb analytics library. */
+export interface FractureMechValidationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechValidationResult { values: number[]; converged: boolean; }
+export function computeFractureMechValidation(data: number[], opts: FractureMechValidationOptions = {}): FractureMechValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechValidation };
diff --git a/src/fracture_mech/verification.ts b/src/fracture_mech/verification.ts
new file mode 100644
index 000000000..070d21b2f
--- /dev/null
+++ b/src/fracture_mech/verification.ts
@@ -0,0 +1,14 @@
+/** fracture_mech verification module — tsb analytics library. */
+export interface FractureMechVerificationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechVerificationResult { values: number[]; converged: boolean; }
+export function computeFractureMechVerification(data: number[], opts: FractureMechVerificationOptions = {}): FractureMechVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechVerification };
diff --git a/src/fracture_mech/visualization.ts b/src/fracture_mech/visualization.ts
new file mode 100644
index 000000000..80d95195b
--- /dev/null
+++ b/src/fracture_mech/visualization.ts
@@ -0,0 +1,14 @@
+/** fracture_mech visualization module — tsb analytics library. */
+export interface FractureMechVisualizationOptions { tol?: number; maxIter?: number; }
+export interface FractureMechVisualizationResult { values: number[]; converged: boolean; }
+export function computeFractureMechVisualization(data: number[], opts: FractureMechVisualizationOptions = {}): FractureMechVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechVisualization };
diff --git a/src/fracture_mech/voting.ts b/src/fracture_mech/voting.ts
new file mode 100644
index 000000000..49d135cb2
--- /dev/null
+++ b/src/fracture_mech/voting.ts
@@ -0,0 +1,14 @@
+/** fracture_mech voting module — tsb analytics library. */
+export interface FractureMechVotingOptions { tol?: number; maxIter?: number; }
+export interface FractureMechVotingResult { values: number[]; converged: boolean; }
+export function computeFractureMechVoting(data: number[], opts: FractureMechVotingOptions = {}): FractureMechVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechVoting };
diff --git a/src/fracture_mech/wavelet.ts b/src/fracture_mech/wavelet.ts
new file mode 100644
index 000000000..df4d08e1e
--- /dev/null
+++ b/src/fracture_mech/wavelet.ts
@@ -0,0 +1,14 @@
+/** fracture_mech wavelet module — tsb analytics library. */
+export interface FractureMechWaveletOptions { tol?: number; maxIter?: number; }
+export interface FractureMechWaveletResult { values: number[]; converged: boolean; }
+export function computeFractureMechWavelet(data: number[], opts: FractureMechWaveletOptions = {}): FractureMechWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFractureMechWavelet };
diff --git a/src/freshwater_bio/adaptation.ts b/src/freshwater_bio/adaptation.ts
new file mode 100644
index 000000000..3bc696980
--- /dev/null
+++ b/src/freshwater_bio/adaptation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio adaptation module — tsb analytics library. */
+export interface FreshwaterBioAdaptationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioAdaptationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioAdaptation(data: number[], opts: FreshwaterBioAdaptationOptions = {}): FreshwaterBioAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioAdaptation };
diff --git a/src/freshwater_bio/aggregation.ts b/src/freshwater_bio/aggregation.ts
new file mode 100644
index 000000000..012797fb4
--- /dev/null
+++ b/src/freshwater_bio/aggregation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio aggregation module — tsb analytics library. */
+export interface FreshwaterBioAggregationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioAggregationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioAggregation(data: number[], opts: FreshwaterBioAggregationOptions = {}): FreshwaterBioAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioAggregation };
diff --git a/src/freshwater_bio/algebra.ts b/src/freshwater_bio/algebra.ts
new file mode 100644
index 000000000..3a7b02923
--- /dev/null
+++ b/src/freshwater_bio/algebra.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio algebra module — tsb analytics library. */
+export interface FreshwaterBioAlgebraOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioAlgebraResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioAlgebra(data: number[], opts: FreshwaterBioAlgebraOptions = {}): FreshwaterBioAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioAlgebra };
diff --git a/src/freshwater_bio/alignment.ts b/src/freshwater_bio/alignment.ts
new file mode 100644
index 000000000..9de3f24af
--- /dev/null
+++ b/src/freshwater_bio/alignment.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio alignment module — tsb analytics library. */
+export interface FreshwaterBioAlignmentOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioAlignmentResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioAlignment(data: number[], opts: FreshwaterBioAlignmentOptions = {}): FreshwaterBioAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioAlignment };
diff --git a/src/freshwater_bio/analysis.ts b/src/freshwater_bio/analysis.ts
new file mode 100644
index 000000000..e02a91be6
--- /dev/null
+++ b/src/freshwater_bio/analysis.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio analysis module — tsb analytics library. */
+export interface FreshwaterBioAnalysisOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioAnalysisResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioAnalysis(data: number[], opts: FreshwaterBioAnalysisOptions = {}): FreshwaterBioAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioAnalysis };
diff --git a/src/freshwater_bio/augmentation.ts b/src/freshwater_bio/augmentation.ts
new file mode 100644
index 000000000..6a0679c4a
--- /dev/null
+++ b/src/freshwater_bio/augmentation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio augmentation module — tsb analytics library. */
+export interface FreshwaterBioAugmentationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioAugmentationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioAugmentation(data: number[], opts: FreshwaterBioAugmentationOptions = {}): FreshwaterBioAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioAugmentation };
diff --git a/src/freshwater_bio/bagging.ts b/src/freshwater_bio/bagging.ts
new file mode 100644
index 000000000..f20fadfb3
--- /dev/null
+++ b/src/freshwater_bio/bagging.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio bagging module — tsb analytics library. */
+export interface FreshwaterBioBaggingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioBaggingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioBagging(data: number[], opts: FreshwaterBioBaggingOptions = {}): FreshwaterBioBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioBagging };
diff --git a/src/freshwater_bio/basis.ts b/src/freshwater_bio/basis.ts
new file mode 100644
index 000000000..c125b7b05
--- /dev/null
+++ b/src/freshwater_bio/basis.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio basis module — tsb analytics library. */
+export interface FreshwaterBioBasisOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioBasisResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioBasis(data: number[], opts: FreshwaterBioBasisOptions = {}): FreshwaterBioBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioBasis };
diff --git a/src/freshwater_bio/benchmarking.ts b/src/freshwater_bio/benchmarking.ts
new file mode 100644
index 000000000..1de1a90c9
--- /dev/null
+++ b/src/freshwater_bio/benchmarking.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio benchmarking module — tsb analytics library. */
+export interface FreshwaterBioBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioBenchmarking(data: number[], opts: FreshwaterBioBenchmarkingOptions = {}): FreshwaterBioBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioBenchmarking };
diff --git a/src/freshwater_bio/blending.ts b/src/freshwater_bio/blending.ts
new file mode 100644
index 000000000..e8817b556
--- /dev/null
+++ b/src/freshwater_bio/blending.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio blending module — tsb analytics library. */
+export interface FreshwaterBioBlendingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioBlendingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioBlending(data: number[], opts: FreshwaterBioBlendingOptions = {}): FreshwaterBioBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioBlending };
diff --git a/src/freshwater_bio/boosting.ts b/src/freshwater_bio/boosting.ts
new file mode 100644
index 000000000..503f8dd52
--- /dev/null
+++ b/src/freshwater_bio/boosting.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio boosting module — tsb analytics library. */
+export interface FreshwaterBioBoostingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioBoostingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioBoosting(data: number[], opts: FreshwaterBioBoostingOptions = {}): FreshwaterBioBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioBoosting };
diff --git a/src/freshwater_bio/bootstrap.ts b/src/freshwater_bio/bootstrap.ts
new file mode 100644
index 000000000..ba08511ed
--- /dev/null
+++ b/src/freshwater_bio/bootstrap.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio bootstrap module — tsb analytics library. */
+export interface FreshwaterBioBootstrapOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioBootstrapResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioBootstrap(data: number[], opts: FreshwaterBioBootstrapOptions = {}): FreshwaterBioBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioBootstrap };
diff --git a/src/freshwater_bio/calculus.ts b/src/freshwater_bio/calculus.ts
new file mode 100644
index 000000000..7eea08f41
--- /dev/null
+++ b/src/freshwater_bio/calculus.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio calculus module — tsb analytics library. */
+export interface FreshwaterBioCalculusOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioCalculusResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioCalculus(data: number[], opts: FreshwaterBioCalculusOptions = {}): FreshwaterBioCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioCalculus };
diff --git a/src/freshwater_bio/calibration.ts b/src/freshwater_bio/calibration.ts
new file mode 100644
index 000000000..f4798fc14
--- /dev/null
+++ b/src/freshwater_bio/calibration.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio calibration module — tsb analytics library. */
+export interface FreshwaterBioCalibrationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioCalibrationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioCalibration(data: number[], opts: FreshwaterBioCalibrationOptions = {}): FreshwaterBioCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioCalibration };
diff --git a/src/freshwater_bio/characterization.ts b/src/freshwater_bio/characterization.ts
new file mode 100644
index 000000000..9baf4ab67
--- /dev/null
+++ b/src/freshwater_bio/characterization.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio characterization module — tsb analytics library. */
+export interface FreshwaterBioCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioCharacterizationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioCharacterization(data: number[], opts: FreshwaterBioCharacterizationOptions = {}): FreshwaterBioCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioCharacterization };
diff --git a/src/freshwater_bio/classification.ts b/src/freshwater_bio/classification.ts
new file mode 100644
index 000000000..8b5c9fe36
--- /dev/null
+++ b/src/freshwater_bio/classification.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio classification module — tsb analytics library. */
+export interface FreshwaterBioClassificationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioClassificationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioClassification(data: number[], opts: FreshwaterBioClassificationOptions = {}): FreshwaterBioClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioClassification };
diff --git a/src/freshwater_bio/clustering.ts b/src/freshwater_bio/clustering.ts
new file mode 100644
index 000000000..127c94039
--- /dev/null
+++ b/src/freshwater_bio/clustering.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio clustering module — tsb analytics library. */
+export interface FreshwaterBioClusteringOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioClusteringResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioClustering(data: number[], opts: FreshwaterBioClusteringOptions = {}): FreshwaterBioClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioClustering };
diff --git a/src/freshwater_bio/compression.ts b/src/freshwater_bio/compression.ts
new file mode 100644
index 000000000..6fe55ba5b
--- /dev/null
+++ b/src/freshwater_bio/compression.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio compression module — tsb analytics library. */
+export interface FreshwaterBioCompressionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioCompressionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioCompression(data: number[], opts: FreshwaterBioCompressionOptions = {}): FreshwaterBioCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioCompression };
diff --git a/src/freshwater_bio/continuous.ts b/src/freshwater_bio/continuous.ts
new file mode 100644
index 000000000..a8ada1fef
--- /dev/null
+++ b/src/freshwater_bio/continuous.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio continuous module — tsb analytics library. */
+export interface FreshwaterBioContinuousOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioContinuousResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioContinuous(data: number[], opts: FreshwaterBioContinuousOptions = {}): FreshwaterBioContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioContinuous };
diff --git a/src/freshwater_bio/control.ts b/src/freshwater_bio/control.ts
new file mode 100644
index 000000000..57c9efa46
--- /dev/null
+++ b/src/freshwater_bio/control.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio control module — tsb analytics library. */
+export interface FreshwaterBioControlOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioControlResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioControl(data: number[], opts: FreshwaterBioControlOptions = {}): FreshwaterBioControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioControl };
diff --git a/src/freshwater_bio/convergence.ts b/src/freshwater_bio/convergence.ts
new file mode 100644
index 000000000..618329e31
--- /dev/null
+++ b/src/freshwater_bio/convergence.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio convergence module — tsb analytics library. */
+export interface FreshwaterBioConvergenceOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioConvergenceResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioConvergence(data: number[], opts: FreshwaterBioConvergenceOptions = {}): FreshwaterBioConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioConvergence };
diff --git a/src/freshwater_bio/convex.ts b/src/freshwater_bio/convex.ts
new file mode 100644
index 000000000..ae9071b20
--- /dev/null
+++ b/src/freshwater_bio/convex.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio convex module — tsb analytics library. */
+export interface FreshwaterBioConvexOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioConvexResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioConvex(data: number[], opts: FreshwaterBioConvexOptions = {}): FreshwaterBioConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioConvex };
diff --git a/src/freshwater_bio/correlation.ts b/src/freshwater_bio/correlation.ts
new file mode 100644
index 000000000..7718e91bb
--- /dev/null
+++ b/src/freshwater_bio/correlation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio correlation module — tsb analytics library. */
+export interface FreshwaterBioCorrelationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioCorrelationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioCorrelation(data: number[], opts: FreshwaterBioCorrelationOptions = {}): FreshwaterBioCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioCorrelation };
diff --git a/src/freshwater_bio/covariance.ts b/src/freshwater_bio/covariance.ts
new file mode 100644
index 000000000..2dd664823
--- /dev/null
+++ b/src/freshwater_bio/covariance.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio covariance module — tsb analytics library. */
+export interface FreshwaterBioCovarianceOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioCovarianceResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioCovariance(data: number[], opts: FreshwaterBioCovarianceOptions = {}): FreshwaterBioCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioCovariance };
diff --git a/src/freshwater_bio/cross_validation.ts b/src/freshwater_bio/cross_validation.ts
new file mode 100644
index 000000000..d1f96d644
--- /dev/null
+++ b/src/freshwater_bio/cross_validation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio cross_validation module — tsb analytics library. */
+export interface FreshwaterBioCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioCrossValidationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioCrossValidation(data: number[], opts: FreshwaterBioCrossValidationOptions = {}): FreshwaterBioCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioCrossValidation };
diff --git a/src/freshwater_bio/decoding.ts b/src/freshwater_bio/decoding.ts
new file mode 100644
index 000000000..9d05f0d27
--- /dev/null
+++ b/src/freshwater_bio/decoding.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio decoding module — tsb analytics library. */
+export interface FreshwaterBioDecodingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDecodingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDecoding(data: number[], opts: FreshwaterBioDecodingOptions = {}): FreshwaterBioDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDecoding };
diff --git a/src/freshwater_bio/decomposition.ts b/src/freshwater_bio/decomposition.ts
new file mode 100644
index 000000000..c21c03125
--- /dev/null
+++ b/src/freshwater_bio/decomposition.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio decomposition module — tsb analytics library. */
+export interface FreshwaterBioDecompositionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDecompositionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDecomposition(data: number[], opts: FreshwaterBioDecompositionOptions = {}): FreshwaterBioDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDecomposition };
diff --git a/src/freshwater_bio/detection.ts b/src/freshwater_bio/detection.ts
new file mode 100644
index 000000000..29aa00b14
--- /dev/null
+++ b/src/freshwater_bio/detection.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio detection module — tsb analytics library. */
+export interface FreshwaterBioDetectionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDetectionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDetection(data: number[], opts: FreshwaterBioDetectionOptions = {}): FreshwaterBioDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDetection };
diff --git a/src/freshwater_bio/deterministic.ts b/src/freshwater_bio/deterministic.ts
new file mode 100644
index 000000000..fe858278a
--- /dev/null
+++ b/src/freshwater_bio/deterministic.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio deterministic module — tsb analytics library. */
+export interface FreshwaterBioDeterministicOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDeterministicResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDeterministic(data: number[], opts: FreshwaterBioDeterministicOptions = {}): FreshwaterBioDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDeterministic };
diff --git a/src/freshwater_bio/diagnostics.ts b/src/freshwater_bio/diagnostics.ts
new file mode 100644
index 000000000..337713460
--- /dev/null
+++ b/src/freshwater_bio/diagnostics.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio diagnostics module — tsb analytics library. */
+export interface FreshwaterBioDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDiagnostics(data: number[], opts: FreshwaterBioDiagnosticsOptions = {}): FreshwaterBioDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDiagnostics };
diff --git a/src/freshwater_bio/differential.ts b/src/freshwater_bio/differential.ts
new file mode 100644
index 000000000..fa6a717fc
--- /dev/null
+++ b/src/freshwater_bio/differential.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio differential module — tsb analytics library. */
+export interface FreshwaterBioDifferentialOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDifferentialResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDifferential(data: number[], opts: FreshwaterBioDifferentialOptions = {}): FreshwaterBioDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDifferential };
diff --git a/src/freshwater_bio/discrete.ts b/src/freshwater_bio/discrete.ts
new file mode 100644
index 000000000..3d79fb3e1
--- /dev/null
+++ b/src/freshwater_bio/discrete.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio discrete module — tsb analytics library. */
+export interface FreshwaterBioDiscreteOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDiscreteResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDiscrete(data: number[], opts: FreshwaterBioDiscreteOptions = {}): FreshwaterBioDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDiscrete };
diff --git a/src/freshwater_bio/distribution.ts b/src/freshwater_bio/distribution.ts
new file mode 100644
index 000000000..d0b6ad25a
--- /dev/null
+++ b/src/freshwater_bio/distribution.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio distribution module — tsb analytics library. */
+export interface FreshwaterBioDistributionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDistributionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDistribution(data: number[], opts: FreshwaterBioDistributionOptions = {}): FreshwaterBioDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDistribution };
diff --git a/src/freshwater_bio/dynamic.ts b/src/freshwater_bio/dynamic.ts
new file mode 100644
index 000000000..19a5a534b
--- /dev/null
+++ b/src/freshwater_bio/dynamic.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio dynamic module — tsb analytics library. */
+export interface FreshwaterBioDynamicOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioDynamicResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioDynamic(data: number[], opts: FreshwaterBioDynamicOptions = {}): FreshwaterBioDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioDynamic };
diff --git a/src/freshwater_bio/embedding.ts b/src/freshwater_bio/embedding.ts
new file mode 100644
index 000000000..d80fbbea9
--- /dev/null
+++ b/src/freshwater_bio/embedding.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio embedding module — tsb analytics library. */
+export interface FreshwaterBioEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioEmbeddingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioEmbedding(data: number[], opts: FreshwaterBioEmbeddingOptions = {}): FreshwaterBioEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioEmbedding };
diff --git a/src/freshwater_bio/encoding.ts b/src/freshwater_bio/encoding.ts
new file mode 100644
index 000000000..b66f750b1
--- /dev/null
+++ b/src/freshwater_bio/encoding.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio encoding module — tsb analytics library. */
+export interface FreshwaterBioEncodingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioEncodingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioEncoding(data: number[], opts: FreshwaterBioEncodingOptions = {}): FreshwaterBioEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioEncoding };
diff --git a/src/freshwater_bio/ensemble.ts b/src/freshwater_bio/ensemble.ts
new file mode 100644
index 000000000..8bae5c8ed
--- /dev/null
+++ b/src/freshwater_bio/ensemble.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio ensemble module — tsb analytics library. */
+export interface FreshwaterBioEnsembleOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioEnsembleResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioEnsemble(data: number[], opts: FreshwaterBioEnsembleOptions = {}): FreshwaterBioEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioEnsemble };
diff --git a/src/freshwater_bio/estimation.ts b/src/freshwater_bio/estimation.ts
new file mode 100644
index 000000000..632e9a05e
--- /dev/null
+++ b/src/freshwater_bio/estimation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio estimation module — tsb analytics library. */
+export interface FreshwaterBioEstimationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioEstimationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioEstimation(data: number[], opts: FreshwaterBioEstimationOptions = {}): FreshwaterBioEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioEstimation };
diff --git a/src/freshwater_bio/evaluation.ts b/src/freshwater_bio/evaluation.ts
new file mode 100644
index 000000000..b6dd39a4a
--- /dev/null
+++ b/src/freshwater_bio/evaluation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio evaluation module — tsb analytics library. */
+export interface FreshwaterBioEvaluationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioEvaluationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioEvaluation(data: number[], opts: FreshwaterBioEvaluationOptions = {}): FreshwaterBioEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioEvaluation };
diff --git a/src/freshwater_bio/extrapolation.ts b/src/freshwater_bio/extrapolation.ts
new file mode 100644
index 000000000..0cb26f8a1
--- /dev/null
+++ b/src/freshwater_bio/extrapolation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio extrapolation module — tsb analytics library. */
+export interface FreshwaterBioExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioExtrapolationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioExtrapolation(data: number[], opts: FreshwaterBioExtrapolationOptions = {}): FreshwaterBioExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioExtrapolation };
diff --git a/src/freshwater_bio/features.ts b/src/freshwater_bio/features.ts
new file mode 100644
index 000000000..0e6f64e00
--- /dev/null
+++ b/src/freshwater_bio/features.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio features module — tsb analytics library. */
+export interface FreshwaterBioFeaturesOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioFeaturesResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioFeatures(data: number[], opts: FreshwaterBioFeaturesOptions = {}): FreshwaterBioFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioFeatures };
diff --git a/src/freshwater_bio/feedback.ts b/src/freshwater_bio/feedback.ts
new file mode 100644
index 000000000..2ac91f517
--- /dev/null
+++ b/src/freshwater_bio/feedback.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio feedback module — tsb analytics library. */
+export interface FreshwaterBioFeedbackOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioFeedbackResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioFeedback(data: number[], opts: FreshwaterBioFeedbackOptions = {}): FreshwaterBioFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioFeedback };
diff --git a/src/freshwater_bio/filtering.ts b/src/freshwater_bio/filtering.ts
new file mode 100644
index 000000000..65fb8a2b5
--- /dev/null
+++ b/src/freshwater_bio/filtering.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio filtering module — tsb analytics library. */
+export interface FreshwaterBioFilteringOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioFilteringResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioFiltering(data: number[], opts: FreshwaterBioFilteringOptions = {}): FreshwaterBioFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioFiltering };
diff --git a/src/freshwater_bio/fourier.ts b/src/freshwater_bio/fourier.ts
new file mode 100644
index 000000000..c1106b16f
--- /dev/null
+++ b/src/freshwater_bio/fourier.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio fourier module — tsb analytics library. */
+export interface FreshwaterBioFourierOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioFourierResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioFourier(data: number[], opts: FreshwaterBioFourierOptions = {}): FreshwaterBioFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioFourier };
diff --git a/src/freshwater_bio/fusion.ts b/src/freshwater_bio/fusion.ts
new file mode 100644
index 000000000..1c6669464
--- /dev/null
+++ b/src/freshwater_bio/fusion.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio fusion module — tsb analytics library. */
+export interface FreshwaterBioFusionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioFusionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioFusion(data: number[], opts: FreshwaterBioFusionOptions = {}): FreshwaterBioFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioFusion };
diff --git a/src/freshwater_bio/generation.ts b/src/freshwater_bio/generation.ts
new file mode 100644
index 000000000..13e978f24
--- /dev/null
+++ b/src/freshwater_bio/generation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio generation module — tsb analytics library. */
+export interface FreshwaterBioGenerationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioGenerationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioGeneration(data: number[], opts: FreshwaterBioGenerationOptions = {}): FreshwaterBioGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioGeneration };
diff --git a/src/freshwater_bio/geometry.ts b/src/freshwater_bio/geometry.ts
new file mode 100644
index 000000000..4d2bd25ad
--- /dev/null
+++ b/src/freshwater_bio/geometry.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio geometry module — tsb analytics library. */
+export interface FreshwaterBioGeometryOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioGeometryResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioGeometry(data: number[], opts: FreshwaterBioGeometryOptions = {}): FreshwaterBioGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioGeometry };
diff --git a/src/freshwater_bio/gradient.ts b/src/freshwater_bio/gradient.ts
new file mode 100644
index 000000000..9a1993582
--- /dev/null
+++ b/src/freshwater_bio/gradient.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio gradient module — tsb analytics library. */
+export interface FreshwaterBioGradientOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioGradientResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioGradient(data: number[], opts: FreshwaterBioGradientOptions = {}): FreshwaterBioGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioGradient };
diff --git a/src/freshwater_bio/hessian.ts b/src/freshwater_bio/hessian.ts
new file mode 100644
index 000000000..e66d2cd4c
--- /dev/null
+++ b/src/freshwater_bio/hessian.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio hessian module — tsb analytics library. */
+export interface FreshwaterBioHessianOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioHessianResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioHessian(data: number[], opts: FreshwaterBioHessianOptions = {}): FreshwaterBioHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioHessian };
diff --git a/src/freshwater_bio/hypothesis.ts b/src/freshwater_bio/hypothesis.ts
new file mode 100644
index 000000000..b30d44955
--- /dev/null
+++ b/src/freshwater_bio/hypothesis.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio hypothesis module — tsb analytics library. */
+export interface FreshwaterBioHypothesisOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioHypothesisResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioHypothesis(data: number[], opts: FreshwaterBioHypothesisOptions = {}): FreshwaterBioHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioHypothesis };
diff --git a/src/freshwater_bio/inference.ts b/src/freshwater_bio/inference.ts
new file mode 100644
index 000000000..1457935cd
--- /dev/null
+++ b/src/freshwater_bio/inference.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio inference module — tsb analytics library. */
+export interface FreshwaterBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioInferenceResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioInference(data: number[], opts: FreshwaterBioInferenceOptions = {}): FreshwaterBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioInference };
diff --git a/src/freshwater_bio/inference2.ts b/src/freshwater_bio/inference2.ts
new file mode 100644
index 000000000..fe8c4095d
--- /dev/null
+++ b/src/freshwater_bio/inference2.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio inference2 module — tsb analytics library. */
+export interface FreshwaterBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioInferenceResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioInference(data: number[], opts: FreshwaterBioInferenceOptions = {}): FreshwaterBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioInference };
diff --git a/src/freshwater_bio/integral.ts b/src/freshwater_bio/integral.ts
new file mode 100644
index 000000000..8095554e7
--- /dev/null
+++ b/src/freshwater_bio/integral.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio integral module — tsb analytics library. */
+export interface FreshwaterBioIntegralOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioIntegralResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioIntegral(data: number[], opts: FreshwaterBioIntegralOptions = {}): FreshwaterBioIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioIntegral };
diff --git a/src/freshwater_bio/integration.ts b/src/freshwater_bio/integration.ts
new file mode 100644
index 000000000..551a83fac
--- /dev/null
+++ b/src/freshwater_bio/integration.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio integration module — tsb analytics library. */
+export interface FreshwaterBioIntegrationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioIntegrationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioIntegration(data: number[], opts: FreshwaterBioIntegrationOptions = {}): FreshwaterBioIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioIntegration };
diff --git a/src/freshwater_bio/interpolation.ts b/src/freshwater_bio/interpolation.ts
new file mode 100644
index 000000000..11e34b04c
--- /dev/null
+++ b/src/freshwater_bio/interpolation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio interpolation module — tsb analytics library. */
+export interface FreshwaterBioInterpolationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioInterpolationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioInterpolation(data: number[], opts: FreshwaterBioInterpolationOptions = {}): FreshwaterBioInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioInterpolation };
diff --git a/src/freshwater_bio/jacobian.ts b/src/freshwater_bio/jacobian.ts
new file mode 100644
index 000000000..8ca42af6e
--- /dev/null
+++ b/src/freshwater_bio/jacobian.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio jacobian module — tsb analytics library. */
+export interface FreshwaterBioJacobianOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioJacobianResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioJacobian(data: number[], opts: FreshwaterBioJacobianOptions = {}): FreshwaterBioJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioJacobian };
diff --git a/src/freshwater_bio/kernel.ts b/src/freshwater_bio/kernel.ts
new file mode 100644
index 000000000..e02c048c5
--- /dev/null
+++ b/src/freshwater_bio/kernel.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio kernel module — tsb analytics library. */
+export interface FreshwaterBioKernelOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioKernelResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioKernel(data: number[], opts: FreshwaterBioKernelOptions = {}): FreshwaterBioKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioKernel };
diff --git a/src/freshwater_bio/laplacian.ts b/src/freshwater_bio/laplacian.ts
new file mode 100644
index 000000000..4ef121b7a
--- /dev/null
+++ b/src/freshwater_bio/laplacian.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio laplacian module — tsb analytics library. */
+export interface FreshwaterBioLaplacianOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioLaplacianResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioLaplacian(data: number[], opts: FreshwaterBioLaplacianOptions = {}): FreshwaterBioLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioLaplacian };
diff --git a/src/freshwater_bio/learning.ts b/src/freshwater_bio/learning.ts
new file mode 100644
index 000000000..8b850fe58
--- /dev/null
+++ b/src/freshwater_bio/learning.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio learning module — tsb analytics library. */
+export interface FreshwaterBioLearningOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioLearningResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioLearning(data: number[], opts: FreshwaterBioLearningOptions = {}): FreshwaterBioLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioLearning };
diff --git a/src/freshwater_bio/linear.ts b/src/freshwater_bio/linear.ts
new file mode 100644
index 000000000..2358537e2
--- /dev/null
+++ b/src/freshwater_bio/linear.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio linear module — tsb analytics library. */
+export interface FreshwaterBioLinearOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioLinearResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioLinear(data: number[], opts: FreshwaterBioLinearOptions = {}): FreshwaterBioLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioLinear };
diff --git a/src/freshwater_bio/manifold.ts b/src/freshwater_bio/manifold.ts
new file mode 100644
index 000000000..08f38ec63
--- /dev/null
+++ b/src/freshwater_bio/manifold.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio manifold module — tsb analytics library. */
+export interface FreshwaterBioManifoldOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioManifoldResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioManifold(data: number[], opts: FreshwaterBioManifoldOptions = {}): FreshwaterBioManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioManifold };
diff --git a/src/freshwater_bio/matching.ts b/src/freshwater_bio/matching.ts
new file mode 100644
index 000000000..0eccf9bbe
--- /dev/null
+++ b/src/freshwater_bio/matching.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio matching module — tsb analytics library. */
+export interface FreshwaterBioMatchingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioMatchingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioMatching(data: number[], opts: FreshwaterBioMatchingOptions = {}): FreshwaterBioMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioMatching };
diff --git a/src/freshwater_bio/measurement.ts b/src/freshwater_bio/measurement.ts
new file mode 100644
index 000000000..487369c7a
--- /dev/null
+++ b/src/freshwater_bio/measurement.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio measurement module — tsb analytics library. */
+export interface FreshwaterBioMeasurementOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioMeasurementResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioMeasurement(data: number[], opts: FreshwaterBioMeasurementOptions = {}): FreshwaterBioMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioMeasurement };
diff --git a/src/freshwater_bio/metrics.ts b/src/freshwater_bio/metrics.ts
new file mode 100644
index 000000000..d9af26c7f
--- /dev/null
+++ b/src/freshwater_bio/metrics.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio metrics module — tsb analytics library. */
+export interface FreshwaterBioMetricsOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioMetricsResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioMetrics(data: number[], opts: FreshwaterBioMetricsOptions = {}): FreshwaterBioMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioMetrics };
diff --git a/src/freshwater_bio/modeling.ts b/src/freshwater_bio/modeling.ts
new file mode 100644
index 000000000..0a5ca28ac
--- /dev/null
+++ b/src/freshwater_bio/modeling.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio modeling module — tsb analytics library. */
+export interface FreshwaterBioModelingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioModelingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioModeling(data: number[], opts: FreshwaterBioModelingOptions = {}): FreshwaterBioModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioModeling };
diff --git a/src/freshwater_bio/monitoring.ts b/src/freshwater_bio/monitoring.ts
new file mode 100644
index 000000000..fc4a9696d
--- /dev/null
+++ b/src/freshwater_bio/monitoring.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio monitoring module — tsb analytics library. */
+export interface FreshwaterBioMonitoringOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioMonitoringResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioMonitoring(data: number[], opts: FreshwaterBioMonitoringOptions = {}): FreshwaterBioMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioMonitoring };
diff --git a/src/freshwater_bio/nonlinear.ts b/src/freshwater_bio/nonlinear.ts
new file mode 100644
index 000000000..31ab70cb5
--- /dev/null
+++ b/src/freshwater_bio/nonlinear.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio nonlinear module — tsb analytics library. */
+export interface FreshwaterBioNonlinearOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioNonlinearResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioNonlinear(data: number[], opts: FreshwaterBioNonlinearOptions = {}): FreshwaterBioNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioNonlinear };
diff --git a/src/freshwater_bio/normalization.ts b/src/freshwater_bio/normalization.ts
new file mode 100644
index 000000000..fd8519ee3
--- /dev/null
+++ b/src/freshwater_bio/normalization.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio normalization module — tsb analytics library. */
+export interface FreshwaterBioNormalizationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioNormalizationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioNormalization(data: number[], opts: FreshwaterBioNormalizationOptions = {}): FreshwaterBioNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioNormalization };
diff --git a/src/freshwater_bio/optimization.ts b/src/freshwater_bio/optimization.ts
new file mode 100644
index 000000000..fc3e43a75
--- /dev/null
+++ b/src/freshwater_bio/optimization.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio optimization module — tsb analytics library. */
+export interface FreshwaterBioOptimizationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioOptimizationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioOptimization(data: number[], opts: FreshwaterBioOptimizationOptions = {}): FreshwaterBioOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioOptimization };
diff --git a/src/freshwater_bio/patterns.ts b/src/freshwater_bio/patterns.ts
new file mode 100644
index 000000000..1e8c55c30
--- /dev/null
+++ b/src/freshwater_bio/patterns.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio patterns module — tsb analytics library. */
+export interface FreshwaterBioPatternsOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioPatternsResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioPatterns(data: number[], opts: FreshwaterBioPatternsOptions = {}): FreshwaterBioPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioPatterns };
diff --git a/src/freshwater_bio/permutation.ts b/src/freshwater_bio/permutation.ts
new file mode 100644
index 000000000..902ec139c
--- /dev/null
+++ b/src/freshwater_bio/permutation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio permutation module — tsb analytics library. */
+export interface FreshwaterBioPermutationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioPermutationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioPermutation(data: number[], opts: FreshwaterBioPermutationOptions = {}): FreshwaterBioPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioPermutation };
diff --git a/src/freshwater_bio/prediction.ts b/src/freshwater_bio/prediction.ts
new file mode 100644
index 000000000..256584246
--- /dev/null
+++ b/src/freshwater_bio/prediction.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio prediction module — tsb analytics library. */
+export interface FreshwaterBioPredictionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioPredictionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioPrediction(data: number[], opts: FreshwaterBioPredictionOptions = {}): FreshwaterBioPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioPrediction };
diff --git a/src/freshwater_bio/processing.ts b/src/freshwater_bio/processing.ts
new file mode 100644
index 000000000..d74f6b44e
--- /dev/null
+++ b/src/freshwater_bio/processing.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio processing module — tsb analytics library. */
+export interface FreshwaterBioProcessingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioProcessingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioProcessing(data: number[], opts: FreshwaterBioProcessingOptions = {}): FreshwaterBioProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioProcessing };
diff --git a/src/freshwater_bio/profiling.ts b/src/freshwater_bio/profiling.ts
new file mode 100644
index 000000000..2278d15d7
--- /dev/null
+++ b/src/freshwater_bio/profiling.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio profiling module — tsb analytics library. */
+export interface FreshwaterBioProfilingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioProfilingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioProfiling(data: number[], opts: FreshwaterBioProfilingOptions = {}): FreshwaterBioProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioProfiling };
diff --git a/src/freshwater_bio/projection.ts b/src/freshwater_bio/projection.ts
new file mode 100644
index 000000000..c9fd5fe7b
--- /dev/null
+++ b/src/freshwater_bio/projection.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio projection module — tsb analytics library. */
+export interface FreshwaterBioProjectionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioProjectionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioProjection(data: number[], opts: FreshwaterBioProjectionOptions = {}): FreshwaterBioProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioProjection };
diff --git a/src/freshwater_bio/ranking.ts b/src/freshwater_bio/ranking.ts
new file mode 100644
index 000000000..0276e2b11
--- /dev/null
+++ b/src/freshwater_bio/ranking.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio ranking module — tsb analytics library. */
+export interface FreshwaterBioRankingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioRankingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioRanking(data: number[], opts: FreshwaterBioRankingOptions = {}): FreshwaterBioRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioRanking };
diff --git a/src/freshwater_bio/reconstruction.ts b/src/freshwater_bio/reconstruction.ts
new file mode 100644
index 000000000..457ceeed3
--- /dev/null
+++ b/src/freshwater_bio/reconstruction.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio reconstruction module — tsb analytics library. */
+export interface FreshwaterBioReconstructionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioReconstructionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioReconstruction(data: number[], opts: FreshwaterBioReconstructionOptions = {}): FreshwaterBioReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioReconstruction };
diff --git a/src/freshwater_bio/registration.ts b/src/freshwater_bio/registration.ts
new file mode 100644
index 000000000..8705e6c95
--- /dev/null
+++ b/src/freshwater_bio/registration.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio registration module — tsb analytics library. */
+export interface FreshwaterBioRegistrationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioRegistrationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioRegistration(data: number[], opts: FreshwaterBioRegistrationOptions = {}): FreshwaterBioRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioRegistration };
diff --git a/src/freshwater_bio/regression.ts b/src/freshwater_bio/regression.ts
new file mode 100644
index 000000000..91871dca1
--- /dev/null
+++ b/src/freshwater_bio/regression.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio regression module — tsb analytics library. */
+export interface FreshwaterBioRegressionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioRegressionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioRegression(data: number[], opts: FreshwaterBioRegressionOptions = {}): FreshwaterBioRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioRegression };
diff --git a/src/freshwater_bio/regularization.ts b/src/freshwater_bio/regularization.ts
new file mode 100644
index 000000000..aa9e5ab2d
--- /dev/null
+++ b/src/freshwater_bio/regularization.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio regularization module — tsb analytics library. */
+export interface FreshwaterBioRegularizationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioRegularizationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioRegularization(data: number[], opts: FreshwaterBioRegularizationOptions = {}): FreshwaterBioRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioRegularization };
diff --git a/src/freshwater_bio/robustness.ts b/src/freshwater_bio/robustness.ts
new file mode 100644
index 000000000..b43bcca25
--- /dev/null
+++ b/src/freshwater_bio/robustness.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio robustness module — tsb analytics library. */
+export interface FreshwaterBioRobustnessOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioRobustnessResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioRobustness(data: number[], opts: FreshwaterBioRobustnessOptions = {}): FreshwaterBioRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioRobustness };
diff --git a/src/freshwater_bio/sampling.ts b/src/freshwater_bio/sampling.ts
new file mode 100644
index 000000000..1798a16ed
--- /dev/null
+++ b/src/freshwater_bio/sampling.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio sampling module — tsb analytics library. */
+export interface FreshwaterBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioSamplingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioSampling(data: number[], opts: FreshwaterBioSamplingOptions = {}): FreshwaterBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioSampling };
diff --git a/src/freshwater_bio/sampling2.ts b/src/freshwater_bio/sampling2.ts
new file mode 100644
index 000000000..8c890f962
--- /dev/null
+++ b/src/freshwater_bio/sampling2.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio sampling2 module — tsb analytics library. */
+export interface FreshwaterBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioSamplingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioSampling(data: number[], opts: FreshwaterBioSamplingOptions = {}): FreshwaterBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioSampling };
diff --git a/src/freshwater_bio/scaling.ts b/src/freshwater_bio/scaling.ts
new file mode 100644
index 000000000..0c78b24e9
--- /dev/null
+++ b/src/freshwater_bio/scaling.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio scaling module — tsb analytics library. */
+export interface FreshwaterBioScalingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioScalingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioScaling(data: number[], opts: FreshwaterBioScalingOptions = {}): FreshwaterBioScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioScaling };
diff --git a/src/freshwater_bio/scoring.ts b/src/freshwater_bio/scoring.ts
new file mode 100644
index 000000000..c2e8bbfcc
--- /dev/null
+++ b/src/freshwater_bio/scoring.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio scoring module — tsb analytics library. */
+export interface FreshwaterBioScoringOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioScoringResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioScoring(data: number[], opts: FreshwaterBioScoringOptions = {}): FreshwaterBioScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioScoring };
diff --git a/src/freshwater_bio/segmentation.ts b/src/freshwater_bio/segmentation.ts
new file mode 100644
index 000000000..2d561722a
--- /dev/null
+++ b/src/freshwater_bio/segmentation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio segmentation module — tsb analytics library. */
+export interface FreshwaterBioSegmentationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioSegmentationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioSegmentation(data: number[], opts: FreshwaterBioSegmentationOptions = {}): FreshwaterBioSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioSegmentation };
diff --git a/src/freshwater_bio/selection.ts b/src/freshwater_bio/selection.ts
new file mode 100644
index 000000000..1e949c42c
--- /dev/null
+++ b/src/freshwater_bio/selection.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio selection module — tsb analytics library. */
+export interface FreshwaterBioSelectionOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioSelectionResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioSelection(data: number[], opts: FreshwaterBioSelectionOptions = {}): FreshwaterBioSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioSelection };
diff --git a/src/freshwater_bio/sensitivity.ts b/src/freshwater_bio/sensitivity.ts
new file mode 100644
index 000000000..e48af1316
--- /dev/null
+++ b/src/freshwater_bio/sensitivity.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio sensitivity module — tsb analytics library. */
+export interface FreshwaterBioSensitivityOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioSensitivityResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioSensitivity(data: number[], opts: FreshwaterBioSensitivityOptions = {}): FreshwaterBioSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioSensitivity };
diff --git a/src/freshwater_bio/simulation.ts b/src/freshwater_bio/simulation.ts
new file mode 100644
index 000000000..9d023fd57
--- /dev/null
+++ b/src/freshwater_bio/simulation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio simulation module — tsb analytics library. */
+export interface FreshwaterBioSimulationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioSimulationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioSimulation(data: number[], opts: FreshwaterBioSimulationOptions = {}): FreshwaterBioSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioSimulation };
diff --git a/src/freshwater_bio/smoothing.ts b/src/freshwater_bio/smoothing.ts
new file mode 100644
index 000000000..e02ef0fd9
--- /dev/null
+++ b/src/freshwater_bio/smoothing.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio smoothing module — tsb analytics library. */
+export interface FreshwaterBioSmoothingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioSmoothingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioSmoothing(data: number[], opts: FreshwaterBioSmoothingOptions = {}): FreshwaterBioSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioSmoothing };
diff --git a/src/freshwater_bio/stability.ts b/src/freshwater_bio/stability.ts
new file mode 100644
index 000000000..8d552ac6c
--- /dev/null
+++ b/src/freshwater_bio/stability.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio stability module — tsb analytics library. */
+export interface FreshwaterBioStabilityOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioStabilityResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioStability(data: number[], opts: FreshwaterBioStabilityOptions = {}): FreshwaterBioStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioStability };
diff --git a/src/freshwater_bio/stacking.ts b/src/freshwater_bio/stacking.ts
new file mode 100644
index 000000000..cc8668d7d
--- /dev/null
+++ b/src/freshwater_bio/stacking.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio stacking module — tsb analytics library. */
+export interface FreshwaterBioStackingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioStackingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioStacking(data: number[], opts: FreshwaterBioStackingOptions = {}): FreshwaterBioStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioStacking };
diff --git a/src/freshwater_bio/standardization.ts b/src/freshwater_bio/standardization.ts
new file mode 100644
index 000000000..517cad0df
--- /dev/null
+++ b/src/freshwater_bio/standardization.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio standardization module — tsb analytics library. */
+export interface FreshwaterBioStandardizationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioStandardizationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioStandardization(data: number[], opts: FreshwaterBioStandardizationOptions = {}): FreshwaterBioStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioStandardization };
diff --git a/src/freshwater_bio/static.ts b/src/freshwater_bio/static.ts
new file mode 100644
index 000000000..89f9f0cac
--- /dev/null
+++ b/src/freshwater_bio/static.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio static module — tsb analytics library. */
+export interface FreshwaterBioStaticOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioStaticResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioStatic(data: number[], opts: FreshwaterBioStaticOptions = {}): FreshwaterBioStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioStatic };
diff --git a/src/freshwater_bio/stochastic.ts b/src/freshwater_bio/stochastic.ts
new file mode 100644
index 000000000..40b98799d
--- /dev/null
+++ b/src/freshwater_bio/stochastic.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio stochastic module — tsb analytics library. */
+export interface FreshwaterBioStochasticOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioStochasticResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioStochastic(data: number[], opts: FreshwaterBioStochasticOptions = {}): FreshwaterBioStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioStochastic };
diff --git a/src/freshwater_bio/synthesis.ts b/src/freshwater_bio/synthesis.ts
new file mode 100644
index 000000000..4924d7f08
--- /dev/null
+++ b/src/freshwater_bio/synthesis.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio synthesis module — tsb analytics library. */
+export interface FreshwaterBioSynthesisOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioSynthesisResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioSynthesis(data: number[], opts: FreshwaterBioSynthesisOptions = {}): FreshwaterBioSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioSynthesis };
diff --git a/src/freshwater_bio/topology.ts b/src/freshwater_bio/topology.ts
new file mode 100644
index 000000000..e19b86a18
--- /dev/null
+++ b/src/freshwater_bio/topology.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio topology module — tsb analytics library. */
+export interface FreshwaterBioTopologyOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioTopologyResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioTopology(data: number[], opts: FreshwaterBioTopologyOptions = {}): FreshwaterBioTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioTopology };
diff --git a/src/freshwater_bio/tracking.ts b/src/freshwater_bio/tracking.ts
new file mode 100644
index 000000000..d859f3b33
--- /dev/null
+++ b/src/freshwater_bio/tracking.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio tracking module — tsb analytics library. */
+export interface FreshwaterBioTrackingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioTrackingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioTracking(data: number[], opts: FreshwaterBioTrackingOptions = {}): FreshwaterBioTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioTracking };
diff --git a/src/freshwater_bio/transform.ts b/src/freshwater_bio/transform.ts
new file mode 100644
index 000000000..3d1da5f89
--- /dev/null
+++ b/src/freshwater_bio/transform.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio transform module — tsb analytics library. */
+export interface FreshwaterBioTransformOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioTransformResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioTransform(data: number[], opts: FreshwaterBioTransformOptions = {}): FreshwaterBioTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioTransform };
diff --git a/src/freshwater_bio/uncertainty.ts b/src/freshwater_bio/uncertainty.ts
new file mode 100644
index 000000000..11c26343e
--- /dev/null
+++ b/src/freshwater_bio/uncertainty.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio uncertainty module — tsb analytics library. */
+export interface FreshwaterBioUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioUncertaintyResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioUncertainty(data: number[], opts: FreshwaterBioUncertaintyOptions = {}): FreshwaterBioUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioUncertainty };
diff --git a/src/freshwater_bio/validation.ts b/src/freshwater_bio/validation.ts
new file mode 100644
index 000000000..7c9800921
--- /dev/null
+++ b/src/freshwater_bio/validation.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio validation module — tsb analytics library. */
+export interface FreshwaterBioValidationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioValidationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioValidation(data: number[], opts: FreshwaterBioValidationOptions = {}): FreshwaterBioValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioValidation };
diff --git a/src/freshwater_bio/verification.ts b/src/freshwater_bio/verification.ts
new file mode 100644
index 000000000..3c28892c3
--- /dev/null
+++ b/src/freshwater_bio/verification.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio verification module — tsb analytics library. */
+export interface FreshwaterBioVerificationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioVerificationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioVerification(data: number[], opts: FreshwaterBioVerificationOptions = {}): FreshwaterBioVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioVerification };
diff --git a/src/freshwater_bio/visualization.ts b/src/freshwater_bio/visualization.ts
new file mode 100644
index 000000000..618be5b2d
--- /dev/null
+++ b/src/freshwater_bio/visualization.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio visualization module — tsb analytics library. */
+export interface FreshwaterBioVisualizationOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioVisualizationResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioVisualization(data: number[], opts: FreshwaterBioVisualizationOptions = {}): FreshwaterBioVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioVisualization };
diff --git a/src/freshwater_bio/voting.ts b/src/freshwater_bio/voting.ts
new file mode 100644
index 000000000..c0283737f
--- /dev/null
+++ b/src/freshwater_bio/voting.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio voting module — tsb analytics library. */
+export interface FreshwaterBioVotingOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioVotingResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioVoting(data: number[], opts: FreshwaterBioVotingOptions = {}): FreshwaterBioVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioVoting };
diff --git a/src/freshwater_bio/wavelet.ts b/src/freshwater_bio/wavelet.ts
new file mode 100644
index 000000000..4e11fee86
--- /dev/null
+++ b/src/freshwater_bio/wavelet.ts
@@ -0,0 +1,14 @@
+/** freshwater_bio wavelet module — tsb analytics library. */
+export interface FreshwaterBioWaveletOptions { tol?: number; maxIter?: number; }
+export interface FreshwaterBioWaveletResult { values: number[]; converged: boolean; }
+export function computeFreshwaterBioWavelet(data: number[], opts: FreshwaterBioWaveletOptions = {}): FreshwaterBioWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeFreshwaterBioWavelet };
diff --git a/src/galactic_sci/adaptation.ts b/src/galactic_sci/adaptation.ts
new file mode 100644
index 000000000..6d2a04951
--- /dev/null
+++ b/src/galactic_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci adaptation module — tsb analytics library. */
+export interface GalacticSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciAdaptation(data: number[], opts: GalacticSciAdaptationOptions = {}): GalacticSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciAdaptation };
diff --git a/src/galactic_sci/aggregation.ts b/src/galactic_sci/aggregation.ts
new file mode 100644
index 000000000..b9b3c47d1
--- /dev/null
+++ b/src/galactic_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci aggregation module — tsb analytics library. */
+export interface GalacticSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciAggregationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciAggregation(data: number[], opts: GalacticSciAggregationOptions = {}): GalacticSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciAggregation };
diff --git a/src/galactic_sci/algebra.ts b/src/galactic_sci/algebra.ts
new file mode 100644
index 000000000..315a0f7f0
--- /dev/null
+++ b/src/galactic_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** galactic_sci algebra module — tsb analytics library. */
+export interface GalacticSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeGalacticSciAlgebra(data: number[], opts: GalacticSciAlgebraOptions = {}): GalacticSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciAlgebra };
diff --git a/src/galactic_sci/alignment.ts b/src/galactic_sci/alignment.ts
new file mode 100644
index 000000000..a2977756e
--- /dev/null
+++ b/src/galactic_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** galactic_sci alignment module — tsb analytics library. */
+export interface GalacticSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeGalacticSciAlignment(data: number[], opts: GalacticSciAlignmentOptions = {}): GalacticSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciAlignment };
diff --git a/src/galactic_sci/analysis.ts b/src/galactic_sci/analysis.ts
new file mode 100644
index 000000000..08ffd175c
--- /dev/null
+++ b/src/galactic_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** galactic_sci analysis module — tsb analytics library. */
+export interface GalacticSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeGalacticSciAnalysis(data: number[], opts: GalacticSciAnalysisOptions = {}): GalacticSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciAnalysis };
diff --git a/src/galactic_sci/augmentation.ts b/src/galactic_sci/augmentation.ts
new file mode 100644
index 000000000..e591ae294
--- /dev/null
+++ b/src/galactic_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci augmentation module — tsb analytics library. */
+export interface GalacticSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciAugmentation(data: number[], opts: GalacticSciAugmentationOptions = {}): GalacticSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciAugmentation };
diff --git a/src/galactic_sci/bagging.ts b/src/galactic_sci/bagging.ts
new file mode 100644
index 000000000..ef2cccb91
--- /dev/null
+++ b/src/galactic_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** galactic_sci bagging module — tsb analytics library. */
+export interface GalacticSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciBaggingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciBagging(data: number[], opts: GalacticSciBaggingOptions = {}): GalacticSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciBagging };
diff --git a/src/galactic_sci/basis.ts b/src/galactic_sci/basis.ts
new file mode 100644
index 000000000..651ca022c
--- /dev/null
+++ b/src/galactic_sci/basis.ts
@@ -0,0 +1,14 @@
+/** galactic_sci basis module — tsb analytics library. */
+export interface GalacticSciBasisOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciBasisResult { values: number[]; converged: boolean; }
+export function computeGalacticSciBasis(data: number[], opts: GalacticSciBasisOptions = {}): GalacticSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciBasis };
diff --git a/src/galactic_sci/benchmarking.ts b/src/galactic_sci/benchmarking.ts
new file mode 100644
index 000000000..c2ecf0d4b
--- /dev/null
+++ b/src/galactic_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** galactic_sci benchmarking module — tsb analytics library. */
+export interface GalacticSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciBenchmarking(data: number[], opts: GalacticSciBenchmarkingOptions = {}): GalacticSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciBenchmarking };
diff --git a/src/galactic_sci/blending.ts b/src/galactic_sci/blending.ts
new file mode 100644
index 000000000..238ffc35f
--- /dev/null
+++ b/src/galactic_sci/blending.ts
@@ -0,0 +1,14 @@
+/** galactic_sci blending module — tsb analytics library. */
+export interface GalacticSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciBlendingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciBlending(data: number[], opts: GalacticSciBlendingOptions = {}): GalacticSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciBlending };
diff --git a/src/galactic_sci/boosting.ts b/src/galactic_sci/boosting.ts
new file mode 100644
index 000000000..b92082d9f
--- /dev/null
+++ b/src/galactic_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** galactic_sci boosting module — tsb analytics library. */
+export interface GalacticSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciBoostingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciBoosting(data: number[], opts: GalacticSciBoostingOptions = {}): GalacticSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciBoosting };
diff --git a/src/galactic_sci/bootstrap.ts b/src/galactic_sci/bootstrap.ts
new file mode 100644
index 000000000..38ee0a9e6
--- /dev/null
+++ b/src/galactic_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** galactic_sci bootstrap module — tsb analytics library. */
+export interface GalacticSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeGalacticSciBootstrap(data: number[], opts: GalacticSciBootstrapOptions = {}): GalacticSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciBootstrap };
diff --git a/src/galactic_sci/calculus.ts b/src/galactic_sci/calculus.ts
new file mode 100644
index 000000000..75a3f1ba8
--- /dev/null
+++ b/src/galactic_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** galactic_sci calculus module — tsb analytics library. */
+export interface GalacticSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciCalculusResult { values: number[]; converged: boolean; }
+export function computeGalacticSciCalculus(data: number[], opts: GalacticSciCalculusOptions = {}): GalacticSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciCalculus };
diff --git a/src/galactic_sci/calibration.ts b/src/galactic_sci/calibration.ts
new file mode 100644
index 000000000..68cb59d9e
--- /dev/null
+++ b/src/galactic_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** galactic_sci calibration module — tsb analytics library. */
+export interface GalacticSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciCalibration(data: number[], opts: GalacticSciCalibrationOptions = {}): GalacticSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciCalibration };
diff --git a/src/galactic_sci/characterization.ts b/src/galactic_sci/characterization.ts
new file mode 100644
index 000000000..65fc1c05b
--- /dev/null
+++ b/src/galactic_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** galactic_sci characterization module — tsb analytics library. */
+export interface GalacticSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciCharacterization(data: number[], opts: GalacticSciCharacterizationOptions = {}): GalacticSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciCharacterization };
diff --git a/src/galactic_sci/classification.ts b/src/galactic_sci/classification.ts
new file mode 100644
index 000000000..e4a057f2d
--- /dev/null
+++ b/src/galactic_sci/classification.ts
@@ -0,0 +1,14 @@
+/** galactic_sci classification module — tsb analytics library. */
+export interface GalacticSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciClassificationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciClassification(data: number[], opts: GalacticSciClassificationOptions = {}): GalacticSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciClassification };
diff --git a/src/galactic_sci/clustering.ts b/src/galactic_sci/clustering.ts
new file mode 100644
index 000000000..7571245bc
--- /dev/null
+++ b/src/galactic_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** galactic_sci clustering module — tsb analytics library. */
+export interface GalacticSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciClusteringResult { values: number[]; converged: boolean; }
+export function computeGalacticSciClustering(data: number[], opts: GalacticSciClusteringOptions = {}): GalacticSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciClustering };
diff --git a/src/galactic_sci/compression.ts b/src/galactic_sci/compression.ts
new file mode 100644
index 000000000..e2ad9bcb4
--- /dev/null
+++ b/src/galactic_sci/compression.ts
@@ -0,0 +1,14 @@
+/** galactic_sci compression module — tsb analytics library. */
+export interface GalacticSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciCompressionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciCompression(data: number[], opts: GalacticSciCompressionOptions = {}): GalacticSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciCompression };
diff --git a/src/galactic_sci/continuous.ts b/src/galactic_sci/continuous.ts
new file mode 100644
index 000000000..19a20bd1f
--- /dev/null
+++ b/src/galactic_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** galactic_sci continuous module — tsb analytics library. */
+export interface GalacticSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciContinuousResult { values: number[]; converged: boolean; }
+export function computeGalacticSciContinuous(data: number[], opts: GalacticSciContinuousOptions = {}): GalacticSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciContinuous };
diff --git a/src/galactic_sci/control.ts b/src/galactic_sci/control.ts
new file mode 100644
index 000000000..7dc447480
--- /dev/null
+++ b/src/galactic_sci/control.ts
@@ -0,0 +1,14 @@
+/** galactic_sci control module — tsb analytics library. */
+export interface GalacticSciControlOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciControlResult { values: number[]; converged: boolean; }
+export function computeGalacticSciControl(data: number[], opts: GalacticSciControlOptions = {}): GalacticSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciControl };
diff --git a/src/galactic_sci/convergence.ts b/src/galactic_sci/convergence.ts
new file mode 100644
index 000000000..cdb06fe1c
--- /dev/null
+++ b/src/galactic_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** galactic_sci convergence module — tsb analytics library. */
+export interface GalacticSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeGalacticSciConvergence(data: number[], opts: GalacticSciConvergenceOptions = {}): GalacticSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciConvergence };
diff --git a/src/galactic_sci/convex.ts b/src/galactic_sci/convex.ts
new file mode 100644
index 000000000..d0ac8636c
--- /dev/null
+++ b/src/galactic_sci/convex.ts
@@ -0,0 +1,14 @@
+/** galactic_sci convex module — tsb analytics library. */
+export interface GalacticSciConvexOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciConvexResult { values: number[]; converged: boolean; }
+export function computeGalacticSciConvex(data: number[], opts: GalacticSciConvexOptions = {}): GalacticSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciConvex };
diff --git a/src/galactic_sci/correlation.ts b/src/galactic_sci/correlation.ts
new file mode 100644
index 000000000..875aedd4e
--- /dev/null
+++ b/src/galactic_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci correlation module — tsb analytics library. */
+export interface GalacticSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciCorrelation(data: number[], opts: GalacticSciCorrelationOptions = {}): GalacticSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciCorrelation };
diff --git a/src/galactic_sci/covariance.ts b/src/galactic_sci/covariance.ts
new file mode 100644
index 000000000..b8042cc17
--- /dev/null
+++ b/src/galactic_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** galactic_sci covariance module — tsb analytics library. */
+export interface GalacticSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeGalacticSciCovariance(data: number[], opts: GalacticSciCovarianceOptions = {}): GalacticSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciCovariance };
diff --git a/src/galactic_sci/cross_validation.ts b/src/galactic_sci/cross_validation.ts
new file mode 100644
index 000000000..b23387eda
--- /dev/null
+++ b/src/galactic_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci cross_validation module — tsb analytics library. */
+export interface GalacticSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciCrossValidation(data: number[], opts: GalacticSciCrossValidationOptions = {}): GalacticSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciCrossValidation };
diff --git a/src/galactic_sci/decoding.ts b/src/galactic_sci/decoding.ts
new file mode 100644
index 000000000..ab08696db
--- /dev/null
+++ b/src/galactic_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** galactic_sci decoding module — tsb analytics library. */
+export interface GalacticSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDecodingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDecoding(data: number[], opts: GalacticSciDecodingOptions = {}): GalacticSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDecoding };
diff --git a/src/galactic_sci/decomposition.ts b/src/galactic_sci/decomposition.ts
new file mode 100644
index 000000000..776049d8b
--- /dev/null
+++ b/src/galactic_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** galactic_sci decomposition module — tsb analytics library. */
+export interface GalacticSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDecomposition(data: number[], opts: GalacticSciDecompositionOptions = {}): GalacticSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDecomposition };
diff --git a/src/galactic_sci/detection.ts b/src/galactic_sci/detection.ts
new file mode 100644
index 000000000..f1745e774
--- /dev/null
+++ b/src/galactic_sci/detection.ts
@@ -0,0 +1,14 @@
+/** galactic_sci detection module — tsb analytics library. */
+export interface GalacticSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDetectionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDetection(data: number[], opts: GalacticSciDetectionOptions = {}): GalacticSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDetection };
diff --git a/src/galactic_sci/deterministic.ts b/src/galactic_sci/deterministic.ts
new file mode 100644
index 000000000..095229244
--- /dev/null
+++ b/src/galactic_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** galactic_sci deterministic module — tsb analytics library. */
+export interface GalacticSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDeterministic(data: number[], opts: GalacticSciDeterministicOptions = {}): GalacticSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDeterministic };
diff --git a/src/galactic_sci/diagnostics.ts b/src/galactic_sci/diagnostics.ts
new file mode 100644
index 000000000..1ed5aa2c1
--- /dev/null
+++ b/src/galactic_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** galactic_sci diagnostics module — tsb analytics library. */
+export interface GalacticSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDiagnostics(data: number[], opts: GalacticSciDiagnosticsOptions = {}): GalacticSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDiagnostics };
diff --git a/src/galactic_sci/differential.ts b/src/galactic_sci/differential.ts
new file mode 100644
index 000000000..a4e07c7d9
--- /dev/null
+++ b/src/galactic_sci/differential.ts
@@ -0,0 +1,14 @@
+/** galactic_sci differential module — tsb analytics library. */
+export interface GalacticSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDifferential(data: number[], opts: GalacticSciDifferentialOptions = {}): GalacticSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDifferential };
diff --git a/src/galactic_sci/discrete.ts b/src/galactic_sci/discrete.ts
new file mode 100644
index 000000000..bf91774fd
--- /dev/null
+++ b/src/galactic_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** galactic_sci discrete module — tsb analytics library. */
+export interface GalacticSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDiscrete(data: number[], opts: GalacticSciDiscreteOptions = {}): GalacticSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDiscrete };
diff --git a/src/galactic_sci/distribution.ts b/src/galactic_sci/distribution.ts
new file mode 100644
index 000000000..860bf3f4f
--- /dev/null
+++ b/src/galactic_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** galactic_sci distribution module — tsb analytics library. */
+export interface GalacticSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDistributionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDistribution(data: number[], opts: GalacticSciDistributionOptions = {}): GalacticSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDistribution };
diff --git a/src/galactic_sci/dynamic.ts b/src/galactic_sci/dynamic.ts
new file mode 100644
index 000000000..1a9077edc
--- /dev/null
+++ b/src/galactic_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** galactic_sci dynamic module — tsb analytics library. */
+export interface GalacticSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciDynamicResult { values: number[]; converged: boolean; }
+export function computeGalacticSciDynamic(data: number[], opts: GalacticSciDynamicOptions = {}): GalacticSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciDynamic };
diff --git a/src/galactic_sci/embedding.ts b/src/galactic_sci/embedding.ts
new file mode 100644
index 000000000..8a291dfaf
--- /dev/null
+++ b/src/galactic_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** galactic_sci embedding module — tsb analytics library. */
+export interface GalacticSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciEmbedding(data: number[], opts: GalacticSciEmbeddingOptions = {}): GalacticSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciEmbedding };
diff --git a/src/galactic_sci/encoding.ts b/src/galactic_sci/encoding.ts
new file mode 100644
index 000000000..5d263a4f3
--- /dev/null
+++ b/src/galactic_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** galactic_sci encoding module — tsb analytics library. */
+export interface GalacticSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciEncodingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciEncoding(data: number[], opts: GalacticSciEncodingOptions = {}): GalacticSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciEncoding };
diff --git a/src/galactic_sci/ensemble.ts b/src/galactic_sci/ensemble.ts
new file mode 100644
index 000000000..ccdd5b4a5
--- /dev/null
+++ b/src/galactic_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** galactic_sci ensemble module — tsb analytics library. */
+export interface GalacticSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeGalacticSciEnsemble(data: number[], opts: GalacticSciEnsembleOptions = {}): GalacticSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciEnsemble };
diff --git a/src/galactic_sci/estimation.ts b/src/galactic_sci/estimation.ts
new file mode 100644
index 000000000..d4d975e8b
--- /dev/null
+++ b/src/galactic_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci estimation module — tsb analytics library. */
+export interface GalacticSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciEstimationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciEstimation(data: number[], opts: GalacticSciEstimationOptions = {}): GalacticSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciEstimation };
diff --git a/src/galactic_sci/evaluation.ts b/src/galactic_sci/evaluation.ts
new file mode 100644
index 000000000..fced132b0
--- /dev/null
+++ b/src/galactic_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci evaluation module — tsb analytics library. */
+export interface GalacticSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciEvaluation(data: number[], opts: GalacticSciEvaluationOptions = {}): GalacticSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciEvaluation };
diff --git a/src/galactic_sci/extrapolation.ts b/src/galactic_sci/extrapolation.ts
new file mode 100644
index 000000000..03e8baccb
--- /dev/null
+++ b/src/galactic_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci extrapolation module — tsb analytics library. */
+export interface GalacticSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciExtrapolation(data: number[], opts: GalacticSciExtrapolationOptions = {}): GalacticSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciExtrapolation };
diff --git a/src/galactic_sci/features.ts b/src/galactic_sci/features.ts
new file mode 100644
index 000000000..5e69acc1e
--- /dev/null
+++ b/src/galactic_sci/features.ts
@@ -0,0 +1,14 @@
+/** galactic_sci features module — tsb analytics library. */
+export interface GalacticSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeGalacticSciFeatures(data: number[], opts: GalacticSciFeaturesOptions = {}): GalacticSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciFeatures };
diff --git a/src/galactic_sci/feedback.ts b/src/galactic_sci/feedback.ts
new file mode 100644
index 000000000..0d7ffdbdf
--- /dev/null
+++ b/src/galactic_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** galactic_sci feedback module — tsb analytics library. */
+export interface GalacticSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeGalacticSciFeedback(data: number[], opts: GalacticSciFeedbackOptions = {}): GalacticSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciFeedback };
diff --git a/src/galactic_sci/filtering.ts b/src/galactic_sci/filtering.ts
new file mode 100644
index 000000000..f232a102e
--- /dev/null
+++ b/src/galactic_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** galactic_sci filtering module — tsb analytics library. */
+export interface GalacticSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciFilteringResult { values: number[]; converged: boolean; }
+export function computeGalacticSciFiltering(data: number[], opts: GalacticSciFilteringOptions = {}): GalacticSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciFiltering };
diff --git a/src/galactic_sci/fourier.ts b/src/galactic_sci/fourier.ts
new file mode 100644
index 000000000..a9beaf52c
--- /dev/null
+++ b/src/galactic_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** galactic_sci fourier module — tsb analytics library. */
+export interface GalacticSciFourierOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciFourierResult { values: number[]; converged: boolean; }
+export function computeGalacticSciFourier(data: number[], opts: GalacticSciFourierOptions = {}): GalacticSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciFourier };
diff --git a/src/galactic_sci/fusion.ts b/src/galactic_sci/fusion.ts
new file mode 100644
index 000000000..14224cb78
--- /dev/null
+++ b/src/galactic_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** galactic_sci fusion module — tsb analytics library. */
+export interface GalacticSciFusionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciFusionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciFusion(data: number[], opts: GalacticSciFusionOptions = {}): GalacticSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciFusion };
diff --git a/src/galactic_sci/generation.ts b/src/galactic_sci/generation.ts
new file mode 100644
index 000000000..ca27bfce8
--- /dev/null
+++ b/src/galactic_sci/generation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci generation module — tsb analytics library. */
+export interface GalacticSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciGenerationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciGeneration(data: number[], opts: GalacticSciGenerationOptions = {}): GalacticSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciGeneration };
diff --git a/src/galactic_sci/geometry.ts b/src/galactic_sci/geometry.ts
new file mode 100644
index 000000000..e99e124eb
--- /dev/null
+++ b/src/galactic_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** galactic_sci geometry module — tsb analytics library. */
+export interface GalacticSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciGeometryResult { values: number[]; converged: boolean; }
+export function computeGalacticSciGeometry(data: number[], opts: GalacticSciGeometryOptions = {}): GalacticSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciGeometry };
diff --git a/src/galactic_sci/gradient.ts b/src/galactic_sci/gradient.ts
new file mode 100644
index 000000000..9cfacfc0a
--- /dev/null
+++ b/src/galactic_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** galactic_sci gradient module — tsb analytics library. */
+export interface GalacticSciGradientOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciGradientResult { values: number[]; converged: boolean; }
+export function computeGalacticSciGradient(data: number[], opts: GalacticSciGradientOptions = {}): GalacticSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciGradient };
diff --git a/src/galactic_sci/hessian.ts b/src/galactic_sci/hessian.ts
new file mode 100644
index 000000000..bfdddf3a7
--- /dev/null
+++ b/src/galactic_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** galactic_sci hessian module — tsb analytics library. */
+export interface GalacticSciHessianOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciHessianResult { values: number[]; converged: boolean; }
+export function computeGalacticSciHessian(data: number[], opts: GalacticSciHessianOptions = {}): GalacticSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciHessian };
diff --git a/src/galactic_sci/hypothesis.ts b/src/galactic_sci/hypothesis.ts
new file mode 100644
index 000000000..48f78f39a
--- /dev/null
+++ b/src/galactic_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** galactic_sci hypothesis module — tsb analytics library. */
+export interface GalacticSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeGalacticSciHypothesis(data: number[], opts: GalacticSciHypothesisOptions = {}): GalacticSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciHypothesis };
diff --git a/src/galactic_sci/inference.ts b/src/galactic_sci/inference.ts
new file mode 100644
index 000000000..dbae586ba
--- /dev/null
+++ b/src/galactic_sci/inference.ts
@@ -0,0 +1,14 @@
+/** galactic_sci inference module — tsb analytics library. */
+export interface GalacticSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciInferenceResult { values: number[]; converged: boolean; }
+export function computeGalacticSciInference(data: number[], opts: GalacticSciInferenceOptions = {}): GalacticSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciInference };
diff --git a/src/galactic_sci/inference2.ts b/src/galactic_sci/inference2.ts
new file mode 100644
index 000000000..7f96fb979
--- /dev/null
+++ b/src/galactic_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** galactic_sci inference2 module — tsb analytics library. */
+export interface GalacticSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciInferenceResult { values: number[]; converged: boolean; }
+export function computeGalacticSciInference(data: number[], opts: GalacticSciInferenceOptions = {}): GalacticSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciInference };
diff --git a/src/galactic_sci/integral.ts b/src/galactic_sci/integral.ts
new file mode 100644
index 000000000..0a16b6710
--- /dev/null
+++ b/src/galactic_sci/integral.ts
@@ -0,0 +1,14 @@
+/** galactic_sci integral module — tsb analytics library. */
+export interface GalacticSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciIntegralResult { values: number[]; converged: boolean; }
+export function computeGalacticSciIntegral(data: number[], opts: GalacticSciIntegralOptions = {}): GalacticSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciIntegral };
diff --git a/src/galactic_sci/integration.ts b/src/galactic_sci/integration.ts
new file mode 100644
index 000000000..c920176ac
--- /dev/null
+++ b/src/galactic_sci/integration.ts
@@ -0,0 +1,14 @@
+/** galactic_sci integration module — tsb analytics library. */
+export interface GalacticSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciIntegration(data: number[], opts: GalacticSciIntegrationOptions = {}): GalacticSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciIntegration };
diff --git a/src/galactic_sci/interpolation.ts b/src/galactic_sci/interpolation.ts
new file mode 100644
index 000000000..f3e27b2f3
--- /dev/null
+++ b/src/galactic_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci interpolation module — tsb analytics library. */
+export interface GalacticSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciInterpolation(data: number[], opts: GalacticSciInterpolationOptions = {}): GalacticSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciInterpolation };
diff --git a/src/galactic_sci/jacobian.ts b/src/galactic_sci/jacobian.ts
new file mode 100644
index 000000000..28fdde500
--- /dev/null
+++ b/src/galactic_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** galactic_sci jacobian module — tsb analytics library. */
+export interface GalacticSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciJacobianResult { values: number[]; converged: boolean; }
+export function computeGalacticSciJacobian(data: number[], opts: GalacticSciJacobianOptions = {}): GalacticSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciJacobian };
diff --git a/src/galactic_sci/kernel.ts b/src/galactic_sci/kernel.ts
new file mode 100644
index 000000000..a86a4a619
--- /dev/null
+++ b/src/galactic_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** galactic_sci kernel module — tsb analytics library. */
+export interface GalacticSciKernelOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciKernelResult { values: number[]; converged: boolean; }
+export function computeGalacticSciKernel(data: number[], opts: GalacticSciKernelOptions = {}): GalacticSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciKernel };
diff --git a/src/galactic_sci/laplacian.ts b/src/galactic_sci/laplacian.ts
new file mode 100644
index 000000000..d6e98d3c5
--- /dev/null
+++ b/src/galactic_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** galactic_sci laplacian module — tsb analytics library. */
+export interface GalacticSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeGalacticSciLaplacian(data: number[], opts: GalacticSciLaplacianOptions = {}): GalacticSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciLaplacian };
diff --git a/src/galactic_sci/learning.ts b/src/galactic_sci/learning.ts
new file mode 100644
index 000000000..41e1f022f
--- /dev/null
+++ b/src/galactic_sci/learning.ts
@@ -0,0 +1,14 @@
+/** galactic_sci learning module — tsb analytics library. */
+export interface GalacticSciLearningOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciLearningResult { values: number[]; converged: boolean; }
+export function computeGalacticSciLearning(data: number[], opts: GalacticSciLearningOptions = {}): GalacticSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciLearning };
diff --git a/src/galactic_sci/linear.ts b/src/galactic_sci/linear.ts
new file mode 100644
index 000000000..e63e728a4
--- /dev/null
+++ b/src/galactic_sci/linear.ts
@@ -0,0 +1,14 @@
+/** galactic_sci linear module — tsb analytics library. */
+export interface GalacticSciLinearOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciLinearResult { values: number[]; converged: boolean; }
+export function computeGalacticSciLinear(data: number[], opts: GalacticSciLinearOptions = {}): GalacticSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciLinear };
diff --git a/src/galactic_sci/manifold.ts b/src/galactic_sci/manifold.ts
new file mode 100644
index 000000000..41f117168
--- /dev/null
+++ b/src/galactic_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** galactic_sci manifold module — tsb analytics library. */
+export interface GalacticSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciManifoldResult { values: number[]; converged: boolean; }
+export function computeGalacticSciManifold(data: number[], opts: GalacticSciManifoldOptions = {}): GalacticSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciManifold };
diff --git a/src/galactic_sci/matching.ts b/src/galactic_sci/matching.ts
new file mode 100644
index 000000000..846b51c04
--- /dev/null
+++ b/src/galactic_sci/matching.ts
@@ -0,0 +1,14 @@
+/** galactic_sci matching module — tsb analytics library. */
+export interface GalacticSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciMatchingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciMatching(data: number[], opts: GalacticSciMatchingOptions = {}): GalacticSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciMatching };
diff --git a/src/galactic_sci/measurement.ts b/src/galactic_sci/measurement.ts
new file mode 100644
index 000000000..ffacae0f6
--- /dev/null
+++ b/src/galactic_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** galactic_sci measurement module — tsb analytics library. */
+export interface GalacticSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeGalacticSciMeasurement(data: number[], opts: GalacticSciMeasurementOptions = {}): GalacticSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciMeasurement };
diff --git a/src/galactic_sci/metrics.ts b/src/galactic_sci/metrics.ts
new file mode 100644
index 000000000..b4f089427
--- /dev/null
+++ b/src/galactic_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** galactic_sci metrics module — tsb analytics library. */
+export interface GalacticSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciMetricsResult { values: number[]; converged: boolean; }
+export function computeGalacticSciMetrics(data: number[], opts: GalacticSciMetricsOptions = {}): GalacticSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciMetrics };
diff --git a/src/galactic_sci/modeling.ts b/src/galactic_sci/modeling.ts
new file mode 100644
index 000000000..bf8114c2c
--- /dev/null
+++ b/src/galactic_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** galactic_sci modeling module — tsb analytics library. */
+export interface GalacticSciModelingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciModelingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciModeling(data: number[], opts: GalacticSciModelingOptions = {}): GalacticSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciModeling };
diff --git a/src/galactic_sci/monitoring.ts b/src/galactic_sci/monitoring.ts
new file mode 100644
index 000000000..725ceba38
--- /dev/null
+++ b/src/galactic_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** galactic_sci monitoring module — tsb analytics library. */
+export interface GalacticSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeGalacticSciMonitoring(data: number[], opts: GalacticSciMonitoringOptions = {}): GalacticSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciMonitoring };
diff --git a/src/galactic_sci/nonlinear.ts b/src/galactic_sci/nonlinear.ts
new file mode 100644
index 000000000..47ce76282
--- /dev/null
+++ b/src/galactic_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** galactic_sci nonlinear module — tsb analytics library. */
+export interface GalacticSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeGalacticSciNonlinear(data: number[], opts: GalacticSciNonlinearOptions = {}): GalacticSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciNonlinear };
diff --git a/src/galactic_sci/normalization.ts b/src/galactic_sci/normalization.ts
new file mode 100644
index 000000000..b60862114
--- /dev/null
+++ b/src/galactic_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** galactic_sci normalization module — tsb analytics library. */
+export interface GalacticSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciNormalization(data: number[], opts: GalacticSciNormalizationOptions = {}): GalacticSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciNormalization };
diff --git a/src/galactic_sci/optimization.ts b/src/galactic_sci/optimization.ts
new file mode 100644
index 000000000..8d0f2ba2c
--- /dev/null
+++ b/src/galactic_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** galactic_sci optimization module — tsb analytics library. */
+export interface GalacticSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciOptimization(data: number[], opts: GalacticSciOptimizationOptions = {}): GalacticSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciOptimization };
diff --git a/src/galactic_sci/patterns.ts b/src/galactic_sci/patterns.ts
new file mode 100644
index 000000000..0f30e7ce3
--- /dev/null
+++ b/src/galactic_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** galactic_sci patterns module — tsb analytics library. */
+export interface GalacticSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciPatternsResult { values: number[]; converged: boolean; }
+export function computeGalacticSciPatterns(data: number[], opts: GalacticSciPatternsOptions = {}): GalacticSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciPatterns };
diff --git a/src/galactic_sci/permutation.ts b/src/galactic_sci/permutation.ts
new file mode 100644
index 000000000..81d059e5b
--- /dev/null
+++ b/src/galactic_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci permutation module — tsb analytics library. */
+export interface GalacticSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciPermutationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciPermutation(data: number[], opts: GalacticSciPermutationOptions = {}): GalacticSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciPermutation };
diff --git a/src/galactic_sci/prediction.ts b/src/galactic_sci/prediction.ts
new file mode 100644
index 000000000..ddde4c64a
--- /dev/null
+++ b/src/galactic_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** galactic_sci prediction module — tsb analytics library. */
+export interface GalacticSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciPredictionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciPrediction(data: number[], opts: GalacticSciPredictionOptions = {}): GalacticSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciPrediction };
diff --git a/src/galactic_sci/processing.ts b/src/galactic_sci/processing.ts
new file mode 100644
index 000000000..0703cfb69
--- /dev/null
+++ b/src/galactic_sci/processing.ts
@@ -0,0 +1,14 @@
+/** galactic_sci processing module — tsb analytics library. */
+export interface GalacticSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciProcessingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciProcessing(data: number[], opts: GalacticSciProcessingOptions = {}): GalacticSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciProcessing };
diff --git a/src/galactic_sci/profiling.ts b/src/galactic_sci/profiling.ts
new file mode 100644
index 000000000..d6a129482
--- /dev/null
+++ b/src/galactic_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** galactic_sci profiling module — tsb analytics library. */
+export interface GalacticSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciProfilingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciProfiling(data: number[], opts: GalacticSciProfilingOptions = {}): GalacticSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciProfiling };
diff --git a/src/galactic_sci/projection.ts b/src/galactic_sci/projection.ts
new file mode 100644
index 000000000..f94869be3
--- /dev/null
+++ b/src/galactic_sci/projection.ts
@@ -0,0 +1,14 @@
+/** galactic_sci projection module — tsb analytics library. */
+export interface GalacticSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciProjectionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciProjection(data: number[], opts: GalacticSciProjectionOptions = {}): GalacticSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciProjection };
diff --git a/src/galactic_sci/ranking.ts b/src/galactic_sci/ranking.ts
new file mode 100644
index 000000000..84544eb40
--- /dev/null
+++ b/src/galactic_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** galactic_sci ranking module — tsb analytics library. */
+export interface GalacticSciRankingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciRankingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciRanking(data: number[], opts: GalacticSciRankingOptions = {}): GalacticSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciRanking };
diff --git a/src/galactic_sci/reconstruction.ts b/src/galactic_sci/reconstruction.ts
new file mode 100644
index 000000000..708347bba
--- /dev/null
+++ b/src/galactic_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** galactic_sci reconstruction module — tsb analytics library. */
+export interface GalacticSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciReconstruction(data: number[], opts: GalacticSciReconstructionOptions = {}): GalacticSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciReconstruction };
diff --git a/src/galactic_sci/registration.ts b/src/galactic_sci/registration.ts
new file mode 100644
index 000000000..0008bffb2
--- /dev/null
+++ b/src/galactic_sci/registration.ts
@@ -0,0 +1,14 @@
+/** galactic_sci registration module — tsb analytics library. */
+export interface GalacticSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciRegistration(data: number[], opts: GalacticSciRegistrationOptions = {}): GalacticSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciRegistration };
diff --git a/src/galactic_sci/regression.ts b/src/galactic_sci/regression.ts
new file mode 100644
index 000000000..0145d027d
--- /dev/null
+++ b/src/galactic_sci/regression.ts
@@ -0,0 +1,14 @@
+/** galactic_sci regression module — tsb analytics library. */
+export interface GalacticSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciRegressionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciRegression(data: number[], opts: GalacticSciRegressionOptions = {}): GalacticSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciRegression };
diff --git a/src/galactic_sci/regularization.ts b/src/galactic_sci/regularization.ts
new file mode 100644
index 000000000..8cc38a615
--- /dev/null
+++ b/src/galactic_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** galactic_sci regularization module — tsb analytics library. */
+export interface GalacticSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciRegularization(data: number[], opts: GalacticSciRegularizationOptions = {}): GalacticSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciRegularization };
diff --git a/src/galactic_sci/robustness.ts b/src/galactic_sci/robustness.ts
new file mode 100644
index 000000000..cc042dea4
--- /dev/null
+++ b/src/galactic_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** galactic_sci robustness module — tsb analytics library. */
+export interface GalacticSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeGalacticSciRobustness(data: number[], opts: GalacticSciRobustnessOptions = {}): GalacticSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciRobustness };
diff --git a/src/galactic_sci/sampling.ts b/src/galactic_sci/sampling.ts
new file mode 100644
index 000000000..993ba224e
--- /dev/null
+++ b/src/galactic_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** galactic_sci sampling module — tsb analytics library. */
+export interface GalacticSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciSamplingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciSampling(data: number[], opts: GalacticSciSamplingOptions = {}): GalacticSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciSampling };
diff --git a/src/galactic_sci/sampling2.ts b/src/galactic_sci/sampling2.ts
new file mode 100644
index 000000000..5b0288f08
--- /dev/null
+++ b/src/galactic_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** galactic_sci sampling2 module — tsb analytics library. */
+export interface GalacticSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciSamplingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciSampling(data: number[], opts: GalacticSciSamplingOptions = {}): GalacticSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciSampling };
diff --git a/src/galactic_sci/scaling.ts b/src/galactic_sci/scaling.ts
new file mode 100644
index 000000000..fc0c25bd8
--- /dev/null
+++ b/src/galactic_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** galactic_sci scaling module — tsb analytics library. */
+export interface GalacticSciScalingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciScalingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciScaling(data: number[], opts: GalacticSciScalingOptions = {}): GalacticSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciScaling };
diff --git a/src/galactic_sci/scoring.ts b/src/galactic_sci/scoring.ts
new file mode 100644
index 000000000..441cbf1e1
--- /dev/null
+++ b/src/galactic_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** galactic_sci scoring module — tsb analytics library. */
+export interface GalacticSciScoringOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciScoringResult { values: number[]; converged: boolean; }
+export function computeGalacticSciScoring(data: number[], opts: GalacticSciScoringOptions = {}): GalacticSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciScoring };
diff --git a/src/galactic_sci/segmentation.ts b/src/galactic_sci/segmentation.ts
new file mode 100644
index 000000000..647b8a22b
--- /dev/null
+++ b/src/galactic_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci segmentation module — tsb analytics library. */
+export interface GalacticSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciSegmentation(data: number[], opts: GalacticSciSegmentationOptions = {}): GalacticSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciSegmentation };
diff --git a/src/galactic_sci/selection.ts b/src/galactic_sci/selection.ts
new file mode 100644
index 000000000..6af1c0b4d
--- /dev/null
+++ b/src/galactic_sci/selection.ts
@@ -0,0 +1,14 @@
+/** galactic_sci selection module — tsb analytics library. */
+export interface GalacticSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciSelectionResult { values: number[]; converged: boolean; }
+export function computeGalacticSciSelection(data: number[], opts: GalacticSciSelectionOptions = {}): GalacticSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciSelection };
diff --git a/src/galactic_sci/sensitivity.ts b/src/galactic_sci/sensitivity.ts
new file mode 100644
index 000000000..9deb860d5
--- /dev/null
+++ b/src/galactic_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** galactic_sci sensitivity module — tsb analytics library. */
+export interface GalacticSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeGalacticSciSensitivity(data: number[], opts: GalacticSciSensitivityOptions = {}): GalacticSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciSensitivity };
diff --git a/src/galactic_sci/simulation.ts b/src/galactic_sci/simulation.ts
new file mode 100644
index 000000000..48673c136
--- /dev/null
+++ b/src/galactic_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci simulation module — tsb analytics library. */
+export interface GalacticSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciSimulationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciSimulation(data: number[], opts: GalacticSciSimulationOptions = {}): GalacticSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciSimulation };
diff --git a/src/galactic_sci/smoothing.ts b/src/galactic_sci/smoothing.ts
new file mode 100644
index 000000000..0caa749e6
--- /dev/null
+++ b/src/galactic_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** galactic_sci smoothing module — tsb analytics library. */
+export interface GalacticSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciSmoothing(data: number[], opts: GalacticSciSmoothingOptions = {}): GalacticSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciSmoothing };
diff --git a/src/galactic_sci/stability.ts b/src/galactic_sci/stability.ts
new file mode 100644
index 000000000..2896ea6bc
--- /dev/null
+++ b/src/galactic_sci/stability.ts
@@ -0,0 +1,14 @@
+/** galactic_sci stability module — tsb analytics library. */
+export interface GalacticSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciStabilityResult { values: number[]; converged: boolean; }
+export function computeGalacticSciStability(data: number[], opts: GalacticSciStabilityOptions = {}): GalacticSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciStability };
diff --git a/src/galactic_sci/stacking.ts b/src/galactic_sci/stacking.ts
new file mode 100644
index 000000000..ac42b4a11
--- /dev/null
+++ b/src/galactic_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** galactic_sci stacking module — tsb analytics library. */
+export interface GalacticSciStackingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciStackingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciStacking(data: number[], opts: GalacticSciStackingOptions = {}): GalacticSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciStacking };
diff --git a/src/galactic_sci/standardization.ts b/src/galactic_sci/standardization.ts
new file mode 100644
index 000000000..9094a039d
--- /dev/null
+++ b/src/galactic_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** galactic_sci standardization module — tsb analytics library. */
+export interface GalacticSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciStandardization(data: number[], opts: GalacticSciStandardizationOptions = {}): GalacticSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciStandardization };
diff --git a/src/galactic_sci/static.ts b/src/galactic_sci/static.ts
new file mode 100644
index 000000000..e530caad1
--- /dev/null
+++ b/src/galactic_sci/static.ts
@@ -0,0 +1,14 @@
+/** galactic_sci static module — tsb analytics library. */
+export interface GalacticSciStaticOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciStaticResult { values: number[]; converged: boolean; }
+export function computeGalacticSciStatic(data: number[], opts: GalacticSciStaticOptions = {}): GalacticSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciStatic };
diff --git a/src/galactic_sci/stochastic.ts b/src/galactic_sci/stochastic.ts
new file mode 100644
index 000000000..17083a85c
--- /dev/null
+++ b/src/galactic_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** galactic_sci stochastic module — tsb analytics library. */
+export interface GalacticSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciStochasticResult { values: number[]; converged: boolean; }
+export function computeGalacticSciStochastic(data: number[], opts: GalacticSciStochasticOptions = {}): GalacticSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciStochastic };
diff --git a/src/galactic_sci/synthesis.ts b/src/galactic_sci/synthesis.ts
new file mode 100644
index 000000000..981505ae7
--- /dev/null
+++ b/src/galactic_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** galactic_sci synthesis module — tsb analytics library. */
+export interface GalacticSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeGalacticSciSynthesis(data: number[], opts: GalacticSciSynthesisOptions = {}): GalacticSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciSynthesis };
diff --git a/src/galactic_sci/topology.ts b/src/galactic_sci/topology.ts
new file mode 100644
index 000000000..82e56d529
--- /dev/null
+++ b/src/galactic_sci/topology.ts
@@ -0,0 +1,14 @@
+/** galactic_sci topology module — tsb analytics library. */
+export interface GalacticSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciTopologyResult { values: number[]; converged: boolean; }
+export function computeGalacticSciTopology(data: number[], opts: GalacticSciTopologyOptions = {}): GalacticSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciTopology };
diff --git a/src/galactic_sci/tracking.ts b/src/galactic_sci/tracking.ts
new file mode 100644
index 000000000..6ea559e90
--- /dev/null
+++ b/src/galactic_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** galactic_sci tracking module — tsb analytics library. */
+export interface GalacticSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciTrackingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciTracking(data: number[], opts: GalacticSciTrackingOptions = {}): GalacticSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciTracking };
diff --git a/src/galactic_sci/transform.ts b/src/galactic_sci/transform.ts
new file mode 100644
index 000000000..9853d34de
--- /dev/null
+++ b/src/galactic_sci/transform.ts
@@ -0,0 +1,14 @@
+/** galactic_sci transform module — tsb analytics library. */
+export interface GalacticSciTransformOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciTransformResult { values: number[]; converged: boolean; }
+export function computeGalacticSciTransform(data: number[], opts: GalacticSciTransformOptions = {}): GalacticSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciTransform };
diff --git a/src/galactic_sci/uncertainty.ts b/src/galactic_sci/uncertainty.ts
new file mode 100644
index 000000000..469230ad6
--- /dev/null
+++ b/src/galactic_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** galactic_sci uncertainty module — tsb analytics library. */
+export interface GalacticSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGalacticSciUncertainty(data: number[], opts: GalacticSciUncertaintyOptions = {}): GalacticSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciUncertainty };
diff --git a/src/galactic_sci/validation.ts b/src/galactic_sci/validation.ts
new file mode 100644
index 000000000..63f5fe3e5
--- /dev/null
+++ b/src/galactic_sci/validation.ts
@@ -0,0 +1,14 @@
+/** galactic_sci validation module — tsb analytics library. */
+export interface GalacticSciValidationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciValidationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciValidation(data: number[], opts: GalacticSciValidationOptions = {}): GalacticSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciValidation };
diff --git a/src/galactic_sci/verification.ts b/src/galactic_sci/verification.ts
new file mode 100644
index 000000000..6582415d8
--- /dev/null
+++ b/src/galactic_sci/verification.ts
@@ -0,0 +1,14 @@
+/** galactic_sci verification module — tsb analytics library. */
+export interface GalacticSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciVerificationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciVerification(data: number[], opts: GalacticSciVerificationOptions = {}): GalacticSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciVerification };
diff --git a/src/galactic_sci/visualization.ts b/src/galactic_sci/visualization.ts
new file mode 100644
index 000000000..457cb6ec0
--- /dev/null
+++ b/src/galactic_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** galactic_sci visualization module — tsb analytics library. */
+export interface GalacticSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeGalacticSciVisualization(data: number[], opts: GalacticSciVisualizationOptions = {}): GalacticSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciVisualization };
diff --git a/src/galactic_sci/voting.ts b/src/galactic_sci/voting.ts
new file mode 100644
index 000000000..ebca1132c
--- /dev/null
+++ b/src/galactic_sci/voting.ts
@@ -0,0 +1,14 @@
+/** galactic_sci voting module — tsb analytics library. */
+export interface GalacticSciVotingOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciVotingResult { values: number[]; converged: boolean; }
+export function computeGalacticSciVoting(data: number[], opts: GalacticSciVotingOptions = {}): GalacticSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciVoting };
diff --git a/src/galactic_sci/wavelet.ts b/src/galactic_sci/wavelet.ts
new file mode 100644
index 000000000..9413e411f
--- /dev/null
+++ b/src/galactic_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** galactic_sci wavelet module — tsb analytics library. */
+export interface GalacticSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface GalacticSciWaveletResult { values: number[]; converged: boolean; }
+export function computeGalacticSciWavelet(data: number[], opts: GalacticSciWaveletOptions = {}): GalacticSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGalacticSciWavelet };
diff --git a/src/gastroenterology/adaptation.ts b/src/gastroenterology/adaptation.ts
new file mode 100644
index 000000000..bbfbf9366
--- /dev/null
+++ b/src/gastroenterology/adaptation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology adaptation module — tsb analytics library. */
+export interface GastroenterologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyAdaptation(data: number[], opts: GastroenterologyAdaptationOptions = {}): GastroenterologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyAdaptation };
diff --git a/src/gastroenterology/aggregation.ts b/src/gastroenterology/aggregation.ts
new file mode 100644
index 000000000..399f1681f
--- /dev/null
+++ b/src/gastroenterology/aggregation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology aggregation module — tsb analytics library. */
+export interface GastroenterologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyAggregationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyAggregation(data: number[], opts: GastroenterologyAggregationOptions = {}): GastroenterologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyAggregation };
diff --git a/src/gastroenterology/algebra.ts b/src/gastroenterology/algebra.ts
new file mode 100644
index 000000000..3ddda5392
--- /dev/null
+++ b/src/gastroenterology/algebra.ts
@@ -0,0 +1,14 @@
+/** gastroenterology algebra module — tsb analytics library. */
+export interface GastroenterologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyAlgebra(data: number[], opts: GastroenterologyAlgebraOptions = {}): GastroenterologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyAlgebra };
diff --git a/src/gastroenterology/alignment.ts b/src/gastroenterology/alignment.ts
new file mode 100644
index 000000000..ca5545937
--- /dev/null
+++ b/src/gastroenterology/alignment.ts
@@ -0,0 +1,14 @@
+/** gastroenterology alignment module — tsb analytics library. */
+export interface GastroenterologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyAlignment(data: number[], opts: GastroenterologyAlignmentOptions = {}): GastroenterologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyAlignment };
diff --git a/src/gastroenterology/analysis.ts b/src/gastroenterology/analysis.ts
new file mode 100644
index 000000000..8edb9062b
--- /dev/null
+++ b/src/gastroenterology/analysis.ts
@@ -0,0 +1,14 @@
+/** gastroenterology analysis module — tsb analytics library. */
+export interface GastroenterologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyAnalysis(data: number[], opts: GastroenterologyAnalysisOptions = {}): GastroenterologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyAnalysis };
diff --git a/src/gastroenterology/augmentation.ts b/src/gastroenterology/augmentation.ts
new file mode 100644
index 000000000..99e2a3c20
--- /dev/null
+++ b/src/gastroenterology/augmentation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology augmentation module — tsb analytics library. */
+export interface GastroenterologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyAugmentation(data: number[], opts: GastroenterologyAugmentationOptions = {}): GastroenterologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyAugmentation };
diff --git a/src/gastroenterology/bagging.ts b/src/gastroenterology/bagging.ts
new file mode 100644
index 000000000..9a57b25c9
--- /dev/null
+++ b/src/gastroenterology/bagging.ts
@@ -0,0 +1,14 @@
+/** gastroenterology bagging module — tsb analytics library. */
+export interface GastroenterologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyBaggingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyBagging(data: number[], opts: GastroenterologyBaggingOptions = {}): GastroenterologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyBagging };
diff --git a/src/gastroenterology/basis.ts b/src/gastroenterology/basis.ts
new file mode 100644
index 000000000..97f447655
--- /dev/null
+++ b/src/gastroenterology/basis.ts
@@ -0,0 +1,14 @@
+/** gastroenterology basis module — tsb analytics library. */
+export interface GastroenterologyBasisOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyBasisResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyBasis(data: number[], opts: GastroenterologyBasisOptions = {}): GastroenterologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyBasis };
diff --git a/src/gastroenterology/benchmarking.ts b/src/gastroenterology/benchmarking.ts
new file mode 100644
index 000000000..473f9572f
--- /dev/null
+++ b/src/gastroenterology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** gastroenterology benchmarking module — tsb analytics library. */
+export interface GastroenterologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyBenchmarking(data: number[], opts: GastroenterologyBenchmarkingOptions = {}): GastroenterologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyBenchmarking };
diff --git a/src/gastroenterology/blending.ts b/src/gastroenterology/blending.ts
new file mode 100644
index 000000000..2cced31b9
--- /dev/null
+++ b/src/gastroenterology/blending.ts
@@ -0,0 +1,14 @@
+/** gastroenterology blending module — tsb analytics library. */
+export interface GastroenterologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyBlendingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyBlending(data: number[], opts: GastroenterologyBlendingOptions = {}): GastroenterologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyBlending };
diff --git a/src/gastroenterology/boosting.ts b/src/gastroenterology/boosting.ts
new file mode 100644
index 000000000..a55792634
--- /dev/null
+++ b/src/gastroenterology/boosting.ts
@@ -0,0 +1,14 @@
+/** gastroenterology boosting module — tsb analytics library. */
+export interface GastroenterologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyBoostingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyBoosting(data: number[], opts: GastroenterologyBoostingOptions = {}): GastroenterologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyBoosting };
diff --git a/src/gastroenterology/bootstrap.ts b/src/gastroenterology/bootstrap.ts
new file mode 100644
index 000000000..ab5ff3894
--- /dev/null
+++ b/src/gastroenterology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** gastroenterology bootstrap module — tsb analytics library. */
+export interface GastroenterologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyBootstrap(data: number[], opts: GastroenterologyBootstrapOptions = {}): GastroenterologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyBootstrap };
diff --git a/src/gastroenterology/calculus.ts b/src/gastroenterology/calculus.ts
new file mode 100644
index 000000000..659d76a98
--- /dev/null
+++ b/src/gastroenterology/calculus.ts
@@ -0,0 +1,14 @@
+/** gastroenterology calculus module — tsb analytics library. */
+export interface GastroenterologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyCalculusResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyCalculus(data: number[], opts: GastroenterologyCalculusOptions = {}): GastroenterologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyCalculus };
diff --git a/src/gastroenterology/calibration.ts b/src/gastroenterology/calibration.ts
new file mode 100644
index 000000000..99843dadd
--- /dev/null
+++ b/src/gastroenterology/calibration.ts
@@ -0,0 +1,14 @@
+/** gastroenterology calibration module — tsb analytics library. */
+export interface GastroenterologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyCalibration(data: number[], opts: GastroenterologyCalibrationOptions = {}): GastroenterologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyCalibration };
diff --git a/src/gastroenterology/characterization.ts b/src/gastroenterology/characterization.ts
new file mode 100644
index 000000000..aff45a7f1
--- /dev/null
+++ b/src/gastroenterology/characterization.ts
@@ -0,0 +1,14 @@
+/** gastroenterology characterization module — tsb analytics library. */
+export interface GastroenterologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyCharacterization(data: number[], opts: GastroenterologyCharacterizationOptions = {}): GastroenterologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyCharacterization };
diff --git a/src/gastroenterology/classification.ts b/src/gastroenterology/classification.ts
new file mode 100644
index 000000000..52d6df533
--- /dev/null
+++ b/src/gastroenterology/classification.ts
@@ -0,0 +1,14 @@
+/** gastroenterology classification module — tsb analytics library. */
+export interface GastroenterologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyClassificationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyClassification(data: number[], opts: GastroenterologyClassificationOptions = {}): GastroenterologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyClassification };
diff --git a/src/gastroenterology/clustering.ts b/src/gastroenterology/clustering.ts
new file mode 100644
index 000000000..d79dd0a1b
--- /dev/null
+++ b/src/gastroenterology/clustering.ts
@@ -0,0 +1,14 @@
+/** gastroenterology clustering module — tsb analytics library. */
+export interface GastroenterologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyClusteringResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyClustering(data: number[], opts: GastroenterologyClusteringOptions = {}): GastroenterologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyClustering };
diff --git a/src/gastroenterology/compression.ts b/src/gastroenterology/compression.ts
new file mode 100644
index 000000000..bc18532d4
--- /dev/null
+++ b/src/gastroenterology/compression.ts
@@ -0,0 +1,14 @@
+/** gastroenterology compression module — tsb analytics library. */
+export interface GastroenterologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyCompressionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyCompression(data: number[], opts: GastroenterologyCompressionOptions = {}): GastroenterologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyCompression };
diff --git a/src/gastroenterology/continuous.ts b/src/gastroenterology/continuous.ts
new file mode 100644
index 000000000..d3c12e99b
--- /dev/null
+++ b/src/gastroenterology/continuous.ts
@@ -0,0 +1,14 @@
+/** gastroenterology continuous module — tsb analytics library. */
+export interface GastroenterologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyContinuousResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyContinuous(data: number[], opts: GastroenterologyContinuousOptions = {}): GastroenterologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyContinuous };
diff --git a/src/gastroenterology/control.ts b/src/gastroenterology/control.ts
new file mode 100644
index 000000000..96ce395e4
--- /dev/null
+++ b/src/gastroenterology/control.ts
@@ -0,0 +1,14 @@
+/** gastroenterology control module — tsb analytics library. */
+export interface GastroenterologyControlOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyControlResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyControl(data: number[], opts: GastroenterologyControlOptions = {}): GastroenterologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyControl };
diff --git a/src/gastroenterology/convergence.ts b/src/gastroenterology/convergence.ts
new file mode 100644
index 000000000..009b73b36
--- /dev/null
+++ b/src/gastroenterology/convergence.ts
@@ -0,0 +1,14 @@
+/** gastroenterology convergence module — tsb analytics library. */
+export interface GastroenterologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyConvergence(data: number[], opts: GastroenterologyConvergenceOptions = {}): GastroenterologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyConvergence };
diff --git a/src/gastroenterology/convex.ts b/src/gastroenterology/convex.ts
new file mode 100644
index 000000000..e6f73e6a2
--- /dev/null
+++ b/src/gastroenterology/convex.ts
@@ -0,0 +1,14 @@
+/** gastroenterology convex module — tsb analytics library. */
+export interface GastroenterologyConvexOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyConvexResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyConvex(data: number[], opts: GastroenterologyConvexOptions = {}): GastroenterologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyConvex };
diff --git a/src/gastroenterology/correlation.ts b/src/gastroenterology/correlation.ts
new file mode 100644
index 000000000..477ba2539
--- /dev/null
+++ b/src/gastroenterology/correlation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology correlation module — tsb analytics library. */
+export interface GastroenterologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyCorrelation(data: number[], opts: GastroenterologyCorrelationOptions = {}): GastroenterologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyCorrelation };
diff --git a/src/gastroenterology/covariance.ts b/src/gastroenterology/covariance.ts
new file mode 100644
index 000000000..b28ac4425
--- /dev/null
+++ b/src/gastroenterology/covariance.ts
@@ -0,0 +1,14 @@
+/** gastroenterology covariance module — tsb analytics library. */
+export interface GastroenterologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyCovariance(data: number[], opts: GastroenterologyCovarianceOptions = {}): GastroenterologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyCovariance };
diff --git a/src/gastroenterology/cross_validation.ts b/src/gastroenterology/cross_validation.ts
new file mode 100644
index 000000000..672d4c583
--- /dev/null
+++ b/src/gastroenterology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology cross_validation module — tsb analytics library. */
+export interface GastroenterologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyCrossValidation(data: number[], opts: GastroenterologyCrossValidationOptions = {}): GastroenterologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyCrossValidation };
diff --git a/src/gastroenterology/decoding.ts b/src/gastroenterology/decoding.ts
new file mode 100644
index 000000000..9bdc1cc6c
--- /dev/null
+++ b/src/gastroenterology/decoding.ts
@@ -0,0 +1,14 @@
+/** gastroenterology decoding module — tsb analytics library. */
+export interface GastroenterologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDecodingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDecoding(data: number[], opts: GastroenterologyDecodingOptions = {}): GastroenterologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDecoding };
diff --git a/src/gastroenterology/decomposition.ts b/src/gastroenterology/decomposition.ts
new file mode 100644
index 000000000..c60e6934e
--- /dev/null
+++ b/src/gastroenterology/decomposition.ts
@@ -0,0 +1,14 @@
+/** gastroenterology decomposition module — tsb analytics library. */
+export interface GastroenterologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDecomposition(data: number[], opts: GastroenterologyDecompositionOptions = {}): GastroenterologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDecomposition };
diff --git a/src/gastroenterology/detection.ts b/src/gastroenterology/detection.ts
new file mode 100644
index 000000000..62d4a7f8c
--- /dev/null
+++ b/src/gastroenterology/detection.ts
@@ -0,0 +1,14 @@
+/** gastroenterology detection module — tsb analytics library. */
+export interface GastroenterologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDetectionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDetection(data: number[], opts: GastroenterologyDetectionOptions = {}): GastroenterologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDetection };
diff --git a/src/gastroenterology/deterministic.ts b/src/gastroenterology/deterministic.ts
new file mode 100644
index 000000000..981b85cbc
--- /dev/null
+++ b/src/gastroenterology/deterministic.ts
@@ -0,0 +1,14 @@
+/** gastroenterology deterministic module — tsb analytics library. */
+export interface GastroenterologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDeterministic(data: number[], opts: GastroenterologyDeterministicOptions = {}): GastroenterologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDeterministic };
diff --git a/src/gastroenterology/diagnostics.ts b/src/gastroenterology/diagnostics.ts
new file mode 100644
index 000000000..f97c21ee3
--- /dev/null
+++ b/src/gastroenterology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** gastroenterology diagnostics module — tsb analytics library. */
+export interface GastroenterologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDiagnostics(data: number[], opts: GastroenterologyDiagnosticsOptions = {}): GastroenterologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDiagnostics };
diff --git a/src/gastroenterology/differential.ts b/src/gastroenterology/differential.ts
new file mode 100644
index 000000000..a0e0c0d35
--- /dev/null
+++ b/src/gastroenterology/differential.ts
@@ -0,0 +1,14 @@
+/** gastroenterology differential module — tsb analytics library. */
+export interface GastroenterologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDifferential(data: number[], opts: GastroenterologyDifferentialOptions = {}): GastroenterologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDifferential };
diff --git a/src/gastroenterology/discrete.ts b/src/gastroenterology/discrete.ts
new file mode 100644
index 000000000..95ea3b5e2
--- /dev/null
+++ b/src/gastroenterology/discrete.ts
@@ -0,0 +1,14 @@
+/** gastroenterology discrete module — tsb analytics library. */
+export interface GastroenterologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDiscrete(data: number[], opts: GastroenterologyDiscreteOptions = {}): GastroenterologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDiscrete };
diff --git a/src/gastroenterology/distribution.ts b/src/gastroenterology/distribution.ts
new file mode 100644
index 000000000..214e26a4e
--- /dev/null
+++ b/src/gastroenterology/distribution.ts
@@ -0,0 +1,14 @@
+/** gastroenterology distribution module — tsb analytics library. */
+export interface GastroenterologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDistributionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDistribution(data: number[], opts: GastroenterologyDistributionOptions = {}): GastroenterologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDistribution };
diff --git a/src/gastroenterology/dynamic.ts b/src/gastroenterology/dynamic.ts
new file mode 100644
index 000000000..b2143a295
--- /dev/null
+++ b/src/gastroenterology/dynamic.ts
@@ -0,0 +1,14 @@
+/** gastroenterology dynamic module — tsb analytics library. */
+export interface GastroenterologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyDynamicResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyDynamic(data: number[], opts: GastroenterologyDynamicOptions = {}): GastroenterologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyDynamic };
diff --git a/src/gastroenterology/embedding.ts b/src/gastroenterology/embedding.ts
new file mode 100644
index 000000000..0228427e8
--- /dev/null
+++ b/src/gastroenterology/embedding.ts
@@ -0,0 +1,14 @@
+/** gastroenterology embedding module — tsb analytics library. */
+export interface GastroenterologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyEmbedding(data: number[], opts: GastroenterologyEmbeddingOptions = {}): GastroenterologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyEmbedding };
diff --git a/src/gastroenterology/encoding.ts b/src/gastroenterology/encoding.ts
new file mode 100644
index 000000000..f77a92989
--- /dev/null
+++ b/src/gastroenterology/encoding.ts
@@ -0,0 +1,14 @@
+/** gastroenterology encoding module — tsb analytics library. */
+export interface GastroenterologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyEncodingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyEncoding(data: number[], opts: GastroenterologyEncodingOptions = {}): GastroenterologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyEncoding };
diff --git a/src/gastroenterology/ensemble.ts b/src/gastroenterology/ensemble.ts
new file mode 100644
index 000000000..ad622f15a
--- /dev/null
+++ b/src/gastroenterology/ensemble.ts
@@ -0,0 +1,14 @@
+/** gastroenterology ensemble module — tsb analytics library. */
+export interface GastroenterologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyEnsemble(data: number[], opts: GastroenterologyEnsembleOptions = {}): GastroenterologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyEnsemble };
diff --git a/src/gastroenterology/estimation.ts b/src/gastroenterology/estimation.ts
new file mode 100644
index 000000000..fca7f248c
--- /dev/null
+++ b/src/gastroenterology/estimation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology estimation module — tsb analytics library. */
+export interface GastroenterologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyEstimationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyEstimation(data: number[], opts: GastroenterologyEstimationOptions = {}): GastroenterologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyEstimation };
diff --git a/src/gastroenterology/evaluation.ts b/src/gastroenterology/evaluation.ts
new file mode 100644
index 000000000..05a6b7c33
--- /dev/null
+++ b/src/gastroenterology/evaluation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology evaluation module — tsb analytics library. */
+export interface GastroenterologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyEvaluation(data: number[], opts: GastroenterologyEvaluationOptions = {}): GastroenterologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyEvaluation };
diff --git a/src/gastroenterology/extrapolation.ts b/src/gastroenterology/extrapolation.ts
new file mode 100644
index 000000000..d0cc29744
--- /dev/null
+++ b/src/gastroenterology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology extrapolation module — tsb analytics library. */
+export interface GastroenterologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyExtrapolation(data: number[], opts: GastroenterologyExtrapolationOptions = {}): GastroenterologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyExtrapolation };
diff --git a/src/gastroenterology/features.ts b/src/gastroenterology/features.ts
new file mode 100644
index 000000000..e11b80193
--- /dev/null
+++ b/src/gastroenterology/features.ts
@@ -0,0 +1,14 @@
+/** gastroenterology features module — tsb analytics library. */
+export interface GastroenterologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyFeatures(data: number[], opts: GastroenterologyFeaturesOptions = {}): GastroenterologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyFeatures };
diff --git a/src/gastroenterology/feedback.ts b/src/gastroenterology/feedback.ts
new file mode 100644
index 000000000..f8f0cef85
--- /dev/null
+++ b/src/gastroenterology/feedback.ts
@@ -0,0 +1,14 @@
+/** gastroenterology feedback module — tsb analytics library. */
+export interface GastroenterologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyFeedback(data: number[], opts: GastroenterologyFeedbackOptions = {}): GastroenterologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyFeedback };
diff --git a/src/gastroenterology/filtering.ts b/src/gastroenterology/filtering.ts
new file mode 100644
index 000000000..36ff49fa8
--- /dev/null
+++ b/src/gastroenterology/filtering.ts
@@ -0,0 +1,14 @@
+/** gastroenterology filtering module — tsb analytics library. */
+export interface GastroenterologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyFilteringResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyFiltering(data: number[], opts: GastroenterologyFilteringOptions = {}): GastroenterologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyFiltering };
diff --git a/src/gastroenterology/fourier.ts b/src/gastroenterology/fourier.ts
new file mode 100644
index 000000000..ada414ccc
--- /dev/null
+++ b/src/gastroenterology/fourier.ts
@@ -0,0 +1,14 @@
+/** gastroenterology fourier module — tsb analytics library. */
+export interface GastroenterologyFourierOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyFourierResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyFourier(data: number[], opts: GastroenterologyFourierOptions = {}): GastroenterologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyFourier };
diff --git a/src/gastroenterology/fusion.ts b/src/gastroenterology/fusion.ts
new file mode 100644
index 000000000..232481604
--- /dev/null
+++ b/src/gastroenterology/fusion.ts
@@ -0,0 +1,14 @@
+/** gastroenterology fusion module — tsb analytics library. */
+export interface GastroenterologyFusionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyFusionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyFusion(data: number[], opts: GastroenterologyFusionOptions = {}): GastroenterologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyFusion };
diff --git a/src/gastroenterology/generation.ts b/src/gastroenterology/generation.ts
new file mode 100644
index 000000000..db3197d08
--- /dev/null
+++ b/src/gastroenterology/generation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology generation module — tsb analytics library. */
+export interface GastroenterologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyGenerationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyGeneration(data: number[], opts: GastroenterologyGenerationOptions = {}): GastroenterologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyGeneration };
diff --git a/src/gastroenterology/geometry.ts b/src/gastroenterology/geometry.ts
new file mode 100644
index 000000000..1da2eb951
--- /dev/null
+++ b/src/gastroenterology/geometry.ts
@@ -0,0 +1,14 @@
+/** gastroenterology geometry module — tsb analytics library. */
+export interface GastroenterologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyGeometryResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyGeometry(data: number[], opts: GastroenterologyGeometryOptions = {}): GastroenterologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyGeometry };
diff --git a/src/gastroenterology/gradient.ts b/src/gastroenterology/gradient.ts
new file mode 100644
index 000000000..8607325f6
--- /dev/null
+++ b/src/gastroenterology/gradient.ts
@@ -0,0 +1,14 @@
+/** gastroenterology gradient module — tsb analytics library. */
+export interface GastroenterologyGradientOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyGradientResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyGradient(data: number[], opts: GastroenterologyGradientOptions = {}): GastroenterologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyGradient };
diff --git a/src/gastroenterology/hessian.ts b/src/gastroenterology/hessian.ts
new file mode 100644
index 000000000..6d51babd3
--- /dev/null
+++ b/src/gastroenterology/hessian.ts
@@ -0,0 +1,14 @@
+/** gastroenterology hessian module — tsb analytics library. */
+export interface GastroenterologyHessianOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyHessianResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyHessian(data: number[], opts: GastroenterologyHessianOptions = {}): GastroenterologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyHessian };
diff --git a/src/gastroenterology/hypothesis.ts b/src/gastroenterology/hypothesis.ts
new file mode 100644
index 000000000..27134dad9
--- /dev/null
+++ b/src/gastroenterology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** gastroenterology hypothesis module — tsb analytics library. */
+export interface GastroenterologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyHypothesis(data: number[], opts: GastroenterologyHypothesisOptions = {}): GastroenterologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyHypothesis };
diff --git a/src/gastroenterology/inference.ts b/src/gastroenterology/inference.ts
new file mode 100644
index 000000000..00a178307
--- /dev/null
+++ b/src/gastroenterology/inference.ts
@@ -0,0 +1,14 @@
+/** gastroenterology inference module — tsb analytics library. */
+export interface GastroenterologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyInferenceResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyInference(data: number[], opts: GastroenterologyInferenceOptions = {}): GastroenterologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyInference };
diff --git a/src/gastroenterology/inference2.ts b/src/gastroenterology/inference2.ts
new file mode 100644
index 000000000..9805d7304
--- /dev/null
+++ b/src/gastroenterology/inference2.ts
@@ -0,0 +1,14 @@
+/** gastroenterology inference2 module — tsb analytics library. */
+export interface GastroenterologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyInferenceResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyInference(data: number[], opts: GastroenterologyInferenceOptions = {}): GastroenterologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyInference };
diff --git a/src/gastroenterology/integral.ts b/src/gastroenterology/integral.ts
new file mode 100644
index 000000000..d570b3edd
--- /dev/null
+++ b/src/gastroenterology/integral.ts
@@ -0,0 +1,14 @@
+/** gastroenterology integral module — tsb analytics library. */
+export interface GastroenterologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyIntegralResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyIntegral(data: number[], opts: GastroenterologyIntegralOptions = {}): GastroenterologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyIntegral };
diff --git a/src/gastroenterology/integration.ts b/src/gastroenterology/integration.ts
new file mode 100644
index 000000000..732aa5ada
--- /dev/null
+++ b/src/gastroenterology/integration.ts
@@ -0,0 +1,14 @@
+/** gastroenterology integration module — tsb analytics library. */
+export interface GastroenterologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyIntegration(data: number[], opts: GastroenterologyIntegrationOptions = {}): GastroenterologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyIntegration };
diff --git a/src/gastroenterology/interpolation.ts b/src/gastroenterology/interpolation.ts
new file mode 100644
index 000000000..d5c5598fc
--- /dev/null
+++ b/src/gastroenterology/interpolation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology interpolation module — tsb analytics library. */
+export interface GastroenterologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyInterpolation(data: number[], opts: GastroenterologyInterpolationOptions = {}): GastroenterologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyInterpolation };
diff --git a/src/gastroenterology/jacobian.ts b/src/gastroenterology/jacobian.ts
new file mode 100644
index 000000000..323c486bc
--- /dev/null
+++ b/src/gastroenterology/jacobian.ts
@@ -0,0 +1,14 @@
+/** gastroenterology jacobian module — tsb analytics library. */
+export interface GastroenterologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyJacobianResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyJacobian(data: number[], opts: GastroenterologyJacobianOptions = {}): GastroenterologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyJacobian };
diff --git a/src/gastroenterology/kernel.ts b/src/gastroenterology/kernel.ts
new file mode 100644
index 000000000..a3f6260ff
--- /dev/null
+++ b/src/gastroenterology/kernel.ts
@@ -0,0 +1,14 @@
+/** gastroenterology kernel module — tsb analytics library. */
+export interface GastroenterologyKernelOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyKernelResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyKernel(data: number[], opts: GastroenterologyKernelOptions = {}): GastroenterologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyKernel };
diff --git a/src/gastroenterology/laplacian.ts b/src/gastroenterology/laplacian.ts
new file mode 100644
index 000000000..39d60e6ef
--- /dev/null
+++ b/src/gastroenterology/laplacian.ts
@@ -0,0 +1,14 @@
+/** gastroenterology laplacian module — tsb analytics library. */
+export interface GastroenterologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyLaplacian(data: number[], opts: GastroenterologyLaplacianOptions = {}): GastroenterologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyLaplacian };
diff --git a/src/gastroenterology/learning.ts b/src/gastroenterology/learning.ts
new file mode 100644
index 000000000..42231d06e
--- /dev/null
+++ b/src/gastroenterology/learning.ts
@@ -0,0 +1,14 @@
+/** gastroenterology learning module — tsb analytics library. */
+export interface GastroenterologyLearningOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyLearningResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyLearning(data: number[], opts: GastroenterologyLearningOptions = {}): GastroenterologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyLearning };
diff --git a/src/gastroenterology/linear.ts b/src/gastroenterology/linear.ts
new file mode 100644
index 000000000..893241e38
--- /dev/null
+++ b/src/gastroenterology/linear.ts
@@ -0,0 +1,14 @@
+/** gastroenterology linear module — tsb analytics library. */
+export interface GastroenterologyLinearOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyLinearResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyLinear(data: number[], opts: GastroenterologyLinearOptions = {}): GastroenterologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyLinear };
diff --git a/src/gastroenterology/manifold.ts b/src/gastroenterology/manifold.ts
new file mode 100644
index 000000000..47ee1e253
--- /dev/null
+++ b/src/gastroenterology/manifold.ts
@@ -0,0 +1,14 @@
+/** gastroenterology manifold module — tsb analytics library. */
+export interface GastroenterologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyManifoldResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyManifold(data: number[], opts: GastroenterologyManifoldOptions = {}): GastroenterologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyManifold };
diff --git a/src/gastroenterology/matching.ts b/src/gastroenterology/matching.ts
new file mode 100644
index 000000000..36684350c
--- /dev/null
+++ b/src/gastroenterology/matching.ts
@@ -0,0 +1,14 @@
+/** gastroenterology matching module — tsb analytics library. */
+export interface GastroenterologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyMatchingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyMatching(data: number[], opts: GastroenterologyMatchingOptions = {}): GastroenterologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyMatching };
diff --git a/src/gastroenterology/measurement.ts b/src/gastroenterology/measurement.ts
new file mode 100644
index 000000000..6004abc8b
--- /dev/null
+++ b/src/gastroenterology/measurement.ts
@@ -0,0 +1,14 @@
+/** gastroenterology measurement module — tsb analytics library. */
+export interface GastroenterologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyMeasurement(data: number[], opts: GastroenterologyMeasurementOptions = {}): GastroenterologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyMeasurement };
diff --git a/src/gastroenterology/metrics.ts b/src/gastroenterology/metrics.ts
new file mode 100644
index 000000000..934cf0542
--- /dev/null
+++ b/src/gastroenterology/metrics.ts
@@ -0,0 +1,14 @@
+/** gastroenterology metrics module — tsb analytics library. */
+export interface GastroenterologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyMetricsResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyMetrics(data: number[], opts: GastroenterologyMetricsOptions = {}): GastroenterologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyMetrics };
diff --git a/src/gastroenterology/modeling.ts b/src/gastroenterology/modeling.ts
new file mode 100644
index 000000000..a2c223eee
--- /dev/null
+++ b/src/gastroenterology/modeling.ts
@@ -0,0 +1,14 @@
+/** gastroenterology modeling module — tsb analytics library. */
+export interface GastroenterologyModelingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyModelingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyModeling(data: number[], opts: GastroenterologyModelingOptions = {}): GastroenterologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyModeling };
diff --git a/src/gastroenterology/monitoring.ts b/src/gastroenterology/monitoring.ts
new file mode 100644
index 000000000..95ee43614
--- /dev/null
+++ b/src/gastroenterology/monitoring.ts
@@ -0,0 +1,14 @@
+/** gastroenterology monitoring module — tsb analytics library. */
+export interface GastroenterologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyMonitoring(data: number[], opts: GastroenterologyMonitoringOptions = {}): GastroenterologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyMonitoring };
diff --git a/src/gastroenterology/nonlinear.ts b/src/gastroenterology/nonlinear.ts
new file mode 100644
index 000000000..18106fa15
--- /dev/null
+++ b/src/gastroenterology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** gastroenterology nonlinear module — tsb analytics library. */
+export interface GastroenterologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyNonlinear(data: number[], opts: GastroenterologyNonlinearOptions = {}): GastroenterologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyNonlinear };
diff --git a/src/gastroenterology/normalization.ts b/src/gastroenterology/normalization.ts
new file mode 100644
index 000000000..ef060f514
--- /dev/null
+++ b/src/gastroenterology/normalization.ts
@@ -0,0 +1,14 @@
+/** gastroenterology normalization module — tsb analytics library. */
+export interface GastroenterologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyNormalization(data: number[], opts: GastroenterologyNormalizationOptions = {}): GastroenterologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyNormalization };
diff --git a/src/gastroenterology/optimization.ts b/src/gastroenterology/optimization.ts
new file mode 100644
index 000000000..b916616b7
--- /dev/null
+++ b/src/gastroenterology/optimization.ts
@@ -0,0 +1,14 @@
+/** gastroenterology optimization module — tsb analytics library. */
+export interface GastroenterologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyOptimization(data: number[], opts: GastroenterologyOptimizationOptions = {}): GastroenterologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyOptimization };
diff --git a/src/gastroenterology/patterns.ts b/src/gastroenterology/patterns.ts
new file mode 100644
index 000000000..3f9bc6f2c
--- /dev/null
+++ b/src/gastroenterology/patterns.ts
@@ -0,0 +1,14 @@
+/** gastroenterology patterns module — tsb analytics library. */
+export interface GastroenterologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyPatternsResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyPatterns(data: number[], opts: GastroenterologyPatternsOptions = {}): GastroenterologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyPatterns };
diff --git a/src/gastroenterology/permutation.ts b/src/gastroenterology/permutation.ts
new file mode 100644
index 000000000..a948a2e70
--- /dev/null
+++ b/src/gastroenterology/permutation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology permutation module — tsb analytics library. */
+export interface GastroenterologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyPermutationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyPermutation(data: number[], opts: GastroenterologyPermutationOptions = {}): GastroenterologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyPermutation };
diff --git a/src/gastroenterology/prediction.ts b/src/gastroenterology/prediction.ts
new file mode 100644
index 000000000..d63b6596a
--- /dev/null
+++ b/src/gastroenterology/prediction.ts
@@ -0,0 +1,14 @@
+/** gastroenterology prediction module — tsb analytics library. */
+export interface GastroenterologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyPredictionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyPrediction(data: number[], opts: GastroenterologyPredictionOptions = {}): GastroenterologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyPrediction };
diff --git a/src/gastroenterology/processing.ts b/src/gastroenterology/processing.ts
new file mode 100644
index 000000000..857cfd052
--- /dev/null
+++ b/src/gastroenterology/processing.ts
@@ -0,0 +1,14 @@
+/** gastroenterology processing module — tsb analytics library. */
+export interface GastroenterologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyProcessingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyProcessing(data: number[], opts: GastroenterologyProcessingOptions = {}): GastroenterologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyProcessing };
diff --git a/src/gastroenterology/profiling.ts b/src/gastroenterology/profiling.ts
new file mode 100644
index 000000000..1447c386e
--- /dev/null
+++ b/src/gastroenterology/profiling.ts
@@ -0,0 +1,14 @@
+/** gastroenterology profiling module — tsb analytics library. */
+export interface GastroenterologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyProfilingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyProfiling(data: number[], opts: GastroenterologyProfilingOptions = {}): GastroenterologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyProfiling };
diff --git a/src/gastroenterology/projection.ts b/src/gastroenterology/projection.ts
new file mode 100644
index 000000000..2c37f352d
--- /dev/null
+++ b/src/gastroenterology/projection.ts
@@ -0,0 +1,14 @@
+/** gastroenterology projection module — tsb analytics library. */
+export interface GastroenterologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyProjectionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyProjection(data: number[], opts: GastroenterologyProjectionOptions = {}): GastroenterologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyProjection };
diff --git a/src/gastroenterology/ranking.ts b/src/gastroenterology/ranking.ts
new file mode 100644
index 000000000..598a16915
--- /dev/null
+++ b/src/gastroenterology/ranking.ts
@@ -0,0 +1,14 @@
+/** gastroenterology ranking module — tsb analytics library. */
+export interface GastroenterologyRankingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyRankingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyRanking(data: number[], opts: GastroenterologyRankingOptions = {}): GastroenterologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyRanking };
diff --git a/src/gastroenterology/reconstruction.ts b/src/gastroenterology/reconstruction.ts
new file mode 100644
index 000000000..8299f92d8
--- /dev/null
+++ b/src/gastroenterology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** gastroenterology reconstruction module — tsb analytics library. */
+export interface GastroenterologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyReconstruction(data: number[], opts: GastroenterologyReconstructionOptions = {}): GastroenterologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyReconstruction };
diff --git a/src/gastroenterology/registration.ts b/src/gastroenterology/registration.ts
new file mode 100644
index 000000000..0e8455b21
--- /dev/null
+++ b/src/gastroenterology/registration.ts
@@ -0,0 +1,14 @@
+/** gastroenterology registration module — tsb analytics library. */
+export interface GastroenterologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyRegistration(data: number[], opts: GastroenterologyRegistrationOptions = {}): GastroenterologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyRegistration };
diff --git a/src/gastroenterology/regression.ts b/src/gastroenterology/regression.ts
new file mode 100644
index 000000000..0c243e8fd
--- /dev/null
+++ b/src/gastroenterology/regression.ts
@@ -0,0 +1,14 @@
+/** gastroenterology regression module — tsb analytics library. */
+export interface GastroenterologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyRegressionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyRegression(data: number[], opts: GastroenterologyRegressionOptions = {}): GastroenterologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyRegression };
diff --git a/src/gastroenterology/regularization.ts b/src/gastroenterology/regularization.ts
new file mode 100644
index 000000000..1e376e888
--- /dev/null
+++ b/src/gastroenterology/regularization.ts
@@ -0,0 +1,14 @@
+/** gastroenterology regularization module — tsb analytics library. */
+export interface GastroenterologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyRegularization(data: number[], opts: GastroenterologyRegularizationOptions = {}): GastroenterologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyRegularization };
diff --git a/src/gastroenterology/robustness.ts b/src/gastroenterology/robustness.ts
new file mode 100644
index 000000000..eb8c82aaa
--- /dev/null
+++ b/src/gastroenterology/robustness.ts
@@ -0,0 +1,14 @@
+/** gastroenterology robustness module — tsb analytics library. */
+export interface GastroenterologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyRobustness(data: number[], opts: GastroenterologyRobustnessOptions = {}): GastroenterologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyRobustness };
diff --git a/src/gastroenterology/sampling.ts b/src/gastroenterology/sampling.ts
new file mode 100644
index 000000000..18bfafa6f
--- /dev/null
+++ b/src/gastroenterology/sampling.ts
@@ -0,0 +1,14 @@
+/** gastroenterology sampling module — tsb analytics library. */
+export interface GastroenterologySamplingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologySamplingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologySampling(data: number[], opts: GastroenterologySamplingOptions = {}): GastroenterologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologySampling };
diff --git a/src/gastroenterology/sampling2.ts b/src/gastroenterology/sampling2.ts
new file mode 100644
index 000000000..7f8863882
--- /dev/null
+++ b/src/gastroenterology/sampling2.ts
@@ -0,0 +1,14 @@
+/** gastroenterology sampling2 module — tsb analytics library. */
+export interface GastroenterologySamplingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologySamplingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologySampling(data: number[], opts: GastroenterologySamplingOptions = {}): GastroenterologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologySampling };
diff --git a/src/gastroenterology/scaling.ts b/src/gastroenterology/scaling.ts
new file mode 100644
index 000000000..00b18244a
--- /dev/null
+++ b/src/gastroenterology/scaling.ts
@@ -0,0 +1,14 @@
+/** gastroenterology scaling module — tsb analytics library. */
+export interface GastroenterologyScalingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyScalingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyScaling(data: number[], opts: GastroenterologyScalingOptions = {}): GastroenterologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyScaling };
diff --git a/src/gastroenterology/scoring.ts b/src/gastroenterology/scoring.ts
new file mode 100644
index 000000000..ccaf3ec89
--- /dev/null
+++ b/src/gastroenterology/scoring.ts
@@ -0,0 +1,14 @@
+/** gastroenterology scoring module — tsb analytics library. */
+export interface GastroenterologyScoringOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyScoringResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyScoring(data: number[], opts: GastroenterologyScoringOptions = {}): GastroenterologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyScoring };
diff --git a/src/gastroenterology/segmentation.ts b/src/gastroenterology/segmentation.ts
new file mode 100644
index 000000000..ad217adc9
--- /dev/null
+++ b/src/gastroenterology/segmentation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology segmentation module — tsb analytics library. */
+export interface GastroenterologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologySegmentationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologySegmentation(data: number[], opts: GastroenterologySegmentationOptions = {}): GastroenterologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologySegmentation };
diff --git a/src/gastroenterology/selection.ts b/src/gastroenterology/selection.ts
new file mode 100644
index 000000000..f815d4056
--- /dev/null
+++ b/src/gastroenterology/selection.ts
@@ -0,0 +1,14 @@
+/** gastroenterology selection module — tsb analytics library. */
+export interface GastroenterologySelectionOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologySelectionResult { values: number[]; converged: boolean; }
+export function computeGastroenterologySelection(data: number[], opts: GastroenterologySelectionOptions = {}): GastroenterologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologySelection };
diff --git a/src/gastroenterology/sensitivity.ts b/src/gastroenterology/sensitivity.ts
new file mode 100644
index 000000000..520112078
--- /dev/null
+++ b/src/gastroenterology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** gastroenterology sensitivity module — tsb analytics library. */
+export interface GastroenterologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologySensitivityResult { values: number[]; converged: boolean; }
+export function computeGastroenterologySensitivity(data: number[], opts: GastroenterologySensitivityOptions = {}): GastroenterologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologySensitivity };
diff --git a/src/gastroenterology/simulation.ts b/src/gastroenterology/simulation.ts
new file mode 100644
index 000000000..c44be052b
--- /dev/null
+++ b/src/gastroenterology/simulation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology simulation module — tsb analytics library. */
+export interface GastroenterologySimulationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologySimulationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologySimulation(data: number[], opts: GastroenterologySimulationOptions = {}): GastroenterologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologySimulation };
diff --git a/src/gastroenterology/smoothing.ts b/src/gastroenterology/smoothing.ts
new file mode 100644
index 000000000..5524c015c
--- /dev/null
+++ b/src/gastroenterology/smoothing.ts
@@ -0,0 +1,14 @@
+/** gastroenterology smoothing module — tsb analytics library. */
+export interface GastroenterologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologySmoothingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologySmoothing(data: number[], opts: GastroenterologySmoothingOptions = {}): GastroenterologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologySmoothing };
diff --git a/src/gastroenterology/stability.ts b/src/gastroenterology/stability.ts
new file mode 100644
index 000000000..b736e3fea
--- /dev/null
+++ b/src/gastroenterology/stability.ts
@@ -0,0 +1,14 @@
+/** gastroenterology stability module — tsb analytics library. */
+export interface GastroenterologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyStabilityResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyStability(data: number[], opts: GastroenterologyStabilityOptions = {}): GastroenterologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyStability };
diff --git a/src/gastroenterology/stacking.ts b/src/gastroenterology/stacking.ts
new file mode 100644
index 000000000..e43be1e5c
--- /dev/null
+++ b/src/gastroenterology/stacking.ts
@@ -0,0 +1,14 @@
+/** gastroenterology stacking module — tsb analytics library. */
+export interface GastroenterologyStackingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyStackingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyStacking(data: number[], opts: GastroenterologyStackingOptions = {}): GastroenterologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyStacking };
diff --git a/src/gastroenterology/standardization.ts b/src/gastroenterology/standardization.ts
new file mode 100644
index 000000000..c53fbd9bd
--- /dev/null
+++ b/src/gastroenterology/standardization.ts
@@ -0,0 +1,14 @@
+/** gastroenterology standardization module — tsb analytics library. */
+export interface GastroenterologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyStandardization(data: number[], opts: GastroenterologyStandardizationOptions = {}): GastroenterologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyStandardization };
diff --git a/src/gastroenterology/static.ts b/src/gastroenterology/static.ts
new file mode 100644
index 000000000..3679bb31d
--- /dev/null
+++ b/src/gastroenterology/static.ts
@@ -0,0 +1,14 @@
+/** gastroenterology static module — tsb analytics library. */
+export interface GastroenterologyStaticOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyStaticResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyStatic(data: number[], opts: GastroenterologyStaticOptions = {}): GastroenterologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyStatic };
diff --git a/src/gastroenterology/stochastic.ts b/src/gastroenterology/stochastic.ts
new file mode 100644
index 000000000..174ff3622
--- /dev/null
+++ b/src/gastroenterology/stochastic.ts
@@ -0,0 +1,14 @@
+/** gastroenterology stochastic module — tsb analytics library. */
+export interface GastroenterologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyStochasticResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyStochastic(data: number[], opts: GastroenterologyStochasticOptions = {}): GastroenterologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyStochastic };
diff --git a/src/gastroenterology/synthesis.ts b/src/gastroenterology/synthesis.ts
new file mode 100644
index 000000000..f4cdcdc37
--- /dev/null
+++ b/src/gastroenterology/synthesis.ts
@@ -0,0 +1,14 @@
+/** gastroenterology synthesis module — tsb analytics library. */
+export interface GastroenterologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologySynthesisResult { values: number[]; converged: boolean; }
+export function computeGastroenterologySynthesis(data: number[], opts: GastroenterologySynthesisOptions = {}): GastroenterologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologySynthesis };
diff --git a/src/gastroenterology/topology.ts b/src/gastroenterology/topology.ts
new file mode 100644
index 000000000..29c13da68
--- /dev/null
+++ b/src/gastroenterology/topology.ts
@@ -0,0 +1,14 @@
+/** gastroenterology topology module — tsb analytics library. */
+export interface GastroenterologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyTopologyResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyTopology(data: number[], opts: GastroenterologyTopologyOptions = {}): GastroenterologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyTopology };
diff --git a/src/gastroenterology/tracking.ts b/src/gastroenterology/tracking.ts
new file mode 100644
index 000000000..dbdc8ec8c
--- /dev/null
+++ b/src/gastroenterology/tracking.ts
@@ -0,0 +1,14 @@
+/** gastroenterology tracking module — tsb analytics library. */
+export interface GastroenterologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyTrackingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyTracking(data: number[], opts: GastroenterologyTrackingOptions = {}): GastroenterologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyTracking };
diff --git a/src/gastroenterology/transform.ts b/src/gastroenterology/transform.ts
new file mode 100644
index 000000000..c5606bee1
--- /dev/null
+++ b/src/gastroenterology/transform.ts
@@ -0,0 +1,14 @@
+/** gastroenterology transform module — tsb analytics library. */
+export interface GastroenterologyTransformOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyTransformResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyTransform(data: number[], opts: GastroenterologyTransformOptions = {}): GastroenterologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyTransform };
diff --git a/src/gastroenterology/uncertainty.ts b/src/gastroenterology/uncertainty.ts
new file mode 100644
index 000000000..75a7bc560
--- /dev/null
+++ b/src/gastroenterology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** gastroenterology uncertainty module — tsb analytics library. */
+export interface GastroenterologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyUncertainty(data: number[], opts: GastroenterologyUncertaintyOptions = {}): GastroenterologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyUncertainty };
diff --git a/src/gastroenterology/validation.ts b/src/gastroenterology/validation.ts
new file mode 100644
index 000000000..6314920a9
--- /dev/null
+++ b/src/gastroenterology/validation.ts
@@ -0,0 +1,14 @@
+/** gastroenterology validation module — tsb analytics library. */
+export interface GastroenterologyValidationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyValidationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyValidation(data: number[], opts: GastroenterologyValidationOptions = {}): GastroenterologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyValidation };
diff --git a/src/gastroenterology/verification.ts b/src/gastroenterology/verification.ts
new file mode 100644
index 000000000..f0a1c2433
--- /dev/null
+++ b/src/gastroenterology/verification.ts
@@ -0,0 +1,14 @@
+/** gastroenterology verification module — tsb analytics library. */
+export interface GastroenterologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyVerificationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyVerification(data: number[], opts: GastroenterologyVerificationOptions = {}): GastroenterologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyVerification };
diff --git a/src/gastroenterology/visualization.ts b/src/gastroenterology/visualization.ts
new file mode 100644
index 000000000..b6e97b04d
--- /dev/null
+++ b/src/gastroenterology/visualization.ts
@@ -0,0 +1,14 @@
+/** gastroenterology visualization module — tsb analytics library. */
+export interface GastroenterologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyVisualization(data: number[], opts: GastroenterologyVisualizationOptions = {}): GastroenterologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyVisualization };
diff --git a/src/gastroenterology/voting.ts b/src/gastroenterology/voting.ts
new file mode 100644
index 000000000..afe26ed30
--- /dev/null
+++ b/src/gastroenterology/voting.ts
@@ -0,0 +1,14 @@
+/** gastroenterology voting module — tsb analytics library. */
+export interface GastroenterologyVotingOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyVotingResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyVoting(data: number[], opts: GastroenterologyVotingOptions = {}): GastroenterologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyVoting };
diff --git a/src/gastroenterology/wavelet.ts b/src/gastroenterology/wavelet.ts
new file mode 100644
index 000000000..6f55d303a
--- /dev/null
+++ b/src/gastroenterology/wavelet.ts
@@ -0,0 +1,14 @@
+/** gastroenterology wavelet module — tsb analytics library. */
+export interface GastroenterologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface GastroenterologyWaveletResult { values: number[]; converged: boolean; }
+export function computeGastroenterologyWavelet(data: number[], opts: GastroenterologyWaveletOptions = {}): GastroenterologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGastroenterologyWavelet };
diff --git a/src/geo/accessibility.ts b/src/geo/accessibility.ts
new file mode 100644
index 000000000..142037edf
--- /dev/null
+++ b/src/geo/accessibility.ts
@@ -0,0 +1,22 @@
+/** Accessibility module — tsb analytics library. */
+
+/** Options for Accessibility. */
+export interface AccessibilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Accessibility. */
+export interface AccessibilityResult { values: number[]; converged: boolean; }
+
+/** Compute Accessibility. */
+export function computeAccessibility(data: number[], opts: AccessibilityOptions = {}): AccessibilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAccessibility };
diff --git a/src/geo/advanced.ts b/src/geo/advanced.ts
new file mode 100644
index 000000000..7c4287c24
--- /dev/null
+++ b/src/geo/advanced.ts
@@ -0,0 +1,15 @@
+/** Geo Advanced module — tsb analytics library. */
+export interface Geo advancedOptions { tol?: number; maxIter?: number; }
+export interface Geo advancedResult { values: number[]; converged: boolean; }
+export function computeGeo advanced(data: number[], opts: Geo advancedOptions = {}): Geo advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo advanced };
diff --git a/src/geo/base2.ts b/src/geo/base2.ts
new file mode 100644
index 000000000..190a68f72
--- /dev/null
+++ b/src/geo/base2.ts
@@ -0,0 +1,15 @@
+/** Geo Base2 module — tsb analytics library. */
+export interface Geo base2Options { tol?: number; maxIter?: number; }
+export interface Geo base2Result { values: number[]; converged: boolean; }
+export function computeGeo base2(data: number[], opts: Geo base2Options = {}): Geo base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo base2 };
diff --git a/src/geo/batch.ts b/src/geo/batch.ts
new file mode 100644
index 000000000..6c984aa60
--- /dev/null
+++ b/src/geo/batch.ts
@@ -0,0 +1,15 @@
+/** Geo Batch module — tsb analytics library. */
+export interface Geo batchOptions { tol?: number; maxIter?: number; }
+export interface Geo batchResult { values: number[]; converged: boolean; }
+export function computeGeo batch(data: number[], opts: Geo batchOptions = {}): Geo batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo batch };
diff --git a/src/geo/beta.ts b/src/geo/beta.ts
new file mode 100644
index 000000000..f2f9214a8
--- /dev/null
+++ b/src/geo/beta.ts
@@ -0,0 +1,15 @@
+/** Geo Beta module — tsb analytics library. */
+export interface Geo betaOptions { tol?: number; maxIter?: number; }
+export interface Geo betaResult { values: number[]; converged: boolean; }
+export function computeGeo beta(data: number[], opts: Geo betaOptions = {}): Geo betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo beta };
diff --git a/src/geo/boundaries.ts b/src/geo/boundaries.ts
new file mode 100644
index 000000000..e0fa507e6
--- /dev/null
+++ b/src/geo/boundaries.ts
@@ -0,0 +1,22 @@
+/** Boundaries module — tsb analytics library. */
+
+/** Options for Boundaries. */
+export interface BoundariesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Boundaries. */
+export interface BoundariesResult { values: number[]; converged: boolean; }
+
+/** Compute Boundaries. */
+export function computeBoundaries(data: number[], opts: BoundariesOptions = {}): BoundariesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBoundaries };
diff --git a/src/geo/buffering.ts b/src/geo/buffering.ts
new file mode 100644
index 000000000..bdeaefccb
--- /dev/null
+++ b/src/geo/buffering.ts
@@ -0,0 +1,22 @@
+/** Buffering module — tsb analytics library. */
+
+/** Options for Buffering. */
+export interface BufferingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Buffering. */
+export interface BufferingResult { values: number[]; converged: boolean; }
+
+/** Compute Buffering. */
+export function computeBuffering(data: number[], opts: BufferingOptions = {}): BufferingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBuffering };
diff --git a/src/geo/catchment.ts b/src/geo/catchment.ts
new file mode 100644
index 000000000..a6e3c50f7
--- /dev/null
+++ b/src/geo/catchment.ts
@@ -0,0 +1,22 @@
+/** Catchment module — tsb analytics library. */
+
+/** Options for Catchment. */
+export interface CatchmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Catchment. */
+export interface CatchmentResult { values: number[]; converged: boolean; }
+
+/** Compute Catchment. */
+export function computeCatchment(data: number[], opts: CatchmentOptions = {}): CatchmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCatchment };
diff --git a/src/geo/clustering.ts b/src/geo/clustering.ts
new file mode 100644
index 000000000..76db9a775
--- /dev/null
+++ b/src/geo/clustering.ts
@@ -0,0 +1,22 @@
+/** Clustering module — tsb analytics library. */
+
+/** Options for Clustering. */
+export interface ClusteringOptions { tol?: number; maxIter?: number; }
+
+/** Result from Clustering. */
+export interface ClusteringResult { values: number[]; converged: boolean; }
+
+/** Compute Clustering. */
+export function computeClustering(data: number[], opts: ClusteringOptions = {}): ClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClustering };
diff --git a/src/geo/convex_hull.ts b/src/geo/convex_hull.ts
new file mode 100644
index 000000000..785058e21
--- /dev/null
+++ b/src/geo/convex_hull.ts
@@ -0,0 +1,22 @@
+/** Convex Hull module — tsb analytics library. */
+
+/** Options for Convex Hull. */
+export interface ConvexHullOptions { tol?: number; maxIter?: number; }
+
+/** Result from Convex Hull. */
+export interface ConvexHullResult { values: number[]; converged: boolean; }
+
+/** Compute Convex Hull. */
+export function computeConvexHull(data: number[], opts: ConvexHullOptions = {}): ConvexHullResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConvexHull };
diff --git a/src/geo/coordinates.ts b/src/geo/coordinates.ts
new file mode 100644
index 000000000..42ab9d17c
--- /dev/null
+++ b/src/geo/coordinates.ts
@@ -0,0 +1,22 @@
+/** Coordinates module — tsb analytics library. */
+
+/** Options for Coordinates. */
+export interface CoordinatesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coordinates. */
+export interface CoordinatesResult { values: number[]; converged: boolean; }
+
+/** Compute Coordinates. */
+export function computeCoordinates(data: number[], opts: CoordinatesOptions = {}): CoordinatesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCoordinates };
diff --git a/src/geo/cpu.ts b/src/geo/cpu.ts
new file mode 100644
index 000000000..166e0fdf3
--- /dev/null
+++ b/src/geo/cpu.ts
@@ -0,0 +1,15 @@
+/** Geo Cpu module — tsb analytics library. */
+export interface Geo cpuOptions { tol?: number; maxIter?: number; }
+export interface Geo cpuResult { values: number[]; converged: boolean; }
+export function computeGeo cpu(data: number[], opts: Geo cpuOptions = {}): Geo cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo cpu };
diff --git a/src/geo/dense.ts b/src/geo/dense.ts
new file mode 100644
index 000000000..f8c765c11
--- /dev/null
+++ b/src/geo/dense.ts
@@ -0,0 +1,15 @@
+/** Geo Dense module — tsb analytics library. */
+export interface Geo denseOptions { tol?: number; maxIter?: number; }
+export interface Geo denseResult { values: number[]; converged: boolean; }
+export function computeGeo dense(data: number[], opts: Geo denseOptions = {}): Geo denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo dense };
diff --git a/src/geo/distances.ts b/src/geo/distances.ts
new file mode 100644
index 000000000..06d696a41
--- /dev/null
+++ b/src/geo/distances.ts
@@ -0,0 +1,22 @@
+/** Distances module — tsb analytics library. */
+
+/** Options for Distances. */
+export interface DistancesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Distances. */
+export interface DistancesResult { values: number[]; converged: boolean; }
+
+/** Compute Distances. */
+export function computeDistances(data: number[], opts: DistancesOptions = {}): DistancesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDistances };
diff --git a/src/geo/distributed.ts b/src/geo/distributed.ts
new file mode 100644
index 000000000..3283733ed
--- /dev/null
+++ b/src/geo/distributed.ts
@@ -0,0 +1,15 @@
+/** Geo Distributed module — tsb analytics library. */
+export interface Geo distributedOptions { tol?: number; maxIter?: number; }
+export interface Geo distributedResult { values: number[]; converged: boolean; }
+export function computeGeo distributed(data: number[], opts: Geo distributedOptions = {}): Geo distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo distributed };
diff --git a/src/geo/elevation.ts b/src/geo/elevation.ts
new file mode 100644
index 000000000..4118099e7
--- /dev/null
+++ b/src/geo/elevation.ts
@@ -0,0 +1,22 @@
+/** Elevation module — tsb analytics library. */
+
+/** Options for Elevation. */
+export interface ElevationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Elevation. */
+export interface ElevationResult { values: number[]; converged: boolean; }
+
+/** Compute Elevation. */
+export function computeElevation(data: number[], opts: ElevationOptions = {}): ElevationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeElevation };
diff --git a/src/geo/experimental.ts b/src/geo/experimental.ts
new file mode 100644
index 000000000..d393618f8
--- /dev/null
+++ b/src/geo/experimental.ts
@@ -0,0 +1,15 @@
+/** Geo Experimental module — tsb analytics library. */
+export interface Geo experimentalOptions { tol?: number; maxIter?: number; }
+export interface Geo experimentalResult { values: number[]; converged: boolean; }
+export function computeGeo experimental(data: number[], opts: Geo experimentalOptions = {}): Geo experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo experimental };
diff --git a/src/geo/fast.ts b/src/geo/fast.ts
new file mode 100644
index 000000000..1614c2c1a
--- /dev/null
+++ b/src/geo/fast.ts
@@ -0,0 +1,15 @@
+/** Geo Fast module — tsb analytics library. */
+export interface Geo fastOptions { tol?: number; maxIter?: number; }
+export interface Geo fastResult { values: number[]; converged: boolean; }
+export function computeGeo fast(data: number[], opts: Geo fastOptions = {}): Geo fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo fast };
diff --git a/src/geo/flow.ts b/src/geo/flow.ts
new file mode 100644
index 000000000..714346a38
--- /dev/null
+++ b/src/geo/flow.ts
@@ -0,0 +1,22 @@
+/** Flow module — tsb analytics library. */
+
+/** Options for Flow. */
+export interface FlowOptions { tol?: number; maxIter?: number; }
+
+/** Result from Flow. */
+export interface FlowResult { values: number[]; converged: boolean; }
+
+/** Compute Flow. */
+export function computeFlow(data: number[], opts: FlowOptions = {}): FlowResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFlow };
diff --git a/src/geo/future.ts b/src/geo/future.ts
new file mode 100644
index 000000000..328b40c21
--- /dev/null
+++ b/src/geo/future.ts
@@ -0,0 +1,15 @@
+/** Geo Future module — tsb analytics library. */
+export interface Geo futureOptions { tol?: number; maxIter?: number; }
+export interface Geo futureResult { values: number[]; converged: boolean; }
+export function computeGeo future(data: number[], opts: Geo futureOptions = {}): Geo futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo future };
diff --git a/src/geo/geocoding.ts b/src/geo/geocoding.ts
new file mode 100644
index 000000000..94722d819
--- /dev/null
+++ b/src/geo/geocoding.ts
@@ -0,0 +1,22 @@
+/** Geocoding module — tsb analytics library. */
+
+/** Options for Geocoding. */
+export interface GeocodingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Geocoding. */
+export interface GeocodingResult { values: number[]; converged: boolean; }
+
+/** Compute Geocoding. */
+export function computeGeocoding(data: number[], opts: GeocodingOptions = {}): GeocodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeocoding };
diff --git a/src/geo/geographically_weighted.ts b/src/geo/geographically_weighted.ts
new file mode 100644
index 000000000..87ef01041
--- /dev/null
+++ b/src/geo/geographically_weighted.ts
@@ -0,0 +1,22 @@
+/** Geographically Weighted module — tsb analytics library. */
+
+/** Options for Geographically Weighted. */
+export interface GeographicallyWeightedOptions { tol?: number; maxIter?: number; }
+
+/** Result from Geographically Weighted. */
+export interface GeographicallyWeightedResult { values: number[]; converged: boolean; }
+
+/** Compute Geographically Weighted. */
+export function computeGeographicallyWeighted(data: number[], opts: GeographicallyWeightedOptions = {}): GeographicallyWeightedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeographicallyWeighted };
diff --git a/src/geo/gpu.ts b/src/geo/gpu.ts
new file mode 100644
index 000000000..c0c1bedcc
--- /dev/null
+++ b/src/geo/gpu.ts
@@ -0,0 +1,15 @@
+/** Geo Gpu module — tsb analytics library. */
+export interface Geo gpuOptions { tol?: number; maxIter?: number; }
+export interface Geo gpuResult { values: number[]; converged: boolean; }
+export function computeGeo gpu(data: number[], opts: Geo gpuOptions = {}): Geo gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo gpu };
diff --git a/src/geo/heatmap.ts b/src/geo/heatmap.ts
new file mode 100644
index 000000000..72c4a17b2
--- /dev/null
+++ b/src/geo/heatmap.ts
@@ -0,0 +1,22 @@
+/** Heatmap module — tsb analytics library. */
+
+/** Options for Heatmap. */
+export interface HeatmapOptions { tol?: number; maxIter?: number; }
+
+/** Result from Heatmap. */
+export interface HeatmapResult { values: number[]; converged: boolean; }
+
+/** Compute Heatmap. */
+export function computeHeatmap(data: number[], opts: HeatmapOptions = {}): HeatmapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHeatmap };
diff --git a/src/geo/interpolation.ts b/src/geo/interpolation.ts
new file mode 100644
index 000000000..ef7af6c1d
--- /dev/null
+++ b/src/geo/interpolation.ts
@@ -0,0 +1,22 @@
+/** Interpolation module — tsb analytics library. */
+
+/** Options for Interpolation. */
+export interface InterpolationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Interpolation. */
+export interface InterpolationResult { values: number[]; converged: boolean; }
+
+/** Compute Interpolation. */
+export function computeInterpolation(data: number[], opts: InterpolationOptions = {}): InterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInterpolation };
diff --git a/src/geo/isochrone.ts b/src/geo/isochrone.ts
new file mode 100644
index 000000000..db327b753
--- /dev/null
+++ b/src/geo/isochrone.ts
@@ -0,0 +1,22 @@
+/** Isochrone module — tsb analytics library. */
+
+/** Options for Isochrone. */
+export interface IsochroneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Isochrone. */
+export interface IsochroneResult { values: number[]; converged: boolean; }
+
+/** Compute Isochrone. */
+export function computeIsochrone(data: number[], opts: IsochroneOptions = {}): IsochroneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIsochrone };
diff --git a/src/geo/kriging.ts b/src/geo/kriging.ts
new file mode 100644
index 000000000..20ec7eee5
--- /dev/null
+++ b/src/geo/kriging.ts
@@ -0,0 +1,22 @@
+/** Kriging module — tsb analytics library. */
+
+/** Options for Kriging. */
+export interface KrigingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Kriging. */
+export interface KrigingResult { values: number[]; converged: boolean; }
+
+/** Compute Kriging. */
+export function computeKriging(data: number[], opts: KrigingOptions = {}): KrigingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKriging };
diff --git a/src/geo/large.ts b/src/geo/large.ts
new file mode 100644
index 000000000..27d0fd052
--- /dev/null
+++ b/src/geo/large.ts
@@ -0,0 +1,15 @@
+/** Geo Large module — tsb analytics library. */
+export interface Geo largeOptions { tol?: number; maxIter?: number; }
+export interface Geo largeResult { values: number[]; converged: boolean; }
+export function computeGeo large(data: number[], opts: Geo largeOptions = {}): Geo largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo large };
diff --git a/src/geo/legacy.ts b/src/geo/legacy.ts
new file mode 100644
index 000000000..b3e9cd680
--- /dev/null
+++ b/src/geo/legacy.ts
@@ -0,0 +1,15 @@
+/** Geo Legacy module — tsb analytics library. */
+export interface Geo legacyOptions { tol?: number; maxIter?: number; }
+export interface Geo legacyResult { values: number[]; converged: boolean; }
+export function computeGeo legacy(data: number[], opts: Geo legacyOptions = {}): Geo legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo legacy };
diff --git a/src/geo/lite.ts b/src/geo/lite.ts
new file mode 100644
index 000000000..8c57e01fb
--- /dev/null
+++ b/src/geo/lite.ts
@@ -0,0 +1,15 @@
+/** Geo Lite module — tsb analytics library. */
+export interface Geo liteOptions { tol?: number; maxIter?: number; }
+export interface Geo liteResult { values: number[]; converged: boolean; }
+export function computeGeo lite(data: number[], opts: Geo liteOptions = {}): Geo liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo lite };
diff --git a/src/geo/mini.ts b/src/geo/mini.ts
new file mode 100644
index 000000000..3963eb380
--- /dev/null
+++ b/src/geo/mini.ts
@@ -0,0 +1,15 @@
+/** Geo Mini module — tsb analytics library. */
+export interface Geo miniOptions { tol?: number; maxIter?: number; }
+export interface Geo miniResult { values: number[]; converged: boolean; }
+export function computeGeo mini(data: number[], opts: Geo miniOptions = {}): Geo miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo mini };
diff --git a/src/geo/mobility.ts b/src/geo/mobility.ts
new file mode 100644
index 000000000..e40457674
--- /dev/null
+++ b/src/geo/mobility.ts
@@ -0,0 +1,22 @@
+/** Mobility module — tsb analytics library. */
+
+/** Options for Mobility. */
+export interface MobilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mobility. */
+export interface MobilityResult { values: number[]; converged: boolean; }
+
+/** Compute Mobility. */
+export function computeMobility(data: number[], opts: MobilityOptions = {}): MobilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMobility };
diff --git a/src/geo/network_geo.ts b/src/geo/network_geo.ts
new file mode 100644
index 000000000..ac8f1db22
--- /dev/null
+++ b/src/geo/network_geo.ts
@@ -0,0 +1,22 @@
+/** Network Geo module — tsb analytics library. */
+
+/** Options for Network Geo. */
+export interface NetworkGeoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Network Geo. */
+export interface NetworkGeoResult { values: number[]; converged: boolean; }
+
+/** Compute Network Geo. */
+export function computeNetworkGeo(data: number[], opts: NetworkGeoOptions = {}): NetworkGeoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNetworkGeo };
diff --git a/src/geo/next.ts b/src/geo/next.ts
new file mode 100644
index 000000000..c08acc0e5
--- /dev/null
+++ b/src/geo/next.ts
@@ -0,0 +1,15 @@
+/** Geo Next module — tsb analytics library. */
+export interface Geo nextOptions { tol?: number; maxIter?: number; }
+export interface Geo nextResult { values: number[]; converged: boolean; }
+export function computeGeo next(data: number[], opts: Geo nextOptions = {}): Geo nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo next };
diff --git a/src/geo/online.ts b/src/geo/online.ts
new file mode 100644
index 000000000..44ab1501b
--- /dev/null
+++ b/src/geo/online.ts
@@ -0,0 +1,15 @@
+/** Geo Online module — tsb analytics library. */
+export interface Geo onlineOptions { tol?: number; maxIter?: number; }
+export interface Geo onlineResult { values: number[]; converged: boolean; }
+export function computeGeo online(data: number[], opts: Geo onlineOptions = {}): Geo onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo online };
diff --git a/src/geo/origin_destination.ts b/src/geo/origin_destination.ts
new file mode 100644
index 000000000..dc86c2408
--- /dev/null
+++ b/src/geo/origin_destination.ts
@@ -0,0 +1,22 @@
+/** Origin Destination module — tsb analytics library. */
+
+/** Options for Origin Destination. */
+export interface OriginDestinationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Origin Destination. */
+export interface OriginDestinationResult { values: number[]; converged: boolean; }
+
+/** Compute Origin Destination. */
+export function computeOriginDestination(data: number[], opts: OriginDestinationOptions = {}): OriginDestinationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOriginDestination };
diff --git a/src/geo/overlay.ts b/src/geo/overlay.ts
new file mode 100644
index 000000000..4e41f6595
--- /dev/null
+++ b/src/geo/overlay.ts
@@ -0,0 +1,22 @@
+/** Overlay module — tsb analytics library. */
+
+/** Options for Overlay. */
+export interface OverlayOptions { tol?: number; maxIter?: number; }
+
+/** Result from Overlay. */
+export interface OverlayResult { values: number[]; converged: boolean; }
+
+/** Compute Overlay. */
+export function computeOverlay(data: number[], opts: OverlayOptions = {}): OverlayResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOverlay };
diff --git a/src/geo/parallel.ts b/src/geo/parallel.ts
new file mode 100644
index 000000000..98039f468
--- /dev/null
+++ b/src/geo/parallel.ts
@@ -0,0 +1,15 @@
+/** Geo Parallel module — tsb analytics library. */
+export interface Geo parallelOptions { tol?: number; maxIter?: number; }
+export interface Geo parallelResult { values: number[]; converged: boolean; }
+export function computeGeo parallel(data: number[], opts: Geo parallelOptions = {}): Geo parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo parallel };
diff --git a/src/geo/plus.ts b/src/geo/plus.ts
new file mode 100644
index 000000000..8d7378436
--- /dev/null
+++ b/src/geo/plus.ts
@@ -0,0 +1,15 @@
+/** Geo Plus module — tsb analytics library. */
+export interface Geo plusOptions { tol?: number; maxIter?: number; }
+export interface Geo plusResult { values: number[]; converged: boolean; }
+export function computeGeo plus(data: number[], opts: Geo plusOptions = {}): Geo plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo plus };
diff --git a/src/geo/point_pattern.ts b/src/geo/point_pattern.ts
new file mode 100644
index 000000000..9ee63b40a
--- /dev/null
+++ b/src/geo/point_pattern.ts
@@ -0,0 +1,22 @@
+/** Point Pattern module — tsb analytics library. */
+
+/** Options for Point Pattern. */
+export interface PointPatternOptions { tol?: number; maxIter?: number; }
+
+/** Result from Point Pattern. */
+export interface PointPatternResult { values: number[]; converged: boolean; }
+
+/** Compute Point Pattern. */
+export function computePointPattern(data: number[], opts: PointPatternOptions = {}): PointPatternResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePointPattern };
diff --git a/src/geo/pro.ts b/src/geo/pro.ts
new file mode 100644
index 000000000..1229a2582
--- /dev/null
+++ b/src/geo/pro.ts
@@ -0,0 +1,15 @@
+/** Geo Pro module — tsb analytics library. */
+export interface Geo proOptions { tol?: number; maxIter?: number; }
+export interface Geo proResult { values: number[]; converged: boolean; }
+export function computeGeo pro(data: number[], opts: Geo proOptions = {}): Geo proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo pro };
diff --git a/src/geo/projections.ts b/src/geo/projections.ts
new file mode 100644
index 000000000..466079bd0
--- /dev/null
+++ b/src/geo/projections.ts
@@ -0,0 +1,22 @@
+/** Projections module — tsb analytics library. */
+
+/** Options for Projections. */
+export interface ProjectionsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Projections. */
+export interface ProjectionsResult { values: number[]; converged: boolean; }
+
+/** Compute Projections. */
+export function computeProjections(data: number[], opts: ProjectionsOptions = {}): ProjectionsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProjections };
diff --git a/src/geo/raster.ts b/src/geo/raster.ts
new file mode 100644
index 000000000..88023947e
--- /dev/null
+++ b/src/geo/raster.ts
@@ -0,0 +1,22 @@
+/** Raster module — tsb analytics library. */
+
+/** Options for Raster. */
+export interface RasterOptions { tol?: number; maxIter?: number; }
+
+/** Result from Raster. */
+export interface RasterResult { values: number[]; converged: boolean; }
+
+/** Compute Raster. */
+export function computeRaster(data: number[], opts: RasterOptions = {}): RasterResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRaster };
diff --git a/src/geo/robust.ts b/src/geo/robust.ts
new file mode 100644
index 000000000..8999f80cc
--- /dev/null
+++ b/src/geo/robust.ts
@@ -0,0 +1,15 @@
+/** Geo Robust module — tsb analytics library. */
+export interface Geo robustOptions { tol?: number; maxIter?: number; }
+export interface Geo robustResult { values: number[]; converged: boolean; }
+export function computeGeo robust(data: number[], opts: Geo robustOptions = {}): Geo robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo robust };
diff --git a/src/geo/routing.ts b/src/geo/routing.ts
new file mode 100644
index 000000000..3de2357ea
--- /dev/null
+++ b/src/geo/routing.ts
@@ -0,0 +1,22 @@
+/** Routing module — tsb analytics library. */
+
+/** Options for Routing. */
+export interface RoutingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Routing. */
+export interface RoutingResult { values: number[]; converged: boolean; }
+
+/** Compute Routing. */
+export function computeRouting(data: number[], opts: RoutingOptions = {}): RoutingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRouting };
diff --git a/src/geo/small.ts b/src/geo/small.ts
new file mode 100644
index 000000000..cef5499d1
--- /dev/null
+++ b/src/geo/small.ts
@@ -0,0 +1,15 @@
+/** Geo Small module — tsb analytics library. */
+export interface Geo smallOptions { tol?: number; maxIter?: number; }
+export interface Geo smallResult { values: number[]; converged: boolean; }
+export function computeGeo small(data: number[], opts: Geo smallOptions = {}): Geo smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo small };
diff --git a/src/geo/sparse.ts b/src/geo/sparse.ts
new file mode 100644
index 000000000..a245c3db0
--- /dev/null
+++ b/src/geo/sparse.ts
@@ -0,0 +1,15 @@
+/** Geo Sparse module — tsb analytics library. */
+export interface Geo sparseOptions { tol?: number; maxIter?: number; }
+export interface Geo sparseResult { values: number[]; converged: boolean; }
+export function computeGeo sparse(data: number[], opts: Geo sparseOptions = {}): Geo sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo sparse };
diff --git a/src/geo/spatial_autocorrelation.ts b/src/geo/spatial_autocorrelation.ts
new file mode 100644
index 000000000..9a96a67b8
--- /dev/null
+++ b/src/geo/spatial_autocorrelation.ts
@@ -0,0 +1,22 @@
+/** Spatial Autocorrelation module — tsb analytics library. */
+
+/** Options for Spatial Autocorrelation. */
+export interface SpatialAutocorrelationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spatial Autocorrelation. */
+export interface SpatialAutocorrelationResult { values: number[]; converged: boolean; }
+
+/** Compute Spatial Autocorrelation. */
+export function computeSpatialAutocorrelation(data: number[], opts: SpatialAutocorrelationOptions = {}): SpatialAutocorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpatialAutocorrelation };
diff --git a/src/geo/spatial_regression.ts b/src/geo/spatial_regression.ts
new file mode 100644
index 000000000..8bc147e3f
--- /dev/null
+++ b/src/geo/spatial_regression.ts
@@ -0,0 +1,22 @@
+/** Spatial Regression module — tsb analytics library. */
+
+/** Options for Spatial Regression. */
+export interface SpatialRegressionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spatial Regression. */
+export interface SpatialRegressionResult { values: number[]; converged: boolean; }
+
+/** Compute Spatial Regression. */
+export function computeSpatialRegression(data: number[], opts: SpatialRegressionOptions = {}): SpatialRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpatialRegression };
diff --git a/src/geo/stable.ts b/src/geo/stable.ts
new file mode 100644
index 000000000..ce41bb75f
--- /dev/null
+++ b/src/geo/stable.ts
@@ -0,0 +1,15 @@
+/** Geo Stable module — tsb analytics library. */
+export interface Geo stableOptions { tol?: number; maxIter?: number; }
+export interface Geo stableResult { values: number[]; converged: boolean; }
+export function computeGeo stable(data: number[], opts: Geo stableOptions = {}): Geo stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo stable };
diff --git a/src/geo/streaming.ts b/src/geo/streaming.ts
new file mode 100644
index 000000000..ab59bbede
--- /dev/null
+++ b/src/geo/streaming.ts
@@ -0,0 +1,15 @@
+/** Geo Streaming module — tsb analytics library. */
+export interface Geo streamingOptions { tol?: number; maxIter?: number; }
+export interface Geo streamingResult { values: number[]; converged: boolean; }
+export function computeGeo streaming(data: number[], opts: Geo streamingOptions = {}): Geo streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo streaming };
diff --git a/src/geo/topology.ts b/src/geo/topology.ts
new file mode 100644
index 000000000..659cdcbb1
--- /dev/null
+++ b/src/geo/topology.ts
@@ -0,0 +1,22 @@
+/** Topology module — tsb analytics library. */
+
+/** Options for Topology. */
+export interface TopologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Topology. */
+export interface TopologyResult { values: number[]; converged: boolean; }
+
+/** Compute Topology. */
+export function computeTopology(data: number[], opts: TopologyOptions = {}): TopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTopology };
diff --git a/src/geo/trajectory.ts b/src/geo/trajectory.ts
new file mode 100644
index 000000000..fef02705c
--- /dev/null
+++ b/src/geo/trajectory.ts
@@ -0,0 +1,22 @@
+/** Trajectory module — tsb analytics library. */
+
+/** Options for Trajectory. */
+export interface TrajectoryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Trajectory. */
+export interface TrajectoryResult { values: number[]; converged: boolean; }
+
+/** Compute Trajectory. */
+export function computeTrajectory(data: number[], opts: TrajectoryOptions = {}): TrajectoryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTrajectory };
diff --git a/src/geo/v2.ts b/src/geo/v2.ts
new file mode 100644
index 000000000..5cde5ddca
--- /dev/null
+++ b/src/geo/v2.ts
@@ -0,0 +1,15 @@
+/** Geo V2 module — tsb analytics library. */
+export interface Geo v2Options { tol?: number; maxIter?: number; }
+export interface Geo v2Result { values: number[]; converged: boolean; }
+export function computeGeo v2(data: number[], opts: Geo v2Options = {}): Geo v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo v2 };
diff --git a/src/geo/v3.ts b/src/geo/v3.ts
new file mode 100644
index 000000000..26fb5149b
--- /dev/null
+++ b/src/geo/v3.ts
@@ -0,0 +1,15 @@
+/** Geo V3 module — tsb analytics library. */
+export interface Geo v3Options { tol?: number; maxIter?: number; }
+export interface Geo v3Result { values: number[]; converged: boolean; }
+export function computeGeo v3(data: number[], opts: Geo v3Options = {}): Geo v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo v3 };
diff --git a/src/geo/vector.ts b/src/geo/vector.ts
new file mode 100644
index 000000000..057a2af12
--- /dev/null
+++ b/src/geo/vector.ts
@@ -0,0 +1,22 @@
+/** Vector module — tsb analytics library. */
+
+/** Options for Vector. */
+export interface VectorOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vector. */
+export interface VectorResult { values: number[]; converged: boolean; }
+
+/** Compute Vector. */
+export function computeVector(data: number[], opts: VectorOptions = {}): VectorResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVector };
diff --git a/src/geo/voronoi.ts b/src/geo/voronoi.ts
new file mode 100644
index 000000000..9dd5f6ccb
--- /dev/null
+++ b/src/geo/voronoi.ts
@@ -0,0 +1,22 @@
+/** Voronoi module — tsb analytics library. */
+
+/** Options for Voronoi. */
+export interface VoronoiOptions { tol?: number; maxIter?: number; }
+
+/** Result from Voronoi. */
+export interface VoronoiResult { values: number[]; converged: boolean; }
+
+/** Compute Voronoi. */
+export function computeVoronoi(data: number[], opts: VoronoiOptions = {}): VoronoiResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVoronoi };
diff --git a/src/geo/wasm.ts b/src/geo/wasm.ts
new file mode 100644
index 000000000..42ac3d2dd
--- /dev/null
+++ b/src/geo/wasm.ts
@@ -0,0 +1,15 @@
+/** Geo Wasm module — tsb analytics library. */
+export interface Geo wasmOptions { tol?: number; maxIter?: number; }
+export interface Geo wasmResult { values: number[]; converged: boolean; }
+export function computeGeo wasm(data: number[], opts: Geo wasmOptions = {}): Geo wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo wasm };
diff --git a/src/geo/xlarge.ts b/src/geo/xlarge.ts
new file mode 100644
index 000000000..c948cdb71
--- /dev/null
+++ b/src/geo/xlarge.ts
@@ -0,0 +1,15 @@
+/** Geo Xlarge module — tsb analytics library. */
+export interface Geo xlargeOptions { tol?: number; maxIter?: number; }
+export interface Geo xlargeResult { values: number[]; converged: boolean; }
+export function computeGeo xlarge(data: number[], opts: Geo xlargeOptions = {}): Geo xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeo xlarge };
diff --git a/src/geochronology/adaptation.ts b/src/geochronology/adaptation.ts
new file mode 100644
index 000000000..26410a36f
--- /dev/null
+++ b/src/geochronology/adaptation.ts
@@ -0,0 +1,14 @@
+/** geochronology adaptation module — tsb analytics library. */
+export interface GeochronologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyAdaptation(data: number[], opts: GeochronologyAdaptationOptions = {}): GeochronologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyAdaptation };
diff --git a/src/geochronology/aggregation.ts b/src/geochronology/aggregation.ts
new file mode 100644
index 000000000..ba837e4ba
--- /dev/null
+++ b/src/geochronology/aggregation.ts
@@ -0,0 +1,14 @@
+/** geochronology aggregation module — tsb analytics library. */
+export interface GeochronologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyAggregationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyAggregation(data: number[], opts: GeochronologyAggregationOptions = {}): GeochronologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyAggregation };
diff --git a/src/geochronology/algebra.ts b/src/geochronology/algebra.ts
new file mode 100644
index 000000000..90025a2c6
--- /dev/null
+++ b/src/geochronology/algebra.ts
@@ -0,0 +1,14 @@
+/** geochronology algebra module — tsb analytics library. */
+export interface GeochronologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeGeochronologyAlgebra(data: number[], opts: GeochronologyAlgebraOptions = {}): GeochronologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyAlgebra };
diff --git a/src/geochronology/alignment.ts b/src/geochronology/alignment.ts
new file mode 100644
index 000000000..3eb32de80
--- /dev/null
+++ b/src/geochronology/alignment.ts
@@ -0,0 +1,14 @@
+/** geochronology alignment module — tsb analytics library. */
+export interface GeochronologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeGeochronologyAlignment(data: number[], opts: GeochronologyAlignmentOptions = {}): GeochronologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyAlignment };
diff --git a/src/geochronology/analysis.ts b/src/geochronology/analysis.ts
new file mode 100644
index 000000000..872e90cda
--- /dev/null
+++ b/src/geochronology/analysis.ts
@@ -0,0 +1,14 @@
+/** geochronology analysis module — tsb analytics library. */
+export interface GeochronologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeGeochronologyAnalysis(data: number[], opts: GeochronologyAnalysisOptions = {}): GeochronologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyAnalysis };
diff --git a/src/geochronology/augmentation.ts b/src/geochronology/augmentation.ts
new file mode 100644
index 000000000..b76f4ff10
--- /dev/null
+++ b/src/geochronology/augmentation.ts
@@ -0,0 +1,14 @@
+/** geochronology augmentation module — tsb analytics library. */
+export interface GeochronologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyAugmentation(data: number[], opts: GeochronologyAugmentationOptions = {}): GeochronologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyAugmentation };
diff --git a/src/geochronology/bagging.ts b/src/geochronology/bagging.ts
new file mode 100644
index 000000000..40817cbf5
--- /dev/null
+++ b/src/geochronology/bagging.ts
@@ -0,0 +1,14 @@
+/** geochronology bagging module — tsb analytics library. */
+export interface GeochronologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyBaggingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyBagging(data: number[], opts: GeochronologyBaggingOptions = {}): GeochronologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyBagging };
diff --git a/src/geochronology/basis.ts b/src/geochronology/basis.ts
new file mode 100644
index 000000000..c1d792b77
--- /dev/null
+++ b/src/geochronology/basis.ts
@@ -0,0 +1,14 @@
+/** geochronology basis module — tsb analytics library. */
+export interface GeochronologyBasisOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyBasisResult { values: number[]; converged: boolean; }
+export function computeGeochronologyBasis(data: number[], opts: GeochronologyBasisOptions = {}): GeochronologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyBasis };
diff --git a/src/geochronology/benchmarking.ts b/src/geochronology/benchmarking.ts
new file mode 100644
index 000000000..e29a15ecd
--- /dev/null
+++ b/src/geochronology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** geochronology benchmarking module — tsb analytics library. */
+export interface GeochronologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyBenchmarking(data: number[], opts: GeochronologyBenchmarkingOptions = {}): GeochronologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyBenchmarking };
diff --git a/src/geochronology/blending.ts b/src/geochronology/blending.ts
new file mode 100644
index 000000000..bf7a7e39f
--- /dev/null
+++ b/src/geochronology/blending.ts
@@ -0,0 +1,14 @@
+/** geochronology blending module — tsb analytics library. */
+export interface GeochronologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyBlendingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyBlending(data: number[], opts: GeochronologyBlendingOptions = {}): GeochronologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyBlending };
diff --git a/src/geochronology/boosting.ts b/src/geochronology/boosting.ts
new file mode 100644
index 000000000..8c4a831ca
--- /dev/null
+++ b/src/geochronology/boosting.ts
@@ -0,0 +1,14 @@
+/** geochronology boosting module — tsb analytics library. */
+export interface GeochronologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyBoostingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyBoosting(data: number[], opts: GeochronologyBoostingOptions = {}): GeochronologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyBoosting };
diff --git a/src/geochronology/bootstrap.ts b/src/geochronology/bootstrap.ts
new file mode 100644
index 000000000..2d0f9bd95
--- /dev/null
+++ b/src/geochronology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** geochronology bootstrap module — tsb analytics library. */
+export interface GeochronologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeGeochronologyBootstrap(data: number[], opts: GeochronologyBootstrapOptions = {}): GeochronologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyBootstrap };
diff --git a/src/geochronology/calculus.ts b/src/geochronology/calculus.ts
new file mode 100644
index 000000000..909b1ec56
--- /dev/null
+++ b/src/geochronology/calculus.ts
@@ -0,0 +1,14 @@
+/** geochronology calculus module — tsb analytics library. */
+export interface GeochronologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyCalculusResult { values: number[]; converged: boolean; }
+export function computeGeochronologyCalculus(data: number[], opts: GeochronologyCalculusOptions = {}): GeochronologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyCalculus };
diff --git a/src/geochronology/calibration.ts b/src/geochronology/calibration.ts
new file mode 100644
index 000000000..7c02dd12c
--- /dev/null
+++ b/src/geochronology/calibration.ts
@@ -0,0 +1,14 @@
+/** geochronology calibration module — tsb analytics library. */
+export interface GeochronologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyCalibration(data: number[], opts: GeochronologyCalibrationOptions = {}): GeochronologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyCalibration };
diff --git a/src/geochronology/characterization.ts b/src/geochronology/characterization.ts
new file mode 100644
index 000000000..4d15e854b
--- /dev/null
+++ b/src/geochronology/characterization.ts
@@ -0,0 +1,14 @@
+/** geochronology characterization module — tsb analytics library. */
+export interface GeochronologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyCharacterization(data: number[], opts: GeochronologyCharacterizationOptions = {}): GeochronologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyCharacterization };
diff --git a/src/geochronology/classification.ts b/src/geochronology/classification.ts
new file mode 100644
index 000000000..08afe4795
--- /dev/null
+++ b/src/geochronology/classification.ts
@@ -0,0 +1,14 @@
+/** geochronology classification module — tsb analytics library. */
+export interface GeochronologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyClassificationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyClassification(data: number[], opts: GeochronologyClassificationOptions = {}): GeochronologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyClassification };
diff --git a/src/geochronology/clustering.ts b/src/geochronology/clustering.ts
new file mode 100644
index 000000000..323dcb046
--- /dev/null
+++ b/src/geochronology/clustering.ts
@@ -0,0 +1,14 @@
+/** geochronology clustering module — tsb analytics library. */
+export interface GeochronologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyClusteringResult { values: number[]; converged: boolean; }
+export function computeGeochronologyClustering(data: number[], opts: GeochronologyClusteringOptions = {}): GeochronologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyClustering };
diff --git a/src/geochronology/compression.ts b/src/geochronology/compression.ts
new file mode 100644
index 000000000..d2c9f4612
--- /dev/null
+++ b/src/geochronology/compression.ts
@@ -0,0 +1,14 @@
+/** geochronology compression module — tsb analytics library. */
+export interface GeochronologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyCompressionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyCompression(data: number[], opts: GeochronologyCompressionOptions = {}): GeochronologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyCompression };
diff --git a/src/geochronology/continuous.ts b/src/geochronology/continuous.ts
new file mode 100644
index 000000000..253379e48
--- /dev/null
+++ b/src/geochronology/continuous.ts
@@ -0,0 +1,14 @@
+/** geochronology continuous module — tsb analytics library. */
+export interface GeochronologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyContinuousResult { values: number[]; converged: boolean; }
+export function computeGeochronologyContinuous(data: number[], opts: GeochronologyContinuousOptions = {}): GeochronologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyContinuous };
diff --git a/src/geochronology/control.ts b/src/geochronology/control.ts
new file mode 100644
index 000000000..d7debef8c
--- /dev/null
+++ b/src/geochronology/control.ts
@@ -0,0 +1,14 @@
+/** geochronology control module — tsb analytics library. */
+export interface GeochronologyControlOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyControlResult { values: number[]; converged: boolean; }
+export function computeGeochronologyControl(data: number[], opts: GeochronologyControlOptions = {}): GeochronologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyControl };
diff --git a/src/geochronology/convergence.ts b/src/geochronology/convergence.ts
new file mode 100644
index 000000000..3909b5a0f
--- /dev/null
+++ b/src/geochronology/convergence.ts
@@ -0,0 +1,14 @@
+/** geochronology convergence module — tsb analytics library. */
+export interface GeochronologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeGeochronologyConvergence(data: number[], opts: GeochronologyConvergenceOptions = {}): GeochronologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyConvergence };
diff --git a/src/geochronology/convex.ts b/src/geochronology/convex.ts
new file mode 100644
index 000000000..88043e8eb
--- /dev/null
+++ b/src/geochronology/convex.ts
@@ -0,0 +1,14 @@
+/** geochronology convex module — tsb analytics library. */
+export interface GeochronologyConvexOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyConvexResult { values: number[]; converged: boolean; }
+export function computeGeochronologyConvex(data: number[], opts: GeochronologyConvexOptions = {}): GeochronologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyConvex };
diff --git a/src/geochronology/correlation.ts b/src/geochronology/correlation.ts
new file mode 100644
index 000000000..5257be847
--- /dev/null
+++ b/src/geochronology/correlation.ts
@@ -0,0 +1,14 @@
+/** geochronology correlation module — tsb analytics library. */
+export interface GeochronologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyCorrelation(data: number[], opts: GeochronologyCorrelationOptions = {}): GeochronologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyCorrelation };
diff --git a/src/geochronology/covariance.ts b/src/geochronology/covariance.ts
new file mode 100644
index 000000000..037a5b28f
--- /dev/null
+++ b/src/geochronology/covariance.ts
@@ -0,0 +1,14 @@
+/** geochronology covariance module — tsb analytics library. */
+export interface GeochronologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeGeochronologyCovariance(data: number[], opts: GeochronologyCovarianceOptions = {}): GeochronologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyCovariance };
diff --git a/src/geochronology/cross_validation.ts b/src/geochronology/cross_validation.ts
new file mode 100644
index 000000000..0fbf4ae1b
--- /dev/null
+++ b/src/geochronology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** geochronology cross_validation module — tsb analytics library. */
+export interface GeochronologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyCrossValidation(data: number[], opts: GeochronologyCrossValidationOptions = {}): GeochronologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyCrossValidation };
diff --git a/src/geochronology/decoding.ts b/src/geochronology/decoding.ts
new file mode 100644
index 000000000..cbc6c4acc
--- /dev/null
+++ b/src/geochronology/decoding.ts
@@ -0,0 +1,14 @@
+/** geochronology decoding module — tsb analytics library. */
+export interface GeochronologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDecodingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDecoding(data: number[], opts: GeochronologyDecodingOptions = {}): GeochronologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDecoding };
diff --git a/src/geochronology/decomposition.ts b/src/geochronology/decomposition.ts
new file mode 100644
index 000000000..4d787ec83
--- /dev/null
+++ b/src/geochronology/decomposition.ts
@@ -0,0 +1,14 @@
+/** geochronology decomposition module — tsb analytics library. */
+export interface GeochronologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDecomposition(data: number[], opts: GeochronologyDecompositionOptions = {}): GeochronologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDecomposition };
diff --git a/src/geochronology/detection.ts b/src/geochronology/detection.ts
new file mode 100644
index 000000000..12996b759
--- /dev/null
+++ b/src/geochronology/detection.ts
@@ -0,0 +1,14 @@
+/** geochronology detection module — tsb analytics library. */
+export interface GeochronologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDetectionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDetection(data: number[], opts: GeochronologyDetectionOptions = {}): GeochronologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDetection };
diff --git a/src/geochronology/deterministic.ts b/src/geochronology/deterministic.ts
new file mode 100644
index 000000000..dd8cd4ec1
--- /dev/null
+++ b/src/geochronology/deterministic.ts
@@ -0,0 +1,14 @@
+/** geochronology deterministic module — tsb analytics library. */
+export interface GeochronologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDeterministic(data: number[], opts: GeochronologyDeterministicOptions = {}): GeochronologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDeterministic };
diff --git a/src/geochronology/diagnostics.ts b/src/geochronology/diagnostics.ts
new file mode 100644
index 000000000..a39d1dfa8
--- /dev/null
+++ b/src/geochronology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** geochronology diagnostics module — tsb analytics library. */
+export interface GeochronologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDiagnostics(data: number[], opts: GeochronologyDiagnosticsOptions = {}): GeochronologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDiagnostics };
diff --git a/src/geochronology/differential.ts b/src/geochronology/differential.ts
new file mode 100644
index 000000000..9dfe8f9ea
--- /dev/null
+++ b/src/geochronology/differential.ts
@@ -0,0 +1,14 @@
+/** geochronology differential module — tsb analytics library. */
+export interface GeochronologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDifferential(data: number[], opts: GeochronologyDifferentialOptions = {}): GeochronologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDifferential };
diff --git a/src/geochronology/discrete.ts b/src/geochronology/discrete.ts
new file mode 100644
index 000000000..293fa0929
--- /dev/null
+++ b/src/geochronology/discrete.ts
@@ -0,0 +1,14 @@
+/** geochronology discrete module — tsb analytics library. */
+export interface GeochronologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDiscrete(data: number[], opts: GeochronologyDiscreteOptions = {}): GeochronologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDiscrete };
diff --git a/src/geochronology/distribution.ts b/src/geochronology/distribution.ts
new file mode 100644
index 000000000..ed4dd69c0
--- /dev/null
+++ b/src/geochronology/distribution.ts
@@ -0,0 +1,14 @@
+/** geochronology distribution module — tsb analytics library. */
+export interface GeochronologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDistributionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDistribution(data: number[], opts: GeochronologyDistributionOptions = {}): GeochronologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDistribution };
diff --git a/src/geochronology/dynamic.ts b/src/geochronology/dynamic.ts
new file mode 100644
index 000000000..7646dbe0a
--- /dev/null
+++ b/src/geochronology/dynamic.ts
@@ -0,0 +1,14 @@
+/** geochronology dynamic module — tsb analytics library. */
+export interface GeochronologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyDynamicResult { values: number[]; converged: boolean; }
+export function computeGeochronologyDynamic(data: number[], opts: GeochronologyDynamicOptions = {}): GeochronologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyDynamic };
diff --git a/src/geochronology/embedding.ts b/src/geochronology/embedding.ts
new file mode 100644
index 000000000..24d6dd92d
--- /dev/null
+++ b/src/geochronology/embedding.ts
@@ -0,0 +1,14 @@
+/** geochronology embedding module — tsb analytics library. */
+export interface GeochronologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyEmbedding(data: number[], opts: GeochronologyEmbeddingOptions = {}): GeochronologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyEmbedding };
diff --git a/src/geochronology/encoding.ts b/src/geochronology/encoding.ts
new file mode 100644
index 000000000..87486ae96
--- /dev/null
+++ b/src/geochronology/encoding.ts
@@ -0,0 +1,14 @@
+/** geochronology encoding module — tsb analytics library. */
+export interface GeochronologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyEncodingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyEncoding(data: number[], opts: GeochronologyEncodingOptions = {}): GeochronologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyEncoding };
diff --git a/src/geochronology/ensemble.ts b/src/geochronology/ensemble.ts
new file mode 100644
index 000000000..b4626d320
--- /dev/null
+++ b/src/geochronology/ensemble.ts
@@ -0,0 +1,14 @@
+/** geochronology ensemble module — tsb analytics library. */
+export interface GeochronologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeGeochronologyEnsemble(data: number[], opts: GeochronologyEnsembleOptions = {}): GeochronologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyEnsemble };
diff --git a/src/geochronology/estimation.ts b/src/geochronology/estimation.ts
new file mode 100644
index 000000000..4e33e29c7
--- /dev/null
+++ b/src/geochronology/estimation.ts
@@ -0,0 +1,14 @@
+/** geochronology estimation module — tsb analytics library. */
+export interface GeochronologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyEstimationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyEstimation(data: number[], opts: GeochronologyEstimationOptions = {}): GeochronologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyEstimation };
diff --git a/src/geochronology/evaluation.ts b/src/geochronology/evaluation.ts
new file mode 100644
index 000000000..ada2adcf3
--- /dev/null
+++ b/src/geochronology/evaluation.ts
@@ -0,0 +1,14 @@
+/** geochronology evaluation module — tsb analytics library. */
+export interface GeochronologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyEvaluation(data: number[], opts: GeochronologyEvaluationOptions = {}): GeochronologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyEvaluation };
diff --git a/src/geochronology/extrapolation.ts b/src/geochronology/extrapolation.ts
new file mode 100644
index 000000000..bb618d1e2
--- /dev/null
+++ b/src/geochronology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** geochronology extrapolation module — tsb analytics library. */
+export interface GeochronologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyExtrapolation(data: number[], opts: GeochronologyExtrapolationOptions = {}): GeochronologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyExtrapolation };
diff --git a/src/geochronology/features.ts b/src/geochronology/features.ts
new file mode 100644
index 000000000..271034ef5
--- /dev/null
+++ b/src/geochronology/features.ts
@@ -0,0 +1,14 @@
+/** geochronology features module — tsb analytics library. */
+export interface GeochronologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeGeochronologyFeatures(data: number[], opts: GeochronologyFeaturesOptions = {}): GeochronologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyFeatures };
diff --git a/src/geochronology/feedback.ts b/src/geochronology/feedback.ts
new file mode 100644
index 000000000..2f77b5294
--- /dev/null
+++ b/src/geochronology/feedback.ts
@@ -0,0 +1,14 @@
+/** geochronology feedback module — tsb analytics library. */
+export interface GeochronologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeGeochronologyFeedback(data: number[], opts: GeochronologyFeedbackOptions = {}): GeochronologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyFeedback };
diff --git a/src/geochronology/filtering.ts b/src/geochronology/filtering.ts
new file mode 100644
index 000000000..e57b30fca
--- /dev/null
+++ b/src/geochronology/filtering.ts
@@ -0,0 +1,14 @@
+/** geochronology filtering module — tsb analytics library. */
+export interface GeochronologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyFilteringResult { values: number[]; converged: boolean; }
+export function computeGeochronologyFiltering(data: number[], opts: GeochronologyFilteringOptions = {}): GeochronologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyFiltering };
diff --git a/src/geochronology/fourier.ts b/src/geochronology/fourier.ts
new file mode 100644
index 000000000..3480e3264
--- /dev/null
+++ b/src/geochronology/fourier.ts
@@ -0,0 +1,14 @@
+/** geochronology fourier module — tsb analytics library. */
+export interface GeochronologyFourierOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyFourierResult { values: number[]; converged: boolean; }
+export function computeGeochronologyFourier(data: number[], opts: GeochronologyFourierOptions = {}): GeochronologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyFourier };
diff --git a/src/geochronology/fusion.ts b/src/geochronology/fusion.ts
new file mode 100644
index 000000000..b3e4ddac6
--- /dev/null
+++ b/src/geochronology/fusion.ts
@@ -0,0 +1,14 @@
+/** geochronology fusion module — tsb analytics library. */
+export interface GeochronologyFusionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyFusionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyFusion(data: number[], opts: GeochronologyFusionOptions = {}): GeochronologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyFusion };
diff --git a/src/geochronology/generation.ts b/src/geochronology/generation.ts
new file mode 100644
index 000000000..9f87e7c62
--- /dev/null
+++ b/src/geochronology/generation.ts
@@ -0,0 +1,14 @@
+/** geochronology generation module — tsb analytics library. */
+export interface GeochronologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyGenerationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyGeneration(data: number[], opts: GeochronologyGenerationOptions = {}): GeochronologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyGeneration };
diff --git a/src/geochronology/geometry.ts b/src/geochronology/geometry.ts
new file mode 100644
index 000000000..54b4a5244
--- /dev/null
+++ b/src/geochronology/geometry.ts
@@ -0,0 +1,14 @@
+/** geochronology geometry module — tsb analytics library. */
+export interface GeochronologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyGeometryResult { values: number[]; converged: boolean; }
+export function computeGeochronologyGeometry(data: number[], opts: GeochronologyGeometryOptions = {}): GeochronologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyGeometry };
diff --git a/src/geochronology/gradient.ts b/src/geochronology/gradient.ts
new file mode 100644
index 000000000..d2ac8c7e3
--- /dev/null
+++ b/src/geochronology/gradient.ts
@@ -0,0 +1,14 @@
+/** geochronology gradient module — tsb analytics library. */
+export interface GeochronologyGradientOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyGradientResult { values: number[]; converged: boolean; }
+export function computeGeochronologyGradient(data: number[], opts: GeochronologyGradientOptions = {}): GeochronologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyGradient };
diff --git a/src/geochronology/hessian.ts b/src/geochronology/hessian.ts
new file mode 100644
index 000000000..8e2d295f7
--- /dev/null
+++ b/src/geochronology/hessian.ts
@@ -0,0 +1,14 @@
+/** geochronology hessian module — tsb analytics library. */
+export interface GeochronologyHessianOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyHessianResult { values: number[]; converged: boolean; }
+export function computeGeochronologyHessian(data: number[], opts: GeochronologyHessianOptions = {}): GeochronologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyHessian };
diff --git a/src/geochronology/hypothesis.ts b/src/geochronology/hypothesis.ts
new file mode 100644
index 000000000..63817d207
--- /dev/null
+++ b/src/geochronology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** geochronology hypothesis module — tsb analytics library. */
+export interface GeochronologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeGeochronologyHypothesis(data: number[], opts: GeochronologyHypothesisOptions = {}): GeochronologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyHypothesis };
diff --git a/src/geochronology/inference.ts b/src/geochronology/inference.ts
new file mode 100644
index 000000000..4fc248f21
--- /dev/null
+++ b/src/geochronology/inference.ts
@@ -0,0 +1,14 @@
+/** geochronology inference module — tsb analytics library. */
+export interface GeochronologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyInferenceResult { values: number[]; converged: boolean; }
+export function computeGeochronologyInference(data: number[], opts: GeochronologyInferenceOptions = {}): GeochronologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyInference };
diff --git a/src/geochronology/inference2.ts b/src/geochronology/inference2.ts
new file mode 100644
index 000000000..f30137d06
--- /dev/null
+++ b/src/geochronology/inference2.ts
@@ -0,0 +1,14 @@
+/** geochronology inference2 module — tsb analytics library. */
+export interface GeochronologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyInferenceResult { values: number[]; converged: boolean; }
+export function computeGeochronologyInference(data: number[], opts: GeochronologyInferenceOptions = {}): GeochronologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyInference };
diff --git a/src/geochronology/integral.ts b/src/geochronology/integral.ts
new file mode 100644
index 000000000..bfff20bde
--- /dev/null
+++ b/src/geochronology/integral.ts
@@ -0,0 +1,14 @@
+/** geochronology integral module — tsb analytics library. */
+export interface GeochronologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyIntegralResult { values: number[]; converged: boolean; }
+export function computeGeochronologyIntegral(data: number[], opts: GeochronologyIntegralOptions = {}): GeochronologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyIntegral };
diff --git a/src/geochronology/integration.ts b/src/geochronology/integration.ts
new file mode 100644
index 000000000..893b9f5ce
--- /dev/null
+++ b/src/geochronology/integration.ts
@@ -0,0 +1,14 @@
+/** geochronology integration module — tsb analytics library. */
+export interface GeochronologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyIntegration(data: number[], opts: GeochronologyIntegrationOptions = {}): GeochronologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyIntegration };
diff --git a/src/geochronology/interpolation.ts b/src/geochronology/interpolation.ts
new file mode 100644
index 000000000..02e76b26c
--- /dev/null
+++ b/src/geochronology/interpolation.ts
@@ -0,0 +1,14 @@
+/** geochronology interpolation module — tsb analytics library. */
+export interface GeochronologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyInterpolation(data: number[], opts: GeochronologyInterpolationOptions = {}): GeochronologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyInterpolation };
diff --git a/src/geochronology/jacobian.ts b/src/geochronology/jacobian.ts
new file mode 100644
index 000000000..ca4611b09
--- /dev/null
+++ b/src/geochronology/jacobian.ts
@@ -0,0 +1,14 @@
+/** geochronology jacobian module — tsb analytics library. */
+export interface GeochronologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyJacobianResult { values: number[]; converged: boolean; }
+export function computeGeochronologyJacobian(data: number[], opts: GeochronologyJacobianOptions = {}): GeochronologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyJacobian };
diff --git a/src/geochronology/kernel.ts b/src/geochronology/kernel.ts
new file mode 100644
index 000000000..3598b3ed4
--- /dev/null
+++ b/src/geochronology/kernel.ts
@@ -0,0 +1,14 @@
+/** geochronology kernel module — tsb analytics library. */
+export interface GeochronologyKernelOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyKernelResult { values: number[]; converged: boolean; }
+export function computeGeochronologyKernel(data: number[], opts: GeochronologyKernelOptions = {}): GeochronologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyKernel };
diff --git a/src/geochronology/laplacian.ts b/src/geochronology/laplacian.ts
new file mode 100644
index 000000000..298f0e072
--- /dev/null
+++ b/src/geochronology/laplacian.ts
@@ -0,0 +1,14 @@
+/** geochronology laplacian module — tsb analytics library. */
+export interface GeochronologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeGeochronologyLaplacian(data: number[], opts: GeochronologyLaplacianOptions = {}): GeochronologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyLaplacian };
diff --git a/src/geochronology/learning.ts b/src/geochronology/learning.ts
new file mode 100644
index 000000000..de397b7f9
--- /dev/null
+++ b/src/geochronology/learning.ts
@@ -0,0 +1,14 @@
+/** geochronology learning module — tsb analytics library. */
+export interface GeochronologyLearningOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyLearningResult { values: number[]; converged: boolean; }
+export function computeGeochronologyLearning(data: number[], opts: GeochronologyLearningOptions = {}): GeochronologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyLearning };
diff --git a/src/geochronology/linear.ts b/src/geochronology/linear.ts
new file mode 100644
index 000000000..b2772cd41
--- /dev/null
+++ b/src/geochronology/linear.ts
@@ -0,0 +1,14 @@
+/** geochronology linear module — tsb analytics library. */
+export interface GeochronologyLinearOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyLinearResult { values: number[]; converged: boolean; }
+export function computeGeochronologyLinear(data: number[], opts: GeochronologyLinearOptions = {}): GeochronologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyLinear };
diff --git a/src/geochronology/manifold.ts b/src/geochronology/manifold.ts
new file mode 100644
index 000000000..8feca46aa
--- /dev/null
+++ b/src/geochronology/manifold.ts
@@ -0,0 +1,14 @@
+/** geochronology manifold module — tsb analytics library. */
+export interface GeochronologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyManifoldResult { values: number[]; converged: boolean; }
+export function computeGeochronologyManifold(data: number[], opts: GeochronologyManifoldOptions = {}): GeochronologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyManifold };
diff --git a/src/geochronology/matching.ts b/src/geochronology/matching.ts
new file mode 100644
index 000000000..966462f0f
--- /dev/null
+++ b/src/geochronology/matching.ts
@@ -0,0 +1,14 @@
+/** geochronology matching module — tsb analytics library. */
+export interface GeochronologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyMatchingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyMatching(data: number[], opts: GeochronologyMatchingOptions = {}): GeochronologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyMatching };
diff --git a/src/geochronology/measurement.ts b/src/geochronology/measurement.ts
new file mode 100644
index 000000000..f77e69a5e
--- /dev/null
+++ b/src/geochronology/measurement.ts
@@ -0,0 +1,14 @@
+/** geochronology measurement module — tsb analytics library. */
+export interface GeochronologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeGeochronologyMeasurement(data: number[], opts: GeochronologyMeasurementOptions = {}): GeochronologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyMeasurement };
diff --git a/src/geochronology/metrics.ts b/src/geochronology/metrics.ts
new file mode 100644
index 000000000..57dae38a3
--- /dev/null
+++ b/src/geochronology/metrics.ts
@@ -0,0 +1,14 @@
+/** geochronology metrics module — tsb analytics library. */
+export interface GeochronologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyMetricsResult { values: number[]; converged: boolean; }
+export function computeGeochronologyMetrics(data: number[], opts: GeochronologyMetricsOptions = {}): GeochronologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyMetrics };
diff --git a/src/geochronology/modeling.ts b/src/geochronology/modeling.ts
new file mode 100644
index 000000000..895f33926
--- /dev/null
+++ b/src/geochronology/modeling.ts
@@ -0,0 +1,14 @@
+/** geochronology modeling module — tsb analytics library. */
+export interface GeochronologyModelingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyModelingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyModeling(data: number[], opts: GeochronologyModelingOptions = {}): GeochronologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyModeling };
diff --git a/src/geochronology/monitoring.ts b/src/geochronology/monitoring.ts
new file mode 100644
index 000000000..97dd2aea3
--- /dev/null
+++ b/src/geochronology/monitoring.ts
@@ -0,0 +1,14 @@
+/** geochronology monitoring module — tsb analytics library. */
+export interface GeochronologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeGeochronologyMonitoring(data: number[], opts: GeochronologyMonitoringOptions = {}): GeochronologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyMonitoring };
diff --git a/src/geochronology/nonlinear.ts b/src/geochronology/nonlinear.ts
new file mode 100644
index 000000000..dc2a500f6
--- /dev/null
+++ b/src/geochronology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** geochronology nonlinear module — tsb analytics library. */
+export interface GeochronologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeGeochronologyNonlinear(data: number[], opts: GeochronologyNonlinearOptions = {}): GeochronologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyNonlinear };
diff --git a/src/geochronology/normalization.ts b/src/geochronology/normalization.ts
new file mode 100644
index 000000000..319adefea
--- /dev/null
+++ b/src/geochronology/normalization.ts
@@ -0,0 +1,14 @@
+/** geochronology normalization module — tsb analytics library. */
+export interface GeochronologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyNormalization(data: number[], opts: GeochronologyNormalizationOptions = {}): GeochronologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyNormalization };
diff --git a/src/geochronology/optimization.ts b/src/geochronology/optimization.ts
new file mode 100644
index 000000000..7bfae547b
--- /dev/null
+++ b/src/geochronology/optimization.ts
@@ -0,0 +1,14 @@
+/** geochronology optimization module — tsb analytics library. */
+export interface GeochronologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyOptimization(data: number[], opts: GeochronologyOptimizationOptions = {}): GeochronologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyOptimization };
diff --git a/src/geochronology/patterns.ts b/src/geochronology/patterns.ts
new file mode 100644
index 000000000..567f3de7c
--- /dev/null
+++ b/src/geochronology/patterns.ts
@@ -0,0 +1,14 @@
+/** geochronology patterns module — tsb analytics library. */
+export interface GeochronologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyPatternsResult { values: number[]; converged: boolean; }
+export function computeGeochronologyPatterns(data: number[], opts: GeochronologyPatternsOptions = {}): GeochronologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyPatterns };
diff --git a/src/geochronology/permutation.ts b/src/geochronology/permutation.ts
new file mode 100644
index 000000000..52ccdc606
--- /dev/null
+++ b/src/geochronology/permutation.ts
@@ -0,0 +1,14 @@
+/** geochronology permutation module — tsb analytics library. */
+export interface GeochronologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyPermutationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyPermutation(data: number[], opts: GeochronologyPermutationOptions = {}): GeochronologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyPermutation };
diff --git a/src/geochronology/prediction.ts b/src/geochronology/prediction.ts
new file mode 100644
index 000000000..53ed87b97
--- /dev/null
+++ b/src/geochronology/prediction.ts
@@ -0,0 +1,14 @@
+/** geochronology prediction module — tsb analytics library. */
+export interface GeochronologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyPredictionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyPrediction(data: number[], opts: GeochronologyPredictionOptions = {}): GeochronologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyPrediction };
diff --git a/src/geochronology/processing.ts b/src/geochronology/processing.ts
new file mode 100644
index 000000000..def57b254
--- /dev/null
+++ b/src/geochronology/processing.ts
@@ -0,0 +1,14 @@
+/** geochronology processing module — tsb analytics library. */
+export interface GeochronologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyProcessingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyProcessing(data: number[], opts: GeochronologyProcessingOptions = {}): GeochronologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyProcessing };
diff --git a/src/geochronology/profiling.ts b/src/geochronology/profiling.ts
new file mode 100644
index 000000000..b410fafb1
--- /dev/null
+++ b/src/geochronology/profiling.ts
@@ -0,0 +1,14 @@
+/** geochronology profiling module — tsb analytics library. */
+export interface GeochronologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyProfilingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyProfiling(data: number[], opts: GeochronologyProfilingOptions = {}): GeochronologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyProfiling };
diff --git a/src/geochronology/projection.ts b/src/geochronology/projection.ts
new file mode 100644
index 000000000..c0dbff73d
--- /dev/null
+++ b/src/geochronology/projection.ts
@@ -0,0 +1,14 @@
+/** geochronology projection module — tsb analytics library. */
+export interface GeochronologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyProjectionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyProjection(data: number[], opts: GeochronologyProjectionOptions = {}): GeochronologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyProjection };
diff --git a/src/geochronology/ranking.ts b/src/geochronology/ranking.ts
new file mode 100644
index 000000000..4fcc34ade
--- /dev/null
+++ b/src/geochronology/ranking.ts
@@ -0,0 +1,14 @@
+/** geochronology ranking module — tsb analytics library. */
+export interface GeochronologyRankingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyRankingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyRanking(data: number[], opts: GeochronologyRankingOptions = {}): GeochronologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyRanking };
diff --git a/src/geochronology/reconstruction.ts b/src/geochronology/reconstruction.ts
new file mode 100644
index 000000000..399787c44
--- /dev/null
+++ b/src/geochronology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** geochronology reconstruction module — tsb analytics library. */
+export interface GeochronologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyReconstruction(data: number[], opts: GeochronologyReconstructionOptions = {}): GeochronologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyReconstruction };
diff --git a/src/geochronology/registration.ts b/src/geochronology/registration.ts
new file mode 100644
index 000000000..97109965c
--- /dev/null
+++ b/src/geochronology/registration.ts
@@ -0,0 +1,14 @@
+/** geochronology registration module — tsb analytics library. */
+export interface GeochronologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyRegistration(data: number[], opts: GeochronologyRegistrationOptions = {}): GeochronologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyRegistration };
diff --git a/src/geochronology/regression.ts b/src/geochronology/regression.ts
new file mode 100644
index 000000000..aae9a8512
--- /dev/null
+++ b/src/geochronology/regression.ts
@@ -0,0 +1,14 @@
+/** geochronology regression module — tsb analytics library. */
+export interface GeochronologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyRegressionResult { values: number[]; converged: boolean; }
+export function computeGeochronologyRegression(data: number[], opts: GeochronologyRegressionOptions = {}): GeochronologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyRegression };
diff --git a/src/geochronology/regularization.ts b/src/geochronology/regularization.ts
new file mode 100644
index 000000000..e2ccdc06f
--- /dev/null
+++ b/src/geochronology/regularization.ts
@@ -0,0 +1,14 @@
+/** geochronology regularization module — tsb analytics library. */
+export interface GeochronologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyRegularization(data: number[], opts: GeochronologyRegularizationOptions = {}): GeochronologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyRegularization };
diff --git a/src/geochronology/robustness.ts b/src/geochronology/robustness.ts
new file mode 100644
index 000000000..d5e744f5b
--- /dev/null
+++ b/src/geochronology/robustness.ts
@@ -0,0 +1,14 @@
+/** geochronology robustness module — tsb analytics library. */
+export interface GeochronologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeGeochronologyRobustness(data: number[], opts: GeochronologyRobustnessOptions = {}): GeochronologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyRobustness };
diff --git a/src/geochronology/sampling.ts b/src/geochronology/sampling.ts
new file mode 100644
index 000000000..6bc7fceac
--- /dev/null
+++ b/src/geochronology/sampling.ts
@@ -0,0 +1,14 @@
+/** geochronology sampling module — tsb analytics library. */
+export interface GeochronologySamplingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologySamplingResult { values: number[]; converged: boolean; }
+export function computeGeochronologySampling(data: number[], opts: GeochronologySamplingOptions = {}): GeochronologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologySampling };
diff --git a/src/geochronology/sampling2.ts b/src/geochronology/sampling2.ts
new file mode 100644
index 000000000..ca49da37f
--- /dev/null
+++ b/src/geochronology/sampling2.ts
@@ -0,0 +1,14 @@
+/** geochronology sampling2 module — tsb analytics library. */
+export interface GeochronologySamplingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologySamplingResult { values: number[]; converged: boolean; }
+export function computeGeochronologySampling(data: number[], opts: GeochronologySamplingOptions = {}): GeochronologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologySampling };
diff --git a/src/geochronology/scaling.ts b/src/geochronology/scaling.ts
new file mode 100644
index 000000000..046c38ceb
--- /dev/null
+++ b/src/geochronology/scaling.ts
@@ -0,0 +1,14 @@
+/** geochronology scaling module — tsb analytics library. */
+export interface GeochronologyScalingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyScalingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyScaling(data: number[], opts: GeochronologyScalingOptions = {}): GeochronologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyScaling };
diff --git a/src/geochronology/scoring.ts b/src/geochronology/scoring.ts
new file mode 100644
index 000000000..87e399854
--- /dev/null
+++ b/src/geochronology/scoring.ts
@@ -0,0 +1,14 @@
+/** geochronology scoring module — tsb analytics library. */
+export interface GeochronologyScoringOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyScoringResult { values: number[]; converged: boolean; }
+export function computeGeochronologyScoring(data: number[], opts: GeochronologyScoringOptions = {}): GeochronologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyScoring };
diff --git a/src/geochronology/segmentation.ts b/src/geochronology/segmentation.ts
new file mode 100644
index 000000000..a9468b4bc
--- /dev/null
+++ b/src/geochronology/segmentation.ts
@@ -0,0 +1,14 @@
+/** geochronology segmentation module — tsb analytics library. */
+export interface GeochronologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologySegmentationResult { values: number[]; converged: boolean; }
+export function computeGeochronologySegmentation(data: number[], opts: GeochronologySegmentationOptions = {}): GeochronologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologySegmentation };
diff --git a/src/geochronology/selection.ts b/src/geochronology/selection.ts
new file mode 100644
index 000000000..3285a47fd
--- /dev/null
+++ b/src/geochronology/selection.ts
@@ -0,0 +1,14 @@
+/** geochronology selection module — tsb analytics library. */
+export interface GeochronologySelectionOptions { tol?: number; maxIter?: number; }
+export interface GeochronologySelectionResult { values: number[]; converged: boolean; }
+export function computeGeochronologySelection(data: number[], opts: GeochronologySelectionOptions = {}): GeochronologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologySelection };
diff --git a/src/geochronology/sensitivity.ts b/src/geochronology/sensitivity.ts
new file mode 100644
index 000000000..f03b50e07
--- /dev/null
+++ b/src/geochronology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** geochronology sensitivity module — tsb analytics library. */
+export interface GeochronologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface GeochronologySensitivityResult { values: number[]; converged: boolean; }
+export function computeGeochronologySensitivity(data: number[], opts: GeochronologySensitivityOptions = {}): GeochronologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologySensitivity };
diff --git a/src/geochronology/simulation.ts b/src/geochronology/simulation.ts
new file mode 100644
index 000000000..5ced507fd
--- /dev/null
+++ b/src/geochronology/simulation.ts
@@ -0,0 +1,14 @@
+/** geochronology simulation module — tsb analytics library. */
+export interface GeochronologySimulationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologySimulationResult { values: number[]; converged: boolean; }
+export function computeGeochronologySimulation(data: number[], opts: GeochronologySimulationOptions = {}): GeochronologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologySimulation };
diff --git a/src/geochronology/smoothing.ts b/src/geochronology/smoothing.ts
new file mode 100644
index 000000000..47f62a906
--- /dev/null
+++ b/src/geochronology/smoothing.ts
@@ -0,0 +1,14 @@
+/** geochronology smoothing module — tsb analytics library. */
+export interface GeochronologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologySmoothingResult { values: number[]; converged: boolean; }
+export function computeGeochronologySmoothing(data: number[], opts: GeochronologySmoothingOptions = {}): GeochronologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologySmoothing };
diff --git a/src/geochronology/stability.ts b/src/geochronology/stability.ts
new file mode 100644
index 000000000..03fae77ef
--- /dev/null
+++ b/src/geochronology/stability.ts
@@ -0,0 +1,14 @@
+/** geochronology stability module — tsb analytics library. */
+export interface GeochronologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyStabilityResult { values: number[]; converged: boolean; }
+export function computeGeochronologyStability(data: number[], opts: GeochronologyStabilityOptions = {}): GeochronologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyStability };
diff --git a/src/geochronology/stacking.ts b/src/geochronology/stacking.ts
new file mode 100644
index 000000000..0b740e090
--- /dev/null
+++ b/src/geochronology/stacking.ts
@@ -0,0 +1,14 @@
+/** geochronology stacking module — tsb analytics library. */
+export interface GeochronologyStackingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyStackingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyStacking(data: number[], opts: GeochronologyStackingOptions = {}): GeochronologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyStacking };
diff --git a/src/geochronology/standardization.ts b/src/geochronology/standardization.ts
new file mode 100644
index 000000000..c78228b6c
--- /dev/null
+++ b/src/geochronology/standardization.ts
@@ -0,0 +1,14 @@
+/** geochronology standardization module — tsb analytics library. */
+export interface GeochronologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyStandardization(data: number[], opts: GeochronologyStandardizationOptions = {}): GeochronologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyStandardization };
diff --git a/src/geochronology/static.ts b/src/geochronology/static.ts
new file mode 100644
index 000000000..8989a4935
--- /dev/null
+++ b/src/geochronology/static.ts
@@ -0,0 +1,14 @@
+/** geochronology static module — tsb analytics library. */
+export interface GeochronologyStaticOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyStaticResult { values: number[]; converged: boolean; }
+export function computeGeochronologyStatic(data: number[], opts: GeochronologyStaticOptions = {}): GeochronologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyStatic };
diff --git a/src/geochronology/stochastic.ts b/src/geochronology/stochastic.ts
new file mode 100644
index 000000000..73e899214
--- /dev/null
+++ b/src/geochronology/stochastic.ts
@@ -0,0 +1,14 @@
+/** geochronology stochastic module — tsb analytics library. */
+export interface GeochronologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyStochasticResult { values: number[]; converged: boolean; }
+export function computeGeochronologyStochastic(data: number[], opts: GeochronologyStochasticOptions = {}): GeochronologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyStochastic };
diff --git a/src/geochronology/synthesis.ts b/src/geochronology/synthesis.ts
new file mode 100644
index 000000000..135a53f30
--- /dev/null
+++ b/src/geochronology/synthesis.ts
@@ -0,0 +1,14 @@
+/** geochronology synthesis module — tsb analytics library. */
+export interface GeochronologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface GeochronologySynthesisResult { values: number[]; converged: boolean; }
+export function computeGeochronologySynthesis(data: number[], opts: GeochronologySynthesisOptions = {}): GeochronologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologySynthesis };
diff --git a/src/geochronology/topology.ts b/src/geochronology/topology.ts
new file mode 100644
index 000000000..b021b1cec
--- /dev/null
+++ b/src/geochronology/topology.ts
@@ -0,0 +1,14 @@
+/** geochronology topology module — tsb analytics library. */
+export interface GeochronologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyTopologyResult { values: number[]; converged: boolean; }
+export function computeGeochronologyTopology(data: number[], opts: GeochronologyTopologyOptions = {}): GeochronologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyTopology };
diff --git a/src/geochronology/tracking.ts b/src/geochronology/tracking.ts
new file mode 100644
index 000000000..a0ec05f54
--- /dev/null
+++ b/src/geochronology/tracking.ts
@@ -0,0 +1,14 @@
+/** geochronology tracking module — tsb analytics library. */
+export interface GeochronologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyTrackingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyTracking(data: number[], opts: GeochronologyTrackingOptions = {}): GeochronologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyTracking };
diff --git a/src/geochronology/transform.ts b/src/geochronology/transform.ts
new file mode 100644
index 000000000..ff617d005
--- /dev/null
+++ b/src/geochronology/transform.ts
@@ -0,0 +1,14 @@
+/** geochronology transform module — tsb analytics library. */
+export interface GeochronologyTransformOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyTransformResult { values: number[]; converged: boolean; }
+export function computeGeochronologyTransform(data: number[], opts: GeochronologyTransformOptions = {}): GeochronologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyTransform };
diff --git a/src/geochronology/uncertainty.ts b/src/geochronology/uncertainty.ts
new file mode 100644
index 000000000..36eaf201e
--- /dev/null
+++ b/src/geochronology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** geochronology uncertainty module — tsb analytics library. */
+export interface GeochronologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGeochronologyUncertainty(data: number[], opts: GeochronologyUncertaintyOptions = {}): GeochronologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyUncertainty };
diff --git a/src/geochronology/validation.ts b/src/geochronology/validation.ts
new file mode 100644
index 000000000..01d6c5667
--- /dev/null
+++ b/src/geochronology/validation.ts
@@ -0,0 +1,14 @@
+/** geochronology validation module — tsb analytics library. */
+export interface GeochronologyValidationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyValidationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyValidation(data: number[], opts: GeochronologyValidationOptions = {}): GeochronologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyValidation };
diff --git a/src/geochronology/verification.ts b/src/geochronology/verification.ts
new file mode 100644
index 000000000..8afc4ab3d
--- /dev/null
+++ b/src/geochronology/verification.ts
@@ -0,0 +1,14 @@
+/** geochronology verification module — tsb analytics library. */
+export interface GeochronologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyVerificationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyVerification(data: number[], opts: GeochronologyVerificationOptions = {}): GeochronologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyVerification };
diff --git a/src/geochronology/visualization.ts b/src/geochronology/visualization.ts
new file mode 100644
index 000000000..cc46ce003
--- /dev/null
+++ b/src/geochronology/visualization.ts
@@ -0,0 +1,14 @@
+/** geochronology visualization module — tsb analytics library. */
+export interface GeochronologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeGeochronologyVisualization(data: number[], opts: GeochronologyVisualizationOptions = {}): GeochronologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyVisualization };
diff --git a/src/geochronology/voting.ts b/src/geochronology/voting.ts
new file mode 100644
index 000000000..40f82659c
--- /dev/null
+++ b/src/geochronology/voting.ts
@@ -0,0 +1,14 @@
+/** geochronology voting module — tsb analytics library. */
+export interface GeochronologyVotingOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyVotingResult { values: number[]; converged: boolean; }
+export function computeGeochronologyVoting(data: number[], opts: GeochronologyVotingOptions = {}): GeochronologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyVoting };
diff --git a/src/geochronology/wavelet.ts b/src/geochronology/wavelet.ts
new file mode 100644
index 000000000..d43a7672c
--- /dev/null
+++ b/src/geochronology/wavelet.ts
@@ -0,0 +1,14 @@
+/** geochronology wavelet module — tsb analytics library. */
+export interface GeochronologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface GeochronologyWaveletResult { values: number[]; converged: boolean; }
+export function computeGeochronologyWavelet(data: number[], opts: GeochronologyWaveletOptions = {}): GeochronologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeochronologyWavelet };
diff --git a/src/geodesy_sci/adaptation.ts b/src/geodesy_sci/adaptation.ts
new file mode 100644
index 000000000..36f2c901e
--- /dev/null
+++ b/src/geodesy_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci adaptation module — tsb analytics library. */
+export interface GeodesySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciAdaptation(data: number[], opts: GeodesySciAdaptationOptions = {}): GeodesySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciAdaptation };
diff --git a/src/geodesy_sci/aggregation.ts b/src/geodesy_sci/aggregation.ts
new file mode 100644
index 000000000..9a53c1266
--- /dev/null
+++ b/src/geodesy_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci aggregation module — tsb analytics library. */
+export interface GeodesySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciAggregationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciAggregation(data: number[], opts: GeodesySciAggregationOptions = {}): GeodesySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciAggregation };
diff --git a/src/geodesy_sci/algebra.ts b/src/geodesy_sci/algebra.ts
new file mode 100644
index 000000000..6e8c5a9fc
--- /dev/null
+++ b/src/geodesy_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci algebra module — tsb analytics library. */
+export interface GeodesySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeGeodesySciAlgebra(data: number[], opts: GeodesySciAlgebraOptions = {}): GeodesySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciAlgebra };
diff --git a/src/geodesy_sci/alignment.ts b/src/geodesy_sci/alignment.ts
new file mode 100644
index 000000000..9ebcdd84b
--- /dev/null
+++ b/src/geodesy_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci alignment module — tsb analytics library. */
+export interface GeodesySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeGeodesySciAlignment(data: number[], opts: GeodesySciAlignmentOptions = {}): GeodesySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciAlignment };
diff --git a/src/geodesy_sci/analysis.ts b/src/geodesy_sci/analysis.ts
new file mode 100644
index 000000000..30f6c3cf7
--- /dev/null
+++ b/src/geodesy_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci analysis module — tsb analytics library. */
+export interface GeodesySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeGeodesySciAnalysis(data: number[], opts: GeodesySciAnalysisOptions = {}): GeodesySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciAnalysis };
diff --git a/src/geodesy_sci/augmentation.ts b/src/geodesy_sci/augmentation.ts
new file mode 100644
index 000000000..524150cef
--- /dev/null
+++ b/src/geodesy_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci augmentation module — tsb analytics library. */
+export interface GeodesySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciAugmentation(data: number[], opts: GeodesySciAugmentationOptions = {}): GeodesySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciAugmentation };
diff --git a/src/geodesy_sci/bagging.ts b/src/geodesy_sci/bagging.ts
new file mode 100644
index 000000000..7650c4dae
--- /dev/null
+++ b/src/geodesy_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci bagging module — tsb analytics library. */
+export interface GeodesySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciBaggingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciBagging(data: number[], opts: GeodesySciBaggingOptions = {}): GeodesySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciBagging };
diff --git a/src/geodesy_sci/basis.ts b/src/geodesy_sci/basis.ts
new file mode 100644
index 000000000..d26500824
--- /dev/null
+++ b/src/geodesy_sci/basis.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci basis module — tsb analytics library. */
+export interface GeodesySciBasisOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciBasisResult { values: number[]; converged: boolean; }
+export function computeGeodesySciBasis(data: number[], opts: GeodesySciBasisOptions = {}): GeodesySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciBasis };
diff --git a/src/geodesy_sci/benchmarking.ts b/src/geodesy_sci/benchmarking.ts
new file mode 100644
index 000000000..a38bd84ae
--- /dev/null
+++ b/src/geodesy_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci benchmarking module — tsb analytics library. */
+export interface GeodesySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciBenchmarking(data: number[], opts: GeodesySciBenchmarkingOptions = {}): GeodesySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciBenchmarking };
diff --git a/src/geodesy_sci/blending.ts b/src/geodesy_sci/blending.ts
new file mode 100644
index 000000000..10107a931
--- /dev/null
+++ b/src/geodesy_sci/blending.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci blending module — tsb analytics library. */
+export interface GeodesySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciBlendingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciBlending(data: number[], opts: GeodesySciBlendingOptions = {}): GeodesySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciBlending };
diff --git a/src/geodesy_sci/boosting.ts b/src/geodesy_sci/boosting.ts
new file mode 100644
index 000000000..fdadffbb5
--- /dev/null
+++ b/src/geodesy_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci boosting module — tsb analytics library. */
+export interface GeodesySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciBoostingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciBoosting(data: number[], opts: GeodesySciBoostingOptions = {}): GeodesySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciBoosting };
diff --git a/src/geodesy_sci/bootstrap.ts b/src/geodesy_sci/bootstrap.ts
new file mode 100644
index 000000000..b995b423d
--- /dev/null
+++ b/src/geodesy_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci bootstrap module — tsb analytics library. */
+export interface GeodesySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeGeodesySciBootstrap(data: number[], opts: GeodesySciBootstrapOptions = {}): GeodesySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciBootstrap };
diff --git a/src/geodesy_sci/calculus.ts b/src/geodesy_sci/calculus.ts
new file mode 100644
index 000000000..12c37bba2
--- /dev/null
+++ b/src/geodesy_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci calculus module — tsb analytics library. */
+export interface GeodesySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciCalculusResult { values: number[]; converged: boolean; }
+export function computeGeodesySciCalculus(data: number[], opts: GeodesySciCalculusOptions = {}): GeodesySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciCalculus };
diff --git a/src/geodesy_sci/calibration.ts b/src/geodesy_sci/calibration.ts
new file mode 100644
index 000000000..247108308
--- /dev/null
+++ b/src/geodesy_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci calibration module — tsb analytics library. */
+export interface GeodesySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciCalibration(data: number[], opts: GeodesySciCalibrationOptions = {}): GeodesySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciCalibration };
diff --git a/src/geodesy_sci/characterization.ts b/src/geodesy_sci/characterization.ts
new file mode 100644
index 000000000..aac905b37
--- /dev/null
+++ b/src/geodesy_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci characterization module — tsb analytics library. */
+export interface GeodesySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciCharacterization(data: number[], opts: GeodesySciCharacterizationOptions = {}): GeodesySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciCharacterization };
diff --git a/src/geodesy_sci/classification.ts b/src/geodesy_sci/classification.ts
new file mode 100644
index 000000000..2e25296c7
--- /dev/null
+++ b/src/geodesy_sci/classification.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci classification module — tsb analytics library. */
+export interface GeodesySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciClassificationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciClassification(data: number[], opts: GeodesySciClassificationOptions = {}): GeodesySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciClassification };
diff --git a/src/geodesy_sci/clustering.ts b/src/geodesy_sci/clustering.ts
new file mode 100644
index 000000000..230c7b21a
--- /dev/null
+++ b/src/geodesy_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci clustering module — tsb analytics library. */
+export interface GeodesySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciClusteringResult { values: number[]; converged: boolean; }
+export function computeGeodesySciClustering(data: number[], opts: GeodesySciClusteringOptions = {}): GeodesySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciClustering };
diff --git a/src/geodesy_sci/compression.ts b/src/geodesy_sci/compression.ts
new file mode 100644
index 000000000..b9d5a1d36
--- /dev/null
+++ b/src/geodesy_sci/compression.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci compression module — tsb analytics library. */
+export interface GeodesySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciCompressionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciCompression(data: number[], opts: GeodesySciCompressionOptions = {}): GeodesySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciCompression };
diff --git a/src/geodesy_sci/continuous.ts b/src/geodesy_sci/continuous.ts
new file mode 100644
index 000000000..a0e24cf8a
--- /dev/null
+++ b/src/geodesy_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci continuous module — tsb analytics library. */
+export interface GeodesySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciContinuousResult { values: number[]; converged: boolean; }
+export function computeGeodesySciContinuous(data: number[], opts: GeodesySciContinuousOptions = {}): GeodesySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciContinuous };
diff --git a/src/geodesy_sci/control.ts b/src/geodesy_sci/control.ts
new file mode 100644
index 000000000..a8307592f
--- /dev/null
+++ b/src/geodesy_sci/control.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci control module — tsb analytics library. */
+export interface GeodesySciControlOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciControlResult { values: number[]; converged: boolean; }
+export function computeGeodesySciControl(data: number[], opts: GeodesySciControlOptions = {}): GeodesySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciControl };
diff --git a/src/geodesy_sci/convergence.ts b/src/geodesy_sci/convergence.ts
new file mode 100644
index 000000000..42eb74592
--- /dev/null
+++ b/src/geodesy_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci convergence module — tsb analytics library. */
+export interface GeodesySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeGeodesySciConvergence(data: number[], opts: GeodesySciConvergenceOptions = {}): GeodesySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciConvergence };
diff --git a/src/geodesy_sci/convex.ts b/src/geodesy_sci/convex.ts
new file mode 100644
index 000000000..0bc12e2ab
--- /dev/null
+++ b/src/geodesy_sci/convex.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci convex module — tsb analytics library. */
+export interface GeodesySciConvexOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciConvexResult { values: number[]; converged: boolean; }
+export function computeGeodesySciConvex(data: number[], opts: GeodesySciConvexOptions = {}): GeodesySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciConvex };
diff --git a/src/geodesy_sci/correlation.ts b/src/geodesy_sci/correlation.ts
new file mode 100644
index 000000000..afa91ecfc
--- /dev/null
+++ b/src/geodesy_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci correlation module — tsb analytics library. */
+export interface GeodesySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciCorrelation(data: number[], opts: GeodesySciCorrelationOptions = {}): GeodesySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciCorrelation };
diff --git a/src/geodesy_sci/covariance.ts b/src/geodesy_sci/covariance.ts
new file mode 100644
index 000000000..c9ac751c6
--- /dev/null
+++ b/src/geodesy_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci covariance module — tsb analytics library. */
+export interface GeodesySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeGeodesySciCovariance(data: number[], opts: GeodesySciCovarianceOptions = {}): GeodesySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciCovariance };
diff --git a/src/geodesy_sci/cross_validation.ts b/src/geodesy_sci/cross_validation.ts
new file mode 100644
index 000000000..63e93378c
--- /dev/null
+++ b/src/geodesy_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci cross_validation module — tsb analytics library. */
+export interface GeodesySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciCrossValidation(data: number[], opts: GeodesySciCrossValidationOptions = {}): GeodesySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciCrossValidation };
diff --git a/src/geodesy_sci/decoding.ts b/src/geodesy_sci/decoding.ts
new file mode 100644
index 000000000..7896e0d95
--- /dev/null
+++ b/src/geodesy_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci decoding module — tsb analytics library. */
+export interface GeodesySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDecodingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDecoding(data: number[], opts: GeodesySciDecodingOptions = {}): GeodesySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDecoding };
diff --git a/src/geodesy_sci/decomposition.ts b/src/geodesy_sci/decomposition.ts
new file mode 100644
index 000000000..f7d1715c8
--- /dev/null
+++ b/src/geodesy_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci decomposition module — tsb analytics library. */
+export interface GeodesySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDecomposition(data: number[], opts: GeodesySciDecompositionOptions = {}): GeodesySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDecomposition };
diff --git a/src/geodesy_sci/detection.ts b/src/geodesy_sci/detection.ts
new file mode 100644
index 000000000..ffa5919ae
--- /dev/null
+++ b/src/geodesy_sci/detection.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci detection module — tsb analytics library. */
+export interface GeodesySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDetectionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDetection(data: number[], opts: GeodesySciDetectionOptions = {}): GeodesySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDetection };
diff --git a/src/geodesy_sci/deterministic.ts b/src/geodesy_sci/deterministic.ts
new file mode 100644
index 000000000..e6206b8b7
--- /dev/null
+++ b/src/geodesy_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci deterministic module — tsb analytics library. */
+export interface GeodesySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDeterministic(data: number[], opts: GeodesySciDeterministicOptions = {}): GeodesySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDeterministic };
diff --git a/src/geodesy_sci/diagnostics.ts b/src/geodesy_sci/diagnostics.ts
new file mode 100644
index 000000000..5275a6fe8
--- /dev/null
+++ b/src/geodesy_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci diagnostics module — tsb analytics library. */
+export interface GeodesySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDiagnostics(data: number[], opts: GeodesySciDiagnosticsOptions = {}): GeodesySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDiagnostics };
diff --git a/src/geodesy_sci/differential.ts b/src/geodesy_sci/differential.ts
new file mode 100644
index 000000000..a4fc9a9a1
--- /dev/null
+++ b/src/geodesy_sci/differential.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci differential module — tsb analytics library. */
+export interface GeodesySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDifferential(data: number[], opts: GeodesySciDifferentialOptions = {}): GeodesySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDifferential };
diff --git a/src/geodesy_sci/discrete.ts b/src/geodesy_sci/discrete.ts
new file mode 100644
index 000000000..f784c86d5
--- /dev/null
+++ b/src/geodesy_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci discrete module — tsb analytics library. */
+export interface GeodesySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDiscrete(data: number[], opts: GeodesySciDiscreteOptions = {}): GeodesySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDiscrete };
diff --git a/src/geodesy_sci/distribution.ts b/src/geodesy_sci/distribution.ts
new file mode 100644
index 000000000..cbca4ef62
--- /dev/null
+++ b/src/geodesy_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci distribution module — tsb analytics library. */
+export interface GeodesySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDistributionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDistribution(data: number[], opts: GeodesySciDistributionOptions = {}): GeodesySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDistribution };
diff --git a/src/geodesy_sci/dynamic.ts b/src/geodesy_sci/dynamic.ts
new file mode 100644
index 000000000..e230733de
--- /dev/null
+++ b/src/geodesy_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci dynamic module — tsb analytics library. */
+export interface GeodesySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciDynamicResult { values: number[]; converged: boolean; }
+export function computeGeodesySciDynamic(data: number[], opts: GeodesySciDynamicOptions = {}): GeodesySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciDynamic };
diff --git a/src/geodesy_sci/embedding.ts b/src/geodesy_sci/embedding.ts
new file mode 100644
index 000000000..d959b356b
--- /dev/null
+++ b/src/geodesy_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci embedding module — tsb analytics library. */
+export interface GeodesySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciEmbedding(data: number[], opts: GeodesySciEmbeddingOptions = {}): GeodesySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciEmbedding };
diff --git a/src/geodesy_sci/encoding.ts b/src/geodesy_sci/encoding.ts
new file mode 100644
index 000000000..aeaa940c9
--- /dev/null
+++ b/src/geodesy_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci encoding module — tsb analytics library. */
+export interface GeodesySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciEncodingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciEncoding(data: number[], opts: GeodesySciEncodingOptions = {}): GeodesySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciEncoding };
diff --git a/src/geodesy_sci/ensemble.ts b/src/geodesy_sci/ensemble.ts
new file mode 100644
index 000000000..b8f2ba148
--- /dev/null
+++ b/src/geodesy_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci ensemble module — tsb analytics library. */
+export interface GeodesySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeGeodesySciEnsemble(data: number[], opts: GeodesySciEnsembleOptions = {}): GeodesySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciEnsemble };
diff --git a/src/geodesy_sci/estimation.ts b/src/geodesy_sci/estimation.ts
new file mode 100644
index 000000000..f5ab48d0b
--- /dev/null
+++ b/src/geodesy_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci estimation module — tsb analytics library. */
+export interface GeodesySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciEstimationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciEstimation(data: number[], opts: GeodesySciEstimationOptions = {}): GeodesySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciEstimation };
diff --git a/src/geodesy_sci/evaluation.ts b/src/geodesy_sci/evaluation.ts
new file mode 100644
index 000000000..1d457f65d
--- /dev/null
+++ b/src/geodesy_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci evaluation module — tsb analytics library. */
+export interface GeodesySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciEvaluation(data: number[], opts: GeodesySciEvaluationOptions = {}): GeodesySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciEvaluation };
diff --git a/src/geodesy_sci/extrapolation.ts b/src/geodesy_sci/extrapolation.ts
new file mode 100644
index 000000000..decf1e481
--- /dev/null
+++ b/src/geodesy_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci extrapolation module — tsb analytics library. */
+export interface GeodesySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciExtrapolation(data: number[], opts: GeodesySciExtrapolationOptions = {}): GeodesySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciExtrapolation };
diff --git a/src/geodesy_sci/features.ts b/src/geodesy_sci/features.ts
new file mode 100644
index 000000000..eb453fc25
--- /dev/null
+++ b/src/geodesy_sci/features.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci features module — tsb analytics library. */
+export interface GeodesySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeGeodesySciFeatures(data: number[], opts: GeodesySciFeaturesOptions = {}): GeodesySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciFeatures };
diff --git a/src/geodesy_sci/feedback.ts b/src/geodesy_sci/feedback.ts
new file mode 100644
index 000000000..48a50cd20
--- /dev/null
+++ b/src/geodesy_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci feedback module — tsb analytics library. */
+export interface GeodesySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeGeodesySciFeedback(data: number[], opts: GeodesySciFeedbackOptions = {}): GeodesySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciFeedback };
diff --git a/src/geodesy_sci/filtering.ts b/src/geodesy_sci/filtering.ts
new file mode 100644
index 000000000..544c73c78
--- /dev/null
+++ b/src/geodesy_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci filtering module — tsb analytics library. */
+export interface GeodesySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciFilteringResult { values: number[]; converged: boolean; }
+export function computeGeodesySciFiltering(data: number[], opts: GeodesySciFilteringOptions = {}): GeodesySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciFiltering };
diff --git a/src/geodesy_sci/fourier.ts b/src/geodesy_sci/fourier.ts
new file mode 100644
index 000000000..d03e63e47
--- /dev/null
+++ b/src/geodesy_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci fourier module — tsb analytics library. */
+export interface GeodesySciFourierOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciFourierResult { values: number[]; converged: boolean; }
+export function computeGeodesySciFourier(data: number[], opts: GeodesySciFourierOptions = {}): GeodesySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciFourier };
diff --git a/src/geodesy_sci/fusion.ts b/src/geodesy_sci/fusion.ts
new file mode 100644
index 000000000..7d620e7a9
--- /dev/null
+++ b/src/geodesy_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci fusion module — tsb analytics library. */
+export interface GeodesySciFusionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciFusionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciFusion(data: number[], opts: GeodesySciFusionOptions = {}): GeodesySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciFusion };
diff --git a/src/geodesy_sci/generation.ts b/src/geodesy_sci/generation.ts
new file mode 100644
index 000000000..8e57b39bc
--- /dev/null
+++ b/src/geodesy_sci/generation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci generation module — tsb analytics library. */
+export interface GeodesySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciGenerationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciGeneration(data: number[], opts: GeodesySciGenerationOptions = {}): GeodesySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciGeneration };
diff --git a/src/geodesy_sci/geometry.ts b/src/geodesy_sci/geometry.ts
new file mode 100644
index 000000000..3c73ae508
--- /dev/null
+++ b/src/geodesy_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci geometry module — tsb analytics library. */
+export interface GeodesySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciGeometryResult { values: number[]; converged: boolean; }
+export function computeGeodesySciGeometry(data: number[], opts: GeodesySciGeometryOptions = {}): GeodesySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciGeometry };
diff --git a/src/geodesy_sci/gradient.ts b/src/geodesy_sci/gradient.ts
new file mode 100644
index 000000000..1c193300d
--- /dev/null
+++ b/src/geodesy_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci gradient module — tsb analytics library. */
+export interface GeodesySciGradientOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciGradientResult { values: number[]; converged: boolean; }
+export function computeGeodesySciGradient(data: number[], opts: GeodesySciGradientOptions = {}): GeodesySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciGradient };
diff --git a/src/geodesy_sci/hessian.ts b/src/geodesy_sci/hessian.ts
new file mode 100644
index 000000000..e4036dc68
--- /dev/null
+++ b/src/geodesy_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci hessian module — tsb analytics library. */
+export interface GeodesySciHessianOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciHessianResult { values: number[]; converged: boolean; }
+export function computeGeodesySciHessian(data: number[], opts: GeodesySciHessianOptions = {}): GeodesySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciHessian };
diff --git a/src/geodesy_sci/hypothesis.ts b/src/geodesy_sci/hypothesis.ts
new file mode 100644
index 000000000..0f422c840
--- /dev/null
+++ b/src/geodesy_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci hypothesis module — tsb analytics library. */
+export interface GeodesySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeGeodesySciHypothesis(data: number[], opts: GeodesySciHypothesisOptions = {}): GeodesySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciHypothesis };
diff --git a/src/geodesy_sci/inference.ts b/src/geodesy_sci/inference.ts
new file mode 100644
index 000000000..e641310e1
--- /dev/null
+++ b/src/geodesy_sci/inference.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci inference module — tsb analytics library. */
+export interface GeodesySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciInferenceResult { values: number[]; converged: boolean; }
+export function computeGeodesySciInference(data: number[], opts: GeodesySciInferenceOptions = {}): GeodesySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciInference };
diff --git a/src/geodesy_sci/inference2.ts b/src/geodesy_sci/inference2.ts
new file mode 100644
index 000000000..2404a41a9
--- /dev/null
+++ b/src/geodesy_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci inference2 module — tsb analytics library. */
+export interface GeodesySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciInferenceResult { values: number[]; converged: boolean; }
+export function computeGeodesySciInference(data: number[], opts: GeodesySciInferenceOptions = {}): GeodesySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciInference };
diff --git a/src/geodesy_sci/integral.ts b/src/geodesy_sci/integral.ts
new file mode 100644
index 000000000..155f345e8
--- /dev/null
+++ b/src/geodesy_sci/integral.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci integral module — tsb analytics library. */
+export interface GeodesySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciIntegralResult { values: number[]; converged: boolean; }
+export function computeGeodesySciIntegral(data: number[], opts: GeodesySciIntegralOptions = {}): GeodesySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciIntegral };
diff --git a/src/geodesy_sci/integration.ts b/src/geodesy_sci/integration.ts
new file mode 100644
index 000000000..d18b7a859
--- /dev/null
+++ b/src/geodesy_sci/integration.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci integration module — tsb analytics library. */
+export interface GeodesySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciIntegration(data: number[], opts: GeodesySciIntegrationOptions = {}): GeodesySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciIntegration };
diff --git a/src/geodesy_sci/interpolation.ts b/src/geodesy_sci/interpolation.ts
new file mode 100644
index 000000000..6b2868c78
--- /dev/null
+++ b/src/geodesy_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci interpolation module — tsb analytics library. */
+export interface GeodesySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciInterpolation(data: number[], opts: GeodesySciInterpolationOptions = {}): GeodesySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciInterpolation };
diff --git a/src/geodesy_sci/jacobian.ts b/src/geodesy_sci/jacobian.ts
new file mode 100644
index 000000000..6bdf35efd
--- /dev/null
+++ b/src/geodesy_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci jacobian module — tsb analytics library. */
+export interface GeodesySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciJacobianResult { values: number[]; converged: boolean; }
+export function computeGeodesySciJacobian(data: number[], opts: GeodesySciJacobianOptions = {}): GeodesySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciJacobian };
diff --git a/src/geodesy_sci/kernel.ts b/src/geodesy_sci/kernel.ts
new file mode 100644
index 000000000..f1f4a06c4
--- /dev/null
+++ b/src/geodesy_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci kernel module — tsb analytics library. */
+export interface GeodesySciKernelOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciKernelResult { values: number[]; converged: boolean; }
+export function computeGeodesySciKernel(data: number[], opts: GeodesySciKernelOptions = {}): GeodesySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciKernel };
diff --git a/src/geodesy_sci/laplacian.ts b/src/geodesy_sci/laplacian.ts
new file mode 100644
index 000000000..e19317cab
--- /dev/null
+++ b/src/geodesy_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci laplacian module — tsb analytics library. */
+export interface GeodesySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeGeodesySciLaplacian(data: number[], opts: GeodesySciLaplacianOptions = {}): GeodesySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciLaplacian };
diff --git a/src/geodesy_sci/learning.ts b/src/geodesy_sci/learning.ts
new file mode 100644
index 000000000..d86fdf315
--- /dev/null
+++ b/src/geodesy_sci/learning.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci learning module — tsb analytics library. */
+export interface GeodesySciLearningOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciLearningResult { values: number[]; converged: boolean; }
+export function computeGeodesySciLearning(data: number[], opts: GeodesySciLearningOptions = {}): GeodesySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciLearning };
diff --git a/src/geodesy_sci/linear.ts b/src/geodesy_sci/linear.ts
new file mode 100644
index 000000000..f0e0bd0e0
--- /dev/null
+++ b/src/geodesy_sci/linear.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci linear module — tsb analytics library. */
+export interface GeodesySciLinearOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciLinearResult { values: number[]; converged: boolean; }
+export function computeGeodesySciLinear(data: number[], opts: GeodesySciLinearOptions = {}): GeodesySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciLinear };
diff --git a/src/geodesy_sci/manifold.ts b/src/geodesy_sci/manifold.ts
new file mode 100644
index 000000000..b2df59354
--- /dev/null
+++ b/src/geodesy_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci manifold module — tsb analytics library. */
+export interface GeodesySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciManifoldResult { values: number[]; converged: boolean; }
+export function computeGeodesySciManifold(data: number[], opts: GeodesySciManifoldOptions = {}): GeodesySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciManifold };
diff --git a/src/geodesy_sci/matching.ts b/src/geodesy_sci/matching.ts
new file mode 100644
index 000000000..da6f86b02
--- /dev/null
+++ b/src/geodesy_sci/matching.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci matching module — tsb analytics library. */
+export interface GeodesySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciMatchingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciMatching(data: number[], opts: GeodesySciMatchingOptions = {}): GeodesySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciMatching };
diff --git a/src/geodesy_sci/measurement.ts b/src/geodesy_sci/measurement.ts
new file mode 100644
index 000000000..688be33e9
--- /dev/null
+++ b/src/geodesy_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci measurement module — tsb analytics library. */
+export interface GeodesySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeGeodesySciMeasurement(data: number[], opts: GeodesySciMeasurementOptions = {}): GeodesySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciMeasurement };
diff --git a/src/geodesy_sci/metrics.ts b/src/geodesy_sci/metrics.ts
new file mode 100644
index 000000000..3f917ab37
--- /dev/null
+++ b/src/geodesy_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci metrics module — tsb analytics library. */
+export interface GeodesySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciMetricsResult { values: number[]; converged: boolean; }
+export function computeGeodesySciMetrics(data: number[], opts: GeodesySciMetricsOptions = {}): GeodesySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciMetrics };
diff --git a/src/geodesy_sci/modeling.ts b/src/geodesy_sci/modeling.ts
new file mode 100644
index 000000000..2ace76c4c
--- /dev/null
+++ b/src/geodesy_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci modeling module — tsb analytics library. */
+export interface GeodesySciModelingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciModelingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciModeling(data: number[], opts: GeodesySciModelingOptions = {}): GeodesySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciModeling };
diff --git a/src/geodesy_sci/monitoring.ts b/src/geodesy_sci/monitoring.ts
new file mode 100644
index 000000000..d1d5f661e
--- /dev/null
+++ b/src/geodesy_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci monitoring module — tsb analytics library. */
+export interface GeodesySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeGeodesySciMonitoring(data: number[], opts: GeodesySciMonitoringOptions = {}): GeodesySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciMonitoring };
diff --git a/src/geodesy_sci/nonlinear.ts b/src/geodesy_sci/nonlinear.ts
new file mode 100644
index 000000000..b60018cb0
--- /dev/null
+++ b/src/geodesy_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci nonlinear module — tsb analytics library. */
+export interface GeodesySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeGeodesySciNonlinear(data: number[], opts: GeodesySciNonlinearOptions = {}): GeodesySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciNonlinear };
diff --git a/src/geodesy_sci/normalization.ts b/src/geodesy_sci/normalization.ts
new file mode 100644
index 000000000..867c45bd8
--- /dev/null
+++ b/src/geodesy_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci normalization module — tsb analytics library. */
+export interface GeodesySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciNormalization(data: number[], opts: GeodesySciNormalizationOptions = {}): GeodesySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciNormalization };
diff --git a/src/geodesy_sci/optimization.ts b/src/geodesy_sci/optimization.ts
new file mode 100644
index 000000000..1fd7c4c1d
--- /dev/null
+++ b/src/geodesy_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci optimization module — tsb analytics library. */
+export interface GeodesySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciOptimization(data: number[], opts: GeodesySciOptimizationOptions = {}): GeodesySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciOptimization };
diff --git a/src/geodesy_sci/patterns.ts b/src/geodesy_sci/patterns.ts
new file mode 100644
index 000000000..35480e5b8
--- /dev/null
+++ b/src/geodesy_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci patterns module — tsb analytics library. */
+export interface GeodesySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciPatternsResult { values: number[]; converged: boolean; }
+export function computeGeodesySciPatterns(data: number[], opts: GeodesySciPatternsOptions = {}): GeodesySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciPatterns };
diff --git a/src/geodesy_sci/permutation.ts b/src/geodesy_sci/permutation.ts
new file mode 100644
index 000000000..40f316ed3
--- /dev/null
+++ b/src/geodesy_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci permutation module — tsb analytics library. */
+export interface GeodesySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciPermutationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciPermutation(data: number[], opts: GeodesySciPermutationOptions = {}): GeodesySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciPermutation };
diff --git a/src/geodesy_sci/prediction.ts b/src/geodesy_sci/prediction.ts
new file mode 100644
index 000000000..7812c667c
--- /dev/null
+++ b/src/geodesy_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci prediction module — tsb analytics library. */
+export interface GeodesySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciPredictionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciPrediction(data: number[], opts: GeodesySciPredictionOptions = {}): GeodesySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciPrediction };
diff --git a/src/geodesy_sci/processing.ts b/src/geodesy_sci/processing.ts
new file mode 100644
index 000000000..53469be7d
--- /dev/null
+++ b/src/geodesy_sci/processing.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci processing module — tsb analytics library. */
+export interface GeodesySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciProcessingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciProcessing(data: number[], opts: GeodesySciProcessingOptions = {}): GeodesySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciProcessing };
diff --git a/src/geodesy_sci/profiling.ts b/src/geodesy_sci/profiling.ts
new file mode 100644
index 000000000..72988accf
--- /dev/null
+++ b/src/geodesy_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci profiling module — tsb analytics library. */
+export interface GeodesySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciProfilingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciProfiling(data: number[], opts: GeodesySciProfilingOptions = {}): GeodesySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciProfiling };
diff --git a/src/geodesy_sci/projection.ts b/src/geodesy_sci/projection.ts
new file mode 100644
index 000000000..3981ab375
--- /dev/null
+++ b/src/geodesy_sci/projection.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci projection module — tsb analytics library. */
+export interface GeodesySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciProjectionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciProjection(data: number[], opts: GeodesySciProjectionOptions = {}): GeodesySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciProjection };
diff --git a/src/geodesy_sci/ranking.ts b/src/geodesy_sci/ranking.ts
new file mode 100644
index 000000000..5dd143180
--- /dev/null
+++ b/src/geodesy_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci ranking module — tsb analytics library. */
+export interface GeodesySciRankingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciRankingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciRanking(data: number[], opts: GeodesySciRankingOptions = {}): GeodesySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciRanking };
diff --git a/src/geodesy_sci/reconstruction.ts b/src/geodesy_sci/reconstruction.ts
new file mode 100644
index 000000000..091732bd6
--- /dev/null
+++ b/src/geodesy_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci reconstruction module — tsb analytics library. */
+export interface GeodesySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciReconstruction(data: number[], opts: GeodesySciReconstructionOptions = {}): GeodesySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciReconstruction };
diff --git a/src/geodesy_sci/registration.ts b/src/geodesy_sci/registration.ts
new file mode 100644
index 000000000..6742b3959
--- /dev/null
+++ b/src/geodesy_sci/registration.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci registration module — tsb analytics library. */
+export interface GeodesySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciRegistration(data: number[], opts: GeodesySciRegistrationOptions = {}): GeodesySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciRegistration };
diff --git a/src/geodesy_sci/regression.ts b/src/geodesy_sci/regression.ts
new file mode 100644
index 000000000..ea27d890e
--- /dev/null
+++ b/src/geodesy_sci/regression.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci regression module — tsb analytics library. */
+export interface GeodesySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciRegressionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciRegression(data: number[], opts: GeodesySciRegressionOptions = {}): GeodesySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciRegression };
diff --git a/src/geodesy_sci/regularization.ts b/src/geodesy_sci/regularization.ts
new file mode 100644
index 000000000..2aff1ac59
--- /dev/null
+++ b/src/geodesy_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci regularization module — tsb analytics library. */
+export interface GeodesySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciRegularization(data: number[], opts: GeodesySciRegularizationOptions = {}): GeodesySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciRegularization };
diff --git a/src/geodesy_sci/robustness.ts b/src/geodesy_sci/robustness.ts
new file mode 100644
index 000000000..fd5bf7119
--- /dev/null
+++ b/src/geodesy_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci robustness module — tsb analytics library. */
+export interface GeodesySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeGeodesySciRobustness(data: number[], opts: GeodesySciRobustnessOptions = {}): GeodesySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciRobustness };
diff --git a/src/geodesy_sci/sampling.ts b/src/geodesy_sci/sampling.ts
new file mode 100644
index 000000000..1f760f671
--- /dev/null
+++ b/src/geodesy_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci sampling module — tsb analytics library. */
+export interface GeodesySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciSamplingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciSampling(data: number[], opts: GeodesySciSamplingOptions = {}): GeodesySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciSampling };
diff --git a/src/geodesy_sci/sampling2.ts b/src/geodesy_sci/sampling2.ts
new file mode 100644
index 000000000..1dbf2f2a6
--- /dev/null
+++ b/src/geodesy_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci sampling2 module — tsb analytics library. */
+export interface GeodesySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciSamplingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciSampling(data: number[], opts: GeodesySciSamplingOptions = {}): GeodesySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciSampling };
diff --git a/src/geodesy_sci/scaling.ts b/src/geodesy_sci/scaling.ts
new file mode 100644
index 000000000..f01fa5033
--- /dev/null
+++ b/src/geodesy_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci scaling module — tsb analytics library. */
+export interface GeodesySciScalingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciScalingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciScaling(data: number[], opts: GeodesySciScalingOptions = {}): GeodesySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciScaling };
diff --git a/src/geodesy_sci/scoring.ts b/src/geodesy_sci/scoring.ts
new file mode 100644
index 000000000..9a7590d9c
--- /dev/null
+++ b/src/geodesy_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci scoring module — tsb analytics library. */
+export interface GeodesySciScoringOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciScoringResult { values: number[]; converged: boolean; }
+export function computeGeodesySciScoring(data: number[], opts: GeodesySciScoringOptions = {}): GeodesySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciScoring };
diff --git a/src/geodesy_sci/segmentation.ts b/src/geodesy_sci/segmentation.ts
new file mode 100644
index 000000000..8e5f013f7
--- /dev/null
+++ b/src/geodesy_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci segmentation module — tsb analytics library. */
+export interface GeodesySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciSegmentation(data: number[], opts: GeodesySciSegmentationOptions = {}): GeodesySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciSegmentation };
diff --git a/src/geodesy_sci/selection.ts b/src/geodesy_sci/selection.ts
new file mode 100644
index 000000000..8aa0f2a19
--- /dev/null
+++ b/src/geodesy_sci/selection.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci selection module — tsb analytics library. */
+export interface GeodesySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciSelectionResult { values: number[]; converged: boolean; }
+export function computeGeodesySciSelection(data: number[], opts: GeodesySciSelectionOptions = {}): GeodesySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciSelection };
diff --git a/src/geodesy_sci/sensitivity.ts b/src/geodesy_sci/sensitivity.ts
new file mode 100644
index 000000000..1331d9bef
--- /dev/null
+++ b/src/geodesy_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci sensitivity module — tsb analytics library. */
+export interface GeodesySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeGeodesySciSensitivity(data: number[], opts: GeodesySciSensitivityOptions = {}): GeodesySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciSensitivity };
diff --git a/src/geodesy_sci/simulation.ts b/src/geodesy_sci/simulation.ts
new file mode 100644
index 000000000..6a70f8488
--- /dev/null
+++ b/src/geodesy_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci simulation module — tsb analytics library. */
+export interface GeodesySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciSimulationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciSimulation(data: number[], opts: GeodesySciSimulationOptions = {}): GeodesySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciSimulation };
diff --git a/src/geodesy_sci/smoothing.ts b/src/geodesy_sci/smoothing.ts
new file mode 100644
index 000000000..06252cb2c
--- /dev/null
+++ b/src/geodesy_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci smoothing module — tsb analytics library. */
+export interface GeodesySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciSmoothing(data: number[], opts: GeodesySciSmoothingOptions = {}): GeodesySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciSmoothing };
diff --git a/src/geodesy_sci/stability.ts b/src/geodesy_sci/stability.ts
new file mode 100644
index 000000000..e3c0a032e
--- /dev/null
+++ b/src/geodesy_sci/stability.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci stability module — tsb analytics library. */
+export interface GeodesySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciStabilityResult { values: number[]; converged: boolean; }
+export function computeGeodesySciStability(data: number[], opts: GeodesySciStabilityOptions = {}): GeodesySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciStability };
diff --git a/src/geodesy_sci/stacking.ts b/src/geodesy_sci/stacking.ts
new file mode 100644
index 000000000..8a7c256ab
--- /dev/null
+++ b/src/geodesy_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci stacking module — tsb analytics library. */
+export interface GeodesySciStackingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciStackingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciStacking(data: number[], opts: GeodesySciStackingOptions = {}): GeodesySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciStacking };
diff --git a/src/geodesy_sci/standardization.ts b/src/geodesy_sci/standardization.ts
new file mode 100644
index 000000000..68cfa6cf8
--- /dev/null
+++ b/src/geodesy_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci standardization module — tsb analytics library. */
+export interface GeodesySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciStandardization(data: number[], opts: GeodesySciStandardizationOptions = {}): GeodesySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciStandardization };
diff --git a/src/geodesy_sci/static.ts b/src/geodesy_sci/static.ts
new file mode 100644
index 000000000..3ab42bf76
--- /dev/null
+++ b/src/geodesy_sci/static.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci static module — tsb analytics library. */
+export interface GeodesySciStaticOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciStaticResult { values: number[]; converged: boolean; }
+export function computeGeodesySciStatic(data: number[], opts: GeodesySciStaticOptions = {}): GeodesySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciStatic };
diff --git a/src/geodesy_sci/stochastic.ts b/src/geodesy_sci/stochastic.ts
new file mode 100644
index 000000000..83993707f
--- /dev/null
+++ b/src/geodesy_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci stochastic module — tsb analytics library. */
+export interface GeodesySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciStochasticResult { values: number[]; converged: boolean; }
+export function computeGeodesySciStochastic(data: number[], opts: GeodesySciStochasticOptions = {}): GeodesySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciStochastic };
diff --git a/src/geodesy_sci/synthesis.ts b/src/geodesy_sci/synthesis.ts
new file mode 100644
index 000000000..123f11c40
--- /dev/null
+++ b/src/geodesy_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci synthesis module — tsb analytics library. */
+export interface GeodesySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeGeodesySciSynthesis(data: number[], opts: GeodesySciSynthesisOptions = {}): GeodesySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciSynthesis };
diff --git a/src/geodesy_sci/topology.ts b/src/geodesy_sci/topology.ts
new file mode 100644
index 000000000..901a19e30
--- /dev/null
+++ b/src/geodesy_sci/topology.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci topology module — tsb analytics library. */
+export interface GeodesySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciTopologyResult { values: number[]; converged: boolean; }
+export function computeGeodesySciTopology(data: number[], opts: GeodesySciTopologyOptions = {}): GeodesySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciTopology };
diff --git a/src/geodesy_sci/tracking.ts b/src/geodesy_sci/tracking.ts
new file mode 100644
index 000000000..aa327c88c
--- /dev/null
+++ b/src/geodesy_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci tracking module — tsb analytics library. */
+export interface GeodesySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciTrackingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciTracking(data: number[], opts: GeodesySciTrackingOptions = {}): GeodesySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciTracking };
diff --git a/src/geodesy_sci/transform.ts b/src/geodesy_sci/transform.ts
new file mode 100644
index 000000000..049ff991d
--- /dev/null
+++ b/src/geodesy_sci/transform.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci transform module — tsb analytics library. */
+export interface GeodesySciTransformOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciTransformResult { values: number[]; converged: boolean; }
+export function computeGeodesySciTransform(data: number[], opts: GeodesySciTransformOptions = {}): GeodesySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciTransform };
diff --git a/src/geodesy_sci/uncertainty.ts b/src/geodesy_sci/uncertainty.ts
new file mode 100644
index 000000000..c7b71b159
--- /dev/null
+++ b/src/geodesy_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci uncertainty module — tsb analytics library. */
+export interface GeodesySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGeodesySciUncertainty(data: number[], opts: GeodesySciUncertaintyOptions = {}): GeodesySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciUncertainty };
diff --git a/src/geodesy_sci/validation.ts b/src/geodesy_sci/validation.ts
new file mode 100644
index 000000000..95e457b1c
--- /dev/null
+++ b/src/geodesy_sci/validation.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci validation module — tsb analytics library. */
+export interface GeodesySciValidationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciValidationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciValidation(data: number[], opts: GeodesySciValidationOptions = {}): GeodesySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciValidation };
diff --git a/src/geodesy_sci/verification.ts b/src/geodesy_sci/verification.ts
new file mode 100644
index 000000000..8e5b0224a
--- /dev/null
+++ b/src/geodesy_sci/verification.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci verification module — tsb analytics library. */
+export interface GeodesySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciVerificationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciVerification(data: number[], opts: GeodesySciVerificationOptions = {}): GeodesySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciVerification };
diff --git a/src/geodesy_sci/visualization.ts b/src/geodesy_sci/visualization.ts
new file mode 100644
index 000000000..b05baaca7
--- /dev/null
+++ b/src/geodesy_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci visualization module — tsb analytics library. */
+export interface GeodesySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeGeodesySciVisualization(data: number[], opts: GeodesySciVisualizationOptions = {}): GeodesySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciVisualization };
diff --git a/src/geodesy_sci/voting.ts b/src/geodesy_sci/voting.ts
new file mode 100644
index 000000000..8fbffaff4
--- /dev/null
+++ b/src/geodesy_sci/voting.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci voting module — tsb analytics library. */
+export interface GeodesySciVotingOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciVotingResult { values: number[]; converged: boolean; }
+export function computeGeodesySciVoting(data: number[], opts: GeodesySciVotingOptions = {}): GeodesySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciVoting };
diff --git a/src/geodesy_sci/wavelet.ts b/src/geodesy_sci/wavelet.ts
new file mode 100644
index 000000000..181d4d17e
--- /dev/null
+++ b/src/geodesy_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** geodesy_sci wavelet module — tsb analytics library. */
+export interface GeodesySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface GeodesySciWaveletResult { values: number[]; converged: boolean; }
+export function computeGeodesySciWavelet(data: number[], opts: GeodesySciWaveletOptions = {}): GeodesySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeodesySciWavelet };
diff --git a/src/geology/advanced.ts b/src/geology/advanced.ts
new file mode 100644
index 000000000..a87a21e7a
--- /dev/null
+++ b/src/geology/advanced.ts
@@ -0,0 +1,15 @@
+/** Geology Advanced module — tsb analytics library. */
+export interface Geology advancedOptions { tol?: number; maxIter?: number; }
+export interface Geology advancedResult { values: number[]; converged: boolean; }
+export function computeGeology advanced(data: number[], opts: Geology advancedOptions = {}): Geology advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology advanced };
diff --git a/src/geology/base2.ts b/src/geology/base2.ts
new file mode 100644
index 000000000..22895a968
--- /dev/null
+++ b/src/geology/base2.ts
@@ -0,0 +1,15 @@
+/** Geology Base2 module — tsb analytics library. */
+export interface Geology base2Options { tol?: number; maxIter?: number; }
+export interface Geology base2Result { values: number[]; converged: boolean; }
+export function computeGeology base2(data: number[], opts: Geology base2Options = {}): Geology base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology base2 };
diff --git a/src/geology/batch.ts b/src/geology/batch.ts
new file mode 100644
index 000000000..0116431f5
--- /dev/null
+++ b/src/geology/batch.ts
@@ -0,0 +1,15 @@
+/** Geology Batch module — tsb analytics library. */
+export interface Geology batchOptions { tol?: number; maxIter?: number; }
+export interface Geology batchResult { values: number[]; converged: boolean; }
+export function computeGeology batch(data: number[], opts: Geology batchOptions = {}): Geology batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology batch };
diff --git a/src/geology/beta.ts b/src/geology/beta.ts
new file mode 100644
index 000000000..411f9414b
--- /dev/null
+++ b/src/geology/beta.ts
@@ -0,0 +1,15 @@
+/** Geology Beta module — tsb analytics library. */
+export interface Geology betaOptions { tol?: number; maxIter?: number; }
+export interface Geology betaResult { values: number[]; converged: boolean; }
+export function computeGeology beta(data: number[], opts: Geology betaOptions = {}): Geology betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology beta };
diff --git a/src/geology/burial_history.ts b/src/geology/burial_history.ts
new file mode 100644
index 000000000..11da62e47
--- /dev/null
+++ b/src/geology/burial_history.ts
@@ -0,0 +1,22 @@
+/** Burial History module — tsb analytics library. */
+
+/** Options for Burial History. */
+export interface BurialHistoryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Burial History. */
+export interface BurialHistoryResult { values: number[]; converged: boolean; }
+
+/** Compute Burial History. */
+export function computeBurialHistory(data: number[], opts: BurialHistoryOptions = {}): BurialHistoryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBurialHistory };
diff --git a/src/geology/cosmogenic.ts b/src/geology/cosmogenic.ts
new file mode 100644
index 000000000..f45d75480
--- /dev/null
+++ b/src/geology/cosmogenic.ts
@@ -0,0 +1,22 @@
+/** Cosmogenic module — tsb analytics library. */
+
+/** Options for Cosmogenic. */
+export interface CosmogenicOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cosmogenic. */
+export interface CosmogenicResult { values: number[]; converged: boolean; }
+
+/** Compute Cosmogenic. */
+export function computeCosmogenic(data: number[], opts: CosmogenicOptions = {}): CosmogenicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCosmogenic };
diff --git a/src/geology/cpu.ts b/src/geology/cpu.ts
new file mode 100644
index 000000000..227c77fbe
--- /dev/null
+++ b/src/geology/cpu.ts
@@ -0,0 +1,15 @@
+/** Geology Cpu module — tsb analytics library. */
+export interface Geology cpuOptions { tol?: number; maxIter?: number; }
+export interface Geology cpuResult { values: number[]; converged: boolean; }
+export function computeGeology cpu(data: number[], opts: Geology cpuOptions = {}): Geology cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology cpu };
diff --git a/src/geology/dense.ts b/src/geology/dense.ts
new file mode 100644
index 000000000..3174365ba
--- /dev/null
+++ b/src/geology/dense.ts
@@ -0,0 +1,15 @@
+/** Geology Dense module — tsb analytics library. */
+export interface Geology denseOptions { tol?: number; maxIter?: number; }
+export interface Geology denseResult { values: number[]; converged: boolean; }
+export function computeGeology dense(data: number[], opts: Geology denseOptions = {}): Geology denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology dense };
diff --git a/src/geology/distributed.ts b/src/geology/distributed.ts
new file mode 100644
index 000000000..ca9dbe8fb
--- /dev/null
+++ b/src/geology/distributed.ts
@@ -0,0 +1,15 @@
+/** Geology Distributed module — tsb analytics library. */
+export interface Geology distributedOptions { tol?: number; maxIter?: number; }
+export interface Geology distributedResult { values: number[]; converged: boolean; }
+export function computeGeology distributed(data: number[], opts: Geology distributedOptions = {}): Geology distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology distributed };
diff --git a/src/geology/experimental.ts b/src/geology/experimental.ts
new file mode 100644
index 000000000..f00904c5d
--- /dev/null
+++ b/src/geology/experimental.ts
@@ -0,0 +1,15 @@
+/** Geology Experimental module — tsb analytics library. */
+export interface Geology experimentalOptions { tol?: number; maxIter?: number; }
+export interface Geology experimentalResult { values: number[]; converged: boolean; }
+export function computeGeology experimental(data: number[], opts: Geology experimentalOptions = {}): Geology experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology experimental };
diff --git a/src/geology/fast.ts b/src/geology/fast.ts
new file mode 100644
index 000000000..4b2ed390d
--- /dev/null
+++ b/src/geology/fast.ts
@@ -0,0 +1,15 @@
+/** Geology Fast module — tsb analytics library. */
+export interface Geology fastOptions { tol?: number; maxIter?: number; }
+export interface Geology fastResult { values: number[]; converged: boolean; }
+export function computeGeology fast(data: number[], opts: Geology fastOptions = {}): Geology fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology fast };
diff --git a/src/geology/future.ts b/src/geology/future.ts
new file mode 100644
index 000000000..99e28e8eb
--- /dev/null
+++ b/src/geology/future.ts
@@ -0,0 +1,15 @@
+/** Geology Future module — tsb analytics library. */
+export interface Geology futureOptions { tol?: number; maxIter?: number; }
+export interface Geology futureResult { values: number[]; converged: boolean; }
+export function computeGeology future(data: number[], opts: Geology futureOptions = {}): Geology futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology future };
diff --git a/src/geology/geochemistry.ts b/src/geology/geochemistry.ts
new file mode 100644
index 000000000..dbde7eded
--- /dev/null
+++ b/src/geology/geochemistry.ts
@@ -0,0 +1,22 @@
+/** Geochemistry module — tsb analytics library. */
+
+/** Options for Geochemistry. */
+export interface GeochemistryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Geochemistry. */
+export interface GeochemistryResult { values: number[]; converged: boolean; }
+
+/** Compute Geochemistry. */
+export function computeGeochemistry(data: number[], opts: GeochemistryOptions = {}): GeochemistryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeochemistry };
diff --git a/src/geology/geochronology.ts b/src/geology/geochronology.ts
new file mode 100644
index 000000000..41272e88c
--- /dev/null
+++ b/src/geology/geochronology.ts
@@ -0,0 +1,22 @@
+/** Geochronology module — tsb analytics library. */
+
+/** Options for Geochronology. */
+export interface GeochronologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Geochronology. */
+export interface GeochronologyResult { values: number[]; converged: boolean; }
+
+/** Compute Geochronology. */
+export function computeGeochronology(data: number[], opts: GeochronologyOptions = {}): GeochronologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeochronology };
diff --git a/src/geology/geomorphology.ts b/src/geology/geomorphology.ts
new file mode 100644
index 000000000..42fb9192b
--- /dev/null
+++ b/src/geology/geomorphology.ts
@@ -0,0 +1,22 @@
+/** Geomorphology module — tsb analytics library. */
+
+/** Options for Geomorphology. */
+export interface GeomorphologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Geomorphology. */
+export interface GeomorphologyResult { values: number[]; converged: boolean; }
+
+/** Compute Geomorphology. */
+export function computeGeomorphology(data: number[], opts: GeomorphologyOptions = {}): GeomorphologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeomorphology };
diff --git a/src/geology/glaciology.ts b/src/geology/glaciology.ts
new file mode 100644
index 000000000..c21e41f16
--- /dev/null
+++ b/src/geology/glaciology.ts
@@ -0,0 +1,22 @@
+/** Glaciology module — tsb analytics library. */
+
+/** Options for Glaciology. */
+export interface GlaciologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Glaciology. */
+export interface GlaciologyResult { values: number[]; converged: boolean; }
+
+/** Compute Glaciology. */
+export function computeGlaciology(data: number[], opts: GlaciologyOptions = {}): GlaciologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGlaciology };
diff --git a/src/geology/gpu.ts b/src/geology/gpu.ts
new file mode 100644
index 000000000..bbc33fa84
--- /dev/null
+++ b/src/geology/gpu.ts
@@ -0,0 +1,15 @@
+/** Geology Gpu module — tsb analytics library. */
+export interface Geology gpuOptions { tol?: number; maxIter?: number; }
+export interface Geology gpuResult { values: number[]; converged: boolean; }
+export function computeGeology gpu(data: number[], opts: Geology gpuOptions = {}): Geology gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology gpu };
diff --git a/src/geology/hydrogeology.ts b/src/geology/hydrogeology.ts
new file mode 100644
index 000000000..911214a2d
--- /dev/null
+++ b/src/geology/hydrogeology.ts
@@ -0,0 +1,22 @@
+/** Hydrogeology module — tsb analytics library. */
+
+/** Options for Hydrogeology. */
+export interface HydrogeologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hydrogeology. */
+export interface HydrogeologyResult { values: number[]; converged: boolean; }
+
+/** Compute Hydrogeology. */
+export function computeHydrogeology(data: number[], opts: HydrogeologyOptions = {}): HydrogeologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHydrogeology };
diff --git a/src/geology/isotope.ts b/src/geology/isotope.ts
new file mode 100644
index 000000000..912e2ae50
--- /dev/null
+++ b/src/geology/isotope.ts
@@ -0,0 +1,22 @@
+/** Isotope module — tsb analytics library. */
+
+/** Options for Isotope. */
+export interface IsotopeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Isotope. */
+export interface IsotopeResult { values: number[]; converged: boolean; }
+
+/** Compute Isotope. */
+export function computeIsotope(data: number[], opts: IsotopeOptions = {}): IsotopeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIsotope };
diff --git a/src/geology/large.ts b/src/geology/large.ts
new file mode 100644
index 000000000..2144a3171
--- /dev/null
+++ b/src/geology/large.ts
@@ -0,0 +1,15 @@
+/** Geology Large module — tsb analytics library. */
+export interface Geology largeOptions { tol?: number; maxIter?: number; }
+export interface Geology largeResult { values: number[]; converged: boolean; }
+export function computeGeology large(data: number[], opts: Geology largeOptions = {}): Geology largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology large };
diff --git a/src/geology/legacy.ts b/src/geology/legacy.ts
new file mode 100644
index 000000000..aa9216916
--- /dev/null
+++ b/src/geology/legacy.ts
@@ -0,0 +1,15 @@
+/** Geology Legacy module — tsb analytics library. */
+export interface Geology legacyOptions { tol?: number; maxIter?: number; }
+export interface Geology legacyResult { values: number[]; converged: boolean; }
+export function computeGeology legacy(data: number[], opts: Geology legacyOptions = {}): Geology legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology legacy };
diff --git a/src/geology/lite.ts b/src/geology/lite.ts
new file mode 100644
index 000000000..4bb060573
--- /dev/null
+++ b/src/geology/lite.ts
@@ -0,0 +1,15 @@
+/** Geology Lite module — tsb analytics library. */
+export interface Geology liteOptions { tol?: number; maxIter?: number; }
+export interface Geology liteResult { values: number[]; converged: boolean; }
+export function computeGeology lite(data: number[], opts: Geology liteOptions = {}): Geology liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology lite };
diff --git a/src/geology/major_element.ts b/src/geology/major_element.ts
new file mode 100644
index 000000000..ce721ecc4
--- /dev/null
+++ b/src/geology/major_element.ts
@@ -0,0 +1,22 @@
+/** Major Element module — tsb analytics library. */
+
+/** Options for Major Element. */
+export interface MajorElementOptions { tol?: number; maxIter?: number; }
+
+/** Result from Major Element. */
+export interface MajorElementResult { values: number[]; converged: boolean; }
+
+/** Compute Major Element. */
+export function computeMajorElement(data: number[], opts: MajorElementOptions = {}): MajorElementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMajorElement };
diff --git a/src/geology/migration_geo.ts b/src/geology/migration_geo.ts
new file mode 100644
index 000000000..745a9d7d4
--- /dev/null
+++ b/src/geology/migration_geo.ts
@@ -0,0 +1,22 @@
+/** Migration Geo module — tsb analytics library. */
+
+/** Options for Migration Geo. */
+export interface MigrationGeoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Migration Geo. */
+export interface MigrationGeoResult { values: number[]; converged: boolean; }
+
+/** Compute Migration Geo. */
+export function computeMigrationGeo(data: number[], opts: MigrationGeoOptions = {}): MigrationGeoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMigrationGeo };
diff --git a/src/geology/mineralogy.ts b/src/geology/mineralogy.ts
new file mode 100644
index 000000000..bc84c875c
--- /dev/null
+++ b/src/geology/mineralogy.ts
@@ -0,0 +1,22 @@
+/** Mineralogy module — tsb analytics library. */
+
+/** Options for Mineralogy. */
+export interface MineralogyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mineralogy. */
+export interface MineralogyResult { values: number[]; converged: boolean; }
+
+/** Compute Mineralogy. */
+export function computeMineralogy(data: number[], opts: MineralogyOptions = {}): MineralogyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMineralogy };
diff --git a/src/geology/mini.ts b/src/geology/mini.ts
new file mode 100644
index 000000000..fe5d5532a
--- /dev/null
+++ b/src/geology/mini.ts
@@ -0,0 +1,15 @@
+/** Geology Mini module — tsb analytics library. */
+export interface Geology miniOptions { tol?: number; maxIter?: number; }
+export interface Geology miniResult { values: number[]; converged: boolean; }
+export function computeGeology mini(data: number[], opts: Geology miniOptions = {}): Geology miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology mini };
diff --git a/src/geology/next.ts b/src/geology/next.ts
new file mode 100644
index 000000000..5bcddcdba
--- /dev/null
+++ b/src/geology/next.ts
@@ -0,0 +1,15 @@
+/** Geology Next module — tsb analytics library. */
+export interface Geology nextOptions { tol?: number; maxIter?: number; }
+export interface Geology nextResult { values: number[]; converged: boolean; }
+export function computeGeology next(data: number[], opts: Geology nextOptions = {}): Geology nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology next };
diff --git a/src/geology/online.ts b/src/geology/online.ts
new file mode 100644
index 000000000..edceb6118
--- /dev/null
+++ b/src/geology/online.ts
@@ -0,0 +1,15 @@
+/** Geology Online module — tsb analytics library. */
+export interface Geology onlineOptions { tol?: number; maxIter?: number; }
+export interface Geology onlineResult { values: number[]; converged: boolean; }
+export function computeGeology online(data: number[], opts: Geology onlineOptions = {}): Geology onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology online };
diff --git a/src/geology/paleoclimatology.ts b/src/geology/paleoclimatology.ts
new file mode 100644
index 000000000..7bf449824
--- /dev/null
+++ b/src/geology/paleoclimatology.ts
@@ -0,0 +1,22 @@
+/** Paleoclimatology module — tsb analytics library. */
+
+/** Options for Paleoclimatology. */
+export interface PaleoclimatologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Paleoclimatology. */
+export interface PaleoclimatologyResult { values: number[]; converged: boolean; }
+
+/** Compute Paleoclimatology. */
+export function computePaleoclimatology(data: number[], opts: PaleoclimatologyOptions = {}): PaleoclimatologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePaleoclimatology };
diff --git a/src/geology/parallel.ts b/src/geology/parallel.ts
new file mode 100644
index 000000000..1a44e2162
--- /dev/null
+++ b/src/geology/parallel.ts
@@ -0,0 +1,15 @@
+/** Geology Parallel module — tsb analytics library. */
+export interface Geology parallelOptions { tol?: number; maxIter?: number; }
+export interface Geology parallelResult { values: number[]; converged: boolean; }
+export function computeGeology parallel(data: number[], opts: Geology parallelOptions = {}): Geology parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology parallel };
diff --git a/src/geology/petrology.ts b/src/geology/petrology.ts
new file mode 100644
index 000000000..83df7cac4
--- /dev/null
+++ b/src/geology/petrology.ts
@@ -0,0 +1,22 @@
+/** Petrology module — tsb analytics library. */
+
+/** Options for Petrology. */
+export interface PetrologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Petrology. */
+export interface PetrologyResult { values: number[]; converged: boolean; }
+
+/** Compute Petrology. */
+export function computePetrology(data: number[], opts: PetrologyOptions = {}): PetrologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePetrology };
diff --git a/src/geology/plus.ts b/src/geology/plus.ts
new file mode 100644
index 000000000..d5edc651f
--- /dev/null
+++ b/src/geology/plus.ts
@@ -0,0 +1,15 @@
+/** Geology Plus module — tsb analytics library. */
+export interface Geology plusOptions { tol?: number; maxIter?: number; }
+export interface Geology plusResult { values: number[]; converged: boolean; }
+export function computeGeology plus(data: number[], opts: Geology plusOptions = {}): Geology plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology plus };
diff --git a/src/geology/pro.ts b/src/geology/pro.ts
new file mode 100644
index 000000000..1a2cea24b
--- /dev/null
+++ b/src/geology/pro.ts
@@ -0,0 +1,15 @@
+/** Geology Pro module — tsb analytics library. */
+export interface Geology proOptions { tol?: number; maxIter?: number; }
+export interface Geology proResult { values: number[]; converged: boolean; }
+export function computeGeology pro(data: number[], opts: Geology proOptions = {}): Geology proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology pro };
diff --git a/src/geology/quaternary.ts b/src/geology/quaternary.ts
new file mode 100644
index 000000000..678d175d9
--- /dev/null
+++ b/src/geology/quaternary.ts
@@ -0,0 +1,22 @@
+/** Quaternary module — tsb analytics library. */
+
+/** Options for Quaternary. */
+export interface QuaternaryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quaternary. */
+export interface QuaternaryResult { values: number[]; converged: boolean; }
+
+/** Compute Quaternary. */
+export function computeQuaternary(data: number[], opts: QuaternaryOptions = {}): QuaternaryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQuaternary };
diff --git a/src/geology/radiogenic.ts b/src/geology/radiogenic.ts
new file mode 100644
index 000000000..b3a835f04
--- /dev/null
+++ b/src/geology/radiogenic.ts
@@ -0,0 +1,22 @@
+/** Radiogenic module — tsb analytics library. */
+
+/** Options for Radiogenic. */
+export interface RadiogenicOptions { tol?: number; maxIter?: number; }
+
+/** Result from Radiogenic. */
+export interface RadiogenicResult { values: number[]; converged: boolean; }
+
+/** Compute Radiogenic. */
+export function computeRadiogenic(data: number[], opts: RadiogenicOptions = {}): RadiogenicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRadiogenic };
diff --git a/src/geology/rare_earth.ts b/src/geology/rare_earth.ts
new file mode 100644
index 000000000..bb90bf9f3
--- /dev/null
+++ b/src/geology/rare_earth.ts
@@ -0,0 +1,22 @@
+/** Rare Earth module — tsb analytics library. */
+
+/** Options for Rare Earth. */
+export interface RareEarthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rare Earth. */
+export interface RareEarthResult { values: number[]; converged: boolean; }
+
+/** Compute Rare Earth. */
+export function computeRareEarth(data: number[], opts: RareEarthOptions = {}): RareEarthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRareEarth };
diff --git a/src/geology/reservoir.ts b/src/geology/reservoir.ts
new file mode 100644
index 000000000..16572c130
--- /dev/null
+++ b/src/geology/reservoir.ts
@@ -0,0 +1,22 @@
+/** Reservoir module — tsb analytics library. */
+
+/** Options for Reservoir. */
+export interface ReservoirOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reservoir. */
+export interface ReservoirResult { values: number[]; converged: boolean; }
+
+/** Compute Reservoir. */
+export function computeReservoir(data: number[], opts: ReservoirOptions = {}): ReservoirResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReservoir };
diff --git a/src/geology/robust.ts b/src/geology/robust.ts
new file mode 100644
index 000000000..8cc916fb8
--- /dev/null
+++ b/src/geology/robust.ts
@@ -0,0 +1,15 @@
+/** Geology Robust module — tsb analytics library. */
+export interface Geology robustOptions { tol?: number; maxIter?: number; }
+export interface Geology robustResult { values: number[]; converged: boolean; }
+export function computeGeology robust(data: number[], opts: Geology robustOptions = {}): Geology robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology robust };
diff --git a/src/geology/seal.ts b/src/geology/seal.ts
new file mode 100644
index 000000000..e6575f9c9
--- /dev/null
+++ b/src/geology/seal.ts
@@ -0,0 +1,22 @@
+/** Seal module — tsb analytics library. */
+
+/** Options for Seal. */
+export interface SealOptions { tol?: number; maxIter?: number; }
+
+/** Result from Seal. */
+export interface SealResult { values: number[]; converged: boolean; }
+
+/** Compute Seal. */
+export function computeSeal(data: number[], opts: SealOptions = {}): SealResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeal };
diff --git a/src/geology/sedimentology.ts b/src/geology/sedimentology.ts
new file mode 100644
index 000000000..ae57728fb
--- /dev/null
+++ b/src/geology/sedimentology.ts
@@ -0,0 +1,22 @@
+/** Sedimentology module — tsb analytics library. */
+
+/** Options for Sedimentology. */
+export interface SedimentologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sedimentology. */
+export interface SedimentologyResult { values: number[]; converged: boolean; }
+
+/** Compute Sedimentology. */
+export function computeSedimentology(data: number[], opts: SedimentologyOptions = {}): SedimentologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSedimentology };
diff --git a/src/geology/seismology.ts b/src/geology/seismology.ts
new file mode 100644
index 000000000..de3044fc7
--- /dev/null
+++ b/src/geology/seismology.ts
@@ -0,0 +1,22 @@
+/** Seismology module — tsb analytics library. */
+
+/** Options for Seismology. */
+export interface SeismologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Seismology. */
+export interface SeismologyResult { values: number[]; converged: boolean; }
+
+/** Compute Seismology. */
+export function computeSeismology(data: number[], opts: SeismologyOptions = {}): SeismologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeismology };
diff --git a/src/geology/small.ts b/src/geology/small.ts
new file mode 100644
index 000000000..3d938158b
--- /dev/null
+++ b/src/geology/small.ts
@@ -0,0 +1,15 @@
+/** Geology Small module — tsb analytics library. */
+export interface Geology smallOptions { tol?: number; maxIter?: number; }
+export interface Geology smallResult { values: number[]; converged: boolean; }
+export function computeGeology small(data: number[], opts: Geology smallOptions = {}): Geology smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology small };
diff --git a/src/geology/source_rock.ts b/src/geology/source_rock.ts
new file mode 100644
index 000000000..bcd346808
--- /dev/null
+++ b/src/geology/source_rock.ts
@@ -0,0 +1,22 @@
+/** Source Rock module — tsb analytics library. */
+
+/** Options for Source Rock. */
+export interface SourceRockOptions { tol?: number; maxIter?: number; }
+
+/** Result from Source Rock. */
+export interface SourceRockResult { values: number[]; converged: boolean; }
+
+/** Compute Source Rock. */
+export function computeSourceRock(data: number[], opts: SourceRockOptions = {}): SourceRockResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSourceRock };
diff --git a/src/geology/sparse.ts b/src/geology/sparse.ts
new file mode 100644
index 000000000..313d889e3
--- /dev/null
+++ b/src/geology/sparse.ts
@@ -0,0 +1,15 @@
+/** Geology Sparse module — tsb analytics library. */
+export interface Geology sparseOptions { tol?: number; maxIter?: number; }
+export interface Geology sparseResult { values: number[]; converged: boolean; }
+export function computeGeology sparse(data: number[], opts: Geology sparseOptions = {}): Geology sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology sparse };
diff --git a/src/geology/stable.ts b/src/geology/stable.ts
new file mode 100644
index 000000000..53a7fce1c
--- /dev/null
+++ b/src/geology/stable.ts
@@ -0,0 +1,15 @@
+/** Geology Stable module — tsb analytics library. */
+export interface Geology stableOptions { tol?: number; maxIter?: number; }
+export interface Geology stableResult { values: number[]; converged: boolean; }
+export function computeGeology stable(data: number[], opts: Geology stableOptions = {}): Geology stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology stable };
diff --git a/src/geology/stable_isotope.ts b/src/geology/stable_isotope.ts
new file mode 100644
index 000000000..3ded34d9a
--- /dev/null
+++ b/src/geology/stable_isotope.ts
@@ -0,0 +1,22 @@
+/** Stable Isotope module — tsb analytics library. */
+
+/** Options for Stable Isotope. */
+export interface StableIsotopeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stable Isotope. */
+export interface StableIsotopeResult { values: number[]; converged: boolean; }
+
+/** Compute Stable Isotope. */
+export function computeStableIsotope(data: number[], opts: StableIsotopeOptions = {}): StableIsotopeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStableIsotope };
diff --git a/src/geology/stratigraphy.ts b/src/geology/stratigraphy.ts
new file mode 100644
index 000000000..35371f10e
--- /dev/null
+++ b/src/geology/stratigraphy.ts
@@ -0,0 +1,22 @@
+/** Stratigraphy module — tsb analytics library. */
+
+/** Options for Stratigraphy. */
+export interface StratigraphyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stratigraphy. */
+export interface StratigraphyResult { values: number[]; converged: boolean; }
+
+/** Compute Stratigraphy. */
+export function computeStratigraphy(data: number[], opts: StratigraphyOptions = {}): StratigraphyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStratigraphy };
diff --git a/src/geology/streaming.ts b/src/geology/streaming.ts
new file mode 100644
index 000000000..9ecc7ed79
--- /dev/null
+++ b/src/geology/streaming.ts
@@ -0,0 +1,15 @@
+/** Geology Streaming module — tsb analytics library. */
+export interface Geology streamingOptions { tol?: number; maxIter?: number; }
+export interface Geology streamingResult { values: number[]; converged: boolean; }
+export function computeGeology streaming(data: number[], opts: Geology streamingOptions = {}): Geology streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology streaming };
diff --git a/src/geology/structural.ts b/src/geology/structural.ts
new file mode 100644
index 000000000..71be1bcc7
--- /dev/null
+++ b/src/geology/structural.ts
@@ -0,0 +1,22 @@
+/** Structural module — tsb analytics library. */
+
+/** Options for Structural. */
+export interface StructuralOptions { tol?: number; maxIter?: number; }
+
+/** Result from Structural. */
+export interface StructuralResult { values: number[]; converged: boolean; }
+
+/** Compute Structural. */
+export function computeStructural(data: number[], opts: StructuralOptions = {}): StructuralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStructural };
diff --git a/src/geology/tectonics.ts b/src/geology/tectonics.ts
new file mode 100644
index 000000000..fa276bd7a
--- /dev/null
+++ b/src/geology/tectonics.ts
@@ -0,0 +1,22 @@
+/** Tectonics module — tsb analytics library. */
+
+/** Options for Tectonics. */
+export interface TectonicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tectonics. */
+export interface TectonicsResult { values: number[]; converged: boolean; }
+
+/** Compute Tectonics. */
+export function computeTectonics(data: number[], opts: TectonicsOptions = {}): TectonicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTectonics };
diff --git a/src/geology/thermal_maturation.ts b/src/geology/thermal_maturation.ts
new file mode 100644
index 000000000..b4bec26ef
--- /dev/null
+++ b/src/geology/thermal_maturation.ts
@@ -0,0 +1,22 @@
+/** Thermal Maturation module — tsb analytics library. */
+
+/** Options for Thermal Maturation. */
+export interface ThermalMaturationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Thermal Maturation. */
+export interface ThermalMaturationResult { values: number[]; converged: boolean; }
+
+/** Compute Thermal Maturation. */
+export function computeThermalMaturation(data: number[], opts: ThermalMaturationOptions = {}): ThermalMaturationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeThermalMaturation };
diff --git a/src/geology/thermochronology.ts b/src/geology/thermochronology.ts
new file mode 100644
index 000000000..18773a0ce
--- /dev/null
+++ b/src/geology/thermochronology.ts
@@ -0,0 +1,22 @@
+/** Thermochronology module — tsb analytics library. */
+
+/** Options for Thermochronology. */
+export interface ThermochronologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Thermochronology. */
+export interface ThermochronologyResult { values: number[]; converged: boolean; }
+
+/** Compute Thermochronology. */
+export function computeThermochronology(data: number[], opts: ThermochronologyOptions = {}): ThermochronologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeThermochronology };
diff --git a/src/geology/trace_element.ts b/src/geology/trace_element.ts
new file mode 100644
index 000000000..e645bbb7d
--- /dev/null
+++ b/src/geology/trace_element.ts
@@ -0,0 +1,22 @@
+/** Trace Element module — tsb analytics library. */
+
+/** Options for Trace Element. */
+export interface TraceElementOptions { tol?: number; maxIter?: number; }
+
+/** Result from Trace Element. */
+export interface TraceElementResult { values: number[]; converged: boolean; }
+
+/** Compute Trace Element. */
+export function computeTraceElement(data: number[], opts: TraceElementOptions = {}): TraceElementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTraceElement };
diff --git a/src/geology/trap.ts b/src/geology/trap.ts
new file mode 100644
index 000000000..62510caa0
--- /dev/null
+++ b/src/geology/trap.ts
@@ -0,0 +1,22 @@
+/** Trap module — tsb analytics library. */
+
+/** Options for Trap. */
+export interface TrapOptions { tol?: number; maxIter?: number; }
+
+/** Result from Trap. */
+export interface TrapResult { values: number[]; converged: boolean; }
+
+/** Compute Trap. */
+export function computeTrap(data: number[], opts: TrapOptions = {}): TrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTrap };
diff --git a/src/geology/v2.ts b/src/geology/v2.ts
new file mode 100644
index 000000000..63b0580a1
--- /dev/null
+++ b/src/geology/v2.ts
@@ -0,0 +1,15 @@
+/** Geology V2 module — tsb analytics library. */
+export interface Geology v2Options { tol?: number; maxIter?: number; }
+export interface Geology v2Result { values: number[]; converged: boolean; }
+export function computeGeology v2(data: number[], opts: Geology v2Options = {}): Geology v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology v2 };
diff --git a/src/geology/v3.ts b/src/geology/v3.ts
new file mode 100644
index 000000000..bc560b463
--- /dev/null
+++ b/src/geology/v3.ts
@@ -0,0 +1,15 @@
+/** Geology V3 module — tsb analytics library. */
+export interface Geology v3Options { tol?: number; maxIter?: number; }
+export interface Geology v3Result { values: number[]; converged: boolean; }
+export function computeGeology v3(data: number[], opts: Geology v3Options = {}): Geology v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology v3 };
diff --git a/src/geology/volcanology.ts b/src/geology/volcanology.ts
new file mode 100644
index 000000000..7c32ae45e
--- /dev/null
+++ b/src/geology/volcanology.ts
@@ -0,0 +1,22 @@
+/** Volcanology module — tsb analytics library. */
+
+/** Options for Volcanology. */
+export interface VolcanologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Volcanology. */
+export interface VolcanologyResult { values: number[]; converged: boolean; }
+
+/** Compute Volcanology. */
+export function computeVolcanology(data: number[], opts: VolcanologyOptions = {}): VolcanologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVolcanology };
diff --git a/src/geology/wasm.ts b/src/geology/wasm.ts
new file mode 100644
index 000000000..7eec9d43b
--- /dev/null
+++ b/src/geology/wasm.ts
@@ -0,0 +1,15 @@
+/** Geology Wasm module — tsb analytics library. */
+export interface Geology wasmOptions { tol?: number; maxIter?: number; }
+export interface Geology wasmResult { values: number[]; converged: boolean; }
+export function computeGeology wasm(data: number[], opts: Geology wasmOptions = {}): Geology wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology wasm };
diff --git a/src/geology/xlarge.ts b/src/geology/xlarge.ts
new file mode 100644
index 000000000..790d4d863
--- /dev/null
+++ b/src/geology/xlarge.ts
@@ -0,0 +1,15 @@
+/** Geology Xlarge module — tsb analytics library. */
+export interface Geology xlargeOptions { tol?: number; maxIter?: number; }
+export interface Geology xlargeResult { values: number[]; converged: boolean; }
+export function computeGeology xlarge(data: number[], opts: Geology xlargeOptions = {}): Geology xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeology xlarge };
diff --git a/src/geomechanics/adaptation.ts b/src/geomechanics/adaptation.ts
new file mode 100644
index 000000000..1875a83e7
--- /dev/null
+++ b/src/geomechanics/adaptation.ts
@@ -0,0 +1,14 @@
+/** geomechanics adaptation module — tsb analytics library. */
+export interface GeomechanicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsAdaptation(data: number[], opts: GeomechanicsAdaptationOptions = {}): GeomechanicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsAdaptation };
diff --git a/src/geomechanics/aggregation.ts b/src/geomechanics/aggregation.ts
new file mode 100644
index 000000000..46ef68dcd
--- /dev/null
+++ b/src/geomechanics/aggregation.ts
@@ -0,0 +1,14 @@
+/** geomechanics aggregation module — tsb analytics library. */
+export interface GeomechanicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsAggregationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsAggregation(data: number[], opts: GeomechanicsAggregationOptions = {}): GeomechanicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsAggregation };
diff --git a/src/geomechanics/algebra.ts b/src/geomechanics/algebra.ts
new file mode 100644
index 000000000..fdaf22f0e
--- /dev/null
+++ b/src/geomechanics/algebra.ts
@@ -0,0 +1,14 @@
+/** geomechanics algebra module — tsb analytics library. */
+export interface GeomechanicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsAlgebra(data: number[], opts: GeomechanicsAlgebraOptions = {}): GeomechanicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsAlgebra };
diff --git a/src/geomechanics/alignment.ts b/src/geomechanics/alignment.ts
new file mode 100644
index 000000000..b60da2138
--- /dev/null
+++ b/src/geomechanics/alignment.ts
@@ -0,0 +1,14 @@
+/** geomechanics alignment module — tsb analytics library. */
+export interface GeomechanicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsAlignment(data: number[], opts: GeomechanicsAlignmentOptions = {}): GeomechanicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsAlignment };
diff --git a/src/geomechanics/analysis.ts b/src/geomechanics/analysis.ts
new file mode 100644
index 000000000..23b8f8f75
--- /dev/null
+++ b/src/geomechanics/analysis.ts
@@ -0,0 +1,14 @@
+/** geomechanics analysis module — tsb analytics library. */
+export interface GeomechanicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsAnalysis(data: number[], opts: GeomechanicsAnalysisOptions = {}): GeomechanicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsAnalysis };
diff --git a/src/geomechanics/augmentation.ts b/src/geomechanics/augmentation.ts
new file mode 100644
index 000000000..31effa664
--- /dev/null
+++ b/src/geomechanics/augmentation.ts
@@ -0,0 +1,14 @@
+/** geomechanics augmentation module — tsb analytics library. */
+export interface GeomechanicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsAugmentation(data: number[], opts: GeomechanicsAugmentationOptions = {}): GeomechanicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsAugmentation };
diff --git a/src/geomechanics/bagging.ts b/src/geomechanics/bagging.ts
new file mode 100644
index 000000000..0a424aad7
--- /dev/null
+++ b/src/geomechanics/bagging.ts
@@ -0,0 +1,14 @@
+/** geomechanics bagging module — tsb analytics library. */
+export interface GeomechanicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsBaggingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsBagging(data: number[], opts: GeomechanicsBaggingOptions = {}): GeomechanicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsBagging };
diff --git a/src/geomechanics/basis.ts b/src/geomechanics/basis.ts
new file mode 100644
index 000000000..43ca734fb
--- /dev/null
+++ b/src/geomechanics/basis.ts
@@ -0,0 +1,14 @@
+/** geomechanics basis module — tsb analytics library. */
+export interface GeomechanicsBasisOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsBasisResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsBasis(data: number[], opts: GeomechanicsBasisOptions = {}): GeomechanicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsBasis };
diff --git a/src/geomechanics/benchmarking.ts b/src/geomechanics/benchmarking.ts
new file mode 100644
index 000000000..49b5ebccb
--- /dev/null
+++ b/src/geomechanics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** geomechanics benchmarking module — tsb analytics library. */
+export interface GeomechanicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsBenchmarking(data: number[], opts: GeomechanicsBenchmarkingOptions = {}): GeomechanicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsBenchmarking };
diff --git a/src/geomechanics/blending.ts b/src/geomechanics/blending.ts
new file mode 100644
index 000000000..7069763c0
--- /dev/null
+++ b/src/geomechanics/blending.ts
@@ -0,0 +1,14 @@
+/** geomechanics blending module — tsb analytics library. */
+export interface GeomechanicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsBlendingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsBlending(data: number[], opts: GeomechanicsBlendingOptions = {}): GeomechanicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsBlending };
diff --git a/src/geomechanics/boosting.ts b/src/geomechanics/boosting.ts
new file mode 100644
index 000000000..fc3dc0c7d
--- /dev/null
+++ b/src/geomechanics/boosting.ts
@@ -0,0 +1,14 @@
+/** geomechanics boosting module — tsb analytics library. */
+export interface GeomechanicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsBoostingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsBoosting(data: number[], opts: GeomechanicsBoostingOptions = {}): GeomechanicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsBoosting };
diff --git a/src/geomechanics/bootstrap.ts b/src/geomechanics/bootstrap.ts
new file mode 100644
index 000000000..a12c56ee2
--- /dev/null
+++ b/src/geomechanics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** geomechanics bootstrap module — tsb analytics library. */
+export interface GeomechanicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsBootstrap(data: number[], opts: GeomechanicsBootstrapOptions = {}): GeomechanicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsBootstrap };
diff --git a/src/geomechanics/calculus.ts b/src/geomechanics/calculus.ts
new file mode 100644
index 000000000..4578525be
--- /dev/null
+++ b/src/geomechanics/calculus.ts
@@ -0,0 +1,14 @@
+/** geomechanics calculus module — tsb analytics library. */
+export interface GeomechanicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsCalculusResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsCalculus(data: number[], opts: GeomechanicsCalculusOptions = {}): GeomechanicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsCalculus };
diff --git a/src/geomechanics/calibration.ts b/src/geomechanics/calibration.ts
new file mode 100644
index 000000000..5d674ff43
--- /dev/null
+++ b/src/geomechanics/calibration.ts
@@ -0,0 +1,14 @@
+/** geomechanics calibration module — tsb analytics library. */
+export interface GeomechanicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsCalibration(data: number[], opts: GeomechanicsCalibrationOptions = {}): GeomechanicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsCalibration };
diff --git a/src/geomechanics/characterization.ts b/src/geomechanics/characterization.ts
new file mode 100644
index 000000000..71d4b72d8
--- /dev/null
+++ b/src/geomechanics/characterization.ts
@@ -0,0 +1,14 @@
+/** geomechanics characterization module — tsb analytics library. */
+export interface GeomechanicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsCharacterization(data: number[], opts: GeomechanicsCharacterizationOptions = {}): GeomechanicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsCharacterization };
diff --git a/src/geomechanics/classification.ts b/src/geomechanics/classification.ts
new file mode 100644
index 000000000..6a12a45f3
--- /dev/null
+++ b/src/geomechanics/classification.ts
@@ -0,0 +1,14 @@
+/** geomechanics classification module — tsb analytics library. */
+export interface GeomechanicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsClassificationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsClassification(data: number[], opts: GeomechanicsClassificationOptions = {}): GeomechanicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsClassification };
diff --git a/src/geomechanics/clustering.ts b/src/geomechanics/clustering.ts
new file mode 100644
index 000000000..5eec6fe6c
--- /dev/null
+++ b/src/geomechanics/clustering.ts
@@ -0,0 +1,14 @@
+/** geomechanics clustering module — tsb analytics library. */
+export interface GeomechanicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsClusteringResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsClustering(data: number[], opts: GeomechanicsClusteringOptions = {}): GeomechanicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsClustering };
diff --git a/src/geomechanics/compression.ts b/src/geomechanics/compression.ts
new file mode 100644
index 000000000..60afda640
--- /dev/null
+++ b/src/geomechanics/compression.ts
@@ -0,0 +1,14 @@
+/** geomechanics compression module — tsb analytics library. */
+export interface GeomechanicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsCompressionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsCompression(data: number[], opts: GeomechanicsCompressionOptions = {}): GeomechanicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsCompression };
diff --git a/src/geomechanics/continuous.ts b/src/geomechanics/continuous.ts
new file mode 100644
index 000000000..b20009143
--- /dev/null
+++ b/src/geomechanics/continuous.ts
@@ -0,0 +1,14 @@
+/** geomechanics continuous module — tsb analytics library. */
+export interface GeomechanicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsContinuousResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsContinuous(data: number[], opts: GeomechanicsContinuousOptions = {}): GeomechanicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsContinuous };
diff --git a/src/geomechanics/control.ts b/src/geomechanics/control.ts
new file mode 100644
index 000000000..ba89a31e0
--- /dev/null
+++ b/src/geomechanics/control.ts
@@ -0,0 +1,14 @@
+/** geomechanics control module — tsb analytics library. */
+export interface GeomechanicsControlOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsControlResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsControl(data: number[], opts: GeomechanicsControlOptions = {}): GeomechanicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsControl };
diff --git a/src/geomechanics/convergence.ts b/src/geomechanics/convergence.ts
new file mode 100644
index 000000000..77a7a9d6a
--- /dev/null
+++ b/src/geomechanics/convergence.ts
@@ -0,0 +1,14 @@
+/** geomechanics convergence module — tsb analytics library. */
+export interface GeomechanicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsConvergence(data: number[], opts: GeomechanicsConvergenceOptions = {}): GeomechanicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsConvergence };
diff --git a/src/geomechanics/convex.ts b/src/geomechanics/convex.ts
new file mode 100644
index 000000000..713edf4bf
--- /dev/null
+++ b/src/geomechanics/convex.ts
@@ -0,0 +1,14 @@
+/** geomechanics convex module — tsb analytics library. */
+export interface GeomechanicsConvexOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsConvexResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsConvex(data: number[], opts: GeomechanicsConvexOptions = {}): GeomechanicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsConvex };
diff --git a/src/geomechanics/correlation.ts b/src/geomechanics/correlation.ts
new file mode 100644
index 000000000..cd374f486
--- /dev/null
+++ b/src/geomechanics/correlation.ts
@@ -0,0 +1,14 @@
+/** geomechanics correlation module — tsb analytics library. */
+export interface GeomechanicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsCorrelation(data: number[], opts: GeomechanicsCorrelationOptions = {}): GeomechanicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsCorrelation };
diff --git a/src/geomechanics/covariance.ts b/src/geomechanics/covariance.ts
new file mode 100644
index 000000000..0cdd1e78b
--- /dev/null
+++ b/src/geomechanics/covariance.ts
@@ -0,0 +1,14 @@
+/** geomechanics covariance module — tsb analytics library. */
+export interface GeomechanicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsCovariance(data: number[], opts: GeomechanicsCovarianceOptions = {}): GeomechanicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsCovariance };
diff --git a/src/geomechanics/cross_validation.ts b/src/geomechanics/cross_validation.ts
new file mode 100644
index 000000000..1c37252ff
--- /dev/null
+++ b/src/geomechanics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** geomechanics cross_validation module — tsb analytics library. */
+export interface GeomechanicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsCrossValidation(data: number[], opts: GeomechanicsCrossValidationOptions = {}): GeomechanicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsCrossValidation };
diff --git a/src/geomechanics/decoding.ts b/src/geomechanics/decoding.ts
new file mode 100644
index 000000000..76281d017
--- /dev/null
+++ b/src/geomechanics/decoding.ts
@@ -0,0 +1,14 @@
+/** geomechanics decoding module — tsb analytics library. */
+export interface GeomechanicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDecodingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDecoding(data: number[], opts: GeomechanicsDecodingOptions = {}): GeomechanicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDecoding };
diff --git a/src/geomechanics/decomposition.ts b/src/geomechanics/decomposition.ts
new file mode 100644
index 000000000..d72b85ec7
--- /dev/null
+++ b/src/geomechanics/decomposition.ts
@@ -0,0 +1,14 @@
+/** geomechanics decomposition module — tsb analytics library. */
+export interface GeomechanicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDecomposition(data: number[], opts: GeomechanicsDecompositionOptions = {}): GeomechanicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDecomposition };
diff --git a/src/geomechanics/detection.ts b/src/geomechanics/detection.ts
new file mode 100644
index 000000000..bcec044f6
--- /dev/null
+++ b/src/geomechanics/detection.ts
@@ -0,0 +1,14 @@
+/** geomechanics detection module — tsb analytics library. */
+export interface GeomechanicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDetectionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDetection(data: number[], opts: GeomechanicsDetectionOptions = {}): GeomechanicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDetection };
diff --git a/src/geomechanics/deterministic.ts b/src/geomechanics/deterministic.ts
new file mode 100644
index 000000000..7bf11fa9e
--- /dev/null
+++ b/src/geomechanics/deterministic.ts
@@ -0,0 +1,14 @@
+/** geomechanics deterministic module — tsb analytics library. */
+export interface GeomechanicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDeterministic(data: number[], opts: GeomechanicsDeterministicOptions = {}): GeomechanicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDeterministic };
diff --git a/src/geomechanics/diagnostics.ts b/src/geomechanics/diagnostics.ts
new file mode 100644
index 000000000..82c8dda89
--- /dev/null
+++ b/src/geomechanics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** geomechanics diagnostics module — tsb analytics library. */
+export interface GeomechanicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDiagnostics(data: number[], opts: GeomechanicsDiagnosticsOptions = {}): GeomechanicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDiagnostics };
diff --git a/src/geomechanics/differential.ts b/src/geomechanics/differential.ts
new file mode 100644
index 000000000..12ca028e3
--- /dev/null
+++ b/src/geomechanics/differential.ts
@@ -0,0 +1,14 @@
+/** geomechanics differential module — tsb analytics library. */
+export interface GeomechanicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDifferential(data: number[], opts: GeomechanicsDifferentialOptions = {}): GeomechanicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDifferential };
diff --git a/src/geomechanics/discrete.ts b/src/geomechanics/discrete.ts
new file mode 100644
index 000000000..00de58fcb
--- /dev/null
+++ b/src/geomechanics/discrete.ts
@@ -0,0 +1,14 @@
+/** geomechanics discrete module — tsb analytics library. */
+export interface GeomechanicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDiscrete(data: number[], opts: GeomechanicsDiscreteOptions = {}): GeomechanicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDiscrete };
diff --git a/src/geomechanics/distribution.ts b/src/geomechanics/distribution.ts
new file mode 100644
index 000000000..ebf96b497
--- /dev/null
+++ b/src/geomechanics/distribution.ts
@@ -0,0 +1,14 @@
+/** geomechanics distribution module — tsb analytics library. */
+export interface GeomechanicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDistributionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDistribution(data: number[], opts: GeomechanicsDistributionOptions = {}): GeomechanicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDistribution };
diff --git a/src/geomechanics/dynamic.ts b/src/geomechanics/dynamic.ts
new file mode 100644
index 000000000..6b344f162
--- /dev/null
+++ b/src/geomechanics/dynamic.ts
@@ -0,0 +1,14 @@
+/** geomechanics dynamic module — tsb analytics library. */
+export interface GeomechanicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsDynamicResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsDynamic(data: number[], opts: GeomechanicsDynamicOptions = {}): GeomechanicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsDynamic };
diff --git a/src/geomechanics/embedding.ts b/src/geomechanics/embedding.ts
new file mode 100644
index 000000000..036f1f2ad
--- /dev/null
+++ b/src/geomechanics/embedding.ts
@@ -0,0 +1,14 @@
+/** geomechanics embedding module — tsb analytics library. */
+export interface GeomechanicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsEmbedding(data: number[], opts: GeomechanicsEmbeddingOptions = {}): GeomechanicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsEmbedding };
diff --git a/src/geomechanics/encoding.ts b/src/geomechanics/encoding.ts
new file mode 100644
index 000000000..ca8c37c0b
--- /dev/null
+++ b/src/geomechanics/encoding.ts
@@ -0,0 +1,14 @@
+/** geomechanics encoding module — tsb analytics library. */
+export interface GeomechanicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsEncodingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsEncoding(data: number[], opts: GeomechanicsEncodingOptions = {}): GeomechanicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsEncoding };
diff --git a/src/geomechanics/ensemble.ts b/src/geomechanics/ensemble.ts
new file mode 100644
index 000000000..94430db9b
--- /dev/null
+++ b/src/geomechanics/ensemble.ts
@@ -0,0 +1,14 @@
+/** geomechanics ensemble module — tsb analytics library. */
+export interface GeomechanicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsEnsemble(data: number[], opts: GeomechanicsEnsembleOptions = {}): GeomechanicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsEnsemble };
diff --git a/src/geomechanics/estimation.ts b/src/geomechanics/estimation.ts
new file mode 100644
index 000000000..5f36f112c
--- /dev/null
+++ b/src/geomechanics/estimation.ts
@@ -0,0 +1,14 @@
+/** geomechanics estimation module — tsb analytics library. */
+export interface GeomechanicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsEstimationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsEstimation(data: number[], opts: GeomechanicsEstimationOptions = {}): GeomechanicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsEstimation };
diff --git a/src/geomechanics/evaluation.ts b/src/geomechanics/evaluation.ts
new file mode 100644
index 000000000..094389eca
--- /dev/null
+++ b/src/geomechanics/evaluation.ts
@@ -0,0 +1,14 @@
+/** geomechanics evaluation module — tsb analytics library. */
+export interface GeomechanicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsEvaluation(data: number[], opts: GeomechanicsEvaluationOptions = {}): GeomechanicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsEvaluation };
diff --git a/src/geomechanics/extrapolation.ts b/src/geomechanics/extrapolation.ts
new file mode 100644
index 000000000..567075d15
--- /dev/null
+++ b/src/geomechanics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** geomechanics extrapolation module — tsb analytics library. */
+export interface GeomechanicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsExtrapolation(data: number[], opts: GeomechanicsExtrapolationOptions = {}): GeomechanicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsExtrapolation };
diff --git a/src/geomechanics/features.ts b/src/geomechanics/features.ts
new file mode 100644
index 000000000..100602ce0
--- /dev/null
+++ b/src/geomechanics/features.ts
@@ -0,0 +1,14 @@
+/** geomechanics features module — tsb analytics library. */
+export interface GeomechanicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsFeatures(data: number[], opts: GeomechanicsFeaturesOptions = {}): GeomechanicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsFeatures };
diff --git a/src/geomechanics/feedback.ts b/src/geomechanics/feedback.ts
new file mode 100644
index 000000000..822cf5e6b
--- /dev/null
+++ b/src/geomechanics/feedback.ts
@@ -0,0 +1,14 @@
+/** geomechanics feedback module — tsb analytics library. */
+export interface GeomechanicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsFeedback(data: number[], opts: GeomechanicsFeedbackOptions = {}): GeomechanicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsFeedback };
diff --git a/src/geomechanics/filtering.ts b/src/geomechanics/filtering.ts
new file mode 100644
index 000000000..6c80fd22d
--- /dev/null
+++ b/src/geomechanics/filtering.ts
@@ -0,0 +1,14 @@
+/** geomechanics filtering module — tsb analytics library. */
+export interface GeomechanicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsFilteringResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsFiltering(data: number[], opts: GeomechanicsFilteringOptions = {}): GeomechanicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsFiltering };
diff --git a/src/geomechanics/fourier.ts b/src/geomechanics/fourier.ts
new file mode 100644
index 000000000..99401684e
--- /dev/null
+++ b/src/geomechanics/fourier.ts
@@ -0,0 +1,14 @@
+/** geomechanics fourier module — tsb analytics library. */
+export interface GeomechanicsFourierOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsFourierResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsFourier(data: number[], opts: GeomechanicsFourierOptions = {}): GeomechanicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsFourier };
diff --git a/src/geomechanics/fusion.ts b/src/geomechanics/fusion.ts
new file mode 100644
index 000000000..f2efb0c09
--- /dev/null
+++ b/src/geomechanics/fusion.ts
@@ -0,0 +1,14 @@
+/** geomechanics fusion module — tsb analytics library. */
+export interface GeomechanicsFusionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsFusionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsFusion(data: number[], opts: GeomechanicsFusionOptions = {}): GeomechanicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsFusion };
diff --git a/src/geomechanics/generation.ts b/src/geomechanics/generation.ts
new file mode 100644
index 000000000..648e8be13
--- /dev/null
+++ b/src/geomechanics/generation.ts
@@ -0,0 +1,14 @@
+/** geomechanics generation module — tsb analytics library. */
+export interface GeomechanicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsGenerationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsGeneration(data: number[], opts: GeomechanicsGenerationOptions = {}): GeomechanicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsGeneration };
diff --git a/src/geomechanics/geometry.ts b/src/geomechanics/geometry.ts
new file mode 100644
index 000000000..75ee3651e
--- /dev/null
+++ b/src/geomechanics/geometry.ts
@@ -0,0 +1,14 @@
+/** geomechanics geometry module — tsb analytics library. */
+export interface GeomechanicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsGeometryResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsGeometry(data: number[], opts: GeomechanicsGeometryOptions = {}): GeomechanicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsGeometry };
diff --git a/src/geomechanics/gradient.ts b/src/geomechanics/gradient.ts
new file mode 100644
index 000000000..b08860aa3
--- /dev/null
+++ b/src/geomechanics/gradient.ts
@@ -0,0 +1,14 @@
+/** geomechanics gradient module — tsb analytics library. */
+export interface GeomechanicsGradientOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsGradientResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsGradient(data: number[], opts: GeomechanicsGradientOptions = {}): GeomechanicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsGradient };
diff --git a/src/geomechanics/hessian.ts b/src/geomechanics/hessian.ts
new file mode 100644
index 000000000..d65eb457e
--- /dev/null
+++ b/src/geomechanics/hessian.ts
@@ -0,0 +1,14 @@
+/** geomechanics hessian module — tsb analytics library. */
+export interface GeomechanicsHessianOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsHessianResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsHessian(data: number[], opts: GeomechanicsHessianOptions = {}): GeomechanicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsHessian };
diff --git a/src/geomechanics/hypothesis.ts b/src/geomechanics/hypothesis.ts
new file mode 100644
index 000000000..4f0be162b
--- /dev/null
+++ b/src/geomechanics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** geomechanics hypothesis module — tsb analytics library. */
+export interface GeomechanicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsHypothesis(data: number[], opts: GeomechanicsHypothesisOptions = {}): GeomechanicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsHypothesis };
diff --git a/src/geomechanics/inference.ts b/src/geomechanics/inference.ts
new file mode 100644
index 000000000..affc0887c
--- /dev/null
+++ b/src/geomechanics/inference.ts
@@ -0,0 +1,14 @@
+/** geomechanics inference module — tsb analytics library. */
+export interface GeomechanicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsInferenceResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsInference(data: number[], opts: GeomechanicsInferenceOptions = {}): GeomechanicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsInference };
diff --git a/src/geomechanics/inference2.ts b/src/geomechanics/inference2.ts
new file mode 100644
index 000000000..fefbc365d
--- /dev/null
+++ b/src/geomechanics/inference2.ts
@@ -0,0 +1,14 @@
+/** geomechanics inference2 module — tsb analytics library. */
+export interface GeomechanicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsInferenceResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsInference(data: number[], opts: GeomechanicsInferenceOptions = {}): GeomechanicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsInference };
diff --git a/src/geomechanics/integral.ts b/src/geomechanics/integral.ts
new file mode 100644
index 000000000..e2e9baecd
--- /dev/null
+++ b/src/geomechanics/integral.ts
@@ -0,0 +1,14 @@
+/** geomechanics integral module — tsb analytics library. */
+export interface GeomechanicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsIntegralResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsIntegral(data: number[], opts: GeomechanicsIntegralOptions = {}): GeomechanicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsIntegral };
diff --git a/src/geomechanics/integration.ts b/src/geomechanics/integration.ts
new file mode 100644
index 000000000..205e31c70
--- /dev/null
+++ b/src/geomechanics/integration.ts
@@ -0,0 +1,14 @@
+/** geomechanics integration module — tsb analytics library. */
+export interface GeomechanicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsIntegration(data: number[], opts: GeomechanicsIntegrationOptions = {}): GeomechanicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsIntegration };
diff --git a/src/geomechanics/interpolation.ts b/src/geomechanics/interpolation.ts
new file mode 100644
index 000000000..66d554018
--- /dev/null
+++ b/src/geomechanics/interpolation.ts
@@ -0,0 +1,14 @@
+/** geomechanics interpolation module — tsb analytics library. */
+export interface GeomechanicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsInterpolation(data: number[], opts: GeomechanicsInterpolationOptions = {}): GeomechanicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsInterpolation };
diff --git a/src/geomechanics/jacobian.ts b/src/geomechanics/jacobian.ts
new file mode 100644
index 000000000..cc1c8f405
--- /dev/null
+++ b/src/geomechanics/jacobian.ts
@@ -0,0 +1,14 @@
+/** geomechanics jacobian module — tsb analytics library. */
+export interface GeomechanicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsJacobianResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsJacobian(data: number[], opts: GeomechanicsJacobianOptions = {}): GeomechanicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsJacobian };
diff --git a/src/geomechanics/kernel.ts b/src/geomechanics/kernel.ts
new file mode 100644
index 000000000..06c890448
--- /dev/null
+++ b/src/geomechanics/kernel.ts
@@ -0,0 +1,14 @@
+/** geomechanics kernel module — tsb analytics library. */
+export interface GeomechanicsKernelOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsKernelResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsKernel(data: number[], opts: GeomechanicsKernelOptions = {}): GeomechanicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsKernel };
diff --git a/src/geomechanics/laplacian.ts b/src/geomechanics/laplacian.ts
new file mode 100644
index 000000000..5a0305a5f
--- /dev/null
+++ b/src/geomechanics/laplacian.ts
@@ -0,0 +1,14 @@
+/** geomechanics laplacian module — tsb analytics library. */
+export interface GeomechanicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsLaplacian(data: number[], opts: GeomechanicsLaplacianOptions = {}): GeomechanicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsLaplacian };
diff --git a/src/geomechanics/learning.ts b/src/geomechanics/learning.ts
new file mode 100644
index 000000000..2476bf8e6
--- /dev/null
+++ b/src/geomechanics/learning.ts
@@ -0,0 +1,14 @@
+/** geomechanics learning module — tsb analytics library. */
+export interface GeomechanicsLearningOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsLearningResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsLearning(data: number[], opts: GeomechanicsLearningOptions = {}): GeomechanicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsLearning };
diff --git a/src/geomechanics/linear.ts b/src/geomechanics/linear.ts
new file mode 100644
index 000000000..fad6075cd
--- /dev/null
+++ b/src/geomechanics/linear.ts
@@ -0,0 +1,14 @@
+/** geomechanics linear module — tsb analytics library. */
+export interface GeomechanicsLinearOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsLinearResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsLinear(data: number[], opts: GeomechanicsLinearOptions = {}): GeomechanicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsLinear };
diff --git a/src/geomechanics/manifold.ts b/src/geomechanics/manifold.ts
new file mode 100644
index 000000000..b569a5f94
--- /dev/null
+++ b/src/geomechanics/manifold.ts
@@ -0,0 +1,14 @@
+/** geomechanics manifold module — tsb analytics library. */
+export interface GeomechanicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsManifoldResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsManifold(data: number[], opts: GeomechanicsManifoldOptions = {}): GeomechanicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsManifold };
diff --git a/src/geomechanics/matching.ts b/src/geomechanics/matching.ts
new file mode 100644
index 000000000..72467f865
--- /dev/null
+++ b/src/geomechanics/matching.ts
@@ -0,0 +1,14 @@
+/** geomechanics matching module — tsb analytics library. */
+export interface GeomechanicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsMatchingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsMatching(data: number[], opts: GeomechanicsMatchingOptions = {}): GeomechanicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsMatching };
diff --git a/src/geomechanics/measurement.ts b/src/geomechanics/measurement.ts
new file mode 100644
index 000000000..ab2a97dd8
--- /dev/null
+++ b/src/geomechanics/measurement.ts
@@ -0,0 +1,14 @@
+/** geomechanics measurement module — tsb analytics library. */
+export interface GeomechanicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsMeasurement(data: number[], opts: GeomechanicsMeasurementOptions = {}): GeomechanicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsMeasurement };
diff --git a/src/geomechanics/metrics.ts b/src/geomechanics/metrics.ts
new file mode 100644
index 000000000..794bf66cd
--- /dev/null
+++ b/src/geomechanics/metrics.ts
@@ -0,0 +1,14 @@
+/** geomechanics metrics module — tsb analytics library. */
+export interface GeomechanicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsMetricsResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsMetrics(data: number[], opts: GeomechanicsMetricsOptions = {}): GeomechanicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsMetrics };
diff --git a/src/geomechanics/modeling.ts b/src/geomechanics/modeling.ts
new file mode 100644
index 000000000..455e53fdb
--- /dev/null
+++ b/src/geomechanics/modeling.ts
@@ -0,0 +1,14 @@
+/** geomechanics modeling module — tsb analytics library. */
+export interface GeomechanicsModelingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsModelingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsModeling(data: number[], opts: GeomechanicsModelingOptions = {}): GeomechanicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsModeling };
diff --git a/src/geomechanics/monitoring.ts b/src/geomechanics/monitoring.ts
new file mode 100644
index 000000000..a20210696
--- /dev/null
+++ b/src/geomechanics/monitoring.ts
@@ -0,0 +1,14 @@
+/** geomechanics monitoring module — tsb analytics library. */
+export interface GeomechanicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsMonitoring(data: number[], opts: GeomechanicsMonitoringOptions = {}): GeomechanicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsMonitoring };
diff --git a/src/geomechanics/nonlinear.ts b/src/geomechanics/nonlinear.ts
new file mode 100644
index 000000000..f68e3e555
--- /dev/null
+++ b/src/geomechanics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** geomechanics nonlinear module — tsb analytics library. */
+export interface GeomechanicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsNonlinear(data: number[], opts: GeomechanicsNonlinearOptions = {}): GeomechanicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsNonlinear };
diff --git a/src/geomechanics/normalization.ts b/src/geomechanics/normalization.ts
new file mode 100644
index 000000000..bccbad570
--- /dev/null
+++ b/src/geomechanics/normalization.ts
@@ -0,0 +1,14 @@
+/** geomechanics normalization module — tsb analytics library. */
+export interface GeomechanicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsNormalization(data: number[], opts: GeomechanicsNormalizationOptions = {}): GeomechanicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsNormalization };
diff --git a/src/geomechanics/optimization.ts b/src/geomechanics/optimization.ts
new file mode 100644
index 000000000..b78768106
--- /dev/null
+++ b/src/geomechanics/optimization.ts
@@ -0,0 +1,14 @@
+/** geomechanics optimization module — tsb analytics library. */
+export interface GeomechanicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsOptimization(data: number[], opts: GeomechanicsOptimizationOptions = {}): GeomechanicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsOptimization };
diff --git a/src/geomechanics/patterns.ts b/src/geomechanics/patterns.ts
new file mode 100644
index 000000000..ce87f099d
--- /dev/null
+++ b/src/geomechanics/patterns.ts
@@ -0,0 +1,14 @@
+/** geomechanics patterns module — tsb analytics library. */
+export interface GeomechanicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsPatternsResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsPatterns(data: number[], opts: GeomechanicsPatternsOptions = {}): GeomechanicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsPatterns };
diff --git a/src/geomechanics/permutation.ts b/src/geomechanics/permutation.ts
new file mode 100644
index 000000000..24419dca4
--- /dev/null
+++ b/src/geomechanics/permutation.ts
@@ -0,0 +1,14 @@
+/** geomechanics permutation module — tsb analytics library. */
+export interface GeomechanicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsPermutationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsPermutation(data: number[], opts: GeomechanicsPermutationOptions = {}): GeomechanicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsPermutation };
diff --git a/src/geomechanics/prediction.ts b/src/geomechanics/prediction.ts
new file mode 100644
index 000000000..2a22edb77
--- /dev/null
+++ b/src/geomechanics/prediction.ts
@@ -0,0 +1,14 @@
+/** geomechanics prediction module — tsb analytics library. */
+export interface GeomechanicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsPredictionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsPrediction(data: number[], opts: GeomechanicsPredictionOptions = {}): GeomechanicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsPrediction };
diff --git a/src/geomechanics/processing.ts b/src/geomechanics/processing.ts
new file mode 100644
index 000000000..0bc4e978a
--- /dev/null
+++ b/src/geomechanics/processing.ts
@@ -0,0 +1,14 @@
+/** geomechanics processing module — tsb analytics library. */
+export interface GeomechanicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsProcessingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsProcessing(data: number[], opts: GeomechanicsProcessingOptions = {}): GeomechanicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsProcessing };
diff --git a/src/geomechanics/profiling.ts b/src/geomechanics/profiling.ts
new file mode 100644
index 000000000..b6ed80755
--- /dev/null
+++ b/src/geomechanics/profiling.ts
@@ -0,0 +1,14 @@
+/** geomechanics profiling module — tsb analytics library. */
+export interface GeomechanicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsProfilingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsProfiling(data: number[], opts: GeomechanicsProfilingOptions = {}): GeomechanicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsProfiling };
diff --git a/src/geomechanics/projection.ts b/src/geomechanics/projection.ts
new file mode 100644
index 000000000..d637411eb
--- /dev/null
+++ b/src/geomechanics/projection.ts
@@ -0,0 +1,14 @@
+/** geomechanics projection module — tsb analytics library. */
+export interface GeomechanicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsProjectionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsProjection(data: number[], opts: GeomechanicsProjectionOptions = {}): GeomechanicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsProjection };
diff --git a/src/geomechanics/ranking.ts b/src/geomechanics/ranking.ts
new file mode 100644
index 000000000..0ddbcfd3d
--- /dev/null
+++ b/src/geomechanics/ranking.ts
@@ -0,0 +1,14 @@
+/** geomechanics ranking module — tsb analytics library. */
+export interface GeomechanicsRankingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsRankingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsRanking(data: number[], opts: GeomechanicsRankingOptions = {}): GeomechanicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsRanking };
diff --git a/src/geomechanics/reconstruction.ts b/src/geomechanics/reconstruction.ts
new file mode 100644
index 000000000..76cc70928
--- /dev/null
+++ b/src/geomechanics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** geomechanics reconstruction module — tsb analytics library. */
+export interface GeomechanicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsReconstruction(data: number[], opts: GeomechanicsReconstructionOptions = {}): GeomechanicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsReconstruction };
diff --git a/src/geomechanics/registration.ts b/src/geomechanics/registration.ts
new file mode 100644
index 000000000..02deb4d12
--- /dev/null
+++ b/src/geomechanics/registration.ts
@@ -0,0 +1,14 @@
+/** geomechanics registration module — tsb analytics library. */
+export interface GeomechanicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsRegistration(data: number[], opts: GeomechanicsRegistrationOptions = {}): GeomechanicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsRegistration };
diff --git a/src/geomechanics/regression.ts b/src/geomechanics/regression.ts
new file mode 100644
index 000000000..7a863f110
--- /dev/null
+++ b/src/geomechanics/regression.ts
@@ -0,0 +1,14 @@
+/** geomechanics regression module — tsb analytics library. */
+export interface GeomechanicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsRegressionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsRegression(data: number[], opts: GeomechanicsRegressionOptions = {}): GeomechanicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsRegression };
diff --git a/src/geomechanics/regularization.ts b/src/geomechanics/regularization.ts
new file mode 100644
index 000000000..cf2a316b6
--- /dev/null
+++ b/src/geomechanics/regularization.ts
@@ -0,0 +1,14 @@
+/** geomechanics regularization module — tsb analytics library. */
+export interface GeomechanicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsRegularization(data: number[], opts: GeomechanicsRegularizationOptions = {}): GeomechanicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsRegularization };
diff --git a/src/geomechanics/robustness.ts b/src/geomechanics/robustness.ts
new file mode 100644
index 000000000..d4032c308
--- /dev/null
+++ b/src/geomechanics/robustness.ts
@@ -0,0 +1,14 @@
+/** geomechanics robustness module — tsb analytics library. */
+export interface GeomechanicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsRobustness(data: number[], opts: GeomechanicsRobustnessOptions = {}): GeomechanicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsRobustness };
diff --git a/src/geomechanics/sampling.ts b/src/geomechanics/sampling.ts
new file mode 100644
index 000000000..c7e5d741e
--- /dev/null
+++ b/src/geomechanics/sampling.ts
@@ -0,0 +1,14 @@
+/** geomechanics sampling module — tsb analytics library. */
+export interface GeomechanicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsSamplingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsSampling(data: number[], opts: GeomechanicsSamplingOptions = {}): GeomechanicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsSampling };
diff --git a/src/geomechanics/sampling2.ts b/src/geomechanics/sampling2.ts
new file mode 100644
index 000000000..bfc76b72b
--- /dev/null
+++ b/src/geomechanics/sampling2.ts
@@ -0,0 +1,14 @@
+/** geomechanics sampling2 module — tsb analytics library. */
+export interface GeomechanicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsSamplingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsSampling(data: number[], opts: GeomechanicsSamplingOptions = {}): GeomechanicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsSampling };
diff --git a/src/geomechanics/scaling.ts b/src/geomechanics/scaling.ts
new file mode 100644
index 000000000..3037f2057
--- /dev/null
+++ b/src/geomechanics/scaling.ts
@@ -0,0 +1,14 @@
+/** geomechanics scaling module — tsb analytics library. */
+export interface GeomechanicsScalingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsScalingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsScaling(data: number[], opts: GeomechanicsScalingOptions = {}): GeomechanicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsScaling };
diff --git a/src/geomechanics/scoring.ts b/src/geomechanics/scoring.ts
new file mode 100644
index 000000000..95c927541
--- /dev/null
+++ b/src/geomechanics/scoring.ts
@@ -0,0 +1,14 @@
+/** geomechanics scoring module — tsb analytics library. */
+export interface GeomechanicsScoringOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsScoringResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsScoring(data: number[], opts: GeomechanicsScoringOptions = {}): GeomechanicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsScoring };
diff --git a/src/geomechanics/segmentation.ts b/src/geomechanics/segmentation.ts
new file mode 100644
index 000000000..44d908cac
--- /dev/null
+++ b/src/geomechanics/segmentation.ts
@@ -0,0 +1,14 @@
+/** geomechanics segmentation module — tsb analytics library. */
+export interface GeomechanicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsSegmentation(data: number[], opts: GeomechanicsSegmentationOptions = {}): GeomechanicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsSegmentation };
diff --git a/src/geomechanics/selection.ts b/src/geomechanics/selection.ts
new file mode 100644
index 000000000..25240d9bb
--- /dev/null
+++ b/src/geomechanics/selection.ts
@@ -0,0 +1,14 @@
+/** geomechanics selection module — tsb analytics library. */
+export interface GeomechanicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsSelectionResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsSelection(data: number[], opts: GeomechanicsSelectionOptions = {}): GeomechanicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsSelection };
diff --git a/src/geomechanics/sensitivity.ts b/src/geomechanics/sensitivity.ts
new file mode 100644
index 000000000..4180dc52f
--- /dev/null
+++ b/src/geomechanics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** geomechanics sensitivity module — tsb analytics library. */
+export interface GeomechanicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsSensitivity(data: number[], opts: GeomechanicsSensitivityOptions = {}): GeomechanicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsSensitivity };
diff --git a/src/geomechanics/simulation.ts b/src/geomechanics/simulation.ts
new file mode 100644
index 000000000..48545d865
--- /dev/null
+++ b/src/geomechanics/simulation.ts
@@ -0,0 +1,14 @@
+/** geomechanics simulation module — tsb analytics library. */
+export interface GeomechanicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsSimulationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsSimulation(data: number[], opts: GeomechanicsSimulationOptions = {}): GeomechanicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsSimulation };
diff --git a/src/geomechanics/smoothing.ts b/src/geomechanics/smoothing.ts
new file mode 100644
index 000000000..9cca13b2b
--- /dev/null
+++ b/src/geomechanics/smoothing.ts
@@ -0,0 +1,14 @@
+/** geomechanics smoothing module — tsb analytics library. */
+export interface GeomechanicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsSmoothing(data: number[], opts: GeomechanicsSmoothingOptions = {}): GeomechanicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsSmoothing };
diff --git a/src/geomechanics/stability.ts b/src/geomechanics/stability.ts
new file mode 100644
index 000000000..56f8c9fdf
--- /dev/null
+++ b/src/geomechanics/stability.ts
@@ -0,0 +1,14 @@
+/** geomechanics stability module — tsb analytics library. */
+export interface GeomechanicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsStabilityResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsStability(data: number[], opts: GeomechanicsStabilityOptions = {}): GeomechanicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsStability };
diff --git a/src/geomechanics/stacking.ts b/src/geomechanics/stacking.ts
new file mode 100644
index 000000000..b3ee95712
--- /dev/null
+++ b/src/geomechanics/stacking.ts
@@ -0,0 +1,14 @@
+/** geomechanics stacking module — tsb analytics library. */
+export interface GeomechanicsStackingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsStackingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsStacking(data: number[], opts: GeomechanicsStackingOptions = {}): GeomechanicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsStacking };
diff --git a/src/geomechanics/standardization.ts b/src/geomechanics/standardization.ts
new file mode 100644
index 000000000..11292ddb7
--- /dev/null
+++ b/src/geomechanics/standardization.ts
@@ -0,0 +1,14 @@
+/** geomechanics standardization module — tsb analytics library. */
+export interface GeomechanicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsStandardization(data: number[], opts: GeomechanicsStandardizationOptions = {}): GeomechanicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsStandardization };
diff --git a/src/geomechanics/static.ts b/src/geomechanics/static.ts
new file mode 100644
index 000000000..d03645993
--- /dev/null
+++ b/src/geomechanics/static.ts
@@ -0,0 +1,14 @@
+/** geomechanics static module — tsb analytics library. */
+export interface GeomechanicsStaticOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsStaticResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsStatic(data: number[], opts: GeomechanicsStaticOptions = {}): GeomechanicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsStatic };
diff --git a/src/geomechanics/stochastic.ts b/src/geomechanics/stochastic.ts
new file mode 100644
index 000000000..754265b1c
--- /dev/null
+++ b/src/geomechanics/stochastic.ts
@@ -0,0 +1,14 @@
+/** geomechanics stochastic module — tsb analytics library. */
+export interface GeomechanicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsStochasticResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsStochastic(data: number[], opts: GeomechanicsStochasticOptions = {}): GeomechanicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsStochastic };
diff --git a/src/geomechanics/synthesis.ts b/src/geomechanics/synthesis.ts
new file mode 100644
index 000000000..56fd66cbc
--- /dev/null
+++ b/src/geomechanics/synthesis.ts
@@ -0,0 +1,14 @@
+/** geomechanics synthesis module — tsb analytics library. */
+export interface GeomechanicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsSynthesis(data: number[], opts: GeomechanicsSynthesisOptions = {}): GeomechanicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsSynthesis };
diff --git a/src/geomechanics/topology.ts b/src/geomechanics/topology.ts
new file mode 100644
index 000000000..53e991405
--- /dev/null
+++ b/src/geomechanics/topology.ts
@@ -0,0 +1,14 @@
+/** geomechanics topology module — tsb analytics library. */
+export interface GeomechanicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsTopologyResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsTopology(data: number[], opts: GeomechanicsTopologyOptions = {}): GeomechanicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsTopology };
diff --git a/src/geomechanics/tracking.ts b/src/geomechanics/tracking.ts
new file mode 100644
index 000000000..98b62c0af
--- /dev/null
+++ b/src/geomechanics/tracking.ts
@@ -0,0 +1,14 @@
+/** geomechanics tracking module — tsb analytics library. */
+export interface GeomechanicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsTrackingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsTracking(data: number[], opts: GeomechanicsTrackingOptions = {}): GeomechanicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsTracking };
diff --git a/src/geomechanics/transform.ts b/src/geomechanics/transform.ts
new file mode 100644
index 000000000..97440153d
--- /dev/null
+++ b/src/geomechanics/transform.ts
@@ -0,0 +1,14 @@
+/** geomechanics transform module — tsb analytics library. */
+export interface GeomechanicsTransformOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsTransformResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsTransform(data: number[], opts: GeomechanicsTransformOptions = {}): GeomechanicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsTransform };
diff --git a/src/geomechanics/uncertainty.ts b/src/geomechanics/uncertainty.ts
new file mode 100644
index 000000000..552217324
--- /dev/null
+++ b/src/geomechanics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** geomechanics uncertainty module — tsb analytics library. */
+export interface GeomechanicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsUncertainty(data: number[], opts: GeomechanicsUncertaintyOptions = {}): GeomechanicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsUncertainty };
diff --git a/src/geomechanics/validation.ts b/src/geomechanics/validation.ts
new file mode 100644
index 000000000..7ad54ea9c
--- /dev/null
+++ b/src/geomechanics/validation.ts
@@ -0,0 +1,14 @@
+/** geomechanics validation module — tsb analytics library. */
+export interface GeomechanicsValidationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsValidationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsValidation(data: number[], opts: GeomechanicsValidationOptions = {}): GeomechanicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsValidation };
diff --git a/src/geomechanics/verification.ts b/src/geomechanics/verification.ts
new file mode 100644
index 000000000..d5b8dff2e
--- /dev/null
+++ b/src/geomechanics/verification.ts
@@ -0,0 +1,14 @@
+/** geomechanics verification module — tsb analytics library. */
+export interface GeomechanicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsVerificationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsVerification(data: number[], opts: GeomechanicsVerificationOptions = {}): GeomechanicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsVerification };
diff --git a/src/geomechanics/visualization.ts b/src/geomechanics/visualization.ts
new file mode 100644
index 000000000..ee473a809
--- /dev/null
+++ b/src/geomechanics/visualization.ts
@@ -0,0 +1,14 @@
+/** geomechanics visualization module — tsb analytics library. */
+export interface GeomechanicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsVisualization(data: number[], opts: GeomechanicsVisualizationOptions = {}): GeomechanicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsVisualization };
diff --git a/src/geomechanics/voting.ts b/src/geomechanics/voting.ts
new file mode 100644
index 000000000..4d8245c18
--- /dev/null
+++ b/src/geomechanics/voting.ts
@@ -0,0 +1,14 @@
+/** geomechanics voting module — tsb analytics library. */
+export interface GeomechanicsVotingOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsVotingResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsVoting(data: number[], opts: GeomechanicsVotingOptions = {}): GeomechanicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsVoting };
diff --git a/src/geomechanics/wavelet.ts b/src/geomechanics/wavelet.ts
new file mode 100644
index 000000000..cb11aeb62
--- /dev/null
+++ b/src/geomechanics/wavelet.ts
@@ -0,0 +1,14 @@
+/** geomechanics wavelet module — tsb analytics library. */
+export interface GeomechanicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface GeomechanicsWaveletResult { values: number[]; converged: boolean; }
+export function computeGeomechanicsWavelet(data: number[], opts: GeomechanicsWaveletOptions = {}): GeomechanicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomechanicsWavelet };
diff --git a/src/geomorphology/adaptation.ts b/src/geomorphology/adaptation.ts
new file mode 100644
index 000000000..a67343d68
--- /dev/null
+++ b/src/geomorphology/adaptation.ts
@@ -0,0 +1,14 @@
+/** geomorphology adaptation module — tsb analytics library. */
+export interface GeomorphologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyAdaptation(data: number[], opts: GeomorphologyAdaptationOptions = {}): GeomorphologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyAdaptation };
diff --git a/src/geomorphology/aggregation.ts b/src/geomorphology/aggregation.ts
new file mode 100644
index 000000000..e287771b1
--- /dev/null
+++ b/src/geomorphology/aggregation.ts
@@ -0,0 +1,14 @@
+/** geomorphology aggregation module — tsb analytics library. */
+export interface GeomorphologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyAggregationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyAggregation(data: number[], opts: GeomorphologyAggregationOptions = {}): GeomorphologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyAggregation };
diff --git a/src/geomorphology/algebra.ts b/src/geomorphology/algebra.ts
new file mode 100644
index 000000000..e6cee0794
--- /dev/null
+++ b/src/geomorphology/algebra.ts
@@ -0,0 +1,14 @@
+/** geomorphology algebra module — tsb analytics library. */
+export interface GeomorphologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyAlgebra(data: number[], opts: GeomorphologyAlgebraOptions = {}): GeomorphologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyAlgebra };
diff --git a/src/geomorphology/alignment.ts b/src/geomorphology/alignment.ts
new file mode 100644
index 000000000..dfeb7bfab
--- /dev/null
+++ b/src/geomorphology/alignment.ts
@@ -0,0 +1,14 @@
+/** geomorphology alignment module — tsb analytics library. */
+export interface GeomorphologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyAlignment(data: number[], opts: GeomorphologyAlignmentOptions = {}): GeomorphologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyAlignment };
diff --git a/src/geomorphology/analysis.ts b/src/geomorphology/analysis.ts
new file mode 100644
index 000000000..a897313a7
--- /dev/null
+++ b/src/geomorphology/analysis.ts
@@ -0,0 +1,14 @@
+/** geomorphology analysis module — tsb analytics library. */
+export interface GeomorphologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyAnalysis(data: number[], opts: GeomorphologyAnalysisOptions = {}): GeomorphologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyAnalysis };
diff --git a/src/geomorphology/augmentation.ts b/src/geomorphology/augmentation.ts
new file mode 100644
index 000000000..516129c73
--- /dev/null
+++ b/src/geomorphology/augmentation.ts
@@ -0,0 +1,14 @@
+/** geomorphology augmentation module — tsb analytics library. */
+export interface GeomorphologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyAugmentation(data: number[], opts: GeomorphologyAugmentationOptions = {}): GeomorphologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyAugmentation };
diff --git a/src/geomorphology/bagging.ts b/src/geomorphology/bagging.ts
new file mode 100644
index 000000000..dd0e8f346
--- /dev/null
+++ b/src/geomorphology/bagging.ts
@@ -0,0 +1,14 @@
+/** geomorphology bagging module — tsb analytics library. */
+export interface GeomorphologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyBaggingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyBagging(data: number[], opts: GeomorphologyBaggingOptions = {}): GeomorphologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyBagging };
diff --git a/src/geomorphology/basis.ts b/src/geomorphology/basis.ts
new file mode 100644
index 000000000..0d2f262f5
--- /dev/null
+++ b/src/geomorphology/basis.ts
@@ -0,0 +1,14 @@
+/** geomorphology basis module — tsb analytics library. */
+export interface GeomorphologyBasisOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyBasisResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyBasis(data: number[], opts: GeomorphologyBasisOptions = {}): GeomorphologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyBasis };
diff --git a/src/geomorphology/benchmarking.ts b/src/geomorphology/benchmarking.ts
new file mode 100644
index 000000000..410d22242
--- /dev/null
+++ b/src/geomorphology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** geomorphology benchmarking module — tsb analytics library. */
+export interface GeomorphologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyBenchmarking(data: number[], opts: GeomorphologyBenchmarkingOptions = {}): GeomorphologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyBenchmarking };
diff --git a/src/geomorphology/blending.ts b/src/geomorphology/blending.ts
new file mode 100644
index 000000000..223b16692
--- /dev/null
+++ b/src/geomorphology/blending.ts
@@ -0,0 +1,14 @@
+/** geomorphology blending module — tsb analytics library. */
+export interface GeomorphologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyBlendingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyBlending(data: number[], opts: GeomorphologyBlendingOptions = {}): GeomorphologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyBlending };
diff --git a/src/geomorphology/boosting.ts b/src/geomorphology/boosting.ts
new file mode 100644
index 000000000..8ba9f2fa4
--- /dev/null
+++ b/src/geomorphology/boosting.ts
@@ -0,0 +1,14 @@
+/** geomorphology boosting module — tsb analytics library. */
+export interface GeomorphologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyBoostingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyBoosting(data: number[], opts: GeomorphologyBoostingOptions = {}): GeomorphologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyBoosting };
diff --git a/src/geomorphology/bootstrap.ts b/src/geomorphology/bootstrap.ts
new file mode 100644
index 000000000..d5995e4d5
--- /dev/null
+++ b/src/geomorphology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** geomorphology bootstrap module — tsb analytics library. */
+export interface GeomorphologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyBootstrap(data: number[], opts: GeomorphologyBootstrapOptions = {}): GeomorphologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyBootstrap };
diff --git a/src/geomorphology/calculus.ts b/src/geomorphology/calculus.ts
new file mode 100644
index 000000000..bdf91221d
--- /dev/null
+++ b/src/geomorphology/calculus.ts
@@ -0,0 +1,14 @@
+/** geomorphology calculus module — tsb analytics library. */
+export interface GeomorphologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyCalculusResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyCalculus(data: number[], opts: GeomorphologyCalculusOptions = {}): GeomorphologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyCalculus };
diff --git a/src/geomorphology/calibration.ts b/src/geomorphology/calibration.ts
new file mode 100644
index 000000000..aa00c136b
--- /dev/null
+++ b/src/geomorphology/calibration.ts
@@ -0,0 +1,14 @@
+/** geomorphology calibration module — tsb analytics library. */
+export interface GeomorphologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyCalibration(data: number[], opts: GeomorphologyCalibrationOptions = {}): GeomorphologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyCalibration };
diff --git a/src/geomorphology/characterization.ts b/src/geomorphology/characterization.ts
new file mode 100644
index 000000000..de06cd0cf
--- /dev/null
+++ b/src/geomorphology/characterization.ts
@@ -0,0 +1,14 @@
+/** geomorphology characterization module — tsb analytics library. */
+export interface GeomorphologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyCharacterization(data: number[], opts: GeomorphologyCharacterizationOptions = {}): GeomorphologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyCharacterization };
diff --git a/src/geomorphology/classification.ts b/src/geomorphology/classification.ts
new file mode 100644
index 000000000..017f4458c
--- /dev/null
+++ b/src/geomorphology/classification.ts
@@ -0,0 +1,14 @@
+/** geomorphology classification module — tsb analytics library. */
+export interface GeomorphologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyClassificationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyClassification(data: number[], opts: GeomorphologyClassificationOptions = {}): GeomorphologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyClassification };
diff --git a/src/geomorphology/clustering.ts b/src/geomorphology/clustering.ts
new file mode 100644
index 000000000..26c30cacb
--- /dev/null
+++ b/src/geomorphology/clustering.ts
@@ -0,0 +1,14 @@
+/** geomorphology clustering module — tsb analytics library. */
+export interface GeomorphologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyClusteringResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyClustering(data: number[], opts: GeomorphologyClusteringOptions = {}): GeomorphologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyClustering };
diff --git a/src/geomorphology/compression.ts b/src/geomorphology/compression.ts
new file mode 100644
index 000000000..c9591eda9
--- /dev/null
+++ b/src/geomorphology/compression.ts
@@ -0,0 +1,14 @@
+/** geomorphology compression module — tsb analytics library. */
+export interface GeomorphologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyCompressionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyCompression(data: number[], opts: GeomorphologyCompressionOptions = {}): GeomorphologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyCompression };
diff --git a/src/geomorphology/continuous.ts b/src/geomorphology/continuous.ts
new file mode 100644
index 000000000..0206c06aa
--- /dev/null
+++ b/src/geomorphology/continuous.ts
@@ -0,0 +1,14 @@
+/** geomorphology continuous module — tsb analytics library. */
+export interface GeomorphologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyContinuousResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyContinuous(data: number[], opts: GeomorphologyContinuousOptions = {}): GeomorphologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyContinuous };
diff --git a/src/geomorphology/control.ts b/src/geomorphology/control.ts
new file mode 100644
index 000000000..efdd206bb
--- /dev/null
+++ b/src/geomorphology/control.ts
@@ -0,0 +1,14 @@
+/** geomorphology control module — tsb analytics library. */
+export interface GeomorphologyControlOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyControlResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyControl(data: number[], opts: GeomorphologyControlOptions = {}): GeomorphologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyControl };
diff --git a/src/geomorphology/convergence.ts b/src/geomorphology/convergence.ts
new file mode 100644
index 000000000..5ca964bea
--- /dev/null
+++ b/src/geomorphology/convergence.ts
@@ -0,0 +1,14 @@
+/** geomorphology convergence module — tsb analytics library. */
+export interface GeomorphologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyConvergence(data: number[], opts: GeomorphologyConvergenceOptions = {}): GeomorphologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyConvergence };
diff --git a/src/geomorphology/convex.ts b/src/geomorphology/convex.ts
new file mode 100644
index 000000000..14dddda62
--- /dev/null
+++ b/src/geomorphology/convex.ts
@@ -0,0 +1,14 @@
+/** geomorphology convex module — tsb analytics library. */
+export interface GeomorphologyConvexOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyConvexResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyConvex(data: number[], opts: GeomorphologyConvexOptions = {}): GeomorphologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyConvex };
diff --git a/src/geomorphology/correlation.ts b/src/geomorphology/correlation.ts
new file mode 100644
index 000000000..5eb6f7bcc
--- /dev/null
+++ b/src/geomorphology/correlation.ts
@@ -0,0 +1,14 @@
+/** geomorphology correlation module — tsb analytics library. */
+export interface GeomorphologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyCorrelation(data: number[], opts: GeomorphologyCorrelationOptions = {}): GeomorphologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyCorrelation };
diff --git a/src/geomorphology/covariance.ts b/src/geomorphology/covariance.ts
new file mode 100644
index 000000000..b5edf271f
--- /dev/null
+++ b/src/geomorphology/covariance.ts
@@ -0,0 +1,14 @@
+/** geomorphology covariance module — tsb analytics library. */
+export interface GeomorphologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyCovariance(data: number[], opts: GeomorphologyCovarianceOptions = {}): GeomorphologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyCovariance };
diff --git a/src/geomorphology/cross_validation.ts b/src/geomorphology/cross_validation.ts
new file mode 100644
index 000000000..09bd825fc
--- /dev/null
+++ b/src/geomorphology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** geomorphology cross_validation module — tsb analytics library. */
+export interface GeomorphologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyCrossValidation(data: number[], opts: GeomorphologyCrossValidationOptions = {}): GeomorphologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyCrossValidation };
diff --git a/src/geomorphology/decoding.ts b/src/geomorphology/decoding.ts
new file mode 100644
index 000000000..0038c8030
--- /dev/null
+++ b/src/geomorphology/decoding.ts
@@ -0,0 +1,14 @@
+/** geomorphology decoding module — tsb analytics library. */
+export interface GeomorphologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDecodingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDecoding(data: number[], opts: GeomorphologyDecodingOptions = {}): GeomorphologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDecoding };
diff --git a/src/geomorphology/decomposition.ts b/src/geomorphology/decomposition.ts
new file mode 100644
index 000000000..0ac18bf8c
--- /dev/null
+++ b/src/geomorphology/decomposition.ts
@@ -0,0 +1,14 @@
+/** geomorphology decomposition module — tsb analytics library. */
+export interface GeomorphologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDecomposition(data: number[], opts: GeomorphologyDecompositionOptions = {}): GeomorphologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDecomposition };
diff --git a/src/geomorphology/detection.ts b/src/geomorphology/detection.ts
new file mode 100644
index 000000000..24f4975c6
--- /dev/null
+++ b/src/geomorphology/detection.ts
@@ -0,0 +1,14 @@
+/** geomorphology detection module — tsb analytics library. */
+export interface GeomorphologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDetectionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDetection(data: number[], opts: GeomorphologyDetectionOptions = {}): GeomorphologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDetection };
diff --git a/src/geomorphology/deterministic.ts b/src/geomorphology/deterministic.ts
new file mode 100644
index 000000000..fbacf489b
--- /dev/null
+++ b/src/geomorphology/deterministic.ts
@@ -0,0 +1,14 @@
+/** geomorphology deterministic module — tsb analytics library. */
+export interface GeomorphologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDeterministic(data: number[], opts: GeomorphologyDeterministicOptions = {}): GeomorphologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDeterministic };
diff --git a/src/geomorphology/diagnostics.ts b/src/geomorphology/diagnostics.ts
new file mode 100644
index 000000000..2381b4f08
--- /dev/null
+++ b/src/geomorphology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** geomorphology diagnostics module — tsb analytics library. */
+export interface GeomorphologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDiagnostics(data: number[], opts: GeomorphologyDiagnosticsOptions = {}): GeomorphologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDiagnostics };
diff --git a/src/geomorphology/differential.ts b/src/geomorphology/differential.ts
new file mode 100644
index 000000000..8867bb3c4
--- /dev/null
+++ b/src/geomorphology/differential.ts
@@ -0,0 +1,14 @@
+/** geomorphology differential module — tsb analytics library. */
+export interface GeomorphologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDifferential(data: number[], opts: GeomorphologyDifferentialOptions = {}): GeomorphologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDifferential };
diff --git a/src/geomorphology/discrete.ts b/src/geomorphology/discrete.ts
new file mode 100644
index 000000000..b4f974232
--- /dev/null
+++ b/src/geomorphology/discrete.ts
@@ -0,0 +1,14 @@
+/** geomorphology discrete module — tsb analytics library. */
+export interface GeomorphologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDiscrete(data: number[], opts: GeomorphologyDiscreteOptions = {}): GeomorphologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDiscrete };
diff --git a/src/geomorphology/distribution.ts b/src/geomorphology/distribution.ts
new file mode 100644
index 000000000..c9a2a46ea
--- /dev/null
+++ b/src/geomorphology/distribution.ts
@@ -0,0 +1,14 @@
+/** geomorphology distribution module — tsb analytics library. */
+export interface GeomorphologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDistributionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDistribution(data: number[], opts: GeomorphologyDistributionOptions = {}): GeomorphologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDistribution };
diff --git a/src/geomorphology/dynamic.ts b/src/geomorphology/dynamic.ts
new file mode 100644
index 000000000..644cccbcb
--- /dev/null
+++ b/src/geomorphology/dynamic.ts
@@ -0,0 +1,14 @@
+/** geomorphology dynamic module — tsb analytics library. */
+export interface GeomorphologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyDynamicResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyDynamic(data: number[], opts: GeomorphologyDynamicOptions = {}): GeomorphologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyDynamic };
diff --git a/src/geomorphology/embedding.ts b/src/geomorphology/embedding.ts
new file mode 100644
index 000000000..fd184a786
--- /dev/null
+++ b/src/geomorphology/embedding.ts
@@ -0,0 +1,14 @@
+/** geomorphology embedding module — tsb analytics library. */
+export interface GeomorphologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyEmbedding(data: number[], opts: GeomorphologyEmbeddingOptions = {}): GeomorphologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyEmbedding };
diff --git a/src/geomorphology/encoding.ts b/src/geomorphology/encoding.ts
new file mode 100644
index 000000000..2c6414b86
--- /dev/null
+++ b/src/geomorphology/encoding.ts
@@ -0,0 +1,14 @@
+/** geomorphology encoding module — tsb analytics library. */
+export interface GeomorphologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyEncodingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyEncoding(data: number[], opts: GeomorphologyEncodingOptions = {}): GeomorphologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyEncoding };
diff --git a/src/geomorphology/ensemble.ts b/src/geomorphology/ensemble.ts
new file mode 100644
index 000000000..9d85ffec8
--- /dev/null
+++ b/src/geomorphology/ensemble.ts
@@ -0,0 +1,14 @@
+/** geomorphology ensemble module — tsb analytics library. */
+export interface GeomorphologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyEnsemble(data: number[], opts: GeomorphologyEnsembleOptions = {}): GeomorphologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyEnsemble };
diff --git a/src/geomorphology/estimation.ts b/src/geomorphology/estimation.ts
new file mode 100644
index 000000000..ee0fa470f
--- /dev/null
+++ b/src/geomorphology/estimation.ts
@@ -0,0 +1,14 @@
+/** geomorphology estimation module — tsb analytics library. */
+export interface GeomorphologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyEstimationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyEstimation(data: number[], opts: GeomorphologyEstimationOptions = {}): GeomorphologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyEstimation };
diff --git a/src/geomorphology/evaluation.ts b/src/geomorphology/evaluation.ts
new file mode 100644
index 000000000..1884d3d2c
--- /dev/null
+++ b/src/geomorphology/evaluation.ts
@@ -0,0 +1,14 @@
+/** geomorphology evaluation module — tsb analytics library. */
+export interface GeomorphologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyEvaluation(data: number[], opts: GeomorphologyEvaluationOptions = {}): GeomorphologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyEvaluation };
diff --git a/src/geomorphology/extrapolation.ts b/src/geomorphology/extrapolation.ts
new file mode 100644
index 000000000..4a748d6a1
--- /dev/null
+++ b/src/geomorphology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** geomorphology extrapolation module — tsb analytics library. */
+export interface GeomorphologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyExtrapolation(data: number[], opts: GeomorphologyExtrapolationOptions = {}): GeomorphologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyExtrapolation };
diff --git a/src/geomorphology/features.ts b/src/geomorphology/features.ts
new file mode 100644
index 000000000..bd1276594
--- /dev/null
+++ b/src/geomorphology/features.ts
@@ -0,0 +1,14 @@
+/** geomorphology features module — tsb analytics library. */
+export interface GeomorphologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyFeatures(data: number[], opts: GeomorphologyFeaturesOptions = {}): GeomorphologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyFeatures };
diff --git a/src/geomorphology/feedback.ts b/src/geomorphology/feedback.ts
new file mode 100644
index 000000000..828fd0554
--- /dev/null
+++ b/src/geomorphology/feedback.ts
@@ -0,0 +1,14 @@
+/** geomorphology feedback module — tsb analytics library. */
+export interface GeomorphologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyFeedback(data: number[], opts: GeomorphologyFeedbackOptions = {}): GeomorphologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyFeedback };
diff --git a/src/geomorphology/filtering.ts b/src/geomorphology/filtering.ts
new file mode 100644
index 000000000..30f8ee08b
--- /dev/null
+++ b/src/geomorphology/filtering.ts
@@ -0,0 +1,14 @@
+/** geomorphology filtering module — tsb analytics library. */
+export interface GeomorphologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyFilteringResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyFiltering(data: number[], opts: GeomorphologyFilteringOptions = {}): GeomorphologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyFiltering };
diff --git a/src/geomorphology/fourier.ts b/src/geomorphology/fourier.ts
new file mode 100644
index 000000000..b1629049b
--- /dev/null
+++ b/src/geomorphology/fourier.ts
@@ -0,0 +1,14 @@
+/** geomorphology fourier module — tsb analytics library. */
+export interface GeomorphologyFourierOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyFourierResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyFourier(data: number[], opts: GeomorphologyFourierOptions = {}): GeomorphologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyFourier };
diff --git a/src/geomorphology/fusion.ts b/src/geomorphology/fusion.ts
new file mode 100644
index 000000000..7b9eba1b6
--- /dev/null
+++ b/src/geomorphology/fusion.ts
@@ -0,0 +1,14 @@
+/** geomorphology fusion module — tsb analytics library. */
+export interface GeomorphologyFusionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyFusionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyFusion(data: number[], opts: GeomorphologyFusionOptions = {}): GeomorphologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyFusion };
diff --git a/src/geomorphology/generation.ts b/src/geomorphology/generation.ts
new file mode 100644
index 000000000..e3847c4db
--- /dev/null
+++ b/src/geomorphology/generation.ts
@@ -0,0 +1,14 @@
+/** geomorphology generation module — tsb analytics library. */
+export interface GeomorphologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyGenerationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyGeneration(data: number[], opts: GeomorphologyGenerationOptions = {}): GeomorphologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyGeneration };
diff --git a/src/geomorphology/geometry.ts b/src/geomorphology/geometry.ts
new file mode 100644
index 000000000..13efef2d3
--- /dev/null
+++ b/src/geomorphology/geometry.ts
@@ -0,0 +1,14 @@
+/** geomorphology geometry module — tsb analytics library. */
+export interface GeomorphologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyGeometryResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyGeometry(data: number[], opts: GeomorphologyGeometryOptions = {}): GeomorphologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyGeometry };
diff --git a/src/geomorphology/gradient.ts b/src/geomorphology/gradient.ts
new file mode 100644
index 000000000..4a281b5db
--- /dev/null
+++ b/src/geomorphology/gradient.ts
@@ -0,0 +1,14 @@
+/** geomorphology gradient module — tsb analytics library. */
+export interface GeomorphologyGradientOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyGradientResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyGradient(data: number[], opts: GeomorphologyGradientOptions = {}): GeomorphologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyGradient };
diff --git a/src/geomorphology/hessian.ts b/src/geomorphology/hessian.ts
new file mode 100644
index 000000000..5e8432933
--- /dev/null
+++ b/src/geomorphology/hessian.ts
@@ -0,0 +1,14 @@
+/** geomorphology hessian module — tsb analytics library. */
+export interface GeomorphologyHessianOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyHessianResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyHessian(data: number[], opts: GeomorphologyHessianOptions = {}): GeomorphologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyHessian };
diff --git a/src/geomorphology/hypothesis.ts b/src/geomorphology/hypothesis.ts
new file mode 100644
index 000000000..026b7d9da
--- /dev/null
+++ b/src/geomorphology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** geomorphology hypothesis module — tsb analytics library. */
+export interface GeomorphologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyHypothesis(data: number[], opts: GeomorphologyHypothesisOptions = {}): GeomorphologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyHypothesis };
diff --git a/src/geomorphology/inference.ts b/src/geomorphology/inference.ts
new file mode 100644
index 000000000..d430101aa
--- /dev/null
+++ b/src/geomorphology/inference.ts
@@ -0,0 +1,14 @@
+/** geomorphology inference module — tsb analytics library. */
+export interface GeomorphologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyInferenceResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyInference(data: number[], opts: GeomorphologyInferenceOptions = {}): GeomorphologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyInference };
diff --git a/src/geomorphology/inference2.ts b/src/geomorphology/inference2.ts
new file mode 100644
index 000000000..b0f367dd0
--- /dev/null
+++ b/src/geomorphology/inference2.ts
@@ -0,0 +1,14 @@
+/** geomorphology inference2 module — tsb analytics library. */
+export interface GeomorphologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyInferenceResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyInference(data: number[], opts: GeomorphologyInferenceOptions = {}): GeomorphologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyInference };
diff --git a/src/geomorphology/integral.ts b/src/geomorphology/integral.ts
new file mode 100644
index 000000000..be771dbbd
--- /dev/null
+++ b/src/geomorphology/integral.ts
@@ -0,0 +1,14 @@
+/** geomorphology integral module — tsb analytics library. */
+export interface GeomorphologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyIntegralResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyIntegral(data: number[], opts: GeomorphologyIntegralOptions = {}): GeomorphologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyIntegral };
diff --git a/src/geomorphology/integration.ts b/src/geomorphology/integration.ts
new file mode 100644
index 000000000..78a6cb6df
--- /dev/null
+++ b/src/geomorphology/integration.ts
@@ -0,0 +1,14 @@
+/** geomorphology integration module — tsb analytics library. */
+export interface GeomorphologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyIntegration(data: number[], opts: GeomorphologyIntegrationOptions = {}): GeomorphologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyIntegration };
diff --git a/src/geomorphology/interpolation.ts b/src/geomorphology/interpolation.ts
new file mode 100644
index 000000000..4dc4e8ad9
--- /dev/null
+++ b/src/geomorphology/interpolation.ts
@@ -0,0 +1,14 @@
+/** geomorphology interpolation module — tsb analytics library. */
+export interface GeomorphologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyInterpolation(data: number[], opts: GeomorphologyInterpolationOptions = {}): GeomorphologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyInterpolation };
diff --git a/src/geomorphology/jacobian.ts b/src/geomorphology/jacobian.ts
new file mode 100644
index 000000000..4225fabc0
--- /dev/null
+++ b/src/geomorphology/jacobian.ts
@@ -0,0 +1,14 @@
+/** geomorphology jacobian module — tsb analytics library. */
+export interface GeomorphologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyJacobianResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyJacobian(data: number[], opts: GeomorphologyJacobianOptions = {}): GeomorphologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyJacobian };
diff --git a/src/geomorphology/kernel.ts b/src/geomorphology/kernel.ts
new file mode 100644
index 000000000..d5f980df2
--- /dev/null
+++ b/src/geomorphology/kernel.ts
@@ -0,0 +1,14 @@
+/** geomorphology kernel module — tsb analytics library. */
+export interface GeomorphologyKernelOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyKernelResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyKernel(data: number[], opts: GeomorphologyKernelOptions = {}): GeomorphologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyKernel };
diff --git a/src/geomorphology/laplacian.ts b/src/geomorphology/laplacian.ts
new file mode 100644
index 000000000..4a454ccbc
--- /dev/null
+++ b/src/geomorphology/laplacian.ts
@@ -0,0 +1,14 @@
+/** geomorphology laplacian module — tsb analytics library. */
+export interface GeomorphologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyLaplacian(data: number[], opts: GeomorphologyLaplacianOptions = {}): GeomorphologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyLaplacian };
diff --git a/src/geomorphology/learning.ts b/src/geomorphology/learning.ts
new file mode 100644
index 000000000..6de7bf483
--- /dev/null
+++ b/src/geomorphology/learning.ts
@@ -0,0 +1,14 @@
+/** geomorphology learning module — tsb analytics library. */
+export interface GeomorphologyLearningOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyLearningResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyLearning(data: number[], opts: GeomorphologyLearningOptions = {}): GeomorphologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyLearning };
diff --git a/src/geomorphology/linear.ts b/src/geomorphology/linear.ts
new file mode 100644
index 000000000..af332c250
--- /dev/null
+++ b/src/geomorphology/linear.ts
@@ -0,0 +1,14 @@
+/** geomorphology linear module — tsb analytics library. */
+export interface GeomorphologyLinearOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyLinearResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyLinear(data: number[], opts: GeomorphologyLinearOptions = {}): GeomorphologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyLinear };
diff --git a/src/geomorphology/manifold.ts b/src/geomorphology/manifold.ts
new file mode 100644
index 000000000..38f6d482b
--- /dev/null
+++ b/src/geomorphology/manifold.ts
@@ -0,0 +1,14 @@
+/** geomorphology manifold module — tsb analytics library. */
+export interface GeomorphologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyManifoldResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyManifold(data: number[], opts: GeomorphologyManifoldOptions = {}): GeomorphologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyManifold };
diff --git a/src/geomorphology/matching.ts b/src/geomorphology/matching.ts
new file mode 100644
index 000000000..b0b17540f
--- /dev/null
+++ b/src/geomorphology/matching.ts
@@ -0,0 +1,14 @@
+/** geomorphology matching module — tsb analytics library. */
+export interface GeomorphologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyMatchingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyMatching(data: number[], opts: GeomorphologyMatchingOptions = {}): GeomorphologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyMatching };
diff --git a/src/geomorphology/measurement.ts b/src/geomorphology/measurement.ts
new file mode 100644
index 000000000..56aea247d
--- /dev/null
+++ b/src/geomorphology/measurement.ts
@@ -0,0 +1,14 @@
+/** geomorphology measurement module — tsb analytics library. */
+export interface GeomorphologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyMeasurement(data: number[], opts: GeomorphologyMeasurementOptions = {}): GeomorphologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyMeasurement };
diff --git a/src/geomorphology/metrics.ts b/src/geomorphology/metrics.ts
new file mode 100644
index 000000000..9bceb7397
--- /dev/null
+++ b/src/geomorphology/metrics.ts
@@ -0,0 +1,14 @@
+/** geomorphology metrics module — tsb analytics library. */
+export interface GeomorphologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyMetricsResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyMetrics(data: number[], opts: GeomorphologyMetricsOptions = {}): GeomorphologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyMetrics };
diff --git a/src/geomorphology/modeling.ts b/src/geomorphology/modeling.ts
new file mode 100644
index 000000000..dd55e9424
--- /dev/null
+++ b/src/geomorphology/modeling.ts
@@ -0,0 +1,14 @@
+/** geomorphology modeling module — tsb analytics library. */
+export interface GeomorphologyModelingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyModelingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyModeling(data: number[], opts: GeomorphologyModelingOptions = {}): GeomorphologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyModeling };
diff --git a/src/geomorphology/monitoring.ts b/src/geomorphology/monitoring.ts
new file mode 100644
index 000000000..db418da41
--- /dev/null
+++ b/src/geomorphology/monitoring.ts
@@ -0,0 +1,14 @@
+/** geomorphology monitoring module — tsb analytics library. */
+export interface GeomorphologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyMonitoring(data: number[], opts: GeomorphologyMonitoringOptions = {}): GeomorphologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyMonitoring };
diff --git a/src/geomorphology/nonlinear.ts b/src/geomorphology/nonlinear.ts
new file mode 100644
index 000000000..a45494794
--- /dev/null
+++ b/src/geomorphology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** geomorphology nonlinear module — tsb analytics library. */
+export interface GeomorphologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyNonlinear(data: number[], opts: GeomorphologyNonlinearOptions = {}): GeomorphologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyNonlinear };
diff --git a/src/geomorphology/normalization.ts b/src/geomorphology/normalization.ts
new file mode 100644
index 000000000..ce76e5462
--- /dev/null
+++ b/src/geomorphology/normalization.ts
@@ -0,0 +1,14 @@
+/** geomorphology normalization module — tsb analytics library. */
+export interface GeomorphologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyNormalization(data: number[], opts: GeomorphologyNormalizationOptions = {}): GeomorphologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyNormalization };
diff --git a/src/geomorphology/optimization.ts b/src/geomorphology/optimization.ts
new file mode 100644
index 000000000..28697a7d8
--- /dev/null
+++ b/src/geomorphology/optimization.ts
@@ -0,0 +1,14 @@
+/** geomorphology optimization module — tsb analytics library. */
+export interface GeomorphologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyOptimization(data: number[], opts: GeomorphologyOptimizationOptions = {}): GeomorphologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyOptimization };
diff --git a/src/geomorphology/patterns.ts b/src/geomorphology/patterns.ts
new file mode 100644
index 000000000..d6a68b02b
--- /dev/null
+++ b/src/geomorphology/patterns.ts
@@ -0,0 +1,14 @@
+/** geomorphology patterns module — tsb analytics library. */
+export interface GeomorphologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyPatternsResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyPatterns(data: number[], opts: GeomorphologyPatternsOptions = {}): GeomorphologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyPatterns };
diff --git a/src/geomorphology/permutation.ts b/src/geomorphology/permutation.ts
new file mode 100644
index 000000000..f1f0c4548
--- /dev/null
+++ b/src/geomorphology/permutation.ts
@@ -0,0 +1,14 @@
+/** geomorphology permutation module — tsb analytics library. */
+export interface GeomorphologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyPermutationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyPermutation(data: number[], opts: GeomorphologyPermutationOptions = {}): GeomorphologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyPermutation };
diff --git a/src/geomorphology/prediction.ts b/src/geomorphology/prediction.ts
new file mode 100644
index 000000000..f749a0382
--- /dev/null
+++ b/src/geomorphology/prediction.ts
@@ -0,0 +1,14 @@
+/** geomorphology prediction module — tsb analytics library. */
+export interface GeomorphologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyPredictionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyPrediction(data: number[], opts: GeomorphologyPredictionOptions = {}): GeomorphologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyPrediction };
diff --git a/src/geomorphology/processing.ts b/src/geomorphology/processing.ts
new file mode 100644
index 000000000..11dbac971
--- /dev/null
+++ b/src/geomorphology/processing.ts
@@ -0,0 +1,14 @@
+/** geomorphology processing module — tsb analytics library. */
+export interface GeomorphologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyProcessingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyProcessing(data: number[], opts: GeomorphologyProcessingOptions = {}): GeomorphologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyProcessing };
diff --git a/src/geomorphology/profiling.ts b/src/geomorphology/profiling.ts
new file mode 100644
index 000000000..9d3c2a9bf
--- /dev/null
+++ b/src/geomorphology/profiling.ts
@@ -0,0 +1,14 @@
+/** geomorphology profiling module — tsb analytics library. */
+export interface GeomorphologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyProfilingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyProfiling(data: number[], opts: GeomorphologyProfilingOptions = {}): GeomorphologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyProfiling };
diff --git a/src/geomorphology/projection.ts b/src/geomorphology/projection.ts
new file mode 100644
index 000000000..bd924f6d2
--- /dev/null
+++ b/src/geomorphology/projection.ts
@@ -0,0 +1,14 @@
+/** geomorphology projection module — tsb analytics library. */
+export interface GeomorphologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyProjectionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyProjection(data: number[], opts: GeomorphologyProjectionOptions = {}): GeomorphologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyProjection };
diff --git a/src/geomorphology/ranking.ts b/src/geomorphology/ranking.ts
new file mode 100644
index 000000000..29ad3d7b9
--- /dev/null
+++ b/src/geomorphology/ranking.ts
@@ -0,0 +1,14 @@
+/** geomorphology ranking module — tsb analytics library. */
+export interface GeomorphologyRankingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyRankingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyRanking(data: number[], opts: GeomorphologyRankingOptions = {}): GeomorphologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyRanking };
diff --git a/src/geomorphology/reconstruction.ts b/src/geomorphology/reconstruction.ts
new file mode 100644
index 000000000..780d51e5a
--- /dev/null
+++ b/src/geomorphology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** geomorphology reconstruction module — tsb analytics library. */
+export interface GeomorphologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyReconstruction(data: number[], opts: GeomorphologyReconstructionOptions = {}): GeomorphologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyReconstruction };
diff --git a/src/geomorphology/registration.ts b/src/geomorphology/registration.ts
new file mode 100644
index 000000000..8c6476e06
--- /dev/null
+++ b/src/geomorphology/registration.ts
@@ -0,0 +1,14 @@
+/** geomorphology registration module — tsb analytics library. */
+export interface GeomorphologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyRegistration(data: number[], opts: GeomorphologyRegistrationOptions = {}): GeomorphologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyRegistration };
diff --git a/src/geomorphology/regression.ts b/src/geomorphology/regression.ts
new file mode 100644
index 000000000..14686b407
--- /dev/null
+++ b/src/geomorphology/regression.ts
@@ -0,0 +1,14 @@
+/** geomorphology regression module — tsb analytics library. */
+export interface GeomorphologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyRegressionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyRegression(data: number[], opts: GeomorphologyRegressionOptions = {}): GeomorphologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyRegression };
diff --git a/src/geomorphology/regularization.ts b/src/geomorphology/regularization.ts
new file mode 100644
index 000000000..97816bec6
--- /dev/null
+++ b/src/geomorphology/regularization.ts
@@ -0,0 +1,14 @@
+/** geomorphology regularization module — tsb analytics library. */
+export interface GeomorphologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyRegularization(data: number[], opts: GeomorphologyRegularizationOptions = {}): GeomorphologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyRegularization };
diff --git a/src/geomorphology/robustness.ts b/src/geomorphology/robustness.ts
new file mode 100644
index 000000000..50a85f51a
--- /dev/null
+++ b/src/geomorphology/robustness.ts
@@ -0,0 +1,14 @@
+/** geomorphology robustness module — tsb analytics library. */
+export interface GeomorphologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyRobustness(data: number[], opts: GeomorphologyRobustnessOptions = {}): GeomorphologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyRobustness };
diff --git a/src/geomorphology/sampling.ts b/src/geomorphology/sampling.ts
new file mode 100644
index 000000000..2d8588672
--- /dev/null
+++ b/src/geomorphology/sampling.ts
@@ -0,0 +1,14 @@
+/** geomorphology sampling module — tsb analytics library. */
+export interface GeomorphologySamplingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologySamplingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologySampling(data: number[], opts: GeomorphologySamplingOptions = {}): GeomorphologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologySampling };
diff --git a/src/geomorphology/sampling2.ts b/src/geomorphology/sampling2.ts
new file mode 100644
index 000000000..7bcd1e623
--- /dev/null
+++ b/src/geomorphology/sampling2.ts
@@ -0,0 +1,14 @@
+/** geomorphology sampling2 module — tsb analytics library. */
+export interface GeomorphologySamplingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologySamplingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologySampling(data: number[], opts: GeomorphologySamplingOptions = {}): GeomorphologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologySampling };
diff --git a/src/geomorphology/scaling.ts b/src/geomorphology/scaling.ts
new file mode 100644
index 000000000..9bcbe6bc6
--- /dev/null
+++ b/src/geomorphology/scaling.ts
@@ -0,0 +1,14 @@
+/** geomorphology scaling module — tsb analytics library. */
+export interface GeomorphologyScalingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyScalingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyScaling(data: number[], opts: GeomorphologyScalingOptions = {}): GeomorphologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyScaling };
diff --git a/src/geomorphology/scoring.ts b/src/geomorphology/scoring.ts
new file mode 100644
index 000000000..eabcdf9d7
--- /dev/null
+++ b/src/geomorphology/scoring.ts
@@ -0,0 +1,14 @@
+/** geomorphology scoring module — tsb analytics library. */
+export interface GeomorphologyScoringOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyScoringResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyScoring(data: number[], opts: GeomorphologyScoringOptions = {}): GeomorphologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyScoring };
diff --git a/src/geomorphology/segmentation.ts b/src/geomorphology/segmentation.ts
new file mode 100644
index 000000000..efe1cca0f
--- /dev/null
+++ b/src/geomorphology/segmentation.ts
@@ -0,0 +1,14 @@
+/** geomorphology segmentation module — tsb analytics library. */
+export interface GeomorphologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologySegmentationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologySegmentation(data: number[], opts: GeomorphologySegmentationOptions = {}): GeomorphologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologySegmentation };
diff --git a/src/geomorphology/selection.ts b/src/geomorphology/selection.ts
new file mode 100644
index 000000000..f5f2c5926
--- /dev/null
+++ b/src/geomorphology/selection.ts
@@ -0,0 +1,14 @@
+/** geomorphology selection module — tsb analytics library. */
+export interface GeomorphologySelectionOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologySelectionResult { values: number[]; converged: boolean; }
+export function computeGeomorphologySelection(data: number[], opts: GeomorphologySelectionOptions = {}): GeomorphologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologySelection };
diff --git a/src/geomorphology/sensitivity.ts b/src/geomorphology/sensitivity.ts
new file mode 100644
index 000000000..b49ec641c
--- /dev/null
+++ b/src/geomorphology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** geomorphology sensitivity module — tsb analytics library. */
+export interface GeomorphologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologySensitivityResult { values: number[]; converged: boolean; }
+export function computeGeomorphologySensitivity(data: number[], opts: GeomorphologySensitivityOptions = {}): GeomorphologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologySensitivity };
diff --git a/src/geomorphology/simulation.ts b/src/geomorphology/simulation.ts
new file mode 100644
index 000000000..3c7fd12cc
--- /dev/null
+++ b/src/geomorphology/simulation.ts
@@ -0,0 +1,14 @@
+/** geomorphology simulation module — tsb analytics library. */
+export interface GeomorphologySimulationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologySimulationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologySimulation(data: number[], opts: GeomorphologySimulationOptions = {}): GeomorphologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologySimulation };
diff --git a/src/geomorphology/smoothing.ts b/src/geomorphology/smoothing.ts
new file mode 100644
index 000000000..3053f184e
--- /dev/null
+++ b/src/geomorphology/smoothing.ts
@@ -0,0 +1,14 @@
+/** geomorphology smoothing module — tsb analytics library. */
+export interface GeomorphologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologySmoothingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologySmoothing(data: number[], opts: GeomorphologySmoothingOptions = {}): GeomorphologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologySmoothing };
diff --git a/src/geomorphology/stability.ts b/src/geomorphology/stability.ts
new file mode 100644
index 000000000..38445be06
--- /dev/null
+++ b/src/geomorphology/stability.ts
@@ -0,0 +1,14 @@
+/** geomorphology stability module — tsb analytics library. */
+export interface GeomorphologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyStabilityResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyStability(data: number[], opts: GeomorphologyStabilityOptions = {}): GeomorphologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyStability };
diff --git a/src/geomorphology/stacking.ts b/src/geomorphology/stacking.ts
new file mode 100644
index 000000000..c96178ddb
--- /dev/null
+++ b/src/geomorphology/stacking.ts
@@ -0,0 +1,14 @@
+/** geomorphology stacking module — tsb analytics library. */
+export interface GeomorphologyStackingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyStackingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyStacking(data: number[], opts: GeomorphologyStackingOptions = {}): GeomorphologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyStacking };
diff --git a/src/geomorphology/standardization.ts b/src/geomorphology/standardization.ts
new file mode 100644
index 000000000..9f6705c28
--- /dev/null
+++ b/src/geomorphology/standardization.ts
@@ -0,0 +1,14 @@
+/** geomorphology standardization module — tsb analytics library. */
+export interface GeomorphologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyStandardization(data: number[], opts: GeomorphologyStandardizationOptions = {}): GeomorphologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyStandardization };
diff --git a/src/geomorphology/static.ts b/src/geomorphology/static.ts
new file mode 100644
index 000000000..92caadf3e
--- /dev/null
+++ b/src/geomorphology/static.ts
@@ -0,0 +1,14 @@
+/** geomorphology static module — tsb analytics library. */
+export interface GeomorphologyStaticOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyStaticResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyStatic(data: number[], opts: GeomorphologyStaticOptions = {}): GeomorphologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyStatic };
diff --git a/src/geomorphology/stochastic.ts b/src/geomorphology/stochastic.ts
new file mode 100644
index 000000000..9a18287b2
--- /dev/null
+++ b/src/geomorphology/stochastic.ts
@@ -0,0 +1,14 @@
+/** geomorphology stochastic module — tsb analytics library. */
+export interface GeomorphologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyStochasticResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyStochastic(data: number[], opts: GeomorphologyStochasticOptions = {}): GeomorphologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyStochastic };
diff --git a/src/geomorphology/synthesis.ts b/src/geomorphology/synthesis.ts
new file mode 100644
index 000000000..2ca042fd8
--- /dev/null
+++ b/src/geomorphology/synthesis.ts
@@ -0,0 +1,14 @@
+/** geomorphology synthesis module — tsb analytics library. */
+export interface GeomorphologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologySynthesisResult { values: number[]; converged: boolean; }
+export function computeGeomorphologySynthesis(data: number[], opts: GeomorphologySynthesisOptions = {}): GeomorphologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologySynthesis };
diff --git a/src/geomorphology/topology.ts b/src/geomorphology/topology.ts
new file mode 100644
index 000000000..40b6e481e
--- /dev/null
+++ b/src/geomorphology/topology.ts
@@ -0,0 +1,14 @@
+/** geomorphology topology module — tsb analytics library. */
+export interface GeomorphologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyTopologyResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyTopology(data: number[], opts: GeomorphologyTopologyOptions = {}): GeomorphologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyTopology };
diff --git a/src/geomorphology/tracking.ts b/src/geomorphology/tracking.ts
new file mode 100644
index 000000000..4573c600a
--- /dev/null
+++ b/src/geomorphology/tracking.ts
@@ -0,0 +1,14 @@
+/** geomorphology tracking module — tsb analytics library. */
+export interface GeomorphologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyTrackingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyTracking(data: number[], opts: GeomorphologyTrackingOptions = {}): GeomorphologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyTracking };
diff --git a/src/geomorphology/transform.ts b/src/geomorphology/transform.ts
new file mode 100644
index 000000000..6471e88c8
--- /dev/null
+++ b/src/geomorphology/transform.ts
@@ -0,0 +1,14 @@
+/** geomorphology transform module — tsb analytics library. */
+export interface GeomorphologyTransformOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyTransformResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyTransform(data: number[], opts: GeomorphologyTransformOptions = {}): GeomorphologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyTransform };
diff --git a/src/geomorphology/uncertainty.ts b/src/geomorphology/uncertainty.ts
new file mode 100644
index 000000000..8471eda4e
--- /dev/null
+++ b/src/geomorphology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** geomorphology uncertainty module — tsb analytics library. */
+export interface GeomorphologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyUncertainty(data: number[], opts: GeomorphologyUncertaintyOptions = {}): GeomorphologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyUncertainty };
diff --git a/src/geomorphology/validation.ts b/src/geomorphology/validation.ts
new file mode 100644
index 000000000..a8c75f0f8
--- /dev/null
+++ b/src/geomorphology/validation.ts
@@ -0,0 +1,14 @@
+/** geomorphology validation module — tsb analytics library. */
+export interface GeomorphologyValidationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyValidationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyValidation(data: number[], opts: GeomorphologyValidationOptions = {}): GeomorphologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyValidation };
diff --git a/src/geomorphology/verification.ts b/src/geomorphology/verification.ts
new file mode 100644
index 000000000..86468f258
--- /dev/null
+++ b/src/geomorphology/verification.ts
@@ -0,0 +1,14 @@
+/** geomorphology verification module — tsb analytics library. */
+export interface GeomorphologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyVerificationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyVerification(data: number[], opts: GeomorphologyVerificationOptions = {}): GeomorphologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyVerification };
diff --git a/src/geomorphology/visualization.ts b/src/geomorphology/visualization.ts
new file mode 100644
index 000000000..b5284c024
--- /dev/null
+++ b/src/geomorphology/visualization.ts
@@ -0,0 +1,14 @@
+/** geomorphology visualization module — tsb analytics library. */
+export interface GeomorphologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyVisualization(data: number[], opts: GeomorphologyVisualizationOptions = {}): GeomorphologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyVisualization };
diff --git a/src/geomorphology/voting.ts b/src/geomorphology/voting.ts
new file mode 100644
index 000000000..754aa98a4
--- /dev/null
+++ b/src/geomorphology/voting.ts
@@ -0,0 +1,14 @@
+/** geomorphology voting module — tsb analytics library. */
+export interface GeomorphologyVotingOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyVotingResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyVoting(data: number[], opts: GeomorphologyVotingOptions = {}): GeomorphologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyVoting };
diff --git a/src/geomorphology/wavelet.ts b/src/geomorphology/wavelet.ts
new file mode 100644
index 000000000..981b5b941
--- /dev/null
+++ b/src/geomorphology/wavelet.ts
@@ -0,0 +1,14 @@
+/** geomorphology wavelet module — tsb analytics library. */
+export interface GeomorphologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface GeomorphologyWaveletResult { values: number[]; converged: boolean; }
+export function computeGeomorphologyWavelet(data: number[], opts: GeomorphologyWaveletOptions = {}): GeomorphologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeomorphologyWavelet };
diff --git a/src/geophysics_sci/adaptation.ts b/src/geophysics_sci/adaptation.ts
new file mode 100644
index 000000000..8b3a510ca
--- /dev/null
+++ b/src/geophysics_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci adaptation module — tsb analytics library. */
+export interface GeophysicsSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciAdaptation(data: number[], opts: GeophysicsSciAdaptationOptions = {}): GeophysicsSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciAdaptation };
diff --git a/src/geophysics_sci/aggregation.ts b/src/geophysics_sci/aggregation.ts
new file mode 100644
index 000000000..8f49c8922
--- /dev/null
+++ b/src/geophysics_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci aggregation module — tsb analytics library. */
+export interface GeophysicsSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciAggregationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciAggregation(data: number[], opts: GeophysicsSciAggregationOptions = {}): GeophysicsSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciAggregation };
diff --git a/src/geophysics_sci/algebra.ts b/src/geophysics_sci/algebra.ts
new file mode 100644
index 000000000..31170a3ee
--- /dev/null
+++ b/src/geophysics_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci algebra module — tsb analytics library. */
+export interface GeophysicsSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciAlgebra(data: number[], opts: GeophysicsSciAlgebraOptions = {}): GeophysicsSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciAlgebra };
diff --git a/src/geophysics_sci/alignment.ts b/src/geophysics_sci/alignment.ts
new file mode 100644
index 000000000..96f2ce0ba
--- /dev/null
+++ b/src/geophysics_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci alignment module — tsb analytics library. */
+export interface GeophysicsSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciAlignment(data: number[], opts: GeophysicsSciAlignmentOptions = {}): GeophysicsSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciAlignment };
diff --git a/src/geophysics_sci/analysis.ts b/src/geophysics_sci/analysis.ts
new file mode 100644
index 000000000..8edd86dfc
--- /dev/null
+++ b/src/geophysics_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci analysis module — tsb analytics library. */
+export interface GeophysicsSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciAnalysis(data: number[], opts: GeophysicsSciAnalysisOptions = {}): GeophysicsSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciAnalysis };
diff --git a/src/geophysics_sci/augmentation.ts b/src/geophysics_sci/augmentation.ts
new file mode 100644
index 000000000..2a2bb3ece
--- /dev/null
+++ b/src/geophysics_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci augmentation module — tsb analytics library. */
+export interface GeophysicsSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciAugmentation(data: number[], opts: GeophysicsSciAugmentationOptions = {}): GeophysicsSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciAugmentation };
diff --git a/src/geophysics_sci/bagging.ts b/src/geophysics_sci/bagging.ts
new file mode 100644
index 000000000..d904023a6
--- /dev/null
+++ b/src/geophysics_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci bagging module — tsb analytics library. */
+export interface GeophysicsSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciBaggingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciBagging(data: number[], opts: GeophysicsSciBaggingOptions = {}): GeophysicsSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciBagging };
diff --git a/src/geophysics_sci/basis.ts b/src/geophysics_sci/basis.ts
new file mode 100644
index 000000000..1d50b1c1c
--- /dev/null
+++ b/src/geophysics_sci/basis.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci basis module — tsb analytics library. */
+export interface GeophysicsSciBasisOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciBasisResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciBasis(data: number[], opts: GeophysicsSciBasisOptions = {}): GeophysicsSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciBasis };
diff --git a/src/geophysics_sci/benchmarking.ts b/src/geophysics_sci/benchmarking.ts
new file mode 100644
index 000000000..cdb2afb1f
--- /dev/null
+++ b/src/geophysics_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci benchmarking module — tsb analytics library. */
+export interface GeophysicsSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciBenchmarking(data: number[], opts: GeophysicsSciBenchmarkingOptions = {}): GeophysicsSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciBenchmarking };
diff --git a/src/geophysics_sci/blending.ts b/src/geophysics_sci/blending.ts
new file mode 100644
index 000000000..b2d38cb3d
--- /dev/null
+++ b/src/geophysics_sci/blending.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci blending module — tsb analytics library. */
+export interface GeophysicsSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciBlendingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciBlending(data: number[], opts: GeophysicsSciBlendingOptions = {}): GeophysicsSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciBlending };
diff --git a/src/geophysics_sci/boosting.ts b/src/geophysics_sci/boosting.ts
new file mode 100644
index 000000000..a3fcb4f51
--- /dev/null
+++ b/src/geophysics_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci boosting module — tsb analytics library. */
+export interface GeophysicsSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciBoostingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciBoosting(data: number[], opts: GeophysicsSciBoostingOptions = {}): GeophysicsSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciBoosting };
diff --git a/src/geophysics_sci/bootstrap.ts b/src/geophysics_sci/bootstrap.ts
new file mode 100644
index 000000000..c376a55f6
--- /dev/null
+++ b/src/geophysics_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci bootstrap module — tsb analytics library. */
+export interface GeophysicsSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciBootstrap(data: number[], opts: GeophysicsSciBootstrapOptions = {}): GeophysicsSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciBootstrap };
diff --git a/src/geophysics_sci/calculus.ts b/src/geophysics_sci/calculus.ts
new file mode 100644
index 000000000..cef80d4e0
--- /dev/null
+++ b/src/geophysics_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci calculus module — tsb analytics library. */
+export interface GeophysicsSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciCalculusResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciCalculus(data: number[], opts: GeophysicsSciCalculusOptions = {}): GeophysicsSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciCalculus };
diff --git a/src/geophysics_sci/calibration.ts b/src/geophysics_sci/calibration.ts
new file mode 100644
index 000000000..2d6fb5dc1
--- /dev/null
+++ b/src/geophysics_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci calibration module — tsb analytics library. */
+export interface GeophysicsSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciCalibration(data: number[], opts: GeophysicsSciCalibrationOptions = {}): GeophysicsSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciCalibration };
diff --git a/src/geophysics_sci/characterization.ts b/src/geophysics_sci/characterization.ts
new file mode 100644
index 000000000..df1124ba7
--- /dev/null
+++ b/src/geophysics_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci characterization module — tsb analytics library. */
+export interface GeophysicsSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciCharacterization(data: number[], opts: GeophysicsSciCharacterizationOptions = {}): GeophysicsSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciCharacterization };
diff --git a/src/geophysics_sci/classification.ts b/src/geophysics_sci/classification.ts
new file mode 100644
index 000000000..9e154aac3
--- /dev/null
+++ b/src/geophysics_sci/classification.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci classification module — tsb analytics library. */
+export interface GeophysicsSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciClassificationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciClassification(data: number[], opts: GeophysicsSciClassificationOptions = {}): GeophysicsSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciClassification };
diff --git a/src/geophysics_sci/clustering.ts b/src/geophysics_sci/clustering.ts
new file mode 100644
index 000000000..60f9f40c5
--- /dev/null
+++ b/src/geophysics_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci clustering module — tsb analytics library. */
+export interface GeophysicsSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciClusteringResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciClustering(data: number[], opts: GeophysicsSciClusteringOptions = {}): GeophysicsSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciClustering };
diff --git a/src/geophysics_sci/compression.ts b/src/geophysics_sci/compression.ts
new file mode 100644
index 000000000..7ac7ce2a8
--- /dev/null
+++ b/src/geophysics_sci/compression.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci compression module — tsb analytics library. */
+export interface GeophysicsSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciCompressionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciCompression(data: number[], opts: GeophysicsSciCompressionOptions = {}): GeophysicsSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciCompression };
diff --git a/src/geophysics_sci/continuous.ts b/src/geophysics_sci/continuous.ts
new file mode 100644
index 000000000..6e2b49e27
--- /dev/null
+++ b/src/geophysics_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci continuous module — tsb analytics library. */
+export interface GeophysicsSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciContinuousResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciContinuous(data: number[], opts: GeophysicsSciContinuousOptions = {}): GeophysicsSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciContinuous };
diff --git a/src/geophysics_sci/control.ts b/src/geophysics_sci/control.ts
new file mode 100644
index 000000000..3fa415656
--- /dev/null
+++ b/src/geophysics_sci/control.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci control module — tsb analytics library. */
+export interface GeophysicsSciControlOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciControlResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciControl(data: number[], opts: GeophysicsSciControlOptions = {}): GeophysicsSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciControl };
diff --git a/src/geophysics_sci/convergence.ts b/src/geophysics_sci/convergence.ts
new file mode 100644
index 000000000..53f8db4c1
--- /dev/null
+++ b/src/geophysics_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci convergence module — tsb analytics library. */
+export interface GeophysicsSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciConvergence(data: number[], opts: GeophysicsSciConvergenceOptions = {}): GeophysicsSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciConvergence };
diff --git a/src/geophysics_sci/convex.ts b/src/geophysics_sci/convex.ts
new file mode 100644
index 000000000..4f28fe4d8
--- /dev/null
+++ b/src/geophysics_sci/convex.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci convex module — tsb analytics library. */
+export interface GeophysicsSciConvexOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciConvexResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciConvex(data: number[], opts: GeophysicsSciConvexOptions = {}): GeophysicsSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciConvex };
diff --git a/src/geophysics_sci/correlation.ts b/src/geophysics_sci/correlation.ts
new file mode 100644
index 000000000..62b4648b8
--- /dev/null
+++ b/src/geophysics_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci correlation module — tsb analytics library. */
+export interface GeophysicsSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciCorrelation(data: number[], opts: GeophysicsSciCorrelationOptions = {}): GeophysicsSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciCorrelation };
diff --git a/src/geophysics_sci/covariance.ts b/src/geophysics_sci/covariance.ts
new file mode 100644
index 000000000..861d6fe8e
--- /dev/null
+++ b/src/geophysics_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci covariance module — tsb analytics library. */
+export interface GeophysicsSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciCovariance(data: number[], opts: GeophysicsSciCovarianceOptions = {}): GeophysicsSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciCovariance };
diff --git a/src/geophysics_sci/cross_validation.ts b/src/geophysics_sci/cross_validation.ts
new file mode 100644
index 000000000..dd49e76f1
--- /dev/null
+++ b/src/geophysics_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci cross_validation module — tsb analytics library. */
+export interface GeophysicsSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciCrossValidation(data: number[], opts: GeophysicsSciCrossValidationOptions = {}): GeophysicsSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciCrossValidation };
diff --git a/src/geophysics_sci/decoding.ts b/src/geophysics_sci/decoding.ts
new file mode 100644
index 000000000..a2e408e2c
--- /dev/null
+++ b/src/geophysics_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci decoding module — tsb analytics library. */
+export interface GeophysicsSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDecodingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDecoding(data: number[], opts: GeophysicsSciDecodingOptions = {}): GeophysicsSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDecoding };
diff --git a/src/geophysics_sci/decomposition.ts b/src/geophysics_sci/decomposition.ts
new file mode 100644
index 000000000..b6648697c
--- /dev/null
+++ b/src/geophysics_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci decomposition module — tsb analytics library. */
+export interface GeophysicsSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDecomposition(data: number[], opts: GeophysicsSciDecompositionOptions = {}): GeophysicsSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDecomposition };
diff --git a/src/geophysics_sci/detection.ts b/src/geophysics_sci/detection.ts
new file mode 100644
index 000000000..b98de4a53
--- /dev/null
+++ b/src/geophysics_sci/detection.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci detection module — tsb analytics library. */
+export interface GeophysicsSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDetectionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDetection(data: number[], opts: GeophysicsSciDetectionOptions = {}): GeophysicsSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDetection };
diff --git a/src/geophysics_sci/deterministic.ts b/src/geophysics_sci/deterministic.ts
new file mode 100644
index 000000000..a97563761
--- /dev/null
+++ b/src/geophysics_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci deterministic module — tsb analytics library. */
+export interface GeophysicsSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDeterministic(data: number[], opts: GeophysicsSciDeterministicOptions = {}): GeophysicsSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDeterministic };
diff --git a/src/geophysics_sci/diagnostics.ts b/src/geophysics_sci/diagnostics.ts
new file mode 100644
index 000000000..d438c433d
--- /dev/null
+++ b/src/geophysics_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci diagnostics module — tsb analytics library. */
+export interface GeophysicsSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDiagnostics(data: number[], opts: GeophysicsSciDiagnosticsOptions = {}): GeophysicsSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDiagnostics };
diff --git a/src/geophysics_sci/differential.ts b/src/geophysics_sci/differential.ts
new file mode 100644
index 000000000..8131268c4
--- /dev/null
+++ b/src/geophysics_sci/differential.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci differential module — tsb analytics library. */
+export interface GeophysicsSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDifferential(data: number[], opts: GeophysicsSciDifferentialOptions = {}): GeophysicsSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDifferential };
diff --git a/src/geophysics_sci/discrete.ts b/src/geophysics_sci/discrete.ts
new file mode 100644
index 000000000..b8c7cb3ee
--- /dev/null
+++ b/src/geophysics_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci discrete module — tsb analytics library. */
+export interface GeophysicsSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDiscrete(data: number[], opts: GeophysicsSciDiscreteOptions = {}): GeophysicsSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDiscrete };
diff --git a/src/geophysics_sci/distribution.ts b/src/geophysics_sci/distribution.ts
new file mode 100644
index 000000000..77ffab4cd
--- /dev/null
+++ b/src/geophysics_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci distribution module — tsb analytics library. */
+export interface GeophysicsSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDistributionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDistribution(data: number[], opts: GeophysicsSciDistributionOptions = {}): GeophysicsSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDistribution };
diff --git a/src/geophysics_sci/dynamic.ts b/src/geophysics_sci/dynamic.ts
new file mode 100644
index 000000000..1225abc9e
--- /dev/null
+++ b/src/geophysics_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci dynamic module — tsb analytics library. */
+export interface GeophysicsSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciDynamicResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciDynamic(data: number[], opts: GeophysicsSciDynamicOptions = {}): GeophysicsSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciDynamic };
diff --git a/src/geophysics_sci/embedding.ts b/src/geophysics_sci/embedding.ts
new file mode 100644
index 000000000..418f291dd
--- /dev/null
+++ b/src/geophysics_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci embedding module — tsb analytics library. */
+export interface GeophysicsSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciEmbedding(data: number[], opts: GeophysicsSciEmbeddingOptions = {}): GeophysicsSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciEmbedding };
diff --git a/src/geophysics_sci/encoding.ts b/src/geophysics_sci/encoding.ts
new file mode 100644
index 000000000..43dc42e9b
--- /dev/null
+++ b/src/geophysics_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci encoding module — tsb analytics library. */
+export interface GeophysicsSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciEncodingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciEncoding(data: number[], opts: GeophysicsSciEncodingOptions = {}): GeophysicsSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciEncoding };
diff --git a/src/geophysics_sci/ensemble.ts b/src/geophysics_sci/ensemble.ts
new file mode 100644
index 000000000..1a70b6508
--- /dev/null
+++ b/src/geophysics_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci ensemble module — tsb analytics library. */
+export interface GeophysicsSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciEnsemble(data: number[], opts: GeophysicsSciEnsembleOptions = {}): GeophysicsSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciEnsemble };
diff --git a/src/geophysics_sci/estimation.ts b/src/geophysics_sci/estimation.ts
new file mode 100644
index 000000000..bcddafac0
--- /dev/null
+++ b/src/geophysics_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci estimation module — tsb analytics library. */
+export interface GeophysicsSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciEstimationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciEstimation(data: number[], opts: GeophysicsSciEstimationOptions = {}): GeophysicsSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciEstimation };
diff --git a/src/geophysics_sci/evaluation.ts b/src/geophysics_sci/evaluation.ts
new file mode 100644
index 000000000..ed80c7ca2
--- /dev/null
+++ b/src/geophysics_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci evaluation module — tsb analytics library. */
+export interface GeophysicsSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciEvaluation(data: number[], opts: GeophysicsSciEvaluationOptions = {}): GeophysicsSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciEvaluation };
diff --git a/src/geophysics_sci/extrapolation.ts b/src/geophysics_sci/extrapolation.ts
new file mode 100644
index 000000000..39ffc5342
--- /dev/null
+++ b/src/geophysics_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci extrapolation module — tsb analytics library. */
+export interface GeophysicsSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciExtrapolation(data: number[], opts: GeophysicsSciExtrapolationOptions = {}): GeophysicsSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciExtrapolation };
diff --git a/src/geophysics_sci/features.ts b/src/geophysics_sci/features.ts
new file mode 100644
index 000000000..b79eeff8c
--- /dev/null
+++ b/src/geophysics_sci/features.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci features module — tsb analytics library. */
+export interface GeophysicsSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciFeatures(data: number[], opts: GeophysicsSciFeaturesOptions = {}): GeophysicsSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciFeatures };
diff --git a/src/geophysics_sci/feedback.ts b/src/geophysics_sci/feedback.ts
new file mode 100644
index 000000000..8a462aa71
--- /dev/null
+++ b/src/geophysics_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci feedback module — tsb analytics library. */
+export interface GeophysicsSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciFeedback(data: number[], opts: GeophysicsSciFeedbackOptions = {}): GeophysicsSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciFeedback };
diff --git a/src/geophysics_sci/filtering.ts b/src/geophysics_sci/filtering.ts
new file mode 100644
index 000000000..507e02d29
--- /dev/null
+++ b/src/geophysics_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci filtering module — tsb analytics library. */
+export interface GeophysicsSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciFilteringResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciFiltering(data: number[], opts: GeophysicsSciFilteringOptions = {}): GeophysicsSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciFiltering };
diff --git a/src/geophysics_sci/fourier.ts b/src/geophysics_sci/fourier.ts
new file mode 100644
index 000000000..4be51b602
--- /dev/null
+++ b/src/geophysics_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci fourier module — tsb analytics library. */
+export interface GeophysicsSciFourierOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciFourierResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciFourier(data: number[], opts: GeophysicsSciFourierOptions = {}): GeophysicsSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciFourier };
diff --git a/src/geophysics_sci/fusion.ts b/src/geophysics_sci/fusion.ts
new file mode 100644
index 000000000..3a88d519d
--- /dev/null
+++ b/src/geophysics_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci fusion module — tsb analytics library. */
+export interface GeophysicsSciFusionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciFusionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciFusion(data: number[], opts: GeophysicsSciFusionOptions = {}): GeophysicsSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciFusion };
diff --git a/src/geophysics_sci/generation.ts b/src/geophysics_sci/generation.ts
new file mode 100644
index 000000000..fdd823f46
--- /dev/null
+++ b/src/geophysics_sci/generation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci generation module — tsb analytics library. */
+export interface GeophysicsSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciGenerationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciGeneration(data: number[], opts: GeophysicsSciGenerationOptions = {}): GeophysicsSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciGeneration };
diff --git a/src/geophysics_sci/geometry.ts b/src/geophysics_sci/geometry.ts
new file mode 100644
index 000000000..7e4f4d0a9
--- /dev/null
+++ b/src/geophysics_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci geometry module — tsb analytics library. */
+export interface GeophysicsSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciGeometryResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciGeometry(data: number[], opts: GeophysicsSciGeometryOptions = {}): GeophysicsSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciGeometry };
diff --git a/src/geophysics_sci/gradient.ts b/src/geophysics_sci/gradient.ts
new file mode 100644
index 000000000..f976e396e
--- /dev/null
+++ b/src/geophysics_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci gradient module — tsb analytics library. */
+export interface GeophysicsSciGradientOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciGradientResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciGradient(data: number[], opts: GeophysicsSciGradientOptions = {}): GeophysicsSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciGradient };
diff --git a/src/geophysics_sci/hessian.ts b/src/geophysics_sci/hessian.ts
new file mode 100644
index 000000000..f67882c32
--- /dev/null
+++ b/src/geophysics_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci hessian module — tsb analytics library. */
+export interface GeophysicsSciHessianOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciHessianResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciHessian(data: number[], opts: GeophysicsSciHessianOptions = {}): GeophysicsSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciHessian };
diff --git a/src/geophysics_sci/hypothesis.ts b/src/geophysics_sci/hypothesis.ts
new file mode 100644
index 000000000..29ba47e08
--- /dev/null
+++ b/src/geophysics_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci hypothesis module — tsb analytics library. */
+export interface GeophysicsSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciHypothesis(data: number[], opts: GeophysicsSciHypothesisOptions = {}): GeophysicsSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciHypothesis };
diff --git a/src/geophysics_sci/inference.ts b/src/geophysics_sci/inference.ts
new file mode 100644
index 000000000..ea234d821
--- /dev/null
+++ b/src/geophysics_sci/inference.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci inference module — tsb analytics library. */
+export interface GeophysicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciInference(data: number[], opts: GeophysicsSciInferenceOptions = {}): GeophysicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciInference };
diff --git a/src/geophysics_sci/inference2.ts b/src/geophysics_sci/inference2.ts
new file mode 100644
index 000000000..40b089db6
--- /dev/null
+++ b/src/geophysics_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci inference2 module — tsb analytics library. */
+export interface GeophysicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciInference(data: number[], opts: GeophysicsSciInferenceOptions = {}): GeophysicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciInference };
diff --git a/src/geophysics_sci/integral.ts b/src/geophysics_sci/integral.ts
new file mode 100644
index 000000000..570f8be2d
--- /dev/null
+++ b/src/geophysics_sci/integral.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci integral module — tsb analytics library. */
+export interface GeophysicsSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciIntegralResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciIntegral(data: number[], opts: GeophysicsSciIntegralOptions = {}): GeophysicsSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciIntegral };
diff --git a/src/geophysics_sci/integration.ts b/src/geophysics_sci/integration.ts
new file mode 100644
index 000000000..d9608f52a
--- /dev/null
+++ b/src/geophysics_sci/integration.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci integration module — tsb analytics library. */
+export interface GeophysicsSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciIntegration(data: number[], opts: GeophysicsSciIntegrationOptions = {}): GeophysicsSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciIntegration };
diff --git a/src/geophysics_sci/interpolation.ts b/src/geophysics_sci/interpolation.ts
new file mode 100644
index 000000000..fb87988b1
--- /dev/null
+++ b/src/geophysics_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci interpolation module — tsb analytics library. */
+export interface GeophysicsSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciInterpolation(data: number[], opts: GeophysicsSciInterpolationOptions = {}): GeophysicsSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciInterpolation };
diff --git a/src/geophysics_sci/jacobian.ts b/src/geophysics_sci/jacobian.ts
new file mode 100644
index 000000000..dfb987f19
--- /dev/null
+++ b/src/geophysics_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci jacobian module — tsb analytics library. */
+export interface GeophysicsSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciJacobianResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciJacobian(data: number[], opts: GeophysicsSciJacobianOptions = {}): GeophysicsSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciJacobian };
diff --git a/src/geophysics_sci/kernel.ts b/src/geophysics_sci/kernel.ts
new file mode 100644
index 000000000..3e350e488
--- /dev/null
+++ b/src/geophysics_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci kernel module — tsb analytics library. */
+export interface GeophysicsSciKernelOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciKernelResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciKernel(data: number[], opts: GeophysicsSciKernelOptions = {}): GeophysicsSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciKernel };
diff --git a/src/geophysics_sci/laplacian.ts b/src/geophysics_sci/laplacian.ts
new file mode 100644
index 000000000..94c7650d0
--- /dev/null
+++ b/src/geophysics_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci laplacian module — tsb analytics library. */
+export interface GeophysicsSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciLaplacian(data: number[], opts: GeophysicsSciLaplacianOptions = {}): GeophysicsSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciLaplacian };
diff --git a/src/geophysics_sci/learning.ts b/src/geophysics_sci/learning.ts
new file mode 100644
index 000000000..98276c7ae
--- /dev/null
+++ b/src/geophysics_sci/learning.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci learning module — tsb analytics library. */
+export interface GeophysicsSciLearningOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciLearningResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciLearning(data: number[], opts: GeophysicsSciLearningOptions = {}): GeophysicsSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciLearning };
diff --git a/src/geophysics_sci/linear.ts b/src/geophysics_sci/linear.ts
new file mode 100644
index 000000000..a8c75d77e
--- /dev/null
+++ b/src/geophysics_sci/linear.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci linear module — tsb analytics library. */
+export interface GeophysicsSciLinearOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciLinearResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciLinear(data: number[], opts: GeophysicsSciLinearOptions = {}): GeophysicsSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciLinear };
diff --git a/src/geophysics_sci/manifold.ts b/src/geophysics_sci/manifold.ts
new file mode 100644
index 000000000..7993d4f93
--- /dev/null
+++ b/src/geophysics_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci manifold module — tsb analytics library. */
+export interface GeophysicsSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciManifoldResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciManifold(data: number[], opts: GeophysicsSciManifoldOptions = {}): GeophysicsSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciManifold };
diff --git a/src/geophysics_sci/matching.ts b/src/geophysics_sci/matching.ts
new file mode 100644
index 000000000..6ee62c346
--- /dev/null
+++ b/src/geophysics_sci/matching.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci matching module — tsb analytics library. */
+export interface GeophysicsSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciMatchingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciMatching(data: number[], opts: GeophysicsSciMatchingOptions = {}): GeophysicsSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciMatching };
diff --git a/src/geophysics_sci/measurement.ts b/src/geophysics_sci/measurement.ts
new file mode 100644
index 000000000..9cf96034c
--- /dev/null
+++ b/src/geophysics_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci measurement module — tsb analytics library. */
+export interface GeophysicsSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciMeasurement(data: number[], opts: GeophysicsSciMeasurementOptions = {}): GeophysicsSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciMeasurement };
diff --git a/src/geophysics_sci/metrics.ts b/src/geophysics_sci/metrics.ts
new file mode 100644
index 000000000..8e93374e5
--- /dev/null
+++ b/src/geophysics_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci metrics module — tsb analytics library. */
+export interface GeophysicsSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciMetricsResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciMetrics(data: number[], opts: GeophysicsSciMetricsOptions = {}): GeophysicsSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciMetrics };
diff --git a/src/geophysics_sci/modeling.ts b/src/geophysics_sci/modeling.ts
new file mode 100644
index 000000000..28ce3e534
--- /dev/null
+++ b/src/geophysics_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci modeling module — tsb analytics library. */
+export interface GeophysicsSciModelingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciModelingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciModeling(data: number[], opts: GeophysicsSciModelingOptions = {}): GeophysicsSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciModeling };
diff --git a/src/geophysics_sci/monitoring.ts b/src/geophysics_sci/monitoring.ts
new file mode 100644
index 000000000..afa83e34d
--- /dev/null
+++ b/src/geophysics_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci monitoring module — tsb analytics library. */
+export interface GeophysicsSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciMonitoring(data: number[], opts: GeophysicsSciMonitoringOptions = {}): GeophysicsSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciMonitoring };
diff --git a/src/geophysics_sci/nonlinear.ts b/src/geophysics_sci/nonlinear.ts
new file mode 100644
index 000000000..395766853
--- /dev/null
+++ b/src/geophysics_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci nonlinear module — tsb analytics library. */
+export interface GeophysicsSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciNonlinear(data: number[], opts: GeophysicsSciNonlinearOptions = {}): GeophysicsSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciNonlinear };
diff --git a/src/geophysics_sci/normalization.ts b/src/geophysics_sci/normalization.ts
new file mode 100644
index 000000000..d7a9ae9a0
--- /dev/null
+++ b/src/geophysics_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci normalization module — tsb analytics library. */
+export interface GeophysicsSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciNormalization(data: number[], opts: GeophysicsSciNormalizationOptions = {}): GeophysicsSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciNormalization };
diff --git a/src/geophysics_sci/optimization.ts b/src/geophysics_sci/optimization.ts
new file mode 100644
index 000000000..fedf96d11
--- /dev/null
+++ b/src/geophysics_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci optimization module — tsb analytics library. */
+export interface GeophysicsSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciOptimization(data: number[], opts: GeophysicsSciOptimizationOptions = {}): GeophysicsSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciOptimization };
diff --git a/src/geophysics_sci/patterns.ts b/src/geophysics_sci/patterns.ts
new file mode 100644
index 000000000..572638046
--- /dev/null
+++ b/src/geophysics_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci patterns module — tsb analytics library. */
+export interface GeophysicsSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciPatternsResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciPatterns(data: number[], opts: GeophysicsSciPatternsOptions = {}): GeophysicsSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciPatterns };
diff --git a/src/geophysics_sci/permutation.ts b/src/geophysics_sci/permutation.ts
new file mode 100644
index 000000000..7ca7cc5ec
--- /dev/null
+++ b/src/geophysics_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci permutation module — tsb analytics library. */
+export interface GeophysicsSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciPermutationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciPermutation(data: number[], opts: GeophysicsSciPermutationOptions = {}): GeophysicsSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciPermutation };
diff --git a/src/geophysics_sci/prediction.ts b/src/geophysics_sci/prediction.ts
new file mode 100644
index 000000000..08c29af37
--- /dev/null
+++ b/src/geophysics_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci prediction module — tsb analytics library. */
+export interface GeophysicsSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciPredictionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciPrediction(data: number[], opts: GeophysicsSciPredictionOptions = {}): GeophysicsSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciPrediction };
diff --git a/src/geophysics_sci/processing.ts b/src/geophysics_sci/processing.ts
new file mode 100644
index 000000000..1b17dee49
--- /dev/null
+++ b/src/geophysics_sci/processing.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci processing module — tsb analytics library. */
+export interface GeophysicsSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciProcessingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciProcessing(data: number[], opts: GeophysicsSciProcessingOptions = {}): GeophysicsSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciProcessing };
diff --git a/src/geophysics_sci/profiling.ts b/src/geophysics_sci/profiling.ts
new file mode 100644
index 000000000..e9409673d
--- /dev/null
+++ b/src/geophysics_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci profiling module — tsb analytics library. */
+export interface GeophysicsSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciProfilingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciProfiling(data: number[], opts: GeophysicsSciProfilingOptions = {}): GeophysicsSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciProfiling };
diff --git a/src/geophysics_sci/projection.ts b/src/geophysics_sci/projection.ts
new file mode 100644
index 000000000..03aca3c8c
--- /dev/null
+++ b/src/geophysics_sci/projection.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci projection module — tsb analytics library. */
+export interface GeophysicsSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciProjectionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciProjection(data: number[], opts: GeophysicsSciProjectionOptions = {}): GeophysicsSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciProjection };
diff --git a/src/geophysics_sci/ranking.ts b/src/geophysics_sci/ranking.ts
new file mode 100644
index 000000000..09a50c672
--- /dev/null
+++ b/src/geophysics_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci ranking module — tsb analytics library. */
+export interface GeophysicsSciRankingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciRankingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciRanking(data: number[], opts: GeophysicsSciRankingOptions = {}): GeophysicsSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciRanking };
diff --git a/src/geophysics_sci/reconstruction.ts b/src/geophysics_sci/reconstruction.ts
new file mode 100644
index 000000000..241845902
--- /dev/null
+++ b/src/geophysics_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci reconstruction module — tsb analytics library. */
+export interface GeophysicsSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciReconstruction(data: number[], opts: GeophysicsSciReconstructionOptions = {}): GeophysicsSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciReconstruction };
diff --git a/src/geophysics_sci/registration.ts b/src/geophysics_sci/registration.ts
new file mode 100644
index 000000000..7e101673c
--- /dev/null
+++ b/src/geophysics_sci/registration.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci registration module — tsb analytics library. */
+export interface GeophysicsSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciRegistration(data: number[], opts: GeophysicsSciRegistrationOptions = {}): GeophysicsSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciRegistration };
diff --git a/src/geophysics_sci/regression.ts b/src/geophysics_sci/regression.ts
new file mode 100644
index 000000000..b3d90c151
--- /dev/null
+++ b/src/geophysics_sci/regression.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci regression module — tsb analytics library. */
+export interface GeophysicsSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciRegressionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciRegression(data: number[], opts: GeophysicsSciRegressionOptions = {}): GeophysicsSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciRegression };
diff --git a/src/geophysics_sci/regularization.ts b/src/geophysics_sci/regularization.ts
new file mode 100644
index 000000000..7fca3a0c2
--- /dev/null
+++ b/src/geophysics_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci regularization module — tsb analytics library. */
+export interface GeophysicsSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciRegularization(data: number[], opts: GeophysicsSciRegularizationOptions = {}): GeophysicsSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciRegularization };
diff --git a/src/geophysics_sci/robustness.ts b/src/geophysics_sci/robustness.ts
new file mode 100644
index 000000000..7fbf88800
--- /dev/null
+++ b/src/geophysics_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci robustness module — tsb analytics library. */
+export interface GeophysicsSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciRobustness(data: number[], opts: GeophysicsSciRobustnessOptions = {}): GeophysicsSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciRobustness };
diff --git a/src/geophysics_sci/sampling.ts b/src/geophysics_sci/sampling.ts
new file mode 100644
index 000000000..d2cd54a99
--- /dev/null
+++ b/src/geophysics_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci sampling module — tsb analytics library. */
+export interface GeophysicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciSampling(data: number[], opts: GeophysicsSciSamplingOptions = {}): GeophysicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciSampling };
diff --git a/src/geophysics_sci/sampling2.ts b/src/geophysics_sci/sampling2.ts
new file mode 100644
index 000000000..9ac56dd6d
--- /dev/null
+++ b/src/geophysics_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci sampling2 module — tsb analytics library. */
+export interface GeophysicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciSampling(data: number[], opts: GeophysicsSciSamplingOptions = {}): GeophysicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciSampling };
diff --git a/src/geophysics_sci/scaling.ts b/src/geophysics_sci/scaling.ts
new file mode 100644
index 000000000..a7756f1a6
--- /dev/null
+++ b/src/geophysics_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci scaling module — tsb analytics library. */
+export interface GeophysicsSciScalingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciScalingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciScaling(data: number[], opts: GeophysicsSciScalingOptions = {}): GeophysicsSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciScaling };
diff --git a/src/geophysics_sci/scoring.ts b/src/geophysics_sci/scoring.ts
new file mode 100644
index 000000000..70c14fe72
--- /dev/null
+++ b/src/geophysics_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci scoring module — tsb analytics library. */
+export interface GeophysicsSciScoringOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciScoringResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciScoring(data: number[], opts: GeophysicsSciScoringOptions = {}): GeophysicsSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciScoring };
diff --git a/src/geophysics_sci/segmentation.ts b/src/geophysics_sci/segmentation.ts
new file mode 100644
index 000000000..7770bdcac
--- /dev/null
+++ b/src/geophysics_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci segmentation module — tsb analytics library. */
+export interface GeophysicsSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciSegmentation(data: number[], opts: GeophysicsSciSegmentationOptions = {}): GeophysicsSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciSegmentation };
diff --git a/src/geophysics_sci/selection.ts b/src/geophysics_sci/selection.ts
new file mode 100644
index 000000000..f2d4271bf
--- /dev/null
+++ b/src/geophysics_sci/selection.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci selection module — tsb analytics library. */
+export interface GeophysicsSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciSelectionResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciSelection(data: number[], opts: GeophysicsSciSelectionOptions = {}): GeophysicsSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciSelection };
diff --git a/src/geophysics_sci/sensitivity.ts b/src/geophysics_sci/sensitivity.ts
new file mode 100644
index 000000000..acb052837
--- /dev/null
+++ b/src/geophysics_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci sensitivity module — tsb analytics library. */
+export interface GeophysicsSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciSensitivity(data: number[], opts: GeophysicsSciSensitivityOptions = {}): GeophysicsSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciSensitivity };
diff --git a/src/geophysics_sci/simulation.ts b/src/geophysics_sci/simulation.ts
new file mode 100644
index 000000000..9b9625084
--- /dev/null
+++ b/src/geophysics_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci simulation module — tsb analytics library. */
+export interface GeophysicsSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciSimulationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciSimulation(data: number[], opts: GeophysicsSciSimulationOptions = {}): GeophysicsSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciSimulation };
diff --git a/src/geophysics_sci/smoothing.ts b/src/geophysics_sci/smoothing.ts
new file mode 100644
index 000000000..d9591e86c
--- /dev/null
+++ b/src/geophysics_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci smoothing module — tsb analytics library. */
+export interface GeophysicsSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciSmoothing(data: number[], opts: GeophysicsSciSmoothingOptions = {}): GeophysicsSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciSmoothing };
diff --git a/src/geophysics_sci/stability.ts b/src/geophysics_sci/stability.ts
new file mode 100644
index 000000000..235a812d4
--- /dev/null
+++ b/src/geophysics_sci/stability.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci stability module — tsb analytics library. */
+export interface GeophysicsSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciStabilityResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciStability(data: number[], opts: GeophysicsSciStabilityOptions = {}): GeophysicsSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciStability };
diff --git a/src/geophysics_sci/stacking.ts b/src/geophysics_sci/stacking.ts
new file mode 100644
index 000000000..08c081986
--- /dev/null
+++ b/src/geophysics_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci stacking module — tsb analytics library. */
+export interface GeophysicsSciStackingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciStackingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciStacking(data: number[], opts: GeophysicsSciStackingOptions = {}): GeophysicsSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciStacking };
diff --git a/src/geophysics_sci/standardization.ts b/src/geophysics_sci/standardization.ts
new file mode 100644
index 000000000..d780b3dfb
--- /dev/null
+++ b/src/geophysics_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci standardization module — tsb analytics library. */
+export interface GeophysicsSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciStandardization(data: number[], opts: GeophysicsSciStandardizationOptions = {}): GeophysicsSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciStandardization };
diff --git a/src/geophysics_sci/static.ts b/src/geophysics_sci/static.ts
new file mode 100644
index 000000000..a30ae283b
--- /dev/null
+++ b/src/geophysics_sci/static.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci static module — tsb analytics library. */
+export interface GeophysicsSciStaticOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciStaticResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciStatic(data: number[], opts: GeophysicsSciStaticOptions = {}): GeophysicsSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciStatic };
diff --git a/src/geophysics_sci/stochastic.ts b/src/geophysics_sci/stochastic.ts
new file mode 100644
index 000000000..c1817c835
--- /dev/null
+++ b/src/geophysics_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci stochastic module — tsb analytics library. */
+export interface GeophysicsSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciStochasticResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciStochastic(data: number[], opts: GeophysicsSciStochasticOptions = {}): GeophysicsSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciStochastic };
diff --git a/src/geophysics_sci/synthesis.ts b/src/geophysics_sci/synthesis.ts
new file mode 100644
index 000000000..49d70cf2b
--- /dev/null
+++ b/src/geophysics_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci synthesis module — tsb analytics library. */
+export interface GeophysicsSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciSynthesis(data: number[], opts: GeophysicsSciSynthesisOptions = {}): GeophysicsSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciSynthesis };
diff --git a/src/geophysics_sci/topology.ts b/src/geophysics_sci/topology.ts
new file mode 100644
index 000000000..31e5c2a67
--- /dev/null
+++ b/src/geophysics_sci/topology.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci topology module — tsb analytics library. */
+export interface GeophysicsSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciTopologyResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciTopology(data: number[], opts: GeophysicsSciTopologyOptions = {}): GeophysicsSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciTopology };
diff --git a/src/geophysics_sci/tracking.ts b/src/geophysics_sci/tracking.ts
new file mode 100644
index 000000000..24221bf37
--- /dev/null
+++ b/src/geophysics_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci tracking module — tsb analytics library. */
+export interface GeophysicsSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciTrackingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciTracking(data: number[], opts: GeophysicsSciTrackingOptions = {}): GeophysicsSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciTracking };
diff --git a/src/geophysics_sci/transform.ts b/src/geophysics_sci/transform.ts
new file mode 100644
index 000000000..0e4e4460d
--- /dev/null
+++ b/src/geophysics_sci/transform.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci transform module — tsb analytics library. */
+export interface GeophysicsSciTransformOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciTransformResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciTransform(data: number[], opts: GeophysicsSciTransformOptions = {}): GeophysicsSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciTransform };
diff --git a/src/geophysics_sci/uncertainty.ts b/src/geophysics_sci/uncertainty.ts
new file mode 100644
index 000000000..be4e9fc3c
--- /dev/null
+++ b/src/geophysics_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci uncertainty module — tsb analytics library. */
+export interface GeophysicsSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciUncertainty(data: number[], opts: GeophysicsSciUncertaintyOptions = {}): GeophysicsSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciUncertainty };
diff --git a/src/geophysics_sci/validation.ts b/src/geophysics_sci/validation.ts
new file mode 100644
index 000000000..9414255ea
--- /dev/null
+++ b/src/geophysics_sci/validation.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci validation module — tsb analytics library. */
+export interface GeophysicsSciValidationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciValidationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciValidation(data: number[], opts: GeophysicsSciValidationOptions = {}): GeophysicsSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciValidation };
diff --git a/src/geophysics_sci/verification.ts b/src/geophysics_sci/verification.ts
new file mode 100644
index 000000000..23cce6211
--- /dev/null
+++ b/src/geophysics_sci/verification.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci verification module — tsb analytics library. */
+export interface GeophysicsSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciVerificationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciVerification(data: number[], opts: GeophysicsSciVerificationOptions = {}): GeophysicsSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciVerification };
diff --git a/src/geophysics_sci/visualization.ts b/src/geophysics_sci/visualization.ts
new file mode 100644
index 000000000..f2cf43c9d
--- /dev/null
+++ b/src/geophysics_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci visualization module — tsb analytics library. */
+export interface GeophysicsSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciVisualization(data: number[], opts: GeophysicsSciVisualizationOptions = {}): GeophysicsSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciVisualization };
diff --git a/src/geophysics_sci/voting.ts b/src/geophysics_sci/voting.ts
new file mode 100644
index 000000000..cb7343cd1
--- /dev/null
+++ b/src/geophysics_sci/voting.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci voting module — tsb analytics library. */
+export interface GeophysicsSciVotingOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciVotingResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciVoting(data: number[], opts: GeophysicsSciVotingOptions = {}): GeophysicsSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciVoting };
diff --git a/src/geophysics_sci/wavelet.ts b/src/geophysics_sci/wavelet.ts
new file mode 100644
index 000000000..2ac880fbf
--- /dev/null
+++ b/src/geophysics_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** geophysics_sci wavelet module — tsb analytics library. */
+export interface GeophysicsSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface GeophysicsSciWaveletResult { values: number[]; converged: boolean; }
+export function computeGeophysicsSciWavelet(data: number[], opts: GeophysicsSciWaveletOptions = {}): GeophysicsSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGeophysicsSciWavelet };
diff --git a/src/glaciology/adaptation.ts b/src/glaciology/adaptation.ts
new file mode 100644
index 000000000..bd995748c
--- /dev/null
+++ b/src/glaciology/adaptation.ts
@@ -0,0 +1,14 @@
+/** glaciology adaptation module — tsb analytics library. */
+export interface GlaciologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyAdaptation(data: number[], opts: GlaciologyAdaptationOptions = {}): GlaciologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyAdaptation };
diff --git a/src/glaciology/aggregation.ts b/src/glaciology/aggregation.ts
new file mode 100644
index 000000000..2209ebd6f
--- /dev/null
+++ b/src/glaciology/aggregation.ts
@@ -0,0 +1,14 @@
+/** glaciology aggregation module — tsb analytics library. */
+export interface GlaciologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyAggregationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyAggregation(data: number[], opts: GlaciologyAggregationOptions = {}): GlaciologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyAggregation };
diff --git a/src/glaciology/algebra.ts b/src/glaciology/algebra.ts
new file mode 100644
index 000000000..a22be3bb1
--- /dev/null
+++ b/src/glaciology/algebra.ts
@@ -0,0 +1,14 @@
+/** glaciology algebra module — tsb analytics library. */
+export interface GlaciologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeGlaciologyAlgebra(data: number[], opts: GlaciologyAlgebraOptions = {}): GlaciologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyAlgebra };
diff --git a/src/glaciology/alignment.ts b/src/glaciology/alignment.ts
new file mode 100644
index 000000000..729f115f9
--- /dev/null
+++ b/src/glaciology/alignment.ts
@@ -0,0 +1,14 @@
+/** glaciology alignment module — tsb analytics library. */
+export interface GlaciologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeGlaciologyAlignment(data: number[], opts: GlaciologyAlignmentOptions = {}): GlaciologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyAlignment };
diff --git a/src/glaciology/analysis.ts b/src/glaciology/analysis.ts
new file mode 100644
index 000000000..bc27cfd63
--- /dev/null
+++ b/src/glaciology/analysis.ts
@@ -0,0 +1,14 @@
+/** glaciology analysis module — tsb analytics library. */
+export interface GlaciologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeGlaciologyAnalysis(data: number[], opts: GlaciologyAnalysisOptions = {}): GlaciologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyAnalysis };
diff --git a/src/glaciology/augmentation.ts b/src/glaciology/augmentation.ts
new file mode 100644
index 000000000..bfb455861
--- /dev/null
+++ b/src/glaciology/augmentation.ts
@@ -0,0 +1,14 @@
+/** glaciology augmentation module — tsb analytics library. */
+export interface GlaciologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyAugmentation(data: number[], opts: GlaciologyAugmentationOptions = {}): GlaciologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyAugmentation };
diff --git a/src/glaciology/bagging.ts b/src/glaciology/bagging.ts
new file mode 100644
index 000000000..e00c2f372
--- /dev/null
+++ b/src/glaciology/bagging.ts
@@ -0,0 +1,14 @@
+/** glaciology bagging module — tsb analytics library. */
+export interface GlaciologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyBaggingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyBagging(data: number[], opts: GlaciologyBaggingOptions = {}): GlaciologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyBagging };
diff --git a/src/glaciology/basis.ts b/src/glaciology/basis.ts
new file mode 100644
index 000000000..c9e3de978
--- /dev/null
+++ b/src/glaciology/basis.ts
@@ -0,0 +1,14 @@
+/** glaciology basis module — tsb analytics library. */
+export interface GlaciologyBasisOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyBasisResult { values: number[]; converged: boolean; }
+export function computeGlaciologyBasis(data: number[], opts: GlaciologyBasisOptions = {}): GlaciologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyBasis };
diff --git a/src/glaciology/benchmarking.ts b/src/glaciology/benchmarking.ts
new file mode 100644
index 000000000..72f1d1d80
--- /dev/null
+++ b/src/glaciology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** glaciology benchmarking module — tsb analytics library. */
+export interface GlaciologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyBenchmarking(data: number[], opts: GlaciologyBenchmarkingOptions = {}): GlaciologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyBenchmarking };
diff --git a/src/glaciology/blending.ts b/src/glaciology/blending.ts
new file mode 100644
index 000000000..9f62b9edf
--- /dev/null
+++ b/src/glaciology/blending.ts
@@ -0,0 +1,14 @@
+/** glaciology blending module — tsb analytics library. */
+export interface GlaciologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyBlendingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyBlending(data: number[], opts: GlaciologyBlendingOptions = {}): GlaciologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyBlending };
diff --git a/src/glaciology/boosting.ts b/src/glaciology/boosting.ts
new file mode 100644
index 000000000..318b29940
--- /dev/null
+++ b/src/glaciology/boosting.ts
@@ -0,0 +1,14 @@
+/** glaciology boosting module — tsb analytics library. */
+export interface GlaciologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyBoostingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyBoosting(data: number[], opts: GlaciologyBoostingOptions = {}): GlaciologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyBoosting };
diff --git a/src/glaciology/bootstrap.ts b/src/glaciology/bootstrap.ts
new file mode 100644
index 000000000..03f8e3924
--- /dev/null
+++ b/src/glaciology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** glaciology bootstrap module — tsb analytics library. */
+export interface GlaciologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeGlaciologyBootstrap(data: number[], opts: GlaciologyBootstrapOptions = {}): GlaciologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyBootstrap };
diff --git a/src/glaciology/calculus.ts b/src/glaciology/calculus.ts
new file mode 100644
index 000000000..5d9ccf558
--- /dev/null
+++ b/src/glaciology/calculus.ts
@@ -0,0 +1,14 @@
+/** glaciology calculus module — tsb analytics library. */
+export interface GlaciologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyCalculusResult { values: number[]; converged: boolean; }
+export function computeGlaciologyCalculus(data: number[], opts: GlaciologyCalculusOptions = {}): GlaciologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyCalculus };
diff --git a/src/glaciology/calibration.ts b/src/glaciology/calibration.ts
new file mode 100644
index 000000000..c33ed4e35
--- /dev/null
+++ b/src/glaciology/calibration.ts
@@ -0,0 +1,14 @@
+/** glaciology calibration module — tsb analytics library. */
+export interface GlaciologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyCalibration(data: number[], opts: GlaciologyCalibrationOptions = {}): GlaciologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyCalibration };
diff --git a/src/glaciology/characterization.ts b/src/glaciology/characterization.ts
new file mode 100644
index 000000000..221271627
--- /dev/null
+++ b/src/glaciology/characterization.ts
@@ -0,0 +1,14 @@
+/** glaciology characterization module — tsb analytics library. */
+export interface GlaciologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyCharacterization(data: number[], opts: GlaciologyCharacterizationOptions = {}): GlaciologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyCharacterization };
diff --git a/src/glaciology/classification.ts b/src/glaciology/classification.ts
new file mode 100644
index 000000000..348f9451c
--- /dev/null
+++ b/src/glaciology/classification.ts
@@ -0,0 +1,14 @@
+/** glaciology classification module — tsb analytics library. */
+export interface GlaciologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyClassificationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyClassification(data: number[], opts: GlaciologyClassificationOptions = {}): GlaciologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyClassification };
diff --git a/src/glaciology/clustering.ts b/src/glaciology/clustering.ts
new file mode 100644
index 000000000..86522b4bb
--- /dev/null
+++ b/src/glaciology/clustering.ts
@@ -0,0 +1,14 @@
+/** glaciology clustering module — tsb analytics library. */
+export interface GlaciologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyClusteringResult { values: number[]; converged: boolean; }
+export function computeGlaciologyClustering(data: number[], opts: GlaciologyClusteringOptions = {}): GlaciologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyClustering };
diff --git a/src/glaciology/compression.ts b/src/glaciology/compression.ts
new file mode 100644
index 000000000..405ddb948
--- /dev/null
+++ b/src/glaciology/compression.ts
@@ -0,0 +1,14 @@
+/** glaciology compression module — tsb analytics library. */
+export interface GlaciologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyCompressionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyCompression(data: number[], opts: GlaciologyCompressionOptions = {}): GlaciologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyCompression };
diff --git a/src/glaciology/continuous.ts b/src/glaciology/continuous.ts
new file mode 100644
index 000000000..73afed7d6
--- /dev/null
+++ b/src/glaciology/continuous.ts
@@ -0,0 +1,14 @@
+/** glaciology continuous module — tsb analytics library. */
+export interface GlaciologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyContinuousResult { values: number[]; converged: boolean; }
+export function computeGlaciologyContinuous(data: number[], opts: GlaciologyContinuousOptions = {}): GlaciologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyContinuous };
diff --git a/src/glaciology/control.ts b/src/glaciology/control.ts
new file mode 100644
index 000000000..7d04b0f21
--- /dev/null
+++ b/src/glaciology/control.ts
@@ -0,0 +1,14 @@
+/** glaciology control module — tsb analytics library. */
+export interface GlaciologyControlOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyControlResult { values: number[]; converged: boolean; }
+export function computeGlaciologyControl(data: number[], opts: GlaciologyControlOptions = {}): GlaciologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyControl };
diff --git a/src/glaciology/convergence.ts b/src/glaciology/convergence.ts
new file mode 100644
index 000000000..c02391359
--- /dev/null
+++ b/src/glaciology/convergence.ts
@@ -0,0 +1,14 @@
+/** glaciology convergence module — tsb analytics library. */
+export interface GlaciologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeGlaciologyConvergence(data: number[], opts: GlaciologyConvergenceOptions = {}): GlaciologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyConvergence };
diff --git a/src/glaciology/convex.ts b/src/glaciology/convex.ts
new file mode 100644
index 000000000..dce5228d2
--- /dev/null
+++ b/src/glaciology/convex.ts
@@ -0,0 +1,14 @@
+/** glaciology convex module — tsb analytics library. */
+export interface GlaciologyConvexOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyConvexResult { values: number[]; converged: boolean; }
+export function computeGlaciologyConvex(data: number[], opts: GlaciologyConvexOptions = {}): GlaciologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyConvex };
diff --git a/src/glaciology/correlation.ts b/src/glaciology/correlation.ts
new file mode 100644
index 000000000..ce78d8878
--- /dev/null
+++ b/src/glaciology/correlation.ts
@@ -0,0 +1,14 @@
+/** glaciology correlation module — tsb analytics library. */
+export interface GlaciologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyCorrelation(data: number[], opts: GlaciologyCorrelationOptions = {}): GlaciologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyCorrelation };
diff --git a/src/glaciology/covariance.ts b/src/glaciology/covariance.ts
new file mode 100644
index 000000000..d09efaab4
--- /dev/null
+++ b/src/glaciology/covariance.ts
@@ -0,0 +1,14 @@
+/** glaciology covariance module — tsb analytics library. */
+export interface GlaciologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeGlaciologyCovariance(data: number[], opts: GlaciologyCovarianceOptions = {}): GlaciologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyCovariance };
diff --git a/src/glaciology/cross_validation.ts b/src/glaciology/cross_validation.ts
new file mode 100644
index 000000000..d8e9c63d8
--- /dev/null
+++ b/src/glaciology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** glaciology cross_validation module — tsb analytics library. */
+export interface GlaciologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyCrossValidation(data: number[], opts: GlaciologyCrossValidationOptions = {}): GlaciologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyCrossValidation };
diff --git a/src/glaciology/decoding.ts b/src/glaciology/decoding.ts
new file mode 100644
index 000000000..c278fa3ba
--- /dev/null
+++ b/src/glaciology/decoding.ts
@@ -0,0 +1,14 @@
+/** glaciology decoding module — tsb analytics library. */
+export interface GlaciologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDecodingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDecoding(data: number[], opts: GlaciologyDecodingOptions = {}): GlaciologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDecoding };
diff --git a/src/glaciology/decomposition.ts b/src/glaciology/decomposition.ts
new file mode 100644
index 000000000..04e806899
--- /dev/null
+++ b/src/glaciology/decomposition.ts
@@ -0,0 +1,14 @@
+/** glaciology decomposition module — tsb analytics library. */
+export interface GlaciologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDecomposition(data: number[], opts: GlaciologyDecompositionOptions = {}): GlaciologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDecomposition };
diff --git a/src/glaciology/detection.ts b/src/glaciology/detection.ts
new file mode 100644
index 000000000..fe672e99d
--- /dev/null
+++ b/src/glaciology/detection.ts
@@ -0,0 +1,14 @@
+/** glaciology detection module — tsb analytics library. */
+export interface GlaciologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDetectionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDetection(data: number[], opts: GlaciologyDetectionOptions = {}): GlaciologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDetection };
diff --git a/src/glaciology/deterministic.ts b/src/glaciology/deterministic.ts
new file mode 100644
index 000000000..c643c19af
--- /dev/null
+++ b/src/glaciology/deterministic.ts
@@ -0,0 +1,14 @@
+/** glaciology deterministic module — tsb analytics library. */
+export interface GlaciologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDeterministic(data: number[], opts: GlaciologyDeterministicOptions = {}): GlaciologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDeterministic };
diff --git a/src/glaciology/diagnostics.ts b/src/glaciology/diagnostics.ts
new file mode 100644
index 000000000..d96268f2c
--- /dev/null
+++ b/src/glaciology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** glaciology diagnostics module — tsb analytics library. */
+export interface GlaciologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDiagnostics(data: number[], opts: GlaciologyDiagnosticsOptions = {}): GlaciologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDiagnostics };
diff --git a/src/glaciology/differential.ts b/src/glaciology/differential.ts
new file mode 100644
index 000000000..958c9ecb3
--- /dev/null
+++ b/src/glaciology/differential.ts
@@ -0,0 +1,14 @@
+/** glaciology differential module — tsb analytics library. */
+export interface GlaciologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDifferential(data: number[], opts: GlaciologyDifferentialOptions = {}): GlaciologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDifferential };
diff --git a/src/glaciology/discrete.ts b/src/glaciology/discrete.ts
new file mode 100644
index 000000000..6bf7ba116
--- /dev/null
+++ b/src/glaciology/discrete.ts
@@ -0,0 +1,14 @@
+/** glaciology discrete module — tsb analytics library. */
+export interface GlaciologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDiscrete(data: number[], opts: GlaciologyDiscreteOptions = {}): GlaciologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDiscrete };
diff --git a/src/glaciology/distribution.ts b/src/glaciology/distribution.ts
new file mode 100644
index 000000000..754ebb874
--- /dev/null
+++ b/src/glaciology/distribution.ts
@@ -0,0 +1,14 @@
+/** glaciology distribution module — tsb analytics library. */
+export interface GlaciologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDistributionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDistribution(data: number[], opts: GlaciologyDistributionOptions = {}): GlaciologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDistribution };
diff --git a/src/glaciology/dynamic.ts b/src/glaciology/dynamic.ts
new file mode 100644
index 000000000..4559ae1e3
--- /dev/null
+++ b/src/glaciology/dynamic.ts
@@ -0,0 +1,14 @@
+/** glaciology dynamic module — tsb analytics library. */
+export interface GlaciologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyDynamicResult { values: number[]; converged: boolean; }
+export function computeGlaciologyDynamic(data: number[], opts: GlaciologyDynamicOptions = {}): GlaciologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyDynamic };
diff --git a/src/glaciology/embedding.ts b/src/glaciology/embedding.ts
new file mode 100644
index 000000000..db4ee543b
--- /dev/null
+++ b/src/glaciology/embedding.ts
@@ -0,0 +1,14 @@
+/** glaciology embedding module — tsb analytics library. */
+export interface GlaciologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyEmbedding(data: number[], opts: GlaciologyEmbeddingOptions = {}): GlaciologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyEmbedding };
diff --git a/src/glaciology/encoding.ts b/src/glaciology/encoding.ts
new file mode 100644
index 000000000..f05387a25
--- /dev/null
+++ b/src/glaciology/encoding.ts
@@ -0,0 +1,14 @@
+/** glaciology encoding module — tsb analytics library. */
+export interface GlaciologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyEncodingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyEncoding(data: number[], opts: GlaciologyEncodingOptions = {}): GlaciologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyEncoding };
diff --git a/src/glaciology/ensemble.ts b/src/glaciology/ensemble.ts
new file mode 100644
index 000000000..e6a2b7168
--- /dev/null
+++ b/src/glaciology/ensemble.ts
@@ -0,0 +1,14 @@
+/** glaciology ensemble module — tsb analytics library. */
+export interface GlaciologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeGlaciologyEnsemble(data: number[], opts: GlaciologyEnsembleOptions = {}): GlaciologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyEnsemble };
diff --git a/src/glaciology/estimation.ts b/src/glaciology/estimation.ts
new file mode 100644
index 000000000..3bd3ac63a
--- /dev/null
+++ b/src/glaciology/estimation.ts
@@ -0,0 +1,14 @@
+/** glaciology estimation module — tsb analytics library. */
+export interface GlaciologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyEstimationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyEstimation(data: number[], opts: GlaciologyEstimationOptions = {}): GlaciologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyEstimation };
diff --git a/src/glaciology/evaluation.ts b/src/glaciology/evaluation.ts
new file mode 100644
index 000000000..145bacf64
--- /dev/null
+++ b/src/glaciology/evaluation.ts
@@ -0,0 +1,14 @@
+/** glaciology evaluation module — tsb analytics library. */
+export interface GlaciologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyEvaluation(data: number[], opts: GlaciologyEvaluationOptions = {}): GlaciologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyEvaluation };
diff --git a/src/glaciology/extrapolation.ts b/src/glaciology/extrapolation.ts
new file mode 100644
index 000000000..c3ca6c7e9
--- /dev/null
+++ b/src/glaciology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** glaciology extrapolation module — tsb analytics library. */
+export interface GlaciologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyExtrapolation(data: number[], opts: GlaciologyExtrapolationOptions = {}): GlaciologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyExtrapolation };
diff --git a/src/glaciology/features.ts b/src/glaciology/features.ts
new file mode 100644
index 000000000..b3e0cbe9f
--- /dev/null
+++ b/src/glaciology/features.ts
@@ -0,0 +1,14 @@
+/** glaciology features module — tsb analytics library. */
+export interface GlaciologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeGlaciologyFeatures(data: number[], opts: GlaciologyFeaturesOptions = {}): GlaciologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyFeatures };
diff --git a/src/glaciology/feedback.ts b/src/glaciology/feedback.ts
new file mode 100644
index 000000000..ea8bde004
--- /dev/null
+++ b/src/glaciology/feedback.ts
@@ -0,0 +1,14 @@
+/** glaciology feedback module — tsb analytics library. */
+export interface GlaciologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeGlaciologyFeedback(data: number[], opts: GlaciologyFeedbackOptions = {}): GlaciologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyFeedback };
diff --git a/src/glaciology/filtering.ts b/src/glaciology/filtering.ts
new file mode 100644
index 000000000..05dfedc2f
--- /dev/null
+++ b/src/glaciology/filtering.ts
@@ -0,0 +1,14 @@
+/** glaciology filtering module — tsb analytics library. */
+export interface GlaciologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyFilteringResult { values: number[]; converged: boolean; }
+export function computeGlaciologyFiltering(data: number[], opts: GlaciologyFilteringOptions = {}): GlaciologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyFiltering };
diff --git a/src/glaciology/fourier.ts b/src/glaciology/fourier.ts
new file mode 100644
index 000000000..fc7bff16f
--- /dev/null
+++ b/src/glaciology/fourier.ts
@@ -0,0 +1,14 @@
+/** glaciology fourier module — tsb analytics library. */
+export interface GlaciologyFourierOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyFourierResult { values: number[]; converged: boolean; }
+export function computeGlaciologyFourier(data: number[], opts: GlaciologyFourierOptions = {}): GlaciologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyFourier };
diff --git a/src/glaciology/fusion.ts b/src/glaciology/fusion.ts
new file mode 100644
index 000000000..56a32c731
--- /dev/null
+++ b/src/glaciology/fusion.ts
@@ -0,0 +1,14 @@
+/** glaciology fusion module — tsb analytics library. */
+export interface GlaciologyFusionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyFusionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyFusion(data: number[], opts: GlaciologyFusionOptions = {}): GlaciologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyFusion };
diff --git a/src/glaciology/generation.ts b/src/glaciology/generation.ts
new file mode 100644
index 000000000..9622706e3
--- /dev/null
+++ b/src/glaciology/generation.ts
@@ -0,0 +1,14 @@
+/** glaciology generation module — tsb analytics library. */
+export interface GlaciologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyGenerationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyGeneration(data: number[], opts: GlaciologyGenerationOptions = {}): GlaciologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyGeneration };
diff --git a/src/glaciology/geometry.ts b/src/glaciology/geometry.ts
new file mode 100644
index 000000000..9c67a37a2
--- /dev/null
+++ b/src/glaciology/geometry.ts
@@ -0,0 +1,14 @@
+/** glaciology geometry module — tsb analytics library. */
+export interface GlaciologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyGeometryResult { values: number[]; converged: boolean; }
+export function computeGlaciologyGeometry(data: number[], opts: GlaciologyGeometryOptions = {}): GlaciologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyGeometry };
diff --git a/src/glaciology/gradient.ts b/src/glaciology/gradient.ts
new file mode 100644
index 000000000..7f3a40b1d
--- /dev/null
+++ b/src/glaciology/gradient.ts
@@ -0,0 +1,14 @@
+/** glaciology gradient module — tsb analytics library. */
+export interface GlaciologyGradientOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyGradientResult { values: number[]; converged: boolean; }
+export function computeGlaciologyGradient(data: number[], opts: GlaciologyGradientOptions = {}): GlaciologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyGradient };
diff --git a/src/glaciology/hessian.ts b/src/glaciology/hessian.ts
new file mode 100644
index 000000000..3bdc1bdaf
--- /dev/null
+++ b/src/glaciology/hessian.ts
@@ -0,0 +1,14 @@
+/** glaciology hessian module — tsb analytics library. */
+export interface GlaciologyHessianOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyHessianResult { values: number[]; converged: boolean; }
+export function computeGlaciologyHessian(data: number[], opts: GlaciologyHessianOptions = {}): GlaciologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyHessian };
diff --git a/src/glaciology/hypothesis.ts b/src/glaciology/hypothesis.ts
new file mode 100644
index 000000000..f9e10e40a
--- /dev/null
+++ b/src/glaciology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** glaciology hypothesis module — tsb analytics library. */
+export interface GlaciologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeGlaciologyHypothesis(data: number[], opts: GlaciologyHypothesisOptions = {}): GlaciologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyHypothesis };
diff --git a/src/glaciology/inference.ts b/src/glaciology/inference.ts
new file mode 100644
index 000000000..7bb83de94
--- /dev/null
+++ b/src/glaciology/inference.ts
@@ -0,0 +1,14 @@
+/** glaciology inference module — tsb analytics library. */
+export interface GlaciologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyInferenceResult { values: number[]; converged: boolean; }
+export function computeGlaciologyInference(data: number[], opts: GlaciologyInferenceOptions = {}): GlaciologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyInference };
diff --git a/src/glaciology/inference2.ts b/src/glaciology/inference2.ts
new file mode 100644
index 000000000..6bfd498c3
--- /dev/null
+++ b/src/glaciology/inference2.ts
@@ -0,0 +1,14 @@
+/** glaciology inference2 module — tsb analytics library. */
+export interface GlaciologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyInferenceResult { values: number[]; converged: boolean; }
+export function computeGlaciologyInference(data: number[], opts: GlaciologyInferenceOptions = {}): GlaciologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyInference };
diff --git a/src/glaciology/integral.ts b/src/glaciology/integral.ts
new file mode 100644
index 000000000..ed4438a15
--- /dev/null
+++ b/src/glaciology/integral.ts
@@ -0,0 +1,14 @@
+/** glaciology integral module — tsb analytics library. */
+export interface GlaciologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyIntegralResult { values: number[]; converged: boolean; }
+export function computeGlaciologyIntegral(data: number[], opts: GlaciologyIntegralOptions = {}): GlaciologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyIntegral };
diff --git a/src/glaciology/integration.ts b/src/glaciology/integration.ts
new file mode 100644
index 000000000..339f4d665
--- /dev/null
+++ b/src/glaciology/integration.ts
@@ -0,0 +1,14 @@
+/** glaciology integration module — tsb analytics library. */
+export interface GlaciologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyIntegration(data: number[], opts: GlaciologyIntegrationOptions = {}): GlaciologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyIntegration };
diff --git a/src/glaciology/interpolation.ts b/src/glaciology/interpolation.ts
new file mode 100644
index 000000000..ee9b2e451
--- /dev/null
+++ b/src/glaciology/interpolation.ts
@@ -0,0 +1,14 @@
+/** glaciology interpolation module — tsb analytics library. */
+export interface GlaciologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyInterpolation(data: number[], opts: GlaciologyInterpolationOptions = {}): GlaciologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyInterpolation };
diff --git a/src/glaciology/jacobian.ts b/src/glaciology/jacobian.ts
new file mode 100644
index 000000000..f7ffd4fe3
--- /dev/null
+++ b/src/glaciology/jacobian.ts
@@ -0,0 +1,14 @@
+/** glaciology jacobian module — tsb analytics library. */
+export interface GlaciologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyJacobianResult { values: number[]; converged: boolean; }
+export function computeGlaciologyJacobian(data: number[], opts: GlaciologyJacobianOptions = {}): GlaciologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyJacobian };
diff --git a/src/glaciology/kernel.ts b/src/glaciology/kernel.ts
new file mode 100644
index 000000000..52fc12763
--- /dev/null
+++ b/src/glaciology/kernel.ts
@@ -0,0 +1,14 @@
+/** glaciology kernel module — tsb analytics library. */
+export interface GlaciologyKernelOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyKernelResult { values: number[]; converged: boolean; }
+export function computeGlaciologyKernel(data: number[], opts: GlaciologyKernelOptions = {}): GlaciologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyKernel };
diff --git a/src/glaciology/laplacian.ts b/src/glaciology/laplacian.ts
new file mode 100644
index 000000000..e773afee5
--- /dev/null
+++ b/src/glaciology/laplacian.ts
@@ -0,0 +1,14 @@
+/** glaciology laplacian module — tsb analytics library. */
+export interface GlaciologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeGlaciologyLaplacian(data: number[], opts: GlaciologyLaplacianOptions = {}): GlaciologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyLaplacian };
diff --git a/src/glaciology/learning.ts b/src/glaciology/learning.ts
new file mode 100644
index 000000000..423783d7a
--- /dev/null
+++ b/src/glaciology/learning.ts
@@ -0,0 +1,14 @@
+/** glaciology learning module — tsb analytics library. */
+export interface GlaciologyLearningOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyLearningResult { values: number[]; converged: boolean; }
+export function computeGlaciologyLearning(data: number[], opts: GlaciologyLearningOptions = {}): GlaciologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyLearning };
diff --git a/src/glaciology/linear.ts b/src/glaciology/linear.ts
new file mode 100644
index 000000000..03adae80d
--- /dev/null
+++ b/src/glaciology/linear.ts
@@ -0,0 +1,14 @@
+/** glaciology linear module — tsb analytics library. */
+export interface GlaciologyLinearOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyLinearResult { values: number[]; converged: boolean; }
+export function computeGlaciologyLinear(data: number[], opts: GlaciologyLinearOptions = {}): GlaciologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyLinear };
diff --git a/src/glaciology/manifold.ts b/src/glaciology/manifold.ts
new file mode 100644
index 000000000..855ce8ce5
--- /dev/null
+++ b/src/glaciology/manifold.ts
@@ -0,0 +1,14 @@
+/** glaciology manifold module — tsb analytics library. */
+export interface GlaciologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyManifoldResult { values: number[]; converged: boolean; }
+export function computeGlaciologyManifold(data: number[], opts: GlaciologyManifoldOptions = {}): GlaciologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyManifold };
diff --git a/src/glaciology/matching.ts b/src/glaciology/matching.ts
new file mode 100644
index 000000000..eb50946c2
--- /dev/null
+++ b/src/glaciology/matching.ts
@@ -0,0 +1,14 @@
+/** glaciology matching module — tsb analytics library. */
+export interface GlaciologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyMatchingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyMatching(data: number[], opts: GlaciologyMatchingOptions = {}): GlaciologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyMatching };
diff --git a/src/glaciology/measurement.ts b/src/glaciology/measurement.ts
new file mode 100644
index 000000000..4eac9b6e5
--- /dev/null
+++ b/src/glaciology/measurement.ts
@@ -0,0 +1,14 @@
+/** glaciology measurement module — tsb analytics library. */
+export interface GlaciologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeGlaciologyMeasurement(data: number[], opts: GlaciologyMeasurementOptions = {}): GlaciologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyMeasurement };
diff --git a/src/glaciology/metrics.ts b/src/glaciology/metrics.ts
new file mode 100644
index 000000000..c87faa83c
--- /dev/null
+++ b/src/glaciology/metrics.ts
@@ -0,0 +1,14 @@
+/** glaciology metrics module — tsb analytics library. */
+export interface GlaciologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyMetricsResult { values: number[]; converged: boolean; }
+export function computeGlaciologyMetrics(data: number[], opts: GlaciologyMetricsOptions = {}): GlaciologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyMetrics };
diff --git a/src/glaciology/modeling.ts b/src/glaciology/modeling.ts
new file mode 100644
index 000000000..53845691d
--- /dev/null
+++ b/src/glaciology/modeling.ts
@@ -0,0 +1,14 @@
+/** glaciology modeling module — tsb analytics library. */
+export interface GlaciologyModelingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyModelingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyModeling(data: number[], opts: GlaciologyModelingOptions = {}): GlaciologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyModeling };
diff --git a/src/glaciology/monitoring.ts b/src/glaciology/monitoring.ts
new file mode 100644
index 000000000..b381aae9b
--- /dev/null
+++ b/src/glaciology/monitoring.ts
@@ -0,0 +1,14 @@
+/** glaciology monitoring module — tsb analytics library. */
+export interface GlaciologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeGlaciologyMonitoring(data: number[], opts: GlaciologyMonitoringOptions = {}): GlaciologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyMonitoring };
diff --git a/src/glaciology/nonlinear.ts b/src/glaciology/nonlinear.ts
new file mode 100644
index 000000000..95404487b
--- /dev/null
+++ b/src/glaciology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** glaciology nonlinear module — tsb analytics library. */
+export interface GlaciologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeGlaciologyNonlinear(data: number[], opts: GlaciologyNonlinearOptions = {}): GlaciologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyNonlinear };
diff --git a/src/glaciology/normalization.ts b/src/glaciology/normalization.ts
new file mode 100644
index 000000000..edb6cb62c
--- /dev/null
+++ b/src/glaciology/normalization.ts
@@ -0,0 +1,14 @@
+/** glaciology normalization module — tsb analytics library. */
+export interface GlaciologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyNormalization(data: number[], opts: GlaciologyNormalizationOptions = {}): GlaciologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyNormalization };
diff --git a/src/glaciology/optimization.ts b/src/glaciology/optimization.ts
new file mode 100644
index 000000000..480807c95
--- /dev/null
+++ b/src/glaciology/optimization.ts
@@ -0,0 +1,14 @@
+/** glaciology optimization module — tsb analytics library. */
+export interface GlaciologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyOptimization(data: number[], opts: GlaciologyOptimizationOptions = {}): GlaciologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyOptimization };
diff --git a/src/glaciology/patterns.ts b/src/glaciology/patterns.ts
new file mode 100644
index 000000000..d56024876
--- /dev/null
+++ b/src/glaciology/patterns.ts
@@ -0,0 +1,14 @@
+/** glaciology patterns module — tsb analytics library. */
+export interface GlaciologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyPatternsResult { values: number[]; converged: boolean; }
+export function computeGlaciologyPatterns(data: number[], opts: GlaciologyPatternsOptions = {}): GlaciologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyPatterns };
diff --git a/src/glaciology/permutation.ts b/src/glaciology/permutation.ts
new file mode 100644
index 000000000..0bcc956b6
--- /dev/null
+++ b/src/glaciology/permutation.ts
@@ -0,0 +1,14 @@
+/** glaciology permutation module — tsb analytics library. */
+export interface GlaciologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyPermutationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyPermutation(data: number[], opts: GlaciologyPermutationOptions = {}): GlaciologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyPermutation };
diff --git a/src/glaciology/prediction.ts b/src/glaciology/prediction.ts
new file mode 100644
index 000000000..20bc22f72
--- /dev/null
+++ b/src/glaciology/prediction.ts
@@ -0,0 +1,14 @@
+/** glaciology prediction module — tsb analytics library. */
+export interface GlaciologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyPredictionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyPrediction(data: number[], opts: GlaciologyPredictionOptions = {}): GlaciologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyPrediction };
diff --git a/src/glaciology/processing.ts b/src/glaciology/processing.ts
new file mode 100644
index 000000000..16611e5ba
--- /dev/null
+++ b/src/glaciology/processing.ts
@@ -0,0 +1,14 @@
+/** glaciology processing module — tsb analytics library. */
+export interface GlaciologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyProcessingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyProcessing(data: number[], opts: GlaciologyProcessingOptions = {}): GlaciologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyProcessing };
diff --git a/src/glaciology/profiling.ts b/src/glaciology/profiling.ts
new file mode 100644
index 000000000..0951f00b6
--- /dev/null
+++ b/src/glaciology/profiling.ts
@@ -0,0 +1,14 @@
+/** glaciology profiling module — tsb analytics library. */
+export interface GlaciologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyProfilingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyProfiling(data: number[], opts: GlaciologyProfilingOptions = {}): GlaciologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyProfiling };
diff --git a/src/glaciology/projection.ts b/src/glaciology/projection.ts
new file mode 100644
index 000000000..e91c79dd3
--- /dev/null
+++ b/src/glaciology/projection.ts
@@ -0,0 +1,14 @@
+/** glaciology projection module — tsb analytics library. */
+export interface GlaciologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyProjectionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyProjection(data: number[], opts: GlaciologyProjectionOptions = {}): GlaciologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyProjection };
diff --git a/src/glaciology/ranking.ts b/src/glaciology/ranking.ts
new file mode 100644
index 000000000..f1a57d72e
--- /dev/null
+++ b/src/glaciology/ranking.ts
@@ -0,0 +1,14 @@
+/** glaciology ranking module — tsb analytics library. */
+export interface GlaciologyRankingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyRankingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyRanking(data: number[], opts: GlaciologyRankingOptions = {}): GlaciologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyRanking };
diff --git a/src/glaciology/reconstruction.ts b/src/glaciology/reconstruction.ts
new file mode 100644
index 000000000..f59de5477
--- /dev/null
+++ b/src/glaciology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** glaciology reconstruction module — tsb analytics library. */
+export interface GlaciologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyReconstruction(data: number[], opts: GlaciologyReconstructionOptions = {}): GlaciologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyReconstruction };
diff --git a/src/glaciology/registration.ts b/src/glaciology/registration.ts
new file mode 100644
index 000000000..a72039924
--- /dev/null
+++ b/src/glaciology/registration.ts
@@ -0,0 +1,14 @@
+/** glaciology registration module — tsb analytics library. */
+export interface GlaciologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyRegistration(data: number[], opts: GlaciologyRegistrationOptions = {}): GlaciologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyRegistration };
diff --git a/src/glaciology/regression.ts b/src/glaciology/regression.ts
new file mode 100644
index 000000000..8ff3893a2
--- /dev/null
+++ b/src/glaciology/regression.ts
@@ -0,0 +1,14 @@
+/** glaciology regression module — tsb analytics library. */
+export interface GlaciologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyRegressionResult { values: number[]; converged: boolean; }
+export function computeGlaciologyRegression(data: number[], opts: GlaciologyRegressionOptions = {}): GlaciologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyRegression };
diff --git a/src/glaciology/regularization.ts b/src/glaciology/regularization.ts
new file mode 100644
index 000000000..8f217ac4e
--- /dev/null
+++ b/src/glaciology/regularization.ts
@@ -0,0 +1,14 @@
+/** glaciology regularization module — tsb analytics library. */
+export interface GlaciologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyRegularization(data: number[], opts: GlaciologyRegularizationOptions = {}): GlaciologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyRegularization };
diff --git a/src/glaciology/robustness.ts b/src/glaciology/robustness.ts
new file mode 100644
index 000000000..e23798388
--- /dev/null
+++ b/src/glaciology/robustness.ts
@@ -0,0 +1,14 @@
+/** glaciology robustness module — tsb analytics library. */
+export interface GlaciologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeGlaciologyRobustness(data: number[], opts: GlaciologyRobustnessOptions = {}): GlaciologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyRobustness };
diff --git a/src/glaciology/sampling.ts b/src/glaciology/sampling.ts
new file mode 100644
index 000000000..64a6e5f80
--- /dev/null
+++ b/src/glaciology/sampling.ts
@@ -0,0 +1,14 @@
+/** glaciology sampling module — tsb analytics library. */
+export interface GlaciologySamplingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologySamplingResult { values: number[]; converged: boolean; }
+export function computeGlaciologySampling(data: number[], opts: GlaciologySamplingOptions = {}): GlaciologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologySampling };
diff --git a/src/glaciology/sampling2.ts b/src/glaciology/sampling2.ts
new file mode 100644
index 000000000..88afef30d
--- /dev/null
+++ b/src/glaciology/sampling2.ts
@@ -0,0 +1,14 @@
+/** glaciology sampling2 module — tsb analytics library. */
+export interface GlaciologySamplingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologySamplingResult { values: number[]; converged: boolean; }
+export function computeGlaciologySampling(data: number[], opts: GlaciologySamplingOptions = {}): GlaciologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologySampling };
diff --git a/src/glaciology/scaling.ts b/src/glaciology/scaling.ts
new file mode 100644
index 000000000..2b73c1137
--- /dev/null
+++ b/src/glaciology/scaling.ts
@@ -0,0 +1,14 @@
+/** glaciology scaling module — tsb analytics library. */
+export interface GlaciologyScalingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyScalingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyScaling(data: number[], opts: GlaciologyScalingOptions = {}): GlaciologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyScaling };
diff --git a/src/glaciology/scoring.ts b/src/glaciology/scoring.ts
new file mode 100644
index 000000000..95cf6dc63
--- /dev/null
+++ b/src/glaciology/scoring.ts
@@ -0,0 +1,14 @@
+/** glaciology scoring module — tsb analytics library. */
+export interface GlaciologyScoringOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyScoringResult { values: number[]; converged: boolean; }
+export function computeGlaciologyScoring(data: number[], opts: GlaciologyScoringOptions = {}): GlaciologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyScoring };
diff --git a/src/glaciology/segmentation.ts b/src/glaciology/segmentation.ts
new file mode 100644
index 000000000..9db26ae1d
--- /dev/null
+++ b/src/glaciology/segmentation.ts
@@ -0,0 +1,14 @@
+/** glaciology segmentation module — tsb analytics library. */
+export interface GlaciologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologySegmentationResult { values: number[]; converged: boolean; }
+export function computeGlaciologySegmentation(data: number[], opts: GlaciologySegmentationOptions = {}): GlaciologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologySegmentation };
diff --git a/src/glaciology/selection.ts b/src/glaciology/selection.ts
new file mode 100644
index 000000000..74727c14a
--- /dev/null
+++ b/src/glaciology/selection.ts
@@ -0,0 +1,14 @@
+/** glaciology selection module — tsb analytics library. */
+export interface GlaciologySelectionOptions { tol?: number; maxIter?: number; }
+export interface GlaciologySelectionResult { values: number[]; converged: boolean; }
+export function computeGlaciologySelection(data: number[], opts: GlaciologySelectionOptions = {}): GlaciologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologySelection };
diff --git a/src/glaciology/sensitivity.ts b/src/glaciology/sensitivity.ts
new file mode 100644
index 000000000..7bd858dea
--- /dev/null
+++ b/src/glaciology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** glaciology sensitivity module — tsb analytics library. */
+export interface GlaciologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface GlaciologySensitivityResult { values: number[]; converged: boolean; }
+export function computeGlaciologySensitivity(data: number[], opts: GlaciologySensitivityOptions = {}): GlaciologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologySensitivity };
diff --git a/src/glaciology/simulation.ts b/src/glaciology/simulation.ts
new file mode 100644
index 000000000..611b74f92
--- /dev/null
+++ b/src/glaciology/simulation.ts
@@ -0,0 +1,14 @@
+/** glaciology simulation module — tsb analytics library. */
+export interface GlaciologySimulationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologySimulationResult { values: number[]; converged: boolean; }
+export function computeGlaciologySimulation(data: number[], opts: GlaciologySimulationOptions = {}): GlaciologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologySimulation };
diff --git a/src/glaciology/smoothing.ts b/src/glaciology/smoothing.ts
new file mode 100644
index 000000000..1a7e07dfe
--- /dev/null
+++ b/src/glaciology/smoothing.ts
@@ -0,0 +1,14 @@
+/** glaciology smoothing module — tsb analytics library. */
+export interface GlaciologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologySmoothingResult { values: number[]; converged: boolean; }
+export function computeGlaciologySmoothing(data: number[], opts: GlaciologySmoothingOptions = {}): GlaciologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologySmoothing };
diff --git a/src/glaciology/stability.ts b/src/glaciology/stability.ts
new file mode 100644
index 000000000..7f3e0c0f1
--- /dev/null
+++ b/src/glaciology/stability.ts
@@ -0,0 +1,14 @@
+/** glaciology stability module — tsb analytics library. */
+export interface GlaciologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyStabilityResult { values: number[]; converged: boolean; }
+export function computeGlaciologyStability(data: number[], opts: GlaciologyStabilityOptions = {}): GlaciologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyStability };
diff --git a/src/glaciology/stacking.ts b/src/glaciology/stacking.ts
new file mode 100644
index 000000000..af8587fc5
--- /dev/null
+++ b/src/glaciology/stacking.ts
@@ -0,0 +1,14 @@
+/** glaciology stacking module — tsb analytics library. */
+export interface GlaciologyStackingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyStackingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyStacking(data: number[], opts: GlaciologyStackingOptions = {}): GlaciologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyStacking };
diff --git a/src/glaciology/standardization.ts b/src/glaciology/standardization.ts
new file mode 100644
index 000000000..98dc9b2f9
--- /dev/null
+++ b/src/glaciology/standardization.ts
@@ -0,0 +1,14 @@
+/** glaciology standardization module — tsb analytics library. */
+export interface GlaciologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyStandardization(data: number[], opts: GlaciologyStandardizationOptions = {}): GlaciologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyStandardization };
diff --git a/src/glaciology/static.ts b/src/glaciology/static.ts
new file mode 100644
index 000000000..e47a34381
--- /dev/null
+++ b/src/glaciology/static.ts
@@ -0,0 +1,14 @@
+/** glaciology static module — tsb analytics library. */
+export interface GlaciologyStaticOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyStaticResult { values: number[]; converged: boolean; }
+export function computeGlaciologyStatic(data: number[], opts: GlaciologyStaticOptions = {}): GlaciologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyStatic };
diff --git a/src/glaciology/stochastic.ts b/src/glaciology/stochastic.ts
new file mode 100644
index 000000000..0a79cc390
--- /dev/null
+++ b/src/glaciology/stochastic.ts
@@ -0,0 +1,14 @@
+/** glaciology stochastic module — tsb analytics library. */
+export interface GlaciologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyStochasticResult { values: number[]; converged: boolean; }
+export function computeGlaciologyStochastic(data: number[], opts: GlaciologyStochasticOptions = {}): GlaciologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyStochastic };
diff --git a/src/glaciology/synthesis.ts b/src/glaciology/synthesis.ts
new file mode 100644
index 000000000..4c6cd21e4
--- /dev/null
+++ b/src/glaciology/synthesis.ts
@@ -0,0 +1,14 @@
+/** glaciology synthesis module — tsb analytics library. */
+export interface GlaciologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface GlaciologySynthesisResult { values: number[]; converged: boolean; }
+export function computeGlaciologySynthesis(data: number[], opts: GlaciologySynthesisOptions = {}): GlaciologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologySynthesis };
diff --git a/src/glaciology/topology.ts b/src/glaciology/topology.ts
new file mode 100644
index 000000000..f4b59c445
--- /dev/null
+++ b/src/glaciology/topology.ts
@@ -0,0 +1,14 @@
+/** glaciology topology module — tsb analytics library. */
+export interface GlaciologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyTopologyResult { values: number[]; converged: boolean; }
+export function computeGlaciologyTopology(data: number[], opts: GlaciologyTopologyOptions = {}): GlaciologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyTopology };
diff --git a/src/glaciology/tracking.ts b/src/glaciology/tracking.ts
new file mode 100644
index 000000000..867015d5e
--- /dev/null
+++ b/src/glaciology/tracking.ts
@@ -0,0 +1,14 @@
+/** glaciology tracking module — tsb analytics library. */
+export interface GlaciologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyTrackingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyTracking(data: number[], opts: GlaciologyTrackingOptions = {}): GlaciologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyTracking };
diff --git a/src/glaciology/transform.ts b/src/glaciology/transform.ts
new file mode 100644
index 000000000..186a4e17d
--- /dev/null
+++ b/src/glaciology/transform.ts
@@ -0,0 +1,14 @@
+/** glaciology transform module — tsb analytics library. */
+export interface GlaciologyTransformOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyTransformResult { values: number[]; converged: boolean; }
+export function computeGlaciologyTransform(data: number[], opts: GlaciologyTransformOptions = {}): GlaciologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyTransform };
diff --git a/src/glaciology/uncertainty.ts b/src/glaciology/uncertainty.ts
new file mode 100644
index 000000000..e0645cacb
--- /dev/null
+++ b/src/glaciology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** glaciology uncertainty module — tsb analytics library. */
+export interface GlaciologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGlaciologyUncertainty(data: number[], opts: GlaciologyUncertaintyOptions = {}): GlaciologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyUncertainty };
diff --git a/src/glaciology/validation.ts b/src/glaciology/validation.ts
new file mode 100644
index 000000000..5d84ff288
--- /dev/null
+++ b/src/glaciology/validation.ts
@@ -0,0 +1,14 @@
+/** glaciology validation module — tsb analytics library. */
+export interface GlaciologyValidationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyValidationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyValidation(data: number[], opts: GlaciologyValidationOptions = {}): GlaciologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyValidation };
diff --git a/src/glaciology/verification.ts b/src/glaciology/verification.ts
new file mode 100644
index 000000000..bb2266e97
--- /dev/null
+++ b/src/glaciology/verification.ts
@@ -0,0 +1,14 @@
+/** glaciology verification module — tsb analytics library. */
+export interface GlaciologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyVerificationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyVerification(data: number[], opts: GlaciologyVerificationOptions = {}): GlaciologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyVerification };
diff --git a/src/glaciology/visualization.ts b/src/glaciology/visualization.ts
new file mode 100644
index 000000000..72559515c
--- /dev/null
+++ b/src/glaciology/visualization.ts
@@ -0,0 +1,14 @@
+/** glaciology visualization module — tsb analytics library. */
+export interface GlaciologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeGlaciologyVisualization(data: number[], opts: GlaciologyVisualizationOptions = {}): GlaciologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyVisualization };
diff --git a/src/glaciology/voting.ts b/src/glaciology/voting.ts
new file mode 100644
index 000000000..e107b33aa
--- /dev/null
+++ b/src/glaciology/voting.ts
@@ -0,0 +1,14 @@
+/** glaciology voting module — tsb analytics library. */
+export interface GlaciologyVotingOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyVotingResult { values: number[]; converged: boolean; }
+export function computeGlaciologyVoting(data: number[], opts: GlaciologyVotingOptions = {}): GlaciologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyVoting };
diff --git a/src/glaciology/wavelet.ts b/src/glaciology/wavelet.ts
new file mode 100644
index 000000000..03388dd3c
--- /dev/null
+++ b/src/glaciology/wavelet.ts
@@ -0,0 +1,14 @@
+/** glaciology wavelet module — tsb analytics library. */
+export interface GlaciologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface GlaciologyWaveletResult { values: number[]; converged: boolean; }
+export function computeGlaciologyWavelet(data: number[], opts: GlaciologyWaveletOptions = {}): GlaciologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlaciologyWavelet };
diff --git a/src/glass_sci/adaptation.ts b/src/glass_sci/adaptation.ts
new file mode 100644
index 000000000..5216a5085
--- /dev/null
+++ b/src/glass_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** glass_sci adaptation module — tsb analytics library. */
+export interface GlassSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeGlassSciAdaptation(data: number[], opts: GlassSciAdaptationOptions = {}): GlassSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciAdaptation };
diff --git a/src/glass_sci/aggregation.ts b/src/glass_sci/aggregation.ts
new file mode 100644
index 000000000..e894513c5
--- /dev/null
+++ b/src/glass_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** glass_sci aggregation module — tsb analytics library. */
+export interface GlassSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciAggregationResult { values: number[]; converged: boolean; }
+export function computeGlassSciAggregation(data: number[], opts: GlassSciAggregationOptions = {}): GlassSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciAggregation };
diff --git a/src/glass_sci/algebra.ts b/src/glass_sci/algebra.ts
new file mode 100644
index 000000000..a0c3ba0f2
--- /dev/null
+++ b/src/glass_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** glass_sci algebra module — tsb analytics library. */
+export interface GlassSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GlassSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeGlassSciAlgebra(data: number[], opts: GlassSciAlgebraOptions = {}): GlassSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciAlgebra };
diff --git a/src/glass_sci/alignment.ts b/src/glass_sci/alignment.ts
new file mode 100644
index 000000000..e812fdeaf
--- /dev/null
+++ b/src/glass_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** glass_sci alignment module — tsb analytics library. */
+export interface GlassSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GlassSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeGlassSciAlignment(data: number[], opts: GlassSciAlignmentOptions = {}): GlassSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciAlignment };
diff --git a/src/glass_sci/analysis.ts b/src/glass_sci/analysis.ts
new file mode 100644
index 000000000..f4c8f3019
--- /dev/null
+++ b/src/glass_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** glass_sci analysis module — tsb analytics library. */
+export interface GlassSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GlassSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeGlassSciAnalysis(data: number[], opts: GlassSciAnalysisOptions = {}): GlassSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciAnalysis };
diff --git a/src/glass_sci/augmentation.ts b/src/glass_sci/augmentation.ts
new file mode 100644
index 000000000..3611f9b38
--- /dev/null
+++ b/src/glass_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** glass_sci augmentation module — tsb analytics library. */
+export interface GlassSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeGlassSciAugmentation(data: number[], opts: GlassSciAugmentationOptions = {}): GlassSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciAugmentation };
diff --git a/src/glass_sci/bagging.ts b/src/glass_sci/bagging.ts
new file mode 100644
index 000000000..45ef27857
--- /dev/null
+++ b/src/glass_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** glass_sci bagging module — tsb analytics library. */
+export interface GlassSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciBaggingResult { values: number[]; converged: boolean; }
+export function computeGlassSciBagging(data: number[], opts: GlassSciBaggingOptions = {}): GlassSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciBagging };
diff --git a/src/glass_sci/basis.ts b/src/glass_sci/basis.ts
new file mode 100644
index 000000000..f43baef9c
--- /dev/null
+++ b/src/glass_sci/basis.ts
@@ -0,0 +1,14 @@
+/** glass_sci basis module — tsb analytics library. */
+export interface GlassSciBasisOptions { tol?: number; maxIter?: number; }
+export interface GlassSciBasisResult { values: number[]; converged: boolean; }
+export function computeGlassSciBasis(data: number[], opts: GlassSciBasisOptions = {}): GlassSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciBasis };
diff --git a/src/glass_sci/benchmarking.ts b/src/glass_sci/benchmarking.ts
new file mode 100644
index 000000000..53ee8973a
--- /dev/null
+++ b/src/glass_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** glass_sci benchmarking module — tsb analytics library. */
+export interface GlassSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGlassSciBenchmarking(data: number[], opts: GlassSciBenchmarkingOptions = {}): GlassSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciBenchmarking };
diff --git a/src/glass_sci/blending.ts b/src/glass_sci/blending.ts
new file mode 100644
index 000000000..983cae7eb
--- /dev/null
+++ b/src/glass_sci/blending.ts
@@ -0,0 +1,14 @@
+/** glass_sci blending module — tsb analytics library. */
+export interface GlassSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciBlendingResult { values: number[]; converged: boolean; }
+export function computeGlassSciBlending(data: number[], opts: GlassSciBlendingOptions = {}): GlassSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciBlending };
diff --git a/src/glass_sci/boosting.ts b/src/glass_sci/boosting.ts
new file mode 100644
index 000000000..6afff37c1
--- /dev/null
+++ b/src/glass_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** glass_sci boosting module — tsb analytics library. */
+export interface GlassSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciBoostingResult { values: number[]; converged: boolean; }
+export function computeGlassSciBoosting(data: number[], opts: GlassSciBoostingOptions = {}): GlassSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciBoosting };
diff --git a/src/glass_sci/bootstrap.ts b/src/glass_sci/bootstrap.ts
new file mode 100644
index 000000000..f38aba9d6
--- /dev/null
+++ b/src/glass_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** glass_sci bootstrap module — tsb analytics library. */
+export interface GlassSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GlassSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeGlassSciBootstrap(data: number[], opts: GlassSciBootstrapOptions = {}): GlassSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciBootstrap };
diff --git a/src/glass_sci/calculus.ts b/src/glass_sci/calculus.ts
new file mode 100644
index 000000000..825b6aa60
--- /dev/null
+++ b/src/glass_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** glass_sci calculus module — tsb analytics library. */
+export interface GlassSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface GlassSciCalculusResult { values: number[]; converged: boolean; }
+export function computeGlassSciCalculus(data: number[], opts: GlassSciCalculusOptions = {}): GlassSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciCalculus };
diff --git a/src/glass_sci/calibration.ts b/src/glass_sci/calibration.ts
new file mode 100644
index 000000000..85a74feb0
--- /dev/null
+++ b/src/glass_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** glass_sci calibration module — tsb analytics library. */
+export interface GlassSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeGlassSciCalibration(data: number[], opts: GlassSciCalibrationOptions = {}): GlassSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciCalibration };
diff --git a/src/glass_sci/characterization.ts b/src/glass_sci/characterization.ts
new file mode 100644
index 000000000..6638cf872
--- /dev/null
+++ b/src/glass_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** glass_sci characterization module — tsb analytics library. */
+export interface GlassSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGlassSciCharacterization(data: number[], opts: GlassSciCharacterizationOptions = {}): GlassSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciCharacterization };
diff --git a/src/glass_sci/classification.ts b/src/glass_sci/classification.ts
new file mode 100644
index 000000000..48a8f2f1e
--- /dev/null
+++ b/src/glass_sci/classification.ts
@@ -0,0 +1,14 @@
+/** glass_sci classification module — tsb analytics library. */
+export interface GlassSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciClassificationResult { values: number[]; converged: boolean; }
+export function computeGlassSciClassification(data: number[], opts: GlassSciClassificationOptions = {}): GlassSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciClassification };
diff --git a/src/glass_sci/clustering.ts b/src/glass_sci/clustering.ts
new file mode 100644
index 000000000..31af168d6
--- /dev/null
+++ b/src/glass_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** glass_sci clustering module — tsb analytics library. */
+export interface GlassSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface GlassSciClusteringResult { values: number[]; converged: boolean; }
+export function computeGlassSciClustering(data: number[], opts: GlassSciClusteringOptions = {}): GlassSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciClustering };
diff --git a/src/glass_sci/compression.ts b/src/glass_sci/compression.ts
new file mode 100644
index 000000000..53ce98c40
--- /dev/null
+++ b/src/glass_sci/compression.ts
@@ -0,0 +1,14 @@
+/** glass_sci compression module — tsb analytics library. */
+export interface GlassSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciCompressionResult { values: number[]; converged: boolean; }
+export function computeGlassSciCompression(data: number[], opts: GlassSciCompressionOptions = {}): GlassSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciCompression };
diff --git a/src/glass_sci/continuous.ts b/src/glass_sci/continuous.ts
new file mode 100644
index 000000000..43dfa491a
--- /dev/null
+++ b/src/glass_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** glass_sci continuous module — tsb analytics library. */
+export interface GlassSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface GlassSciContinuousResult { values: number[]; converged: boolean; }
+export function computeGlassSciContinuous(data: number[], opts: GlassSciContinuousOptions = {}): GlassSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciContinuous };
diff --git a/src/glass_sci/control.ts b/src/glass_sci/control.ts
new file mode 100644
index 000000000..667039ab6
--- /dev/null
+++ b/src/glass_sci/control.ts
@@ -0,0 +1,14 @@
+/** glass_sci control module — tsb analytics library. */
+export interface GlassSciControlOptions { tol?: number; maxIter?: number; }
+export interface GlassSciControlResult { values: number[]; converged: boolean; }
+export function computeGlassSciControl(data: number[], opts: GlassSciControlOptions = {}): GlassSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciControl };
diff --git a/src/glass_sci/convergence.ts b/src/glass_sci/convergence.ts
new file mode 100644
index 000000000..44b39880c
--- /dev/null
+++ b/src/glass_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** glass_sci convergence module — tsb analytics library. */
+export interface GlassSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GlassSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeGlassSciConvergence(data: number[], opts: GlassSciConvergenceOptions = {}): GlassSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciConvergence };
diff --git a/src/glass_sci/convex.ts b/src/glass_sci/convex.ts
new file mode 100644
index 000000000..fb75aaff0
--- /dev/null
+++ b/src/glass_sci/convex.ts
@@ -0,0 +1,14 @@
+/** glass_sci convex module — tsb analytics library. */
+export interface GlassSciConvexOptions { tol?: number; maxIter?: number; }
+export interface GlassSciConvexResult { values: number[]; converged: boolean; }
+export function computeGlassSciConvex(data: number[], opts: GlassSciConvexOptions = {}): GlassSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciConvex };
diff --git a/src/glass_sci/correlation.ts b/src/glass_sci/correlation.ts
new file mode 100644
index 000000000..42c9f492f
--- /dev/null
+++ b/src/glass_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** glass_sci correlation module — tsb analytics library. */
+export interface GlassSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeGlassSciCorrelation(data: number[], opts: GlassSciCorrelationOptions = {}): GlassSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciCorrelation };
diff --git a/src/glass_sci/covariance.ts b/src/glass_sci/covariance.ts
new file mode 100644
index 000000000..2409fafac
--- /dev/null
+++ b/src/glass_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** glass_sci covariance module — tsb analytics library. */
+export interface GlassSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GlassSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeGlassSciCovariance(data: number[], opts: GlassSciCovarianceOptions = {}): GlassSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciCovariance };
diff --git a/src/glass_sci/cross_validation.ts b/src/glass_sci/cross_validation.ts
new file mode 100644
index 000000000..06a0a7aa1
--- /dev/null
+++ b/src/glass_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** glass_sci cross_validation module — tsb analytics library. */
+export interface GlassSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGlassSciCrossValidation(data: number[], opts: GlassSciCrossValidationOptions = {}): GlassSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciCrossValidation };
diff --git a/src/glass_sci/decoding.ts b/src/glass_sci/decoding.ts
new file mode 100644
index 000000000..db141601b
--- /dev/null
+++ b/src/glass_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** glass_sci decoding module — tsb analytics library. */
+export interface GlassSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDecodingResult { values: number[]; converged: boolean; }
+export function computeGlassSciDecoding(data: number[], opts: GlassSciDecodingOptions = {}): GlassSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDecoding };
diff --git a/src/glass_sci/decomposition.ts b/src/glass_sci/decomposition.ts
new file mode 100644
index 000000000..c73103fcb
--- /dev/null
+++ b/src/glass_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** glass_sci decomposition module — tsb analytics library. */
+export interface GlassSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeGlassSciDecomposition(data: number[], opts: GlassSciDecompositionOptions = {}): GlassSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDecomposition };
diff --git a/src/glass_sci/detection.ts b/src/glass_sci/detection.ts
new file mode 100644
index 000000000..04bd2fb66
--- /dev/null
+++ b/src/glass_sci/detection.ts
@@ -0,0 +1,14 @@
+/** glass_sci detection module — tsb analytics library. */
+export interface GlassSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDetectionResult { values: number[]; converged: boolean; }
+export function computeGlassSciDetection(data: number[], opts: GlassSciDetectionOptions = {}): GlassSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDetection };
diff --git a/src/glass_sci/deterministic.ts b/src/glass_sci/deterministic.ts
new file mode 100644
index 000000000..69d40fb94
--- /dev/null
+++ b/src/glass_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** glass_sci deterministic module — tsb analytics library. */
+export interface GlassSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeGlassSciDeterministic(data: number[], opts: GlassSciDeterministicOptions = {}): GlassSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDeterministic };
diff --git a/src/glass_sci/diagnostics.ts b/src/glass_sci/diagnostics.ts
new file mode 100644
index 000000000..1181dc175
--- /dev/null
+++ b/src/glass_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** glass_sci diagnostics module — tsb analytics library. */
+export interface GlassSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGlassSciDiagnostics(data: number[], opts: GlassSciDiagnosticsOptions = {}): GlassSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDiagnostics };
diff --git a/src/glass_sci/differential.ts b/src/glass_sci/differential.ts
new file mode 100644
index 000000000..bf6d874a4
--- /dev/null
+++ b/src/glass_sci/differential.ts
@@ -0,0 +1,14 @@
+/** glass_sci differential module — tsb analytics library. */
+export interface GlassSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeGlassSciDifferential(data: number[], opts: GlassSciDifferentialOptions = {}): GlassSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDifferential };
diff --git a/src/glass_sci/discrete.ts b/src/glass_sci/discrete.ts
new file mode 100644
index 000000000..7d508202f
--- /dev/null
+++ b/src/glass_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** glass_sci discrete module — tsb analytics library. */
+export interface GlassSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeGlassSciDiscrete(data: number[], opts: GlassSciDiscreteOptions = {}): GlassSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDiscrete };
diff --git a/src/glass_sci/distribution.ts b/src/glass_sci/distribution.ts
new file mode 100644
index 000000000..87a90e45d
--- /dev/null
+++ b/src/glass_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** glass_sci distribution module — tsb analytics library. */
+export interface GlassSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDistributionResult { values: number[]; converged: boolean; }
+export function computeGlassSciDistribution(data: number[], opts: GlassSciDistributionOptions = {}): GlassSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDistribution };
diff --git a/src/glass_sci/dynamic.ts b/src/glass_sci/dynamic.ts
new file mode 100644
index 000000000..b533250d1
--- /dev/null
+++ b/src/glass_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** glass_sci dynamic module — tsb analytics library. */
+export interface GlassSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface GlassSciDynamicResult { values: number[]; converged: boolean; }
+export function computeGlassSciDynamic(data: number[], opts: GlassSciDynamicOptions = {}): GlassSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciDynamic };
diff --git a/src/glass_sci/embedding.ts b/src/glass_sci/embedding.ts
new file mode 100644
index 000000000..0493e43f7
--- /dev/null
+++ b/src/glass_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** glass_sci embedding module — tsb analytics library. */
+export interface GlassSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGlassSciEmbedding(data: number[], opts: GlassSciEmbeddingOptions = {}): GlassSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciEmbedding };
diff --git a/src/glass_sci/encoding.ts b/src/glass_sci/encoding.ts
new file mode 100644
index 000000000..1d490a643
--- /dev/null
+++ b/src/glass_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** glass_sci encoding module — tsb analytics library. */
+export interface GlassSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciEncodingResult { values: number[]; converged: boolean; }
+export function computeGlassSciEncoding(data: number[], opts: GlassSciEncodingOptions = {}): GlassSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciEncoding };
diff --git a/src/glass_sci/ensemble.ts b/src/glass_sci/ensemble.ts
new file mode 100644
index 000000000..b5dde67f2
--- /dev/null
+++ b/src/glass_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** glass_sci ensemble module — tsb analytics library. */
+export interface GlassSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GlassSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeGlassSciEnsemble(data: number[], opts: GlassSciEnsembleOptions = {}): GlassSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciEnsemble };
diff --git a/src/glass_sci/estimation.ts b/src/glass_sci/estimation.ts
new file mode 100644
index 000000000..c96b5fd00
--- /dev/null
+++ b/src/glass_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** glass_sci estimation module — tsb analytics library. */
+export interface GlassSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciEstimationResult { values: number[]; converged: boolean; }
+export function computeGlassSciEstimation(data: number[], opts: GlassSciEstimationOptions = {}): GlassSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciEstimation };
diff --git a/src/glass_sci/evaluation.ts b/src/glass_sci/evaluation.ts
new file mode 100644
index 000000000..2b9ea5f8d
--- /dev/null
+++ b/src/glass_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** glass_sci evaluation module — tsb analytics library. */
+export interface GlassSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeGlassSciEvaluation(data: number[], opts: GlassSciEvaluationOptions = {}): GlassSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciEvaluation };
diff --git a/src/glass_sci/extrapolation.ts b/src/glass_sci/extrapolation.ts
new file mode 100644
index 000000000..c885cae3a
--- /dev/null
+++ b/src/glass_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** glass_sci extrapolation module — tsb analytics library. */
+export interface GlassSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGlassSciExtrapolation(data: number[], opts: GlassSciExtrapolationOptions = {}): GlassSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciExtrapolation };
diff --git a/src/glass_sci/features.ts b/src/glass_sci/features.ts
new file mode 100644
index 000000000..db94ad4a2
--- /dev/null
+++ b/src/glass_sci/features.ts
@@ -0,0 +1,14 @@
+/** glass_sci features module — tsb analytics library. */
+export interface GlassSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GlassSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeGlassSciFeatures(data: number[], opts: GlassSciFeaturesOptions = {}): GlassSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciFeatures };
diff --git a/src/glass_sci/feedback.ts b/src/glass_sci/feedback.ts
new file mode 100644
index 000000000..c21a0d264
--- /dev/null
+++ b/src/glass_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** glass_sci feedback module — tsb analytics library. */
+export interface GlassSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GlassSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeGlassSciFeedback(data: number[], opts: GlassSciFeedbackOptions = {}): GlassSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciFeedback };
diff --git a/src/glass_sci/filtering.ts b/src/glass_sci/filtering.ts
new file mode 100644
index 000000000..b63b86909
--- /dev/null
+++ b/src/glass_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** glass_sci filtering module — tsb analytics library. */
+export interface GlassSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface GlassSciFilteringResult { values: number[]; converged: boolean; }
+export function computeGlassSciFiltering(data: number[], opts: GlassSciFilteringOptions = {}): GlassSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciFiltering };
diff --git a/src/glass_sci/fourier.ts b/src/glass_sci/fourier.ts
new file mode 100644
index 000000000..300b1b9bf
--- /dev/null
+++ b/src/glass_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** glass_sci fourier module — tsb analytics library. */
+export interface GlassSciFourierOptions { tol?: number; maxIter?: number; }
+export interface GlassSciFourierResult { values: number[]; converged: boolean; }
+export function computeGlassSciFourier(data: number[], opts: GlassSciFourierOptions = {}): GlassSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciFourier };
diff --git a/src/glass_sci/fusion.ts b/src/glass_sci/fusion.ts
new file mode 100644
index 000000000..234fb2b79
--- /dev/null
+++ b/src/glass_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** glass_sci fusion module — tsb analytics library. */
+export interface GlassSciFusionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciFusionResult { values: number[]; converged: boolean; }
+export function computeGlassSciFusion(data: number[], opts: GlassSciFusionOptions = {}): GlassSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciFusion };
diff --git a/src/glass_sci/generation.ts b/src/glass_sci/generation.ts
new file mode 100644
index 000000000..e1054130c
--- /dev/null
+++ b/src/glass_sci/generation.ts
@@ -0,0 +1,14 @@
+/** glass_sci generation module — tsb analytics library. */
+export interface GlassSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciGenerationResult { values: number[]; converged: boolean; }
+export function computeGlassSciGeneration(data: number[], opts: GlassSciGenerationOptions = {}): GlassSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciGeneration };
diff --git a/src/glass_sci/geometry.ts b/src/glass_sci/geometry.ts
new file mode 100644
index 000000000..0aa65d46e
--- /dev/null
+++ b/src/glass_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** glass_sci geometry module — tsb analytics library. */
+export interface GlassSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface GlassSciGeometryResult { values: number[]; converged: boolean; }
+export function computeGlassSciGeometry(data: number[], opts: GlassSciGeometryOptions = {}): GlassSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciGeometry };
diff --git a/src/glass_sci/gradient.ts b/src/glass_sci/gradient.ts
new file mode 100644
index 000000000..e889e6dac
--- /dev/null
+++ b/src/glass_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** glass_sci gradient module — tsb analytics library. */
+export interface GlassSciGradientOptions { tol?: number; maxIter?: number; }
+export interface GlassSciGradientResult { values: number[]; converged: boolean; }
+export function computeGlassSciGradient(data: number[], opts: GlassSciGradientOptions = {}): GlassSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciGradient };
diff --git a/src/glass_sci/hessian.ts b/src/glass_sci/hessian.ts
new file mode 100644
index 000000000..a79c99c7b
--- /dev/null
+++ b/src/glass_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** glass_sci hessian module — tsb analytics library. */
+export interface GlassSciHessianOptions { tol?: number; maxIter?: number; }
+export interface GlassSciHessianResult { values: number[]; converged: boolean; }
+export function computeGlassSciHessian(data: number[], opts: GlassSciHessianOptions = {}): GlassSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciHessian };
diff --git a/src/glass_sci/hypothesis.ts b/src/glass_sci/hypothesis.ts
new file mode 100644
index 000000000..bdb44a066
--- /dev/null
+++ b/src/glass_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** glass_sci hypothesis module — tsb analytics library. */
+export interface GlassSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GlassSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeGlassSciHypothesis(data: number[], opts: GlassSciHypothesisOptions = {}): GlassSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciHypothesis };
diff --git a/src/glass_sci/inference.ts b/src/glass_sci/inference.ts
new file mode 100644
index 000000000..9fac15b1d
--- /dev/null
+++ b/src/glass_sci/inference.ts
@@ -0,0 +1,14 @@
+/** glass_sci inference module — tsb analytics library. */
+export interface GlassSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface GlassSciInferenceResult { values: number[]; converged: boolean; }
+export function computeGlassSciInference(data: number[], opts: GlassSciInferenceOptions = {}): GlassSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciInference };
diff --git a/src/glass_sci/inference2.ts b/src/glass_sci/inference2.ts
new file mode 100644
index 000000000..1851e7462
--- /dev/null
+++ b/src/glass_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** glass_sci inference2 module — tsb analytics library. */
+export interface GlassSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface GlassSciInferenceResult { values: number[]; converged: boolean; }
+export function computeGlassSciInference(data: number[], opts: GlassSciInferenceOptions = {}): GlassSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciInference };
diff --git a/src/glass_sci/integral.ts b/src/glass_sci/integral.ts
new file mode 100644
index 000000000..34a3d15f0
--- /dev/null
+++ b/src/glass_sci/integral.ts
@@ -0,0 +1,14 @@
+/** glass_sci integral module — tsb analytics library. */
+export interface GlassSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface GlassSciIntegralResult { values: number[]; converged: boolean; }
+export function computeGlassSciIntegral(data: number[], opts: GlassSciIntegralOptions = {}): GlassSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciIntegral };
diff --git a/src/glass_sci/integration.ts b/src/glass_sci/integration.ts
new file mode 100644
index 000000000..8f87f5bb3
--- /dev/null
+++ b/src/glass_sci/integration.ts
@@ -0,0 +1,14 @@
+/** glass_sci integration module — tsb analytics library. */
+export interface GlassSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeGlassSciIntegration(data: number[], opts: GlassSciIntegrationOptions = {}): GlassSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciIntegration };
diff --git a/src/glass_sci/interpolation.ts b/src/glass_sci/interpolation.ts
new file mode 100644
index 000000000..8a04c0b32
--- /dev/null
+++ b/src/glass_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** glass_sci interpolation module — tsb analytics library. */
+export interface GlassSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeGlassSciInterpolation(data: number[], opts: GlassSciInterpolationOptions = {}): GlassSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciInterpolation };
diff --git a/src/glass_sci/jacobian.ts b/src/glass_sci/jacobian.ts
new file mode 100644
index 000000000..91bf5a590
--- /dev/null
+++ b/src/glass_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** glass_sci jacobian module — tsb analytics library. */
+export interface GlassSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface GlassSciJacobianResult { values: number[]; converged: boolean; }
+export function computeGlassSciJacobian(data: number[], opts: GlassSciJacobianOptions = {}): GlassSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciJacobian };
diff --git a/src/glass_sci/kernel.ts b/src/glass_sci/kernel.ts
new file mode 100644
index 000000000..5ae903721
--- /dev/null
+++ b/src/glass_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** glass_sci kernel module — tsb analytics library. */
+export interface GlassSciKernelOptions { tol?: number; maxIter?: number; }
+export interface GlassSciKernelResult { values: number[]; converged: boolean; }
+export function computeGlassSciKernel(data: number[], opts: GlassSciKernelOptions = {}): GlassSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciKernel };
diff --git a/src/glass_sci/laplacian.ts b/src/glass_sci/laplacian.ts
new file mode 100644
index 000000000..8222dc84a
--- /dev/null
+++ b/src/glass_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** glass_sci laplacian module — tsb analytics library. */
+export interface GlassSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GlassSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeGlassSciLaplacian(data: number[], opts: GlassSciLaplacianOptions = {}): GlassSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciLaplacian };
diff --git a/src/glass_sci/learning.ts b/src/glass_sci/learning.ts
new file mode 100644
index 000000000..a6d9e22ad
--- /dev/null
+++ b/src/glass_sci/learning.ts
@@ -0,0 +1,14 @@
+/** glass_sci learning module — tsb analytics library. */
+export interface GlassSciLearningOptions { tol?: number; maxIter?: number; }
+export interface GlassSciLearningResult { values: number[]; converged: boolean; }
+export function computeGlassSciLearning(data: number[], opts: GlassSciLearningOptions = {}): GlassSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciLearning };
diff --git a/src/glass_sci/linear.ts b/src/glass_sci/linear.ts
new file mode 100644
index 000000000..747dc4ad0
--- /dev/null
+++ b/src/glass_sci/linear.ts
@@ -0,0 +1,14 @@
+/** glass_sci linear module — tsb analytics library. */
+export interface GlassSciLinearOptions { tol?: number; maxIter?: number; }
+export interface GlassSciLinearResult { values: number[]; converged: boolean; }
+export function computeGlassSciLinear(data: number[], opts: GlassSciLinearOptions = {}): GlassSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciLinear };
diff --git a/src/glass_sci/manifold.ts b/src/glass_sci/manifold.ts
new file mode 100644
index 000000000..2ddd2efd5
--- /dev/null
+++ b/src/glass_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** glass_sci manifold module — tsb analytics library. */
+export interface GlassSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface GlassSciManifoldResult { values: number[]; converged: boolean; }
+export function computeGlassSciManifold(data: number[], opts: GlassSciManifoldOptions = {}): GlassSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciManifold };
diff --git a/src/glass_sci/matching.ts b/src/glass_sci/matching.ts
new file mode 100644
index 000000000..2ab34be90
--- /dev/null
+++ b/src/glass_sci/matching.ts
@@ -0,0 +1,14 @@
+/** glass_sci matching module — tsb analytics library. */
+export interface GlassSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciMatchingResult { values: number[]; converged: boolean; }
+export function computeGlassSciMatching(data: number[], opts: GlassSciMatchingOptions = {}): GlassSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciMatching };
diff --git a/src/glass_sci/measurement.ts b/src/glass_sci/measurement.ts
new file mode 100644
index 000000000..96cfd4a50
--- /dev/null
+++ b/src/glass_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** glass_sci measurement module — tsb analytics library. */
+export interface GlassSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GlassSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeGlassSciMeasurement(data: number[], opts: GlassSciMeasurementOptions = {}): GlassSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciMeasurement };
diff --git a/src/glass_sci/metrics.ts b/src/glass_sci/metrics.ts
new file mode 100644
index 000000000..399695150
--- /dev/null
+++ b/src/glass_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** glass_sci metrics module — tsb analytics library. */
+export interface GlassSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface GlassSciMetricsResult { values: number[]; converged: boolean; }
+export function computeGlassSciMetrics(data: number[], opts: GlassSciMetricsOptions = {}): GlassSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciMetrics };
diff --git a/src/glass_sci/modeling.ts b/src/glass_sci/modeling.ts
new file mode 100644
index 000000000..409edcba5
--- /dev/null
+++ b/src/glass_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** glass_sci modeling module — tsb analytics library. */
+export interface GlassSciModelingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciModelingResult { values: number[]; converged: boolean; }
+export function computeGlassSciModeling(data: number[], opts: GlassSciModelingOptions = {}): GlassSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciModeling };
diff --git a/src/glass_sci/monitoring.ts b/src/glass_sci/monitoring.ts
new file mode 100644
index 000000000..10fcf7af8
--- /dev/null
+++ b/src/glass_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** glass_sci monitoring module — tsb analytics library. */
+export interface GlassSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GlassSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeGlassSciMonitoring(data: number[], opts: GlassSciMonitoringOptions = {}): GlassSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciMonitoring };
diff --git a/src/glass_sci/nonlinear.ts b/src/glass_sci/nonlinear.ts
new file mode 100644
index 000000000..e41999b25
--- /dev/null
+++ b/src/glass_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** glass_sci nonlinear module — tsb analytics library. */
+export interface GlassSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GlassSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeGlassSciNonlinear(data: number[], opts: GlassSciNonlinearOptions = {}): GlassSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciNonlinear };
diff --git a/src/glass_sci/normalization.ts b/src/glass_sci/normalization.ts
new file mode 100644
index 000000000..29a5005c7
--- /dev/null
+++ b/src/glass_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** glass_sci normalization module — tsb analytics library. */
+export interface GlassSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeGlassSciNormalization(data: number[], opts: GlassSciNormalizationOptions = {}): GlassSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciNormalization };
diff --git a/src/glass_sci/optimization.ts b/src/glass_sci/optimization.ts
new file mode 100644
index 000000000..540c3a5e8
--- /dev/null
+++ b/src/glass_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** glass_sci optimization module — tsb analytics library. */
+export interface GlassSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeGlassSciOptimization(data: number[], opts: GlassSciOptimizationOptions = {}): GlassSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciOptimization };
diff --git a/src/glass_sci/patterns.ts b/src/glass_sci/patterns.ts
new file mode 100644
index 000000000..a60bca977
--- /dev/null
+++ b/src/glass_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** glass_sci patterns module — tsb analytics library. */
+export interface GlassSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface GlassSciPatternsResult { values: number[]; converged: boolean; }
+export function computeGlassSciPatterns(data: number[], opts: GlassSciPatternsOptions = {}): GlassSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciPatterns };
diff --git a/src/glass_sci/permutation.ts b/src/glass_sci/permutation.ts
new file mode 100644
index 000000000..6415d70dc
--- /dev/null
+++ b/src/glass_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** glass_sci permutation module — tsb analytics library. */
+export interface GlassSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciPermutationResult { values: number[]; converged: boolean; }
+export function computeGlassSciPermutation(data: number[], opts: GlassSciPermutationOptions = {}): GlassSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciPermutation };
diff --git a/src/glass_sci/prediction.ts b/src/glass_sci/prediction.ts
new file mode 100644
index 000000000..ee25f415c
--- /dev/null
+++ b/src/glass_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** glass_sci prediction module — tsb analytics library. */
+export interface GlassSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciPredictionResult { values: number[]; converged: boolean; }
+export function computeGlassSciPrediction(data: number[], opts: GlassSciPredictionOptions = {}): GlassSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciPrediction };
diff --git a/src/glass_sci/processing.ts b/src/glass_sci/processing.ts
new file mode 100644
index 000000000..3079d9da5
--- /dev/null
+++ b/src/glass_sci/processing.ts
@@ -0,0 +1,14 @@
+/** glass_sci processing module — tsb analytics library. */
+export interface GlassSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciProcessingResult { values: number[]; converged: boolean; }
+export function computeGlassSciProcessing(data: number[], opts: GlassSciProcessingOptions = {}): GlassSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciProcessing };
diff --git a/src/glass_sci/profiling.ts b/src/glass_sci/profiling.ts
new file mode 100644
index 000000000..0180e5ff0
--- /dev/null
+++ b/src/glass_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** glass_sci profiling module — tsb analytics library. */
+export interface GlassSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciProfilingResult { values: number[]; converged: boolean; }
+export function computeGlassSciProfiling(data: number[], opts: GlassSciProfilingOptions = {}): GlassSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciProfiling };
diff --git a/src/glass_sci/projection.ts b/src/glass_sci/projection.ts
new file mode 100644
index 000000000..214ea9672
--- /dev/null
+++ b/src/glass_sci/projection.ts
@@ -0,0 +1,14 @@
+/** glass_sci projection module — tsb analytics library. */
+export interface GlassSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciProjectionResult { values: number[]; converged: boolean; }
+export function computeGlassSciProjection(data: number[], opts: GlassSciProjectionOptions = {}): GlassSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciProjection };
diff --git a/src/glass_sci/ranking.ts b/src/glass_sci/ranking.ts
new file mode 100644
index 000000000..efae95624
--- /dev/null
+++ b/src/glass_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** glass_sci ranking module — tsb analytics library. */
+export interface GlassSciRankingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciRankingResult { values: number[]; converged: boolean; }
+export function computeGlassSciRanking(data: number[], opts: GlassSciRankingOptions = {}): GlassSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciRanking };
diff --git a/src/glass_sci/reconstruction.ts b/src/glass_sci/reconstruction.ts
new file mode 100644
index 000000000..77d9cef53
--- /dev/null
+++ b/src/glass_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** glass_sci reconstruction module — tsb analytics library. */
+export interface GlassSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeGlassSciReconstruction(data: number[], opts: GlassSciReconstructionOptions = {}): GlassSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciReconstruction };
diff --git a/src/glass_sci/registration.ts b/src/glass_sci/registration.ts
new file mode 100644
index 000000000..372f3f31b
--- /dev/null
+++ b/src/glass_sci/registration.ts
@@ -0,0 +1,14 @@
+/** glass_sci registration module — tsb analytics library. */
+export interface GlassSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeGlassSciRegistration(data: number[], opts: GlassSciRegistrationOptions = {}): GlassSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciRegistration };
diff --git a/src/glass_sci/regression.ts b/src/glass_sci/regression.ts
new file mode 100644
index 000000000..d5c43ef14
--- /dev/null
+++ b/src/glass_sci/regression.ts
@@ -0,0 +1,14 @@
+/** glass_sci regression module — tsb analytics library. */
+export interface GlassSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciRegressionResult { values: number[]; converged: boolean; }
+export function computeGlassSciRegression(data: number[], opts: GlassSciRegressionOptions = {}): GlassSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciRegression };
diff --git a/src/glass_sci/regularization.ts b/src/glass_sci/regularization.ts
new file mode 100644
index 000000000..8a7e63cbd
--- /dev/null
+++ b/src/glass_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** glass_sci regularization module — tsb analytics library. */
+export interface GlassSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeGlassSciRegularization(data: number[], opts: GlassSciRegularizationOptions = {}): GlassSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciRegularization };
diff --git a/src/glass_sci/robustness.ts b/src/glass_sci/robustness.ts
new file mode 100644
index 000000000..d15ac07c3
--- /dev/null
+++ b/src/glass_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** glass_sci robustness module — tsb analytics library. */
+export interface GlassSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GlassSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeGlassSciRobustness(data: number[], opts: GlassSciRobustnessOptions = {}): GlassSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciRobustness };
diff --git a/src/glass_sci/sampling.ts b/src/glass_sci/sampling.ts
new file mode 100644
index 000000000..178b6e3c3
--- /dev/null
+++ b/src/glass_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** glass_sci sampling module — tsb analytics library. */
+export interface GlassSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciSamplingResult { values: number[]; converged: boolean; }
+export function computeGlassSciSampling(data: number[], opts: GlassSciSamplingOptions = {}): GlassSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciSampling };
diff --git a/src/glass_sci/sampling2.ts b/src/glass_sci/sampling2.ts
new file mode 100644
index 000000000..1fbd7235a
--- /dev/null
+++ b/src/glass_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** glass_sci sampling2 module — tsb analytics library. */
+export interface GlassSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciSamplingResult { values: number[]; converged: boolean; }
+export function computeGlassSciSampling(data: number[], opts: GlassSciSamplingOptions = {}): GlassSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciSampling };
diff --git a/src/glass_sci/scaling.ts b/src/glass_sci/scaling.ts
new file mode 100644
index 000000000..26a1b9636
--- /dev/null
+++ b/src/glass_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** glass_sci scaling module — tsb analytics library. */
+export interface GlassSciScalingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciScalingResult { values: number[]; converged: boolean; }
+export function computeGlassSciScaling(data: number[], opts: GlassSciScalingOptions = {}): GlassSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciScaling };
diff --git a/src/glass_sci/scoring.ts b/src/glass_sci/scoring.ts
new file mode 100644
index 000000000..916846679
--- /dev/null
+++ b/src/glass_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** glass_sci scoring module — tsb analytics library. */
+export interface GlassSciScoringOptions { tol?: number; maxIter?: number; }
+export interface GlassSciScoringResult { values: number[]; converged: boolean; }
+export function computeGlassSciScoring(data: number[], opts: GlassSciScoringOptions = {}): GlassSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciScoring };
diff --git a/src/glass_sci/segmentation.ts b/src/glass_sci/segmentation.ts
new file mode 100644
index 000000000..39872f8f6
--- /dev/null
+++ b/src/glass_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** glass_sci segmentation module — tsb analytics library. */
+export interface GlassSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeGlassSciSegmentation(data: number[], opts: GlassSciSegmentationOptions = {}): GlassSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciSegmentation };
diff --git a/src/glass_sci/selection.ts b/src/glass_sci/selection.ts
new file mode 100644
index 000000000..0f776f0ec
--- /dev/null
+++ b/src/glass_sci/selection.ts
@@ -0,0 +1,14 @@
+/** glass_sci selection module — tsb analytics library. */
+export interface GlassSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface GlassSciSelectionResult { values: number[]; converged: boolean; }
+export function computeGlassSciSelection(data: number[], opts: GlassSciSelectionOptions = {}): GlassSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciSelection };
diff --git a/src/glass_sci/sensitivity.ts b/src/glass_sci/sensitivity.ts
new file mode 100644
index 000000000..5fde27d78
--- /dev/null
+++ b/src/glass_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** glass_sci sensitivity module — tsb analytics library. */
+export interface GlassSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface GlassSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeGlassSciSensitivity(data: number[], opts: GlassSciSensitivityOptions = {}): GlassSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciSensitivity };
diff --git a/src/glass_sci/simulation.ts b/src/glass_sci/simulation.ts
new file mode 100644
index 000000000..c40032e04
--- /dev/null
+++ b/src/glass_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** glass_sci simulation module — tsb analytics library. */
+export interface GlassSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciSimulationResult { values: number[]; converged: boolean; }
+export function computeGlassSciSimulation(data: number[], opts: GlassSciSimulationOptions = {}): GlassSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciSimulation };
diff --git a/src/glass_sci/smoothing.ts b/src/glass_sci/smoothing.ts
new file mode 100644
index 000000000..a80eb4aa2
--- /dev/null
+++ b/src/glass_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** glass_sci smoothing module — tsb analytics library. */
+export interface GlassSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeGlassSciSmoothing(data: number[], opts: GlassSciSmoothingOptions = {}): GlassSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciSmoothing };
diff --git a/src/glass_sci/stability.ts b/src/glass_sci/stability.ts
new file mode 100644
index 000000000..d2ab14a2b
--- /dev/null
+++ b/src/glass_sci/stability.ts
@@ -0,0 +1,14 @@
+/** glass_sci stability module — tsb analytics library. */
+export interface GlassSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface GlassSciStabilityResult { values: number[]; converged: boolean; }
+export function computeGlassSciStability(data: number[], opts: GlassSciStabilityOptions = {}): GlassSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciStability };
diff --git a/src/glass_sci/stacking.ts b/src/glass_sci/stacking.ts
new file mode 100644
index 000000000..5775fa029
--- /dev/null
+++ b/src/glass_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** glass_sci stacking module — tsb analytics library. */
+export interface GlassSciStackingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciStackingResult { values: number[]; converged: boolean; }
+export function computeGlassSciStacking(data: number[], opts: GlassSciStackingOptions = {}): GlassSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciStacking };
diff --git a/src/glass_sci/standardization.ts b/src/glass_sci/standardization.ts
new file mode 100644
index 000000000..1e426a7d0
--- /dev/null
+++ b/src/glass_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** glass_sci standardization module — tsb analytics library. */
+export interface GlassSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeGlassSciStandardization(data: number[], opts: GlassSciStandardizationOptions = {}): GlassSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciStandardization };
diff --git a/src/glass_sci/static.ts b/src/glass_sci/static.ts
new file mode 100644
index 000000000..142d60869
--- /dev/null
+++ b/src/glass_sci/static.ts
@@ -0,0 +1,14 @@
+/** glass_sci static module — tsb analytics library. */
+export interface GlassSciStaticOptions { tol?: number; maxIter?: number; }
+export interface GlassSciStaticResult { values: number[]; converged: boolean; }
+export function computeGlassSciStatic(data: number[], opts: GlassSciStaticOptions = {}): GlassSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciStatic };
diff --git a/src/glass_sci/stochastic.ts b/src/glass_sci/stochastic.ts
new file mode 100644
index 000000000..35f5211cf
--- /dev/null
+++ b/src/glass_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** glass_sci stochastic module — tsb analytics library. */
+export interface GlassSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface GlassSciStochasticResult { values: number[]; converged: boolean; }
+export function computeGlassSciStochastic(data: number[], opts: GlassSciStochasticOptions = {}): GlassSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciStochastic };
diff --git a/src/glass_sci/synthesis.ts b/src/glass_sci/synthesis.ts
new file mode 100644
index 000000000..1d42b5c5b
--- /dev/null
+++ b/src/glass_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** glass_sci synthesis module — tsb analytics library. */
+export interface GlassSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface GlassSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeGlassSciSynthesis(data: number[], opts: GlassSciSynthesisOptions = {}): GlassSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciSynthesis };
diff --git a/src/glass_sci/topology.ts b/src/glass_sci/topology.ts
new file mode 100644
index 000000000..270352c06
--- /dev/null
+++ b/src/glass_sci/topology.ts
@@ -0,0 +1,14 @@
+/** glass_sci topology module — tsb analytics library. */
+export interface GlassSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface GlassSciTopologyResult { values: number[]; converged: boolean; }
+export function computeGlassSciTopology(data: number[], opts: GlassSciTopologyOptions = {}): GlassSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciTopology };
diff --git a/src/glass_sci/tracking.ts b/src/glass_sci/tracking.ts
new file mode 100644
index 000000000..32d56cc70
--- /dev/null
+++ b/src/glass_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** glass_sci tracking module — tsb analytics library. */
+export interface GlassSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciTrackingResult { values: number[]; converged: boolean; }
+export function computeGlassSciTracking(data: number[], opts: GlassSciTrackingOptions = {}): GlassSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciTracking };
diff --git a/src/glass_sci/transform.ts b/src/glass_sci/transform.ts
new file mode 100644
index 000000000..1b4a8379d
--- /dev/null
+++ b/src/glass_sci/transform.ts
@@ -0,0 +1,14 @@
+/** glass_sci transform module — tsb analytics library. */
+export interface GlassSciTransformOptions { tol?: number; maxIter?: number; }
+export interface GlassSciTransformResult { values: number[]; converged: boolean; }
+export function computeGlassSciTransform(data: number[], opts: GlassSciTransformOptions = {}): GlassSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciTransform };
diff --git a/src/glass_sci/uncertainty.ts b/src/glass_sci/uncertainty.ts
new file mode 100644
index 000000000..e350c29e0
--- /dev/null
+++ b/src/glass_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** glass_sci uncertainty module — tsb analytics library. */
+export interface GlassSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GlassSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGlassSciUncertainty(data: number[], opts: GlassSciUncertaintyOptions = {}): GlassSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciUncertainty };
diff --git a/src/glass_sci/validation.ts b/src/glass_sci/validation.ts
new file mode 100644
index 000000000..093baa825
--- /dev/null
+++ b/src/glass_sci/validation.ts
@@ -0,0 +1,14 @@
+/** glass_sci validation module — tsb analytics library. */
+export interface GlassSciValidationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciValidationResult { values: number[]; converged: boolean; }
+export function computeGlassSciValidation(data: number[], opts: GlassSciValidationOptions = {}): GlassSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciValidation };
diff --git a/src/glass_sci/verification.ts b/src/glass_sci/verification.ts
new file mode 100644
index 000000000..0ffea5f46
--- /dev/null
+++ b/src/glass_sci/verification.ts
@@ -0,0 +1,14 @@
+/** glass_sci verification module — tsb analytics library. */
+export interface GlassSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciVerificationResult { values: number[]; converged: boolean; }
+export function computeGlassSciVerification(data: number[], opts: GlassSciVerificationOptions = {}): GlassSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciVerification };
diff --git a/src/glass_sci/visualization.ts b/src/glass_sci/visualization.ts
new file mode 100644
index 000000000..df25ed6c0
--- /dev/null
+++ b/src/glass_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** glass_sci visualization module — tsb analytics library. */
+export interface GlassSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GlassSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeGlassSciVisualization(data: number[], opts: GlassSciVisualizationOptions = {}): GlassSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciVisualization };
diff --git a/src/glass_sci/voting.ts b/src/glass_sci/voting.ts
new file mode 100644
index 000000000..569045120
--- /dev/null
+++ b/src/glass_sci/voting.ts
@@ -0,0 +1,14 @@
+/** glass_sci voting module — tsb analytics library. */
+export interface GlassSciVotingOptions { tol?: number; maxIter?: number; }
+export interface GlassSciVotingResult { values: number[]; converged: boolean; }
+export function computeGlassSciVoting(data: number[], opts: GlassSciVotingOptions = {}): GlassSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciVoting };
diff --git a/src/glass_sci/wavelet.ts b/src/glass_sci/wavelet.ts
new file mode 100644
index 000000000..d9a499184
--- /dev/null
+++ b/src/glass_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** glass_sci wavelet module — tsb analytics library. */
+export interface GlassSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface GlassSciWaveletResult { values: number[]; converged: boolean; }
+export function computeGlassSciWavelet(data: number[], opts: GlassSciWaveletOptions = {}): GlassSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlassSciWavelet };
diff --git a/src/glycomics/adaptation.ts b/src/glycomics/adaptation.ts
new file mode 100644
index 000000000..1f6d986ef
--- /dev/null
+++ b/src/glycomics/adaptation.ts
@@ -0,0 +1,14 @@
+/** glycomics adaptation module — tsb analytics library. */
+export interface GlycomicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsAdaptation(data: number[], opts: GlycomicsAdaptationOptions = {}): GlycomicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsAdaptation };
diff --git a/src/glycomics/aggregation.ts b/src/glycomics/aggregation.ts
new file mode 100644
index 000000000..8b9dbddad
--- /dev/null
+++ b/src/glycomics/aggregation.ts
@@ -0,0 +1,14 @@
+/** glycomics aggregation module — tsb analytics library. */
+export interface GlycomicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsAggregationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsAggregation(data: number[], opts: GlycomicsAggregationOptions = {}): GlycomicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsAggregation };
diff --git a/src/glycomics/algebra.ts b/src/glycomics/algebra.ts
new file mode 100644
index 000000000..632c9a656
--- /dev/null
+++ b/src/glycomics/algebra.ts
@@ -0,0 +1,14 @@
+/** glycomics algebra module — tsb analytics library. */
+export interface GlycomicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeGlycomicsAlgebra(data: number[], opts: GlycomicsAlgebraOptions = {}): GlycomicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsAlgebra };
diff --git a/src/glycomics/alignment.ts b/src/glycomics/alignment.ts
new file mode 100644
index 000000000..a5b453137
--- /dev/null
+++ b/src/glycomics/alignment.ts
@@ -0,0 +1,14 @@
+/** glycomics alignment module — tsb analytics library. */
+export interface GlycomicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeGlycomicsAlignment(data: number[], opts: GlycomicsAlignmentOptions = {}): GlycomicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsAlignment };
diff --git a/src/glycomics/analysis.ts b/src/glycomics/analysis.ts
new file mode 100644
index 000000000..62572eb21
--- /dev/null
+++ b/src/glycomics/analysis.ts
@@ -0,0 +1,14 @@
+/** glycomics analysis module — tsb analytics library. */
+export interface GlycomicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeGlycomicsAnalysis(data: number[], opts: GlycomicsAnalysisOptions = {}): GlycomicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsAnalysis };
diff --git a/src/glycomics/augmentation.ts b/src/glycomics/augmentation.ts
new file mode 100644
index 000000000..6c0eac10b
--- /dev/null
+++ b/src/glycomics/augmentation.ts
@@ -0,0 +1,14 @@
+/** glycomics augmentation module — tsb analytics library. */
+export interface GlycomicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsAugmentation(data: number[], opts: GlycomicsAugmentationOptions = {}): GlycomicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsAugmentation };
diff --git a/src/glycomics/bagging.ts b/src/glycomics/bagging.ts
new file mode 100644
index 000000000..bbabc3065
--- /dev/null
+++ b/src/glycomics/bagging.ts
@@ -0,0 +1,14 @@
+/** glycomics bagging module — tsb analytics library. */
+export interface GlycomicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsBaggingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsBagging(data: number[], opts: GlycomicsBaggingOptions = {}): GlycomicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsBagging };
diff --git a/src/glycomics/basis.ts b/src/glycomics/basis.ts
new file mode 100644
index 000000000..56235ab11
--- /dev/null
+++ b/src/glycomics/basis.ts
@@ -0,0 +1,14 @@
+/** glycomics basis module — tsb analytics library. */
+export interface GlycomicsBasisOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsBasisResult { values: number[]; converged: boolean; }
+export function computeGlycomicsBasis(data: number[], opts: GlycomicsBasisOptions = {}): GlycomicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsBasis };
diff --git a/src/glycomics/benchmarking.ts b/src/glycomics/benchmarking.ts
new file mode 100644
index 000000000..7c72bcc63
--- /dev/null
+++ b/src/glycomics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** glycomics benchmarking module — tsb analytics library. */
+export interface GlycomicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsBenchmarking(data: number[], opts: GlycomicsBenchmarkingOptions = {}): GlycomicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsBenchmarking };
diff --git a/src/glycomics/blending.ts b/src/glycomics/blending.ts
new file mode 100644
index 000000000..945e7a37f
--- /dev/null
+++ b/src/glycomics/blending.ts
@@ -0,0 +1,14 @@
+/** glycomics blending module — tsb analytics library. */
+export interface GlycomicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsBlendingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsBlending(data: number[], opts: GlycomicsBlendingOptions = {}): GlycomicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsBlending };
diff --git a/src/glycomics/boosting.ts b/src/glycomics/boosting.ts
new file mode 100644
index 000000000..db5b50463
--- /dev/null
+++ b/src/glycomics/boosting.ts
@@ -0,0 +1,14 @@
+/** glycomics boosting module — tsb analytics library. */
+export interface GlycomicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsBoostingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsBoosting(data: number[], opts: GlycomicsBoostingOptions = {}): GlycomicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsBoosting };
diff --git a/src/glycomics/bootstrap.ts b/src/glycomics/bootstrap.ts
new file mode 100644
index 000000000..be0eac220
--- /dev/null
+++ b/src/glycomics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** glycomics bootstrap module — tsb analytics library. */
+export interface GlycomicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeGlycomicsBootstrap(data: number[], opts: GlycomicsBootstrapOptions = {}): GlycomicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsBootstrap };
diff --git a/src/glycomics/calculus.ts b/src/glycomics/calculus.ts
new file mode 100644
index 000000000..2ce886b5e
--- /dev/null
+++ b/src/glycomics/calculus.ts
@@ -0,0 +1,14 @@
+/** glycomics calculus module — tsb analytics library. */
+export interface GlycomicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsCalculusResult { values: number[]; converged: boolean; }
+export function computeGlycomicsCalculus(data: number[], opts: GlycomicsCalculusOptions = {}): GlycomicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsCalculus };
diff --git a/src/glycomics/calibration.ts b/src/glycomics/calibration.ts
new file mode 100644
index 000000000..b1b6c7756
--- /dev/null
+++ b/src/glycomics/calibration.ts
@@ -0,0 +1,14 @@
+/** glycomics calibration module — tsb analytics library. */
+export interface GlycomicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsCalibration(data: number[], opts: GlycomicsCalibrationOptions = {}): GlycomicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsCalibration };
diff --git a/src/glycomics/characterization.ts b/src/glycomics/characterization.ts
new file mode 100644
index 000000000..6cf49d99f
--- /dev/null
+++ b/src/glycomics/characterization.ts
@@ -0,0 +1,14 @@
+/** glycomics characterization module — tsb analytics library. */
+export interface GlycomicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsCharacterization(data: number[], opts: GlycomicsCharacterizationOptions = {}): GlycomicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsCharacterization };
diff --git a/src/glycomics/classification.ts b/src/glycomics/classification.ts
new file mode 100644
index 000000000..b7738039d
--- /dev/null
+++ b/src/glycomics/classification.ts
@@ -0,0 +1,14 @@
+/** glycomics classification module — tsb analytics library. */
+export interface GlycomicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsClassificationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsClassification(data: number[], opts: GlycomicsClassificationOptions = {}): GlycomicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsClassification };
diff --git a/src/glycomics/clustering.ts b/src/glycomics/clustering.ts
new file mode 100644
index 000000000..eea1919aa
--- /dev/null
+++ b/src/glycomics/clustering.ts
@@ -0,0 +1,14 @@
+/** glycomics clustering module — tsb analytics library. */
+export interface GlycomicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsClusteringResult { values: number[]; converged: boolean; }
+export function computeGlycomicsClustering(data: number[], opts: GlycomicsClusteringOptions = {}): GlycomicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsClustering };
diff --git a/src/glycomics/compression.ts b/src/glycomics/compression.ts
new file mode 100644
index 000000000..dca411581
--- /dev/null
+++ b/src/glycomics/compression.ts
@@ -0,0 +1,14 @@
+/** glycomics compression module — tsb analytics library. */
+export interface GlycomicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsCompressionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsCompression(data: number[], opts: GlycomicsCompressionOptions = {}): GlycomicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsCompression };
diff --git a/src/glycomics/continuous.ts b/src/glycomics/continuous.ts
new file mode 100644
index 000000000..5d8c9e538
--- /dev/null
+++ b/src/glycomics/continuous.ts
@@ -0,0 +1,14 @@
+/** glycomics continuous module — tsb analytics library. */
+export interface GlycomicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsContinuousResult { values: number[]; converged: boolean; }
+export function computeGlycomicsContinuous(data: number[], opts: GlycomicsContinuousOptions = {}): GlycomicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsContinuous };
diff --git a/src/glycomics/control.ts b/src/glycomics/control.ts
new file mode 100644
index 000000000..d6d89f366
--- /dev/null
+++ b/src/glycomics/control.ts
@@ -0,0 +1,14 @@
+/** glycomics control module — tsb analytics library. */
+export interface GlycomicsControlOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsControlResult { values: number[]; converged: boolean; }
+export function computeGlycomicsControl(data: number[], opts: GlycomicsControlOptions = {}): GlycomicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsControl };
diff --git a/src/glycomics/convergence.ts b/src/glycomics/convergence.ts
new file mode 100644
index 000000000..637536ceb
--- /dev/null
+++ b/src/glycomics/convergence.ts
@@ -0,0 +1,14 @@
+/** glycomics convergence module — tsb analytics library. */
+export interface GlycomicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeGlycomicsConvergence(data: number[], opts: GlycomicsConvergenceOptions = {}): GlycomicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsConvergence };
diff --git a/src/glycomics/convex.ts b/src/glycomics/convex.ts
new file mode 100644
index 000000000..5e90a4bed
--- /dev/null
+++ b/src/glycomics/convex.ts
@@ -0,0 +1,14 @@
+/** glycomics convex module — tsb analytics library. */
+export interface GlycomicsConvexOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsConvexResult { values: number[]; converged: boolean; }
+export function computeGlycomicsConvex(data: number[], opts: GlycomicsConvexOptions = {}): GlycomicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsConvex };
diff --git a/src/glycomics/correlation.ts b/src/glycomics/correlation.ts
new file mode 100644
index 000000000..5598defa7
--- /dev/null
+++ b/src/glycomics/correlation.ts
@@ -0,0 +1,14 @@
+/** glycomics correlation module — tsb analytics library. */
+export interface GlycomicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsCorrelation(data: number[], opts: GlycomicsCorrelationOptions = {}): GlycomicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsCorrelation };
diff --git a/src/glycomics/covariance.ts b/src/glycomics/covariance.ts
new file mode 100644
index 000000000..4b4f8da24
--- /dev/null
+++ b/src/glycomics/covariance.ts
@@ -0,0 +1,14 @@
+/** glycomics covariance module — tsb analytics library. */
+export interface GlycomicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeGlycomicsCovariance(data: number[], opts: GlycomicsCovarianceOptions = {}): GlycomicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsCovariance };
diff --git a/src/glycomics/cross_validation.ts b/src/glycomics/cross_validation.ts
new file mode 100644
index 000000000..1c7f8faf7
--- /dev/null
+++ b/src/glycomics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** glycomics cross_validation module — tsb analytics library. */
+export interface GlycomicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsCrossValidation(data: number[], opts: GlycomicsCrossValidationOptions = {}): GlycomicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsCrossValidation };
diff --git a/src/glycomics/decoding.ts b/src/glycomics/decoding.ts
new file mode 100644
index 000000000..658be73f2
--- /dev/null
+++ b/src/glycomics/decoding.ts
@@ -0,0 +1,14 @@
+/** glycomics decoding module — tsb analytics library. */
+export interface GlycomicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDecodingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDecoding(data: number[], opts: GlycomicsDecodingOptions = {}): GlycomicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDecoding };
diff --git a/src/glycomics/decomposition.ts b/src/glycomics/decomposition.ts
new file mode 100644
index 000000000..e293916a6
--- /dev/null
+++ b/src/glycomics/decomposition.ts
@@ -0,0 +1,14 @@
+/** glycomics decomposition module — tsb analytics library. */
+export interface GlycomicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDecomposition(data: number[], opts: GlycomicsDecompositionOptions = {}): GlycomicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDecomposition };
diff --git a/src/glycomics/detection.ts b/src/glycomics/detection.ts
new file mode 100644
index 000000000..19d6c43e4
--- /dev/null
+++ b/src/glycomics/detection.ts
@@ -0,0 +1,14 @@
+/** glycomics detection module — tsb analytics library. */
+export interface GlycomicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDetectionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDetection(data: number[], opts: GlycomicsDetectionOptions = {}): GlycomicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDetection };
diff --git a/src/glycomics/deterministic.ts b/src/glycomics/deterministic.ts
new file mode 100644
index 000000000..95d861c2f
--- /dev/null
+++ b/src/glycomics/deterministic.ts
@@ -0,0 +1,14 @@
+/** glycomics deterministic module — tsb analytics library. */
+export interface GlycomicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDeterministic(data: number[], opts: GlycomicsDeterministicOptions = {}): GlycomicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDeterministic };
diff --git a/src/glycomics/diagnostics.ts b/src/glycomics/diagnostics.ts
new file mode 100644
index 000000000..6b07b561d
--- /dev/null
+++ b/src/glycomics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** glycomics diagnostics module — tsb analytics library. */
+export interface GlycomicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDiagnostics(data: number[], opts: GlycomicsDiagnosticsOptions = {}): GlycomicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDiagnostics };
diff --git a/src/glycomics/differential.ts b/src/glycomics/differential.ts
new file mode 100644
index 000000000..0e1b1b777
--- /dev/null
+++ b/src/glycomics/differential.ts
@@ -0,0 +1,14 @@
+/** glycomics differential module — tsb analytics library. */
+export interface GlycomicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDifferential(data: number[], opts: GlycomicsDifferentialOptions = {}): GlycomicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDifferential };
diff --git a/src/glycomics/discrete.ts b/src/glycomics/discrete.ts
new file mode 100644
index 000000000..30a31942b
--- /dev/null
+++ b/src/glycomics/discrete.ts
@@ -0,0 +1,14 @@
+/** glycomics discrete module — tsb analytics library. */
+export interface GlycomicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDiscrete(data: number[], opts: GlycomicsDiscreteOptions = {}): GlycomicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDiscrete };
diff --git a/src/glycomics/distribution.ts b/src/glycomics/distribution.ts
new file mode 100644
index 000000000..d65462b84
--- /dev/null
+++ b/src/glycomics/distribution.ts
@@ -0,0 +1,14 @@
+/** glycomics distribution module — tsb analytics library. */
+export interface GlycomicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDistributionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDistribution(data: number[], opts: GlycomicsDistributionOptions = {}): GlycomicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDistribution };
diff --git a/src/glycomics/dynamic.ts b/src/glycomics/dynamic.ts
new file mode 100644
index 000000000..da5a6fe92
--- /dev/null
+++ b/src/glycomics/dynamic.ts
@@ -0,0 +1,14 @@
+/** glycomics dynamic module — tsb analytics library. */
+export interface GlycomicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsDynamicResult { values: number[]; converged: boolean; }
+export function computeGlycomicsDynamic(data: number[], opts: GlycomicsDynamicOptions = {}): GlycomicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsDynamic };
diff --git a/src/glycomics/embedding.ts b/src/glycomics/embedding.ts
new file mode 100644
index 000000000..8286bff71
--- /dev/null
+++ b/src/glycomics/embedding.ts
@@ -0,0 +1,14 @@
+/** glycomics embedding module — tsb analytics library. */
+export interface GlycomicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsEmbedding(data: number[], opts: GlycomicsEmbeddingOptions = {}): GlycomicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsEmbedding };
diff --git a/src/glycomics/encoding.ts b/src/glycomics/encoding.ts
new file mode 100644
index 000000000..40ab889ea
--- /dev/null
+++ b/src/glycomics/encoding.ts
@@ -0,0 +1,14 @@
+/** glycomics encoding module — tsb analytics library. */
+export interface GlycomicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsEncodingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsEncoding(data: number[], opts: GlycomicsEncodingOptions = {}): GlycomicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsEncoding };
diff --git a/src/glycomics/ensemble.ts b/src/glycomics/ensemble.ts
new file mode 100644
index 000000000..cb97de21c
--- /dev/null
+++ b/src/glycomics/ensemble.ts
@@ -0,0 +1,14 @@
+/** glycomics ensemble module — tsb analytics library. */
+export interface GlycomicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeGlycomicsEnsemble(data: number[], opts: GlycomicsEnsembleOptions = {}): GlycomicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsEnsemble };
diff --git a/src/glycomics/estimation.ts b/src/glycomics/estimation.ts
new file mode 100644
index 000000000..369ddae35
--- /dev/null
+++ b/src/glycomics/estimation.ts
@@ -0,0 +1,14 @@
+/** glycomics estimation module — tsb analytics library. */
+export interface GlycomicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsEstimationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsEstimation(data: number[], opts: GlycomicsEstimationOptions = {}): GlycomicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsEstimation };
diff --git a/src/glycomics/evaluation.ts b/src/glycomics/evaluation.ts
new file mode 100644
index 000000000..c26e9527f
--- /dev/null
+++ b/src/glycomics/evaluation.ts
@@ -0,0 +1,14 @@
+/** glycomics evaluation module — tsb analytics library. */
+export interface GlycomicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsEvaluation(data: number[], opts: GlycomicsEvaluationOptions = {}): GlycomicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsEvaluation };
diff --git a/src/glycomics/extrapolation.ts b/src/glycomics/extrapolation.ts
new file mode 100644
index 000000000..dfe6a348b
--- /dev/null
+++ b/src/glycomics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** glycomics extrapolation module — tsb analytics library. */
+export interface GlycomicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsExtrapolation(data: number[], opts: GlycomicsExtrapolationOptions = {}): GlycomicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsExtrapolation };
diff --git a/src/glycomics/features.ts b/src/glycomics/features.ts
new file mode 100644
index 000000000..c5ad44d71
--- /dev/null
+++ b/src/glycomics/features.ts
@@ -0,0 +1,14 @@
+/** glycomics features module — tsb analytics library. */
+export interface GlycomicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeGlycomicsFeatures(data: number[], opts: GlycomicsFeaturesOptions = {}): GlycomicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsFeatures };
diff --git a/src/glycomics/feedback.ts b/src/glycomics/feedback.ts
new file mode 100644
index 000000000..a303419f3
--- /dev/null
+++ b/src/glycomics/feedback.ts
@@ -0,0 +1,14 @@
+/** glycomics feedback module — tsb analytics library. */
+export interface GlycomicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeGlycomicsFeedback(data: number[], opts: GlycomicsFeedbackOptions = {}): GlycomicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsFeedback };
diff --git a/src/glycomics/filtering.ts b/src/glycomics/filtering.ts
new file mode 100644
index 000000000..0e7ab9690
--- /dev/null
+++ b/src/glycomics/filtering.ts
@@ -0,0 +1,14 @@
+/** glycomics filtering module — tsb analytics library. */
+export interface GlycomicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsFilteringResult { values: number[]; converged: boolean; }
+export function computeGlycomicsFiltering(data: number[], opts: GlycomicsFilteringOptions = {}): GlycomicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsFiltering };
diff --git a/src/glycomics/fourier.ts b/src/glycomics/fourier.ts
new file mode 100644
index 000000000..63042f046
--- /dev/null
+++ b/src/glycomics/fourier.ts
@@ -0,0 +1,14 @@
+/** glycomics fourier module — tsb analytics library. */
+export interface GlycomicsFourierOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsFourierResult { values: number[]; converged: boolean; }
+export function computeGlycomicsFourier(data: number[], opts: GlycomicsFourierOptions = {}): GlycomicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsFourier };
diff --git a/src/glycomics/fusion.ts b/src/glycomics/fusion.ts
new file mode 100644
index 000000000..3ea004ad3
--- /dev/null
+++ b/src/glycomics/fusion.ts
@@ -0,0 +1,14 @@
+/** glycomics fusion module — tsb analytics library. */
+export interface GlycomicsFusionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsFusionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsFusion(data: number[], opts: GlycomicsFusionOptions = {}): GlycomicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsFusion };
diff --git a/src/glycomics/generation.ts b/src/glycomics/generation.ts
new file mode 100644
index 000000000..66ef5f34d
--- /dev/null
+++ b/src/glycomics/generation.ts
@@ -0,0 +1,14 @@
+/** glycomics generation module — tsb analytics library. */
+export interface GlycomicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsGenerationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsGeneration(data: number[], opts: GlycomicsGenerationOptions = {}): GlycomicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsGeneration };
diff --git a/src/glycomics/geometry.ts b/src/glycomics/geometry.ts
new file mode 100644
index 000000000..125b8094b
--- /dev/null
+++ b/src/glycomics/geometry.ts
@@ -0,0 +1,14 @@
+/** glycomics geometry module — tsb analytics library. */
+export interface GlycomicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsGeometryResult { values: number[]; converged: boolean; }
+export function computeGlycomicsGeometry(data: number[], opts: GlycomicsGeometryOptions = {}): GlycomicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsGeometry };
diff --git a/src/glycomics/gradient.ts b/src/glycomics/gradient.ts
new file mode 100644
index 000000000..d53725ed3
--- /dev/null
+++ b/src/glycomics/gradient.ts
@@ -0,0 +1,14 @@
+/** glycomics gradient module — tsb analytics library. */
+export interface GlycomicsGradientOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsGradientResult { values: number[]; converged: boolean; }
+export function computeGlycomicsGradient(data: number[], opts: GlycomicsGradientOptions = {}): GlycomicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsGradient };
diff --git a/src/glycomics/hessian.ts b/src/glycomics/hessian.ts
new file mode 100644
index 000000000..9e3a9b093
--- /dev/null
+++ b/src/glycomics/hessian.ts
@@ -0,0 +1,14 @@
+/** glycomics hessian module — tsb analytics library. */
+export interface GlycomicsHessianOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsHessianResult { values: number[]; converged: boolean; }
+export function computeGlycomicsHessian(data: number[], opts: GlycomicsHessianOptions = {}): GlycomicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsHessian };
diff --git a/src/glycomics/hypothesis.ts b/src/glycomics/hypothesis.ts
new file mode 100644
index 000000000..cda053d71
--- /dev/null
+++ b/src/glycomics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** glycomics hypothesis module — tsb analytics library. */
+export interface GlycomicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeGlycomicsHypothesis(data: number[], opts: GlycomicsHypothesisOptions = {}): GlycomicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsHypothesis };
diff --git a/src/glycomics/inference.ts b/src/glycomics/inference.ts
new file mode 100644
index 000000000..fba810616
--- /dev/null
+++ b/src/glycomics/inference.ts
@@ -0,0 +1,14 @@
+/** glycomics inference module — tsb analytics library. */
+export interface GlycomicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsInferenceResult { values: number[]; converged: boolean; }
+export function computeGlycomicsInference(data: number[], opts: GlycomicsInferenceOptions = {}): GlycomicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsInference };
diff --git a/src/glycomics/inference2.ts b/src/glycomics/inference2.ts
new file mode 100644
index 000000000..cd6fe0b55
--- /dev/null
+++ b/src/glycomics/inference2.ts
@@ -0,0 +1,14 @@
+/** glycomics inference2 module — tsb analytics library. */
+export interface GlycomicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsInferenceResult { values: number[]; converged: boolean; }
+export function computeGlycomicsInference(data: number[], opts: GlycomicsInferenceOptions = {}): GlycomicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsInference };
diff --git a/src/glycomics/integral.ts b/src/glycomics/integral.ts
new file mode 100644
index 000000000..832ebe87f
--- /dev/null
+++ b/src/glycomics/integral.ts
@@ -0,0 +1,14 @@
+/** glycomics integral module — tsb analytics library. */
+export interface GlycomicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsIntegralResult { values: number[]; converged: boolean; }
+export function computeGlycomicsIntegral(data: number[], opts: GlycomicsIntegralOptions = {}): GlycomicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsIntegral };
diff --git a/src/glycomics/integration.ts b/src/glycomics/integration.ts
new file mode 100644
index 000000000..e254d54e0
--- /dev/null
+++ b/src/glycomics/integration.ts
@@ -0,0 +1,14 @@
+/** glycomics integration module — tsb analytics library. */
+export interface GlycomicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsIntegration(data: number[], opts: GlycomicsIntegrationOptions = {}): GlycomicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsIntegration };
diff --git a/src/glycomics/interpolation.ts b/src/glycomics/interpolation.ts
new file mode 100644
index 000000000..b6544dc3d
--- /dev/null
+++ b/src/glycomics/interpolation.ts
@@ -0,0 +1,14 @@
+/** glycomics interpolation module — tsb analytics library. */
+export interface GlycomicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsInterpolation(data: number[], opts: GlycomicsInterpolationOptions = {}): GlycomicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsInterpolation };
diff --git a/src/glycomics/jacobian.ts b/src/glycomics/jacobian.ts
new file mode 100644
index 000000000..f883dcd64
--- /dev/null
+++ b/src/glycomics/jacobian.ts
@@ -0,0 +1,14 @@
+/** glycomics jacobian module — tsb analytics library. */
+export interface GlycomicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsJacobianResult { values: number[]; converged: boolean; }
+export function computeGlycomicsJacobian(data: number[], opts: GlycomicsJacobianOptions = {}): GlycomicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsJacobian };
diff --git a/src/glycomics/kernel.ts b/src/glycomics/kernel.ts
new file mode 100644
index 000000000..e3420eba2
--- /dev/null
+++ b/src/glycomics/kernel.ts
@@ -0,0 +1,14 @@
+/** glycomics kernel module — tsb analytics library. */
+export interface GlycomicsKernelOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsKernelResult { values: number[]; converged: boolean; }
+export function computeGlycomicsKernel(data: number[], opts: GlycomicsKernelOptions = {}): GlycomicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsKernel };
diff --git a/src/glycomics/laplacian.ts b/src/glycomics/laplacian.ts
new file mode 100644
index 000000000..6d5800ba5
--- /dev/null
+++ b/src/glycomics/laplacian.ts
@@ -0,0 +1,14 @@
+/** glycomics laplacian module — tsb analytics library. */
+export interface GlycomicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeGlycomicsLaplacian(data: number[], opts: GlycomicsLaplacianOptions = {}): GlycomicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsLaplacian };
diff --git a/src/glycomics/learning.ts b/src/glycomics/learning.ts
new file mode 100644
index 000000000..b0f1b3ff9
--- /dev/null
+++ b/src/glycomics/learning.ts
@@ -0,0 +1,14 @@
+/** glycomics learning module — tsb analytics library. */
+export interface GlycomicsLearningOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsLearningResult { values: number[]; converged: boolean; }
+export function computeGlycomicsLearning(data: number[], opts: GlycomicsLearningOptions = {}): GlycomicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsLearning };
diff --git a/src/glycomics/linear.ts b/src/glycomics/linear.ts
new file mode 100644
index 000000000..1f8df1565
--- /dev/null
+++ b/src/glycomics/linear.ts
@@ -0,0 +1,14 @@
+/** glycomics linear module — tsb analytics library. */
+export interface GlycomicsLinearOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsLinearResult { values: number[]; converged: boolean; }
+export function computeGlycomicsLinear(data: number[], opts: GlycomicsLinearOptions = {}): GlycomicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsLinear };
diff --git a/src/glycomics/manifold.ts b/src/glycomics/manifold.ts
new file mode 100644
index 000000000..96201369c
--- /dev/null
+++ b/src/glycomics/manifold.ts
@@ -0,0 +1,14 @@
+/** glycomics manifold module — tsb analytics library. */
+export interface GlycomicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsManifoldResult { values: number[]; converged: boolean; }
+export function computeGlycomicsManifold(data: number[], opts: GlycomicsManifoldOptions = {}): GlycomicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsManifold };
diff --git a/src/glycomics/matching.ts b/src/glycomics/matching.ts
new file mode 100644
index 000000000..0be36f605
--- /dev/null
+++ b/src/glycomics/matching.ts
@@ -0,0 +1,14 @@
+/** glycomics matching module — tsb analytics library. */
+export interface GlycomicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsMatchingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsMatching(data: number[], opts: GlycomicsMatchingOptions = {}): GlycomicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsMatching };
diff --git a/src/glycomics/measurement.ts b/src/glycomics/measurement.ts
new file mode 100644
index 000000000..f368102de
--- /dev/null
+++ b/src/glycomics/measurement.ts
@@ -0,0 +1,14 @@
+/** glycomics measurement module — tsb analytics library. */
+export interface GlycomicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeGlycomicsMeasurement(data: number[], opts: GlycomicsMeasurementOptions = {}): GlycomicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsMeasurement };
diff --git a/src/glycomics/metrics.ts b/src/glycomics/metrics.ts
new file mode 100644
index 000000000..b36adf60f
--- /dev/null
+++ b/src/glycomics/metrics.ts
@@ -0,0 +1,14 @@
+/** glycomics metrics module — tsb analytics library. */
+export interface GlycomicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsMetricsResult { values: number[]; converged: boolean; }
+export function computeGlycomicsMetrics(data: number[], opts: GlycomicsMetricsOptions = {}): GlycomicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsMetrics };
diff --git a/src/glycomics/modeling.ts b/src/glycomics/modeling.ts
new file mode 100644
index 000000000..f930a262c
--- /dev/null
+++ b/src/glycomics/modeling.ts
@@ -0,0 +1,14 @@
+/** glycomics modeling module — tsb analytics library. */
+export interface GlycomicsModelingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsModelingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsModeling(data: number[], opts: GlycomicsModelingOptions = {}): GlycomicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsModeling };
diff --git a/src/glycomics/monitoring.ts b/src/glycomics/monitoring.ts
new file mode 100644
index 000000000..f1cb3b781
--- /dev/null
+++ b/src/glycomics/monitoring.ts
@@ -0,0 +1,14 @@
+/** glycomics monitoring module — tsb analytics library. */
+export interface GlycomicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeGlycomicsMonitoring(data: number[], opts: GlycomicsMonitoringOptions = {}): GlycomicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsMonitoring };
diff --git a/src/glycomics/nonlinear.ts b/src/glycomics/nonlinear.ts
new file mode 100644
index 000000000..93dd1f140
--- /dev/null
+++ b/src/glycomics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** glycomics nonlinear module — tsb analytics library. */
+export interface GlycomicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeGlycomicsNonlinear(data: number[], opts: GlycomicsNonlinearOptions = {}): GlycomicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsNonlinear };
diff --git a/src/glycomics/normalization.ts b/src/glycomics/normalization.ts
new file mode 100644
index 000000000..c187d0a97
--- /dev/null
+++ b/src/glycomics/normalization.ts
@@ -0,0 +1,14 @@
+/** glycomics normalization module — tsb analytics library. */
+export interface GlycomicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsNormalization(data: number[], opts: GlycomicsNormalizationOptions = {}): GlycomicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsNormalization };
diff --git a/src/glycomics/optimization.ts b/src/glycomics/optimization.ts
new file mode 100644
index 000000000..da10510b1
--- /dev/null
+++ b/src/glycomics/optimization.ts
@@ -0,0 +1,14 @@
+/** glycomics optimization module — tsb analytics library. */
+export interface GlycomicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsOptimization(data: number[], opts: GlycomicsOptimizationOptions = {}): GlycomicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsOptimization };
diff --git a/src/glycomics/patterns.ts b/src/glycomics/patterns.ts
new file mode 100644
index 000000000..d51e944ea
--- /dev/null
+++ b/src/glycomics/patterns.ts
@@ -0,0 +1,14 @@
+/** glycomics patterns module — tsb analytics library. */
+export interface GlycomicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsPatternsResult { values: number[]; converged: boolean; }
+export function computeGlycomicsPatterns(data: number[], opts: GlycomicsPatternsOptions = {}): GlycomicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsPatterns };
diff --git a/src/glycomics/permutation.ts b/src/glycomics/permutation.ts
new file mode 100644
index 000000000..8eff3ccad
--- /dev/null
+++ b/src/glycomics/permutation.ts
@@ -0,0 +1,14 @@
+/** glycomics permutation module — tsb analytics library. */
+export interface GlycomicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsPermutationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsPermutation(data: number[], opts: GlycomicsPermutationOptions = {}): GlycomicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsPermutation };
diff --git a/src/glycomics/prediction.ts b/src/glycomics/prediction.ts
new file mode 100644
index 000000000..6ce898c0e
--- /dev/null
+++ b/src/glycomics/prediction.ts
@@ -0,0 +1,14 @@
+/** glycomics prediction module — tsb analytics library. */
+export interface GlycomicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsPredictionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsPrediction(data: number[], opts: GlycomicsPredictionOptions = {}): GlycomicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsPrediction };
diff --git a/src/glycomics/processing.ts b/src/glycomics/processing.ts
new file mode 100644
index 000000000..b18eaa295
--- /dev/null
+++ b/src/glycomics/processing.ts
@@ -0,0 +1,14 @@
+/** glycomics processing module — tsb analytics library. */
+export interface GlycomicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsProcessingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsProcessing(data: number[], opts: GlycomicsProcessingOptions = {}): GlycomicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsProcessing };
diff --git a/src/glycomics/profiling.ts b/src/glycomics/profiling.ts
new file mode 100644
index 000000000..6cba18759
--- /dev/null
+++ b/src/glycomics/profiling.ts
@@ -0,0 +1,14 @@
+/** glycomics profiling module — tsb analytics library. */
+export interface GlycomicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsProfilingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsProfiling(data: number[], opts: GlycomicsProfilingOptions = {}): GlycomicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsProfiling };
diff --git a/src/glycomics/projection.ts b/src/glycomics/projection.ts
new file mode 100644
index 000000000..911cff0c8
--- /dev/null
+++ b/src/glycomics/projection.ts
@@ -0,0 +1,14 @@
+/** glycomics projection module — tsb analytics library. */
+export interface GlycomicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsProjectionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsProjection(data: number[], opts: GlycomicsProjectionOptions = {}): GlycomicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsProjection };
diff --git a/src/glycomics/ranking.ts b/src/glycomics/ranking.ts
new file mode 100644
index 000000000..46ddd5e5a
--- /dev/null
+++ b/src/glycomics/ranking.ts
@@ -0,0 +1,14 @@
+/** glycomics ranking module — tsb analytics library. */
+export interface GlycomicsRankingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsRankingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsRanking(data: number[], opts: GlycomicsRankingOptions = {}): GlycomicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsRanking };
diff --git a/src/glycomics/reconstruction.ts b/src/glycomics/reconstruction.ts
new file mode 100644
index 000000000..e0f20ed0d
--- /dev/null
+++ b/src/glycomics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** glycomics reconstruction module — tsb analytics library. */
+export interface GlycomicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsReconstruction(data: number[], opts: GlycomicsReconstructionOptions = {}): GlycomicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsReconstruction };
diff --git a/src/glycomics/registration.ts b/src/glycomics/registration.ts
new file mode 100644
index 000000000..bc88f8a45
--- /dev/null
+++ b/src/glycomics/registration.ts
@@ -0,0 +1,14 @@
+/** glycomics registration module — tsb analytics library. */
+export interface GlycomicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsRegistration(data: number[], opts: GlycomicsRegistrationOptions = {}): GlycomicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsRegistration };
diff --git a/src/glycomics/regression.ts b/src/glycomics/regression.ts
new file mode 100644
index 000000000..abec9b37b
--- /dev/null
+++ b/src/glycomics/regression.ts
@@ -0,0 +1,14 @@
+/** glycomics regression module — tsb analytics library. */
+export interface GlycomicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsRegressionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsRegression(data: number[], opts: GlycomicsRegressionOptions = {}): GlycomicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsRegression };
diff --git a/src/glycomics/regularization.ts b/src/glycomics/regularization.ts
new file mode 100644
index 000000000..b2dc46e0e
--- /dev/null
+++ b/src/glycomics/regularization.ts
@@ -0,0 +1,14 @@
+/** glycomics regularization module — tsb analytics library. */
+export interface GlycomicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsRegularization(data: number[], opts: GlycomicsRegularizationOptions = {}): GlycomicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsRegularization };
diff --git a/src/glycomics/robustness.ts b/src/glycomics/robustness.ts
new file mode 100644
index 000000000..78b1f28ce
--- /dev/null
+++ b/src/glycomics/robustness.ts
@@ -0,0 +1,14 @@
+/** glycomics robustness module — tsb analytics library. */
+export interface GlycomicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeGlycomicsRobustness(data: number[], opts: GlycomicsRobustnessOptions = {}): GlycomicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsRobustness };
diff --git a/src/glycomics/sampling.ts b/src/glycomics/sampling.ts
new file mode 100644
index 000000000..4c95b330a
--- /dev/null
+++ b/src/glycomics/sampling.ts
@@ -0,0 +1,14 @@
+/** glycomics sampling module — tsb analytics library. */
+export interface GlycomicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsSamplingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsSampling(data: number[], opts: GlycomicsSamplingOptions = {}): GlycomicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsSampling };
diff --git a/src/glycomics/sampling2.ts b/src/glycomics/sampling2.ts
new file mode 100644
index 000000000..47455ae1a
--- /dev/null
+++ b/src/glycomics/sampling2.ts
@@ -0,0 +1,14 @@
+/** glycomics sampling2 module — tsb analytics library. */
+export interface GlycomicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsSamplingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsSampling(data: number[], opts: GlycomicsSamplingOptions = {}): GlycomicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsSampling };
diff --git a/src/glycomics/scaling.ts b/src/glycomics/scaling.ts
new file mode 100644
index 000000000..3e1752b78
--- /dev/null
+++ b/src/glycomics/scaling.ts
@@ -0,0 +1,14 @@
+/** glycomics scaling module — tsb analytics library. */
+export interface GlycomicsScalingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsScalingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsScaling(data: number[], opts: GlycomicsScalingOptions = {}): GlycomicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsScaling };
diff --git a/src/glycomics/scoring.ts b/src/glycomics/scoring.ts
new file mode 100644
index 000000000..5aebea53e
--- /dev/null
+++ b/src/glycomics/scoring.ts
@@ -0,0 +1,14 @@
+/** glycomics scoring module — tsb analytics library. */
+export interface GlycomicsScoringOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsScoringResult { values: number[]; converged: boolean; }
+export function computeGlycomicsScoring(data: number[], opts: GlycomicsScoringOptions = {}): GlycomicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsScoring };
diff --git a/src/glycomics/segmentation.ts b/src/glycomics/segmentation.ts
new file mode 100644
index 000000000..249bbb4ae
--- /dev/null
+++ b/src/glycomics/segmentation.ts
@@ -0,0 +1,14 @@
+/** glycomics segmentation module — tsb analytics library. */
+export interface GlycomicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsSegmentation(data: number[], opts: GlycomicsSegmentationOptions = {}): GlycomicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsSegmentation };
diff --git a/src/glycomics/selection.ts b/src/glycomics/selection.ts
new file mode 100644
index 000000000..bc2074149
--- /dev/null
+++ b/src/glycomics/selection.ts
@@ -0,0 +1,14 @@
+/** glycomics selection module — tsb analytics library. */
+export interface GlycomicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsSelectionResult { values: number[]; converged: boolean; }
+export function computeGlycomicsSelection(data: number[], opts: GlycomicsSelectionOptions = {}): GlycomicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsSelection };
diff --git a/src/glycomics/sensitivity.ts b/src/glycomics/sensitivity.ts
new file mode 100644
index 000000000..875790494
--- /dev/null
+++ b/src/glycomics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** glycomics sensitivity module — tsb analytics library. */
+export interface GlycomicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeGlycomicsSensitivity(data: number[], opts: GlycomicsSensitivityOptions = {}): GlycomicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsSensitivity };
diff --git a/src/glycomics/simulation.ts b/src/glycomics/simulation.ts
new file mode 100644
index 000000000..3c28345e7
--- /dev/null
+++ b/src/glycomics/simulation.ts
@@ -0,0 +1,14 @@
+/** glycomics simulation module — tsb analytics library. */
+export interface GlycomicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsSimulationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsSimulation(data: number[], opts: GlycomicsSimulationOptions = {}): GlycomicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsSimulation };
diff --git a/src/glycomics/smoothing.ts b/src/glycomics/smoothing.ts
new file mode 100644
index 000000000..b4aab42a0
--- /dev/null
+++ b/src/glycomics/smoothing.ts
@@ -0,0 +1,14 @@
+/** glycomics smoothing module — tsb analytics library. */
+export interface GlycomicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsSmoothing(data: number[], opts: GlycomicsSmoothingOptions = {}): GlycomicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsSmoothing };
diff --git a/src/glycomics/stability.ts b/src/glycomics/stability.ts
new file mode 100644
index 000000000..7225bd21f
--- /dev/null
+++ b/src/glycomics/stability.ts
@@ -0,0 +1,14 @@
+/** glycomics stability module — tsb analytics library. */
+export interface GlycomicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsStabilityResult { values: number[]; converged: boolean; }
+export function computeGlycomicsStability(data: number[], opts: GlycomicsStabilityOptions = {}): GlycomicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsStability };
diff --git a/src/glycomics/stacking.ts b/src/glycomics/stacking.ts
new file mode 100644
index 000000000..9b3705b4f
--- /dev/null
+++ b/src/glycomics/stacking.ts
@@ -0,0 +1,14 @@
+/** glycomics stacking module — tsb analytics library. */
+export interface GlycomicsStackingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsStackingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsStacking(data: number[], opts: GlycomicsStackingOptions = {}): GlycomicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsStacking };
diff --git a/src/glycomics/standardization.ts b/src/glycomics/standardization.ts
new file mode 100644
index 000000000..48a018b87
--- /dev/null
+++ b/src/glycomics/standardization.ts
@@ -0,0 +1,14 @@
+/** glycomics standardization module — tsb analytics library. */
+export interface GlycomicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsStandardization(data: number[], opts: GlycomicsStandardizationOptions = {}): GlycomicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsStandardization };
diff --git a/src/glycomics/static.ts b/src/glycomics/static.ts
new file mode 100644
index 000000000..1d9f6f89d
--- /dev/null
+++ b/src/glycomics/static.ts
@@ -0,0 +1,14 @@
+/** glycomics static module — tsb analytics library. */
+export interface GlycomicsStaticOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsStaticResult { values: number[]; converged: boolean; }
+export function computeGlycomicsStatic(data: number[], opts: GlycomicsStaticOptions = {}): GlycomicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsStatic };
diff --git a/src/glycomics/stochastic.ts b/src/glycomics/stochastic.ts
new file mode 100644
index 000000000..4b173b5fd
--- /dev/null
+++ b/src/glycomics/stochastic.ts
@@ -0,0 +1,14 @@
+/** glycomics stochastic module — tsb analytics library. */
+export interface GlycomicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsStochasticResult { values: number[]; converged: boolean; }
+export function computeGlycomicsStochastic(data: number[], opts: GlycomicsStochasticOptions = {}): GlycomicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsStochastic };
diff --git a/src/glycomics/synthesis.ts b/src/glycomics/synthesis.ts
new file mode 100644
index 000000000..d46846f45
--- /dev/null
+++ b/src/glycomics/synthesis.ts
@@ -0,0 +1,14 @@
+/** glycomics synthesis module — tsb analytics library. */
+export interface GlycomicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeGlycomicsSynthesis(data: number[], opts: GlycomicsSynthesisOptions = {}): GlycomicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsSynthesis };
diff --git a/src/glycomics/topology.ts b/src/glycomics/topology.ts
new file mode 100644
index 000000000..f843bb054
--- /dev/null
+++ b/src/glycomics/topology.ts
@@ -0,0 +1,14 @@
+/** glycomics topology module — tsb analytics library. */
+export interface GlycomicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsTopologyResult { values: number[]; converged: boolean; }
+export function computeGlycomicsTopology(data: number[], opts: GlycomicsTopologyOptions = {}): GlycomicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsTopology };
diff --git a/src/glycomics/tracking.ts b/src/glycomics/tracking.ts
new file mode 100644
index 000000000..768d8c809
--- /dev/null
+++ b/src/glycomics/tracking.ts
@@ -0,0 +1,14 @@
+/** glycomics tracking module — tsb analytics library. */
+export interface GlycomicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsTrackingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsTracking(data: number[], opts: GlycomicsTrackingOptions = {}): GlycomicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsTracking };
diff --git a/src/glycomics/transform.ts b/src/glycomics/transform.ts
new file mode 100644
index 000000000..341c48cdd
--- /dev/null
+++ b/src/glycomics/transform.ts
@@ -0,0 +1,14 @@
+/** glycomics transform module — tsb analytics library. */
+export interface GlycomicsTransformOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsTransformResult { values: number[]; converged: boolean; }
+export function computeGlycomicsTransform(data: number[], opts: GlycomicsTransformOptions = {}): GlycomicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsTransform };
diff --git a/src/glycomics/uncertainty.ts b/src/glycomics/uncertainty.ts
new file mode 100644
index 000000000..2b67f3315
--- /dev/null
+++ b/src/glycomics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** glycomics uncertainty module — tsb analytics library. */
+export interface GlycomicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeGlycomicsUncertainty(data: number[], opts: GlycomicsUncertaintyOptions = {}): GlycomicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsUncertainty };
diff --git a/src/glycomics/validation.ts b/src/glycomics/validation.ts
new file mode 100644
index 000000000..d6fa5f224
--- /dev/null
+++ b/src/glycomics/validation.ts
@@ -0,0 +1,14 @@
+/** glycomics validation module — tsb analytics library. */
+export interface GlycomicsValidationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsValidationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsValidation(data: number[], opts: GlycomicsValidationOptions = {}): GlycomicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsValidation };
diff --git a/src/glycomics/verification.ts b/src/glycomics/verification.ts
new file mode 100644
index 000000000..3f4363f54
--- /dev/null
+++ b/src/glycomics/verification.ts
@@ -0,0 +1,14 @@
+/** glycomics verification module — tsb analytics library. */
+export interface GlycomicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsVerificationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsVerification(data: number[], opts: GlycomicsVerificationOptions = {}): GlycomicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsVerification };
diff --git a/src/glycomics/visualization.ts b/src/glycomics/visualization.ts
new file mode 100644
index 000000000..6ed20666d
--- /dev/null
+++ b/src/glycomics/visualization.ts
@@ -0,0 +1,14 @@
+/** glycomics visualization module — tsb analytics library. */
+export interface GlycomicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeGlycomicsVisualization(data: number[], opts: GlycomicsVisualizationOptions = {}): GlycomicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsVisualization };
diff --git a/src/glycomics/voting.ts b/src/glycomics/voting.ts
new file mode 100644
index 000000000..747b2f9bd
--- /dev/null
+++ b/src/glycomics/voting.ts
@@ -0,0 +1,14 @@
+/** glycomics voting module — tsb analytics library. */
+export interface GlycomicsVotingOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsVotingResult { values: number[]; converged: boolean; }
+export function computeGlycomicsVoting(data: number[], opts: GlycomicsVotingOptions = {}): GlycomicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsVoting };
diff --git a/src/glycomics/wavelet.ts b/src/glycomics/wavelet.ts
new file mode 100644
index 000000000..99d95faf7
--- /dev/null
+++ b/src/glycomics/wavelet.ts
@@ -0,0 +1,14 @@
+/** glycomics wavelet module — tsb analytics library. */
+export interface GlycomicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface GlycomicsWaveletResult { values: number[]; converged: boolean; }
+export function computeGlycomicsWavelet(data: number[], opts: GlycomicsWaveletOptions = {}): GlycomicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeGlycomicsWavelet };
diff --git a/src/health/advanced.ts b/src/health/advanced.ts
new file mode 100644
index 000000000..715e75d02
--- /dev/null
+++ b/src/health/advanced.ts
@@ -0,0 +1,15 @@
+/** Health Advanced module — tsb analytics library. */
+export interface Health advancedOptions { tol?: number; maxIter?: number; }
+export interface Health advancedResult { values: number[]; converged: boolean; }
+export function computeHealth advanced(data: number[], opts: Health advancedOptions = {}): Health advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth advanced };
diff --git a/src/health/base2.ts b/src/health/base2.ts
new file mode 100644
index 000000000..f18a8f2cb
--- /dev/null
+++ b/src/health/base2.ts
@@ -0,0 +1,15 @@
+/** Health Base2 module — tsb analytics library. */
+export interface Health base2Options { tol?: number; maxIter?: number; }
+export interface Health base2Result { values: number[]; converged: boolean; }
+export function computeHealth base2(data: number[], opts: Health base2Options = {}): Health base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth base2 };
diff --git a/src/health/batch.ts b/src/health/batch.ts
new file mode 100644
index 000000000..09c545f93
--- /dev/null
+++ b/src/health/batch.ts
@@ -0,0 +1,15 @@
+/** Health Batch module — tsb analytics library. */
+export interface Health batchOptions { tol?: number; maxIter?: number; }
+export interface Health batchResult { values: number[]; converged: boolean; }
+export function computeHealth batch(data: number[], opts: Health batchOptions = {}): Health batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth batch };
diff --git a/src/health/beta.ts b/src/health/beta.ts
new file mode 100644
index 000000000..9cb0e763e
--- /dev/null
+++ b/src/health/beta.ts
@@ -0,0 +1,15 @@
+/** Health Beta module — tsb analytics library. */
+export interface Health betaOptions { tol?: number; maxIter?: number; }
+export interface Health betaResult { values: number[]; converged: boolean; }
+export function computeHealth beta(data: number[], opts: Health betaOptions = {}): Health betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth beta };
diff --git a/src/health/biostatistics.ts b/src/health/biostatistics.ts
new file mode 100644
index 000000000..2e81c092f
--- /dev/null
+++ b/src/health/biostatistics.ts
@@ -0,0 +1,22 @@
+/** Biostatistics module — tsb analytics library. */
+
+/** Options for Biostatistics. */
+export interface BiostatisticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Biostatistics. */
+export interface BiostatisticsResult { values: number[]; converged: boolean; }
+
+/** Compute Biostatistics. */
+export function computeBiostatistics(data: number[], opts: BiostatisticsOptions = {}): BiostatisticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBiostatistics };
diff --git a/src/health/burden.ts b/src/health/burden.ts
new file mode 100644
index 000000000..5781b792b
--- /dev/null
+++ b/src/health/burden.ts
@@ -0,0 +1,22 @@
+/** Burden module — tsb analytics library. */
+
+/** Options for Burden. */
+export interface BurdenOptions { tol?: number; maxIter?: number; }
+
+/** Result from Burden. */
+export interface BurdenResult { values: number[]; converged: boolean; }
+
+/** Compute Burden. */
+export function computeBurden(data: number[], opts: BurdenOptions = {}): BurdenResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBurden };
diff --git a/src/health/case_control.ts b/src/health/case_control.ts
new file mode 100644
index 000000000..d1c583375
--- /dev/null
+++ b/src/health/case_control.ts
@@ -0,0 +1,22 @@
+/** Case Control module — tsb analytics library. */
+
+/** Options for Case Control. */
+export interface CaseControlOptions { tol?: number; maxIter?: number; }
+
+/** Result from Case Control. */
+export interface CaseControlResult { values: number[]; converged: boolean; }
+
+/** Compute Case Control. */
+export function computeCaseControl(data: number[], opts: CaseControlOptions = {}): CaseControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCaseControl };
diff --git a/src/health/clinical_trial.ts b/src/health/clinical_trial.ts
new file mode 100644
index 000000000..a3336cfa3
--- /dev/null
+++ b/src/health/clinical_trial.ts
@@ -0,0 +1,22 @@
+/** Clinical Trial module — tsb analytics library. */
+
+/** Options for Clinical Trial. */
+export interface ClinicalTrialOptions { tol?: number; maxIter?: number; }
+
+/** Result from Clinical Trial. */
+export interface ClinicalTrialResult { values: number[]; converged: boolean; }
+
+/** Compute Clinical Trial. */
+export function computeClinicalTrial(data: number[], opts: ClinicalTrialOptions = {}): ClinicalTrialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClinicalTrial };
diff --git a/src/health/cohort_health.ts b/src/health/cohort_health.ts
new file mode 100644
index 000000000..6de83cf63
--- /dev/null
+++ b/src/health/cohort_health.ts
@@ -0,0 +1,22 @@
+/** Cohort Health module — tsb analytics library. */
+
+/** Options for Cohort Health. */
+export interface CohortHealthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cohort Health. */
+export interface CohortHealthResult { values: number[]; converged: boolean; }
+
+/** Compute Cohort Health. */
+export function computeCohortHealth(data: number[], opts: CohortHealthOptions = {}): CohortHealthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCohortHealth };
diff --git a/src/health/competing_risks.ts b/src/health/competing_risks.ts
new file mode 100644
index 000000000..4a53f27c5
--- /dev/null
+++ b/src/health/competing_risks.ts
@@ -0,0 +1,22 @@
+/** Competing Risks module — tsb analytics library. */
+
+/** Options for Competing Risks. */
+export interface CompetingRisksOptions { tol?: number; maxIter?: number; }
+
+/** Result from Competing Risks. */
+export interface CompetingRisksResult { values: number[]; converged: boolean; }
+
+/** Compute Competing Risks. */
+export function computeCompetingRisks(data: number[], opts: CompetingRisksOptions = {}): CompetingRisksResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCompetingRisks };
diff --git a/src/health/cost_effectiveness.ts b/src/health/cost_effectiveness.ts
new file mode 100644
index 000000000..3bc27fd1d
--- /dev/null
+++ b/src/health/cost_effectiveness.ts
@@ -0,0 +1,22 @@
+/** Cost Effectiveness module — tsb analytics library. */
+
+/** Options for Cost Effectiveness. */
+export interface CostEffectivenessOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cost Effectiveness. */
+export interface CostEffectivenessResult { values: number[]; converged: boolean; }
+
+/** Compute Cost Effectiveness. */
+export function computeCostEffectiveness(data: number[], opts: CostEffectivenessOptions = {}): CostEffectivenessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCostEffectiveness };
diff --git a/src/health/cpu.ts b/src/health/cpu.ts
new file mode 100644
index 000000000..4b8e3d05d
--- /dev/null
+++ b/src/health/cpu.ts
@@ -0,0 +1,15 @@
+/** Health Cpu module — tsb analytics library. */
+export interface Health cpuOptions { tol?: number; maxIter?: number; }
+export interface Health cpuResult { values: number[]; converged: boolean; }
+export function computeHealth cpu(data: number[], opts: Health cpuOptions = {}): Health cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth cpu };
diff --git a/src/health/daly.ts b/src/health/daly.ts
new file mode 100644
index 000000000..8371121f5
--- /dev/null
+++ b/src/health/daly.ts
@@ -0,0 +1,22 @@
+/** Daly module — tsb analytics library. */
+
+/** Options for Daly. */
+export interface DalyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Daly. */
+export interface DalyResult { values: number[]; converged: boolean; }
+
+/** Compute Daly. */
+export function computeDaly(data: number[], opts: DalyOptions = {}): DalyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDaly };
diff --git a/src/health/decision_analysis.ts b/src/health/decision_analysis.ts
new file mode 100644
index 000000000..25042997a
--- /dev/null
+++ b/src/health/decision_analysis.ts
@@ -0,0 +1,22 @@
+/** Decision Analysis module — tsb analytics library. */
+
+/** Options for Decision Analysis. */
+export interface DecisionAnalysisOptions { tol?: number; maxIter?: number; }
+
+/** Result from Decision Analysis. */
+export interface DecisionAnalysisResult { values: number[]; converged: boolean; }
+
+/** Compute Decision Analysis. */
+export function computeDecisionAnalysis(data: number[], opts: DecisionAnalysisOptions = {}): DecisionAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDecisionAnalysis };
diff --git a/src/health/dense.ts b/src/health/dense.ts
new file mode 100644
index 000000000..cb67dfa3c
--- /dev/null
+++ b/src/health/dense.ts
@@ -0,0 +1,15 @@
+/** Health Dense module — tsb analytics library. */
+export interface Health denseOptions { tol?: number; maxIter?: number; }
+export interface Health denseResult { values: number[]; converged: boolean; }
+export function computeHealth dense(data: number[], opts: Health denseOptions = {}): Health denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth dense };
diff --git a/src/health/diagnostic.ts b/src/health/diagnostic.ts
new file mode 100644
index 000000000..b92ee112e
--- /dev/null
+++ b/src/health/diagnostic.ts
@@ -0,0 +1,22 @@
+/** Diagnostic module — tsb analytics library. */
+
+/** Options for Diagnostic. */
+export interface DiagnosticOptions { tol?: number; maxIter?: number; }
+
+/** Result from Diagnostic. */
+export interface DiagnosticResult { values: number[]; converged: boolean; }
+
+/** Compute Diagnostic. */
+export function computeDiagnostic(data: number[], opts: DiagnosticOptions = {}): DiagnosticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDiagnostic };
diff --git a/src/health/disability.ts b/src/health/disability.ts
new file mode 100644
index 000000000..04a1e3cae
--- /dev/null
+++ b/src/health/disability.ts
@@ -0,0 +1,22 @@
+/** Disability module — tsb analytics library. */
+
+/** Options for Disability. */
+export interface DisabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Disability. */
+export interface DisabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Disability. */
+export function computeDisability(data: number[], opts: DisabilityOptions = {}): DisabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDisability };
diff --git a/src/health/dissemination.ts b/src/health/dissemination.ts
new file mode 100644
index 000000000..66d000041
--- /dev/null
+++ b/src/health/dissemination.ts
@@ -0,0 +1,22 @@
+/** Dissemination module — tsb analytics library. */
+
+/** Options for Dissemination. */
+export interface DisseminationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dissemination. */
+export interface DisseminationResult { values: number[]; converged: boolean; }
+
+/** Compute Dissemination. */
+export function computeDissemination(data: number[], opts: DisseminationOptions = {}): DisseminationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDissemination };
diff --git a/src/health/distributed.ts b/src/health/distributed.ts
new file mode 100644
index 000000000..c8da37001
--- /dev/null
+++ b/src/health/distributed.ts
@@ -0,0 +1,15 @@
+/** Health Distributed module — tsb analytics library. */
+export interface Health distributedOptions { tol?: number; maxIter?: number; }
+export interface Health distributedResult { values: number[]; converged: boolean; }
+export function computeHealth distributed(data: number[], opts: Health distributedOptions = {}): Health distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth distributed };
diff --git a/src/health/epidemiology_health.ts b/src/health/epidemiology_health.ts
new file mode 100644
index 000000000..87d406c74
--- /dev/null
+++ b/src/health/epidemiology_health.ts
@@ -0,0 +1,22 @@
+/** Epidemiology Health module — tsb analytics library. */
+
+/** Options for Epidemiology Health. */
+export interface EpidemiologyHealthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Epidemiology Health. */
+export interface EpidemiologyHealthResult { values: number[]; converged: boolean; }
+
+/** Compute Epidemiology Health. */
+export function computeEpidemiologyHealth(data: number[], opts: EpidemiologyHealthOptions = {}): EpidemiologyHealthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEpidemiologyHealth };
diff --git a/src/health/experimental.ts b/src/health/experimental.ts
new file mode 100644
index 000000000..c8967a1fc
--- /dev/null
+++ b/src/health/experimental.ts
@@ -0,0 +1,15 @@
+/** Health Experimental module — tsb analytics library. */
+export interface Health experimentalOptions { tol?: number; maxIter?: number; }
+export interface Health experimentalResult { values: number[]; converged: boolean; }
+export function computeHealth experimental(data: number[], opts: Health experimentalOptions = {}): Health experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth experimental };
diff --git a/src/health/fast.ts b/src/health/fast.ts
new file mode 100644
index 000000000..5a2d6150a
--- /dev/null
+++ b/src/health/fast.ts
@@ -0,0 +1,15 @@
+/** Health Fast module — tsb analytics library. */
+export interface Health fastOptions { tol?: number; maxIter?: number; }
+export interface Health fastResult { values: number[]; converged: boolean; }
+export function computeHealth fast(data: number[], opts: Health fastOptions = {}): Health fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth fast };
diff --git a/src/health/frailty.ts b/src/health/frailty.ts
new file mode 100644
index 000000000..dfa4bf3c4
--- /dev/null
+++ b/src/health/frailty.ts
@@ -0,0 +1,22 @@
+/** Frailty module — tsb analytics library. */
+
+/** Options for Frailty. */
+export interface FrailtyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Frailty. */
+export interface FrailtyResult { values: number[]; converged: boolean; }
+
+/** Compute Frailty. */
+export function computeFrailty(data: number[], opts: FrailtyOptions = {}): FrailtyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFrailty };
diff --git a/src/health/future.ts b/src/health/future.ts
new file mode 100644
index 000000000..de9c8b2a2
--- /dev/null
+++ b/src/health/future.ts
@@ -0,0 +1,15 @@
+/** Health Future module — tsb analytics library. */
+export interface Health futureOptions { tol?: number; maxIter?: number; }
+export interface Health futureResult { values: number[]; converged: boolean; }
+export function computeHealth future(data: number[], opts: Health futureOptions = {}): Health futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth future };
diff --git a/src/health/gpu.ts b/src/health/gpu.ts
new file mode 100644
index 000000000..0ddbcf49f
--- /dev/null
+++ b/src/health/gpu.ts
@@ -0,0 +1,15 @@
+/** Health Gpu module — tsb analytics library. */
+export interface Health gpuOptions { tol?: number; maxIter?: number; }
+export interface Health gpuResult { values: number[]; converged: boolean; }
+export function computeHealth gpu(data: number[], opts: Health gpuOptions = {}): Health gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth gpu };
diff --git a/src/health/health_behavior.ts b/src/health/health_behavior.ts
new file mode 100644
index 000000000..222262068
--- /dev/null
+++ b/src/health/health_behavior.ts
@@ -0,0 +1,22 @@
+/** Health Behavior module — tsb analytics library. */
+
+/** Options for Health Behavior. */
+export interface HealthBehaviorOptions { tol?: number; maxIter?: number; }
+
+/** Result from Health Behavior. */
+export interface HealthBehaviorResult { values: number[]; converged: boolean; }
+
+/** Compute Health Behavior. */
+export function computeHealthBehavior(data: number[], opts: HealthBehaviorOptions = {}): HealthBehaviorResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHealthBehavior };
diff --git a/src/health/health_equity.ts b/src/health/health_equity.ts
new file mode 100644
index 000000000..7c0fcdb14
--- /dev/null
+++ b/src/health/health_equity.ts
@@ -0,0 +1,22 @@
+/** Health Equity module — tsb analytics library. */
+
+/** Options for Health Equity. */
+export interface HealthEquityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Health Equity. */
+export interface HealthEquityResult { values: number[]; converged: boolean; }
+
+/** Compute Health Equity. */
+export function computeHealthEquity(data: number[], opts: HealthEquityOptions = {}): HealthEquityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHealthEquity };
diff --git a/src/health/implementation.ts b/src/health/implementation.ts
new file mode 100644
index 000000000..cef8bfe58
--- /dev/null
+++ b/src/health/implementation.ts
@@ -0,0 +1,22 @@
+/** Implementation module — tsb analytics library. */
+
+/** Options for Implementation. */
+export interface ImplementationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Implementation. */
+export interface ImplementationResult { values: number[]; converged: boolean; }
+
+/** Compute Implementation. */
+export function computeImplementation(data: number[], opts: ImplementationOptions = {}): ImplementationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeImplementation };
diff --git a/src/health/intervention.ts b/src/health/intervention.ts
new file mode 100644
index 000000000..c98859255
--- /dev/null
+++ b/src/health/intervention.ts
@@ -0,0 +1,22 @@
+/** Intervention module — tsb analytics library. */
+
+/** Options for Intervention. */
+export interface InterventionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Intervention. */
+export interface InterventionResult { values: number[]; converged: boolean; }
+
+/** Compute Intervention. */
+export function computeIntervention(data: number[], opts: InterventionOptions = {}): InterventionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIntervention };
diff --git a/src/health/joint_model.ts b/src/health/joint_model.ts
new file mode 100644
index 000000000..1c910670b
--- /dev/null
+++ b/src/health/joint_model.ts
@@ -0,0 +1,22 @@
+/** Joint Model module — tsb analytics library. */
+
+/** Options for Joint Model. */
+export interface JointModelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Joint Model. */
+export interface JointModelResult { values: number[]; converged: boolean; }
+
+/** Compute Joint Model. */
+export function computeJointModel(data: number[], opts: JointModelOptions = {}): JointModelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeJointModel };
diff --git a/src/health/large.ts b/src/health/large.ts
new file mode 100644
index 000000000..b8bde3708
--- /dev/null
+++ b/src/health/large.ts
@@ -0,0 +1,15 @@
+/** Health Large module — tsb analytics library. */
+export interface Health largeOptions { tol?: number; maxIter?: number; }
+export interface Health largeResult { values: number[]; converged: boolean; }
+export function computeHealth large(data: number[], opts: Health largeOptions = {}): Health largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth large };
diff --git a/src/health/legacy.ts b/src/health/legacy.ts
new file mode 100644
index 000000000..a8cbdc42a
--- /dev/null
+++ b/src/health/legacy.ts
@@ -0,0 +1,15 @@
+/** Health Legacy module — tsb analytics library. */
+export interface Health legacyOptions { tol?: number; maxIter?: number; }
+export interface Health legacyResult { values: number[]; converged: boolean; }
+export function computeHealth legacy(data: number[], opts: Health legacyOptions = {}): Health legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth legacy };
diff --git a/src/health/lite.ts b/src/health/lite.ts
new file mode 100644
index 000000000..96e167165
--- /dev/null
+++ b/src/health/lite.ts
@@ -0,0 +1,15 @@
+/** Health Lite module — tsb analytics library. */
+export interface Health liteOptions { tol?: number; maxIter?: number; }
+export interface Health liteResult { values: number[]; converged: boolean; }
+export function computeHealth lite(data: number[], opts: Health liteOptions = {}): Health liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth lite };
diff --git a/src/health/measurement_health.ts b/src/health/measurement_health.ts
new file mode 100644
index 000000000..9df1b06ca
--- /dev/null
+++ b/src/health/measurement_health.ts
@@ -0,0 +1,22 @@
+/** Measurement Health module — tsb analytics library. */
+
+/** Options for Measurement Health. */
+export interface MeasurementHealthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Measurement Health. */
+export interface MeasurementHealthResult { values: number[]; converged: boolean; }
+
+/** Compute Measurement Health. */
+export function computeMeasurementHealth(data: number[], opts: MeasurementHealthOptions = {}): MeasurementHealthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMeasurementHealth };
diff --git a/src/health/meta_analysis.ts b/src/health/meta_analysis.ts
new file mode 100644
index 000000000..3c43ffd1e
--- /dev/null
+++ b/src/health/meta_analysis.ts
@@ -0,0 +1,22 @@
+/** Meta Analysis module — tsb analytics library. */
+
+/** Options for Meta Analysis. */
+export interface MetaAnalysisOptions { tol?: number; maxIter?: number; }
+
+/** Result from Meta Analysis. */
+export interface MetaAnalysisResult { values: number[]; converged: boolean; }
+
+/** Compute Meta Analysis. */
+export function computeMetaAnalysis(data: number[], opts: MetaAnalysisOptions = {}): MetaAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMetaAnalysis };
diff --git a/src/health/mini.ts b/src/health/mini.ts
new file mode 100644
index 000000000..797ee76f4
--- /dev/null
+++ b/src/health/mini.ts
@@ -0,0 +1,15 @@
+/** Health Mini module — tsb analytics library. */
+export interface Health miniOptions { tol?: number; maxIter?: number; }
+export interface Health miniResult { values: number[]; converged: boolean; }
+export function computeHealth mini(data: number[], opts: Health miniOptions = {}): Health miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth mini };
diff --git a/src/health/multistate.ts b/src/health/multistate.ts
new file mode 100644
index 000000000..d5a4d0051
--- /dev/null
+++ b/src/health/multistate.ts
@@ -0,0 +1,22 @@
+/** Multistate module — tsb analytics library. */
+
+/** Options for Multistate. */
+export interface MultistateOptions { tol?: number; maxIter?: number; }
+
+/** Result from Multistate. */
+export interface MultistateResult { values: number[]; converged: boolean; }
+
+/** Compute Multistate. */
+export function computeMultistate(data: number[], opts: MultistateOptions = {}): MultistateResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMultistate };
diff --git a/src/health/next.ts b/src/health/next.ts
new file mode 100644
index 000000000..69600a690
--- /dev/null
+++ b/src/health/next.ts
@@ -0,0 +1,15 @@
+/** Health Next module — tsb analytics library. */
+export interface Health nextOptions { tol?: number; maxIter?: number; }
+export interface Health nextResult { values: number[]; converged: boolean; }
+export function computeHealth next(data: number[], opts: Health nextOptions = {}): Health nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth next };
diff --git a/src/health/observational.ts b/src/health/observational.ts
new file mode 100644
index 000000000..f76c6d081
--- /dev/null
+++ b/src/health/observational.ts
@@ -0,0 +1,22 @@
+/** Observational module — tsb analytics library. */
+
+/** Options for Observational. */
+export interface ObservationalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Observational. */
+export interface ObservationalResult { values: number[]; converged: boolean; }
+
+/** Compute Observational. */
+export function computeObservational(data: number[], opts: ObservationalOptions = {}): ObservationalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeObservational };
diff --git a/src/health/online.ts b/src/health/online.ts
new file mode 100644
index 000000000..85c451908
--- /dev/null
+++ b/src/health/online.ts
@@ -0,0 +1,15 @@
+/** Health Online module — tsb analytics library. */
+export interface Health onlineOptions { tol?: number; maxIter?: number; }
+export interface Health onlineResult { values: number[]; converged: boolean; }
+export function computeHealth online(data: number[], opts: Health onlineOptions = {}): Health onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth online };
diff --git a/src/health/parallel.ts b/src/health/parallel.ts
new file mode 100644
index 000000000..1ed7a10a4
--- /dev/null
+++ b/src/health/parallel.ts
@@ -0,0 +1,15 @@
+/** Health Parallel module — tsb analytics library. */
+export interface Health parallelOptions { tol?: number; maxIter?: number; }
+export interface Health parallelResult { values: number[]; converged: boolean; }
+export function computeHealth parallel(data: number[], opts: Health parallelOptions = {}): Health parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth parallel };
diff --git a/src/health/plus.ts b/src/health/plus.ts
new file mode 100644
index 000000000..1f0ee74cb
--- /dev/null
+++ b/src/health/plus.ts
@@ -0,0 +1,15 @@
+/** Health Plus module — tsb analytics library. */
+export interface Health plusOptions { tol?: number; maxIter?: number; }
+export interface Health plusResult { values: number[]; converged: boolean; }
+export function computeHealth plus(data: number[], opts: Health plusOptions = {}): Health plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth plus };
diff --git a/src/health/pro.ts b/src/health/pro.ts
new file mode 100644
index 000000000..8e90322c4
--- /dev/null
+++ b/src/health/pro.ts
@@ -0,0 +1,15 @@
+/** Health Pro module — tsb analytics library. */
+export interface Health proOptions { tol?: number; maxIter?: number; }
+export interface Health proResult { values: number[]; converged: boolean; }
+export function computeHealth pro(data: number[], opts: Health proOptions = {}): Health proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth pro };
diff --git a/src/health/program_evaluation.ts b/src/health/program_evaluation.ts
new file mode 100644
index 000000000..717135b34
--- /dev/null
+++ b/src/health/program_evaluation.ts
@@ -0,0 +1,22 @@
+/** Program Evaluation module — tsb analytics library. */
+
+/** Options for Program Evaluation. */
+export interface ProgramEvaluationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Program Evaluation. */
+export interface ProgramEvaluationResult { values: number[]; converged: boolean; }
+
+/** Compute Program Evaluation. */
+export function computeProgramEvaluation(data: number[], opts: ProgramEvaluationOptions = {}): ProgramEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProgramEvaluation };
diff --git a/src/health/qaly.ts b/src/health/qaly.ts
new file mode 100644
index 000000000..fc3314d8c
--- /dev/null
+++ b/src/health/qaly.ts
@@ -0,0 +1,22 @@
+/** Qaly module — tsb analytics library. */
+
+/** Options for Qaly. */
+export interface QalyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Qaly. */
+export interface QalyResult { values: number[]; converged: boolean; }
+
+/** Compute Qaly. */
+export function computeQaly(data: number[], opts: QalyOptions = {}): QalyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQaly };
diff --git a/src/health/rct.ts b/src/health/rct.ts
new file mode 100644
index 000000000..b65d98f9f
--- /dev/null
+++ b/src/health/rct.ts
@@ -0,0 +1,22 @@
+/** Rct module — tsb analytics library. */
+
+/** Options for Rct. */
+export interface RctOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rct. */
+export interface RctResult { values: number[]; converged: boolean; }
+
+/** Compute Rct. */
+export function computeRct(data: number[], opts: RctOptions = {}): RctResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRct };
diff --git a/src/health/robust.ts b/src/health/robust.ts
new file mode 100644
index 000000000..c4a658e57
--- /dev/null
+++ b/src/health/robust.ts
@@ -0,0 +1,15 @@
+/** Health Robust module — tsb analytics library. */
+export interface Health robustOptions { tol?: number; maxIter?: number; }
+export interface Health robustResult { values: number[]; converged: boolean; }
+export function computeHealth robust(data: number[], opts: Health robustOptions = {}): Health robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth robust };
diff --git a/src/health/screening.ts b/src/health/screening.ts
new file mode 100644
index 000000000..ab34c4c43
--- /dev/null
+++ b/src/health/screening.ts
@@ -0,0 +1,22 @@
+/** Screening module — tsb analytics library. */
+
+/** Options for Screening. */
+export interface ScreeningOptions { tol?: number; maxIter?: number; }
+
+/** Result from Screening. */
+export interface ScreeningResult { values: number[]; converged: boolean; }
+
+/** Compute Screening. */
+export function computeScreening(data: number[], opts: ScreeningOptions = {}): ScreeningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeScreening };
diff --git a/src/health/small.ts b/src/health/small.ts
new file mode 100644
index 000000000..b3ebd8b9f
--- /dev/null
+++ b/src/health/small.ts
@@ -0,0 +1,15 @@
+/** Health Small module — tsb analytics library. */
+export interface Health smallOptions { tol?: number; maxIter?: number; }
+export interface Health smallResult { values: number[]; converged: boolean; }
+export function computeHealth small(data: number[], opts: Health smallOptions = {}): Health smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth small };
diff --git a/src/health/sparse.ts b/src/health/sparse.ts
new file mode 100644
index 000000000..ac27ab3d6
--- /dev/null
+++ b/src/health/sparse.ts
@@ -0,0 +1,15 @@
+/** Health Sparse module — tsb analytics library. */
+export interface Health sparseOptions { tol?: number; maxIter?: number; }
+export interface Health sparseResult { values: number[]; converged: boolean; }
+export function computeHealth sparse(data: number[], opts: Health sparseOptions = {}): Health sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth sparse };
diff --git a/src/health/stable.ts b/src/health/stable.ts
new file mode 100644
index 000000000..46ed77508
--- /dev/null
+++ b/src/health/stable.ts
@@ -0,0 +1,15 @@
+/** Health Stable module — tsb analytics library. */
+export interface Health stableOptions { tol?: number; maxIter?: number; }
+export interface Health stableResult { values: number[]; converged: boolean; }
+export function computeHealth stable(data: number[], opts: Health stableOptions = {}): Health stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth stable };
diff --git a/src/health/streaming.ts b/src/health/streaming.ts
new file mode 100644
index 000000000..14d5c3187
--- /dev/null
+++ b/src/health/streaming.ts
@@ -0,0 +1,15 @@
+/** Health Streaming module — tsb analytics library. */
+export interface Health streamingOptions { tol?: number; maxIter?: number; }
+export interface Health streamingResult { values: number[]; converged: boolean; }
+export function computeHealth streaming(data: number[], opts: Health streamingOptions = {}): Health streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth streaming };
diff --git a/src/health/survival_health.ts b/src/health/survival_health.ts
new file mode 100644
index 000000000..ffa3ebdf8
--- /dev/null
+++ b/src/health/survival_health.ts
@@ -0,0 +1,22 @@
+/** Survival Health module — tsb analytics library. */
+
+/** Options for Survival Health. */
+export interface SurvivalHealthOptions { tol?: number; maxIter?: number; }
+
+/** Result from Survival Health. */
+export interface SurvivalHealthResult { values: number[]; converged: boolean; }
+
+/** Compute Survival Health. */
+export function computeSurvivalHealth(data: number[], opts: SurvivalHealthOptions = {}): SurvivalHealthResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSurvivalHealth };
diff --git a/src/health/systematic_review.ts b/src/health/systematic_review.ts
new file mode 100644
index 000000000..a8cfe2654
--- /dev/null
+++ b/src/health/systematic_review.ts
@@ -0,0 +1,22 @@
+/** Systematic Review module — tsb analytics library. */
+
+/** Options for Systematic Review. */
+export interface SystematicReviewOptions { tol?: number; maxIter?: number; }
+
+/** Result from Systematic Review. */
+export interface SystematicReviewResult { values: number[]; converged: boolean; }
+
+/** Compute Systematic Review. */
+export function computeSystematicReview(data: number[], opts: SystematicReviewOptions = {}): SystematicReviewResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSystematicReview };
diff --git a/src/health/time_to_event.ts b/src/health/time_to_event.ts
new file mode 100644
index 000000000..d7387764f
--- /dev/null
+++ b/src/health/time_to_event.ts
@@ -0,0 +1,22 @@
+/** Time To Event module — tsb analytics library. */
+
+/** Options for Time To Event. */
+export interface TimeToEventOptions { tol?: number; maxIter?: number; }
+
+/** Result from Time To Event. */
+export interface TimeToEventResult { values: number[]; converged: boolean; }
+
+/** Compute Time To Event. */
+export function computeTimeToEvent(data: number[], opts: TimeToEventOptions = {}): TimeToEventResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTimeToEvent };
diff --git a/src/health/v2.ts b/src/health/v2.ts
new file mode 100644
index 000000000..b40212acd
--- /dev/null
+++ b/src/health/v2.ts
@@ -0,0 +1,15 @@
+/** Health V2 module — tsb analytics library. */
+export interface Health v2Options { tol?: number; maxIter?: number; }
+export interface Health v2Result { values: number[]; converged: boolean; }
+export function computeHealth v2(data: number[], opts: Health v2Options = {}): Health v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth v2 };
diff --git a/src/health/v3.ts b/src/health/v3.ts
new file mode 100644
index 000000000..f14eb1d18
--- /dev/null
+++ b/src/health/v3.ts
@@ -0,0 +1,15 @@
+/** Health V3 module — tsb analytics library. */
+export interface Health v3Options { tol?: number; maxIter?: number; }
+export interface Health v3Result { values: number[]; converged: boolean; }
+export function computeHealth v3(data: number[], opts: Health v3Options = {}): Health v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth v3 };
diff --git a/src/health/wasm.ts b/src/health/wasm.ts
new file mode 100644
index 000000000..283e9651e
--- /dev/null
+++ b/src/health/wasm.ts
@@ -0,0 +1,15 @@
+/** Health Wasm module — tsb analytics library. */
+export interface Health wasmOptions { tol?: number; maxIter?: number; }
+export interface Health wasmResult { values: number[]; converged: boolean; }
+export function computeHealth wasm(data: number[], opts: Health wasmOptions = {}): Health wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth wasm };
diff --git a/src/health/xlarge.ts b/src/health/xlarge.ts
new file mode 100644
index 000000000..5535e28ee
--- /dev/null
+++ b/src/health/xlarge.ts
@@ -0,0 +1,15 @@
+/** Health Xlarge module — tsb analytics library. */
+export interface Health xlargeOptions { tol?: number; maxIter?: number; }
+export interface Health xlargeResult { values: number[]; converged: boolean; }
+export function computeHealth xlarge(data: number[], opts: Health xlargeOptions = {}): Health xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHealth xlarge };
diff --git a/src/heliophysics/adaptation.ts b/src/heliophysics/adaptation.ts
new file mode 100644
index 000000000..a44086e3c
--- /dev/null
+++ b/src/heliophysics/adaptation.ts
@@ -0,0 +1,14 @@
+/** heliophysics adaptation module — tsb analytics library. */
+export interface HeliophysicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsAdaptation(data: number[], opts: HeliophysicsAdaptationOptions = {}): HeliophysicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsAdaptation };
diff --git a/src/heliophysics/aggregation.ts b/src/heliophysics/aggregation.ts
new file mode 100644
index 000000000..4efea8127
--- /dev/null
+++ b/src/heliophysics/aggregation.ts
@@ -0,0 +1,14 @@
+/** heliophysics aggregation module — tsb analytics library. */
+export interface HeliophysicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsAggregationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsAggregation(data: number[], opts: HeliophysicsAggregationOptions = {}): HeliophysicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsAggregation };
diff --git a/src/heliophysics/algebra.ts b/src/heliophysics/algebra.ts
new file mode 100644
index 000000000..7bb444547
--- /dev/null
+++ b/src/heliophysics/algebra.ts
@@ -0,0 +1,14 @@
+/** heliophysics algebra module — tsb analytics library. */
+export interface HeliophysicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsAlgebra(data: number[], opts: HeliophysicsAlgebraOptions = {}): HeliophysicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsAlgebra };
diff --git a/src/heliophysics/alignment.ts b/src/heliophysics/alignment.ts
new file mode 100644
index 000000000..5f43eb971
--- /dev/null
+++ b/src/heliophysics/alignment.ts
@@ -0,0 +1,14 @@
+/** heliophysics alignment module — tsb analytics library. */
+export interface HeliophysicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsAlignment(data: number[], opts: HeliophysicsAlignmentOptions = {}): HeliophysicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsAlignment };
diff --git a/src/heliophysics/analysis.ts b/src/heliophysics/analysis.ts
new file mode 100644
index 000000000..425c0918f
--- /dev/null
+++ b/src/heliophysics/analysis.ts
@@ -0,0 +1,14 @@
+/** heliophysics analysis module — tsb analytics library. */
+export interface HeliophysicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsAnalysis(data: number[], opts: HeliophysicsAnalysisOptions = {}): HeliophysicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsAnalysis };
diff --git a/src/heliophysics/augmentation.ts b/src/heliophysics/augmentation.ts
new file mode 100644
index 000000000..2c3d6c798
--- /dev/null
+++ b/src/heliophysics/augmentation.ts
@@ -0,0 +1,14 @@
+/** heliophysics augmentation module — tsb analytics library. */
+export interface HeliophysicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsAugmentation(data: number[], opts: HeliophysicsAugmentationOptions = {}): HeliophysicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsAugmentation };
diff --git a/src/heliophysics/bagging.ts b/src/heliophysics/bagging.ts
new file mode 100644
index 000000000..1ee1c51e5
--- /dev/null
+++ b/src/heliophysics/bagging.ts
@@ -0,0 +1,14 @@
+/** heliophysics bagging module — tsb analytics library. */
+export interface HeliophysicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsBaggingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsBagging(data: number[], opts: HeliophysicsBaggingOptions = {}): HeliophysicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsBagging };
diff --git a/src/heliophysics/basis.ts b/src/heliophysics/basis.ts
new file mode 100644
index 000000000..16cae19be
--- /dev/null
+++ b/src/heliophysics/basis.ts
@@ -0,0 +1,14 @@
+/** heliophysics basis module — tsb analytics library. */
+export interface HeliophysicsBasisOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsBasisResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsBasis(data: number[], opts: HeliophysicsBasisOptions = {}): HeliophysicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsBasis };
diff --git a/src/heliophysics/benchmarking.ts b/src/heliophysics/benchmarking.ts
new file mode 100644
index 000000000..d41130571
--- /dev/null
+++ b/src/heliophysics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** heliophysics benchmarking module — tsb analytics library. */
+export interface HeliophysicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsBenchmarking(data: number[], opts: HeliophysicsBenchmarkingOptions = {}): HeliophysicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsBenchmarking };
diff --git a/src/heliophysics/blending.ts b/src/heliophysics/blending.ts
new file mode 100644
index 000000000..b4c5d6b16
--- /dev/null
+++ b/src/heliophysics/blending.ts
@@ -0,0 +1,14 @@
+/** heliophysics blending module — tsb analytics library. */
+export interface HeliophysicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsBlendingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsBlending(data: number[], opts: HeliophysicsBlendingOptions = {}): HeliophysicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsBlending };
diff --git a/src/heliophysics/boosting.ts b/src/heliophysics/boosting.ts
new file mode 100644
index 000000000..6ddb512ee
--- /dev/null
+++ b/src/heliophysics/boosting.ts
@@ -0,0 +1,14 @@
+/** heliophysics boosting module — tsb analytics library. */
+export interface HeliophysicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsBoostingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsBoosting(data: number[], opts: HeliophysicsBoostingOptions = {}): HeliophysicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsBoosting };
diff --git a/src/heliophysics/bootstrap.ts b/src/heliophysics/bootstrap.ts
new file mode 100644
index 000000000..8c1885e16
--- /dev/null
+++ b/src/heliophysics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** heliophysics bootstrap module — tsb analytics library. */
+export interface HeliophysicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsBootstrap(data: number[], opts: HeliophysicsBootstrapOptions = {}): HeliophysicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsBootstrap };
diff --git a/src/heliophysics/calculus.ts b/src/heliophysics/calculus.ts
new file mode 100644
index 000000000..fd67db8cc
--- /dev/null
+++ b/src/heliophysics/calculus.ts
@@ -0,0 +1,14 @@
+/** heliophysics calculus module — tsb analytics library. */
+export interface HeliophysicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsCalculusResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsCalculus(data: number[], opts: HeliophysicsCalculusOptions = {}): HeliophysicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsCalculus };
diff --git a/src/heliophysics/calibration.ts b/src/heliophysics/calibration.ts
new file mode 100644
index 000000000..f69451634
--- /dev/null
+++ b/src/heliophysics/calibration.ts
@@ -0,0 +1,14 @@
+/** heliophysics calibration module — tsb analytics library. */
+export interface HeliophysicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsCalibration(data: number[], opts: HeliophysicsCalibrationOptions = {}): HeliophysicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsCalibration };
diff --git a/src/heliophysics/characterization.ts b/src/heliophysics/characterization.ts
new file mode 100644
index 000000000..976c69ba6
--- /dev/null
+++ b/src/heliophysics/characterization.ts
@@ -0,0 +1,14 @@
+/** heliophysics characterization module — tsb analytics library. */
+export interface HeliophysicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsCharacterization(data: number[], opts: HeliophysicsCharacterizationOptions = {}): HeliophysicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsCharacterization };
diff --git a/src/heliophysics/classification.ts b/src/heliophysics/classification.ts
new file mode 100644
index 000000000..a5f9b5169
--- /dev/null
+++ b/src/heliophysics/classification.ts
@@ -0,0 +1,14 @@
+/** heliophysics classification module — tsb analytics library. */
+export interface HeliophysicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsClassificationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsClassification(data: number[], opts: HeliophysicsClassificationOptions = {}): HeliophysicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsClassification };
diff --git a/src/heliophysics/clustering.ts b/src/heliophysics/clustering.ts
new file mode 100644
index 000000000..71cd0d0f2
--- /dev/null
+++ b/src/heliophysics/clustering.ts
@@ -0,0 +1,14 @@
+/** heliophysics clustering module — tsb analytics library. */
+export interface HeliophysicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsClusteringResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsClustering(data: number[], opts: HeliophysicsClusteringOptions = {}): HeliophysicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsClustering };
diff --git a/src/heliophysics/compression.ts b/src/heliophysics/compression.ts
new file mode 100644
index 000000000..ddb2ba541
--- /dev/null
+++ b/src/heliophysics/compression.ts
@@ -0,0 +1,14 @@
+/** heliophysics compression module — tsb analytics library. */
+export interface HeliophysicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsCompressionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsCompression(data: number[], opts: HeliophysicsCompressionOptions = {}): HeliophysicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsCompression };
diff --git a/src/heliophysics/continuous.ts b/src/heliophysics/continuous.ts
new file mode 100644
index 000000000..e77681502
--- /dev/null
+++ b/src/heliophysics/continuous.ts
@@ -0,0 +1,14 @@
+/** heliophysics continuous module — tsb analytics library. */
+export interface HeliophysicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsContinuousResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsContinuous(data: number[], opts: HeliophysicsContinuousOptions = {}): HeliophysicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsContinuous };
diff --git a/src/heliophysics/control.ts b/src/heliophysics/control.ts
new file mode 100644
index 000000000..12345cf00
--- /dev/null
+++ b/src/heliophysics/control.ts
@@ -0,0 +1,14 @@
+/** heliophysics control module — tsb analytics library. */
+export interface HeliophysicsControlOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsControlResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsControl(data: number[], opts: HeliophysicsControlOptions = {}): HeliophysicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsControl };
diff --git a/src/heliophysics/convergence.ts b/src/heliophysics/convergence.ts
new file mode 100644
index 000000000..2ffcc0bd4
--- /dev/null
+++ b/src/heliophysics/convergence.ts
@@ -0,0 +1,14 @@
+/** heliophysics convergence module — tsb analytics library. */
+export interface HeliophysicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsConvergence(data: number[], opts: HeliophysicsConvergenceOptions = {}): HeliophysicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsConvergence };
diff --git a/src/heliophysics/convex.ts b/src/heliophysics/convex.ts
new file mode 100644
index 000000000..87761c40e
--- /dev/null
+++ b/src/heliophysics/convex.ts
@@ -0,0 +1,14 @@
+/** heliophysics convex module — tsb analytics library. */
+export interface HeliophysicsConvexOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsConvexResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsConvex(data: number[], opts: HeliophysicsConvexOptions = {}): HeliophysicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsConvex };
diff --git a/src/heliophysics/correlation.ts b/src/heliophysics/correlation.ts
new file mode 100644
index 000000000..29d4c7d98
--- /dev/null
+++ b/src/heliophysics/correlation.ts
@@ -0,0 +1,14 @@
+/** heliophysics correlation module — tsb analytics library. */
+export interface HeliophysicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsCorrelation(data: number[], opts: HeliophysicsCorrelationOptions = {}): HeliophysicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsCorrelation };
diff --git a/src/heliophysics/covariance.ts b/src/heliophysics/covariance.ts
new file mode 100644
index 000000000..8eb1d39b7
--- /dev/null
+++ b/src/heliophysics/covariance.ts
@@ -0,0 +1,14 @@
+/** heliophysics covariance module — tsb analytics library. */
+export interface HeliophysicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsCovariance(data: number[], opts: HeliophysicsCovarianceOptions = {}): HeliophysicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsCovariance };
diff --git a/src/heliophysics/cross_validation.ts b/src/heliophysics/cross_validation.ts
new file mode 100644
index 000000000..4e2a1ac7c
--- /dev/null
+++ b/src/heliophysics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** heliophysics cross_validation module — tsb analytics library. */
+export interface HeliophysicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsCrossValidation(data: number[], opts: HeliophysicsCrossValidationOptions = {}): HeliophysicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsCrossValidation };
diff --git a/src/heliophysics/decoding.ts b/src/heliophysics/decoding.ts
new file mode 100644
index 000000000..1d3fa4870
--- /dev/null
+++ b/src/heliophysics/decoding.ts
@@ -0,0 +1,14 @@
+/** heliophysics decoding module — tsb analytics library. */
+export interface HeliophysicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDecodingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDecoding(data: number[], opts: HeliophysicsDecodingOptions = {}): HeliophysicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDecoding };
diff --git a/src/heliophysics/decomposition.ts b/src/heliophysics/decomposition.ts
new file mode 100644
index 000000000..61f3b1ef6
--- /dev/null
+++ b/src/heliophysics/decomposition.ts
@@ -0,0 +1,14 @@
+/** heliophysics decomposition module — tsb analytics library. */
+export interface HeliophysicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDecomposition(data: number[], opts: HeliophysicsDecompositionOptions = {}): HeliophysicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDecomposition };
diff --git a/src/heliophysics/detection.ts b/src/heliophysics/detection.ts
new file mode 100644
index 000000000..4e1ec419a
--- /dev/null
+++ b/src/heliophysics/detection.ts
@@ -0,0 +1,14 @@
+/** heliophysics detection module — tsb analytics library. */
+export interface HeliophysicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDetectionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDetection(data: number[], opts: HeliophysicsDetectionOptions = {}): HeliophysicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDetection };
diff --git a/src/heliophysics/deterministic.ts b/src/heliophysics/deterministic.ts
new file mode 100644
index 000000000..9437f3c86
--- /dev/null
+++ b/src/heliophysics/deterministic.ts
@@ -0,0 +1,14 @@
+/** heliophysics deterministic module — tsb analytics library. */
+export interface HeliophysicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDeterministic(data: number[], opts: HeliophysicsDeterministicOptions = {}): HeliophysicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDeterministic };
diff --git a/src/heliophysics/diagnostics.ts b/src/heliophysics/diagnostics.ts
new file mode 100644
index 000000000..53dcdbb7a
--- /dev/null
+++ b/src/heliophysics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** heliophysics diagnostics module — tsb analytics library. */
+export interface HeliophysicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDiagnostics(data: number[], opts: HeliophysicsDiagnosticsOptions = {}): HeliophysicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDiagnostics };
diff --git a/src/heliophysics/differential.ts b/src/heliophysics/differential.ts
new file mode 100644
index 000000000..fa744eb38
--- /dev/null
+++ b/src/heliophysics/differential.ts
@@ -0,0 +1,14 @@
+/** heliophysics differential module — tsb analytics library. */
+export interface HeliophysicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDifferential(data: number[], opts: HeliophysicsDifferentialOptions = {}): HeliophysicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDifferential };
diff --git a/src/heliophysics/discrete.ts b/src/heliophysics/discrete.ts
new file mode 100644
index 000000000..89093faca
--- /dev/null
+++ b/src/heliophysics/discrete.ts
@@ -0,0 +1,14 @@
+/** heliophysics discrete module — tsb analytics library. */
+export interface HeliophysicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDiscrete(data: number[], opts: HeliophysicsDiscreteOptions = {}): HeliophysicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDiscrete };
diff --git a/src/heliophysics/distribution.ts b/src/heliophysics/distribution.ts
new file mode 100644
index 000000000..d89c94346
--- /dev/null
+++ b/src/heliophysics/distribution.ts
@@ -0,0 +1,14 @@
+/** heliophysics distribution module — tsb analytics library. */
+export interface HeliophysicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDistributionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDistribution(data: number[], opts: HeliophysicsDistributionOptions = {}): HeliophysicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDistribution };
diff --git a/src/heliophysics/dynamic.ts b/src/heliophysics/dynamic.ts
new file mode 100644
index 000000000..5cf250e50
--- /dev/null
+++ b/src/heliophysics/dynamic.ts
@@ -0,0 +1,14 @@
+/** heliophysics dynamic module — tsb analytics library. */
+export interface HeliophysicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsDynamicResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsDynamic(data: number[], opts: HeliophysicsDynamicOptions = {}): HeliophysicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsDynamic };
diff --git a/src/heliophysics/embedding.ts b/src/heliophysics/embedding.ts
new file mode 100644
index 000000000..dda0cafa5
--- /dev/null
+++ b/src/heliophysics/embedding.ts
@@ -0,0 +1,14 @@
+/** heliophysics embedding module — tsb analytics library. */
+export interface HeliophysicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsEmbedding(data: number[], opts: HeliophysicsEmbeddingOptions = {}): HeliophysicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsEmbedding };
diff --git a/src/heliophysics/encoding.ts b/src/heliophysics/encoding.ts
new file mode 100644
index 000000000..4efad81a2
--- /dev/null
+++ b/src/heliophysics/encoding.ts
@@ -0,0 +1,14 @@
+/** heliophysics encoding module — tsb analytics library. */
+export interface HeliophysicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsEncodingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsEncoding(data: number[], opts: HeliophysicsEncodingOptions = {}): HeliophysicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsEncoding };
diff --git a/src/heliophysics/ensemble.ts b/src/heliophysics/ensemble.ts
new file mode 100644
index 000000000..f502e736f
--- /dev/null
+++ b/src/heliophysics/ensemble.ts
@@ -0,0 +1,14 @@
+/** heliophysics ensemble module — tsb analytics library. */
+export interface HeliophysicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsEnsemble(data: number[], opts: HeliophysicsEnsembleOptions = {}): HeliophysicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsEnsemble };
diff --git a/src/heliophysics/estimation.ts b/src/heliophysics/estimation.ts
new file mode 100644
index 000000000..0fd58b7a9
--- /dev/null
+++ b/src/heliophysics/estimation.ts
@@ -0,0 +1,14 @@
+/** heliophysics estimation module — tsb analytics library. */
+export interface HeliophysicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsEstimationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsEstimation(data: number[], opts: HeliophysicsEstimationOptions = {}): HeliophysicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsEstimation };
diff --git a/src/heliophysics/evaluation.ts b/src/heliophysics/evaluation.ts
new file mode 100644
index 000000000..8af7e82b3
--- /dev/null
+++ b/src/heliophysics/evaluation.ts
@@ -0,0 +1,14 @@
+/** heliophysics evaluation module — tsb analytics library. */
+export interface HeliophysicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsEvaluation(data: number[], opts: HeliophysicsEvaluationOptions = {}): HeliophysicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsEvaluation };
diff --git a/src/heliophysics/extrapolation.ts b/src/heliophysics/extrapolation.ts
new file mode 100644
index 000000000..8b991fc4e
--- /dev/null
+++ b/src/heliophysics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** heliophysics extrapolation module — tsb analytics library. */
+export interface HeliophysicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsExtrapolation(data: number[], opts: HeliophysicsExtrapolationOptions = {}): HeliophysicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsExtrapolation };
diff --git a/src/heliophysics/features.ts b/src/heliophysics/features.ts
new file mode 100644
index 000000000..2297b6259
--- /dev/null
+++ b/src/heliophysics/features.ts
@@ -0,0 +1,14 @@
+/** heliophysics features module — tsb analytics library. */
+export interface HeliophysicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsFeatures(data: number[], opts: HeliophysicsFeaturesOptions = {}): HeliophysicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsFeatures };
diff --git a/src/heliophysics/feedback.ts b/src/heliophysics/feedback.ts
new file mode 100644
index 000000000..e6e46cacd
--- /dev/null
+++ b/src/heliophysics/feedback.ts
@@ -0,0 +1,14 @@
+/** heliophysics feedback module — tsb analytics library. */
+export interface HeliophysicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsFeedback(data: number[], opts: HeliophysicsFeedbackOptions = {}): HeliophysicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsFeedback };
diff --git a/src/heliophysics/filtering.ts b/src/heliophysics/filtering.ts
new file mode 100644
index 000000000..626c02281
--- /dev/null
+++ b/src/heliophysics/filtering.ts
@@ -0,0 +1,14 @@
+/** heliophysics filtering module — tsb analytics library. */
+export interface HeliophysicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsFilteringResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsFiltering(data: number[], opts: HeliophysicsFilteringOptions = {}): HeliophysicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsFiltering };
diff --git a/src/heliophysics/fourier.ts b/src/heliophysics/fourier.ts
new file mode 100644
index 000000000..9ef181dab
--- /dev/null
+++ b/src/heliophysics/fourier.ts
@@ -0,0 +1,14 @@
+/** heliophysics fourier module — tsb analytics library. */
+export interface HeliophysicsFourierOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsFourierResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsFourier(data: number[], opts: HeliophysicsFourierOptions = {}): HeliophysicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsFourier };
diff --git a/src/heliophysics/fusion.ts b/src/heliophysics/fusion.ts
new file mode 100644
index 000000000..aff7ddb09
--- /dev/null
+++ b/src/heliophysics/fusion.ts
@@ -0,0 +1,14 @@
+/** heliophysics fusion module — tsb analytics library. */
+export interface HeliophysicsFusionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsFusionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsFusion(data: number[], opts: HeliophysicsFusionOptions = {}): HeliophysicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsFusion };
diff --git a/src/heliophysics/generation.ts b/src/heliophysics/generation.ts
new file mode 100644
index 000000000..f1ef44e71
--- /dev/null
+++ b/src/heliophysics/generation.ts
@@ -0,0 +1,14 @@
+/** heliophysics generation module — tsb analytics library. */
+export interface HeliophysicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsGenerationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsGeneration(data: number[], opts: HeliophysicsGenerationOptions = {}): HeliophysicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsGeneration };
diff --git a/src/heliophysics/geometry.ts b/src/heliophysics/geometry.ts
new file mode 100644
index 000000000..f623eedd1
--- /dev/null
+++ b/src/heliophysics/geometry.ts
@@ -0,0 +1,14 @@
+/** heliophysics geometry module — tsb analytics library. */
+export interface HeliophysicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsGeometryResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsGeometry(data: number[], opts: HeliophysicsGeometryOptions = {}): HeliophysicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsGeometry };
diff --git a/src/heliophysics/gradient.ts b/src/heliophysics/gradient.ts
new file mode 100644
index 000000000..585384a04
--- /dev/null
+++ b/src/heliophysics/gradient.ts
@@ -0,0 +1,14 @@
+/** heliophysics gradient module — tsb analytics library. */
+export interface HeliophysicsGradientOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsGradientResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsGradient(data: number[], opts: HeliophysicsGradientOptions = {}): HeliophysicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsGradient };
diff --git a/src/heliophysics/hessian.ts b/src/heliophysics/hessian.ts
new file mode 100644
index 000000000..204c7d18b
--- /dev/null
+++ b/src/heliophysics/hessian.ts
@@ -0,0 +1,14 @@
+/** heliophysics hessian module — tsb analytics library. */
+export interface HeliophysicsHessianOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsHessianResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsHessian(data: number[], opts: HeliophysicsHessianOptions = {}): HeliophysicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsHessian };
diff --git a/src/heliophysics/hypothesis.ts b/src/heliophysics/hypothesis.ts
new file mode 100644
index 000000000..c95a9dbff
--- /dev/null
+++ b/src/heliophysics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** heliophysics hypothesis module — tsb analytics library. */
+export interface HeliophysicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsHypothesis(data: number[], opts: HeliophysicsHypothesisOptions = {}): HeliophysicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsHypothesis };
diff --git a/src/heliophysics/inference.ts b/src/heliophysics/inference.ts
new file mode 100644
index 000000000..5e3cb985f
--- /dev/null
+++ b/src/heliophysics/inference.ts
@@ -0,0 +1,14 @@
+/** heliophysics inference module — tsb analytics library. */
+export interface HeliophysicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsInferenceResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsInference(data: number[], opts: HeliophysicsInferenceOptions = {}): HeliophysicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsInference };
diff --git a/src/heliophysics/inference2.ts b/src/heliophysics/inference2.ts
new file mode 100644
index 000000000..b03ff084c
--- /dev/null
+++ b/src/heliophysics/inference2.ts
@@ -0,0 +1,14 @@
+/** heliophysics inference2 module — tsb analytics library. */
+export interface HeliophysicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsInferenceResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsInference(data: number[], opts: HeliophysicsInferenceOptions = {}): HeliophysicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsInference };
diff --git a/src/heliophysics/integral.ts b/src/heliophysics/integral.ts
new file mode 100644
index 000000000..7f7a819dd
--- /dev/null
+++ b/src/heliophysics/integral.ts
@@ -0,0 +1,14 @@
+/** heliophysics integral module — tsb analytics library. */
+export interface HeliophysicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsIntegralResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsIntegral(data: number[], opts: HeliophysicsIntegralOptions = {}): HeliophysicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsIntegral };
diff --git a/src/heliophysics/integration.ts b/src/heliophysics/integration.ts
new file mode 100644
index 000000000..5dd6ce836
--- /dev/null
+++ b/src/heliophysics/integration.ts
@@ -0,0 +1,14 @@
+/** heliophysics integration module — tsb analytics library. */
+export interface HeliophysicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsIntegration(data: number[], opts: HeliophysicsIntegrationOptions = {}): HeliophysicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsIntegration };
diff --git a/src/heliophysics/interpolation.ts b/src/heliophysics/interpolation.ts
new file mode 100644
index 000000000..a2778fecc
--- /dev/null
+++ b/src/heliophysics/interpolation.ts
@@ -0,0 +1,14 @@
+/** heliophysics interpolation module — tsb analytics library. */
+export interface HeliophysicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsInterpolation(data: number[], opts: HeliophysicsInterpolationOptions = {}): HeliophysicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsInterpolation };
diff --git a/src/heliophysics/jacobian.ts b/src/heliophysics/jacobian.ts
new file mode 100644
index 000000000..c9e37ad28
--- /dev/null
+++ b/src/heliophysics/jacobian.ts
@@ -0,0 +1,14 @@
+/** heliophysics jacobian module — tsb analytics library. */
+export interface HeliophysicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsJacobianResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsJacobian(data: number[], opts: HeliophysicsJacobianOptions = {}): HeliophysicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsJacobian };
diff --git a/src/heliophysics/kernel.ts b/src/heliophysics/kernel.ts
new file mode 100644
index 000000000..4ebe533d3
--- /dev/null
+++ b/src/heliophysics/kernel.ts
@@ -0,0 +1,14 @@
+/** heliophysics kernel module — tsb analytics library. */
+export interface HeliophysicsKernelOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsKernelResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsKernel(data: number[], opts: HeliophysicsKernelOptions = {}): HeliophysicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsKernel };
diff --git a/src/heliophysics/laplacian.ts b/src/heliophysics/laplacian.ts
new file mode 100644
index 000000000..3ad0e8084
--- /dev/null
+++ b/src/heliophysics/laplacian.ts
@@ -0,0 +1,14 @@
+/** heliophysics laplacian module — tsb analytics library. */
+export interface HeliophysicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsLaplacian(data: number[], opts: HeliophysicsLaplacianOptions = {}): HeliophysicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsLaplacian };
diff --git a/src/heliophysics/learning.ts b/src/heliophysics/learning.ts
new file mode 100644
index 000000000..f8fbe86fb
--- /dev/null
+++ b/src/heliophysics/learning.ts
@@ -0,0 +1,14 @@
+/** heliophysics learning module — tsb analytics library. */
+export interface HeliophysicsLearningOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsLearningResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsLearning(data: number[], opts: HeliophysicsLearningOptions = {}): HeliophysicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsLearning };
diff --git a/src/heliophysics/linear.ts b/src/heliophysics/linear.ts
new file mode 100644
index 000000000..913491587
--- /dev/null
+++ b/src/heliophysics/linear.ts
@@ -0,0 +1,14 @@
+/** heliophysics linear module — tsb analytics library. */
+export interface HeliophysicsLinearOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsLinearResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsLinear(data: number[], opts: HeliophysicsLinearOptions = {}): HeliophysicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsLinear };
diff --git a/src/heliophysics/manifold.ts b/src/heliophysics/manifold.ts
new file mode 100644
index 000000000..0e820d7ed
--- /dev/null
+++ b/src/heliophysics/manifold.ts
@@ -0,0 +1,14 @@
+/** heliophysics manifold module — tsb analytics library. */
+export interface HeliophysicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsManifoldResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsManifold(data: number[], opts: HeliophysicsManifoldOptions = {}): HeliophysicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsManifold };
diff --git a/src/heliophysics/matching.ts b/src/heliophysics/matching.ts
new file mode 100644
index 000000000..ef494ec22
--- /dev/null
+++ b/src/heliophysics/matching.ts
@@ -0,0 +1,14 @@
+/** heliophysics matching module — tsb analytics library. */
+export interface HeliophysicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsMatchingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsMatching(data: number[], opts: HeliophysicsMatchingOptions = {}): HeliophysicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsMatching };
diff --git a/src/heliophysics/measurement.ts b/src/heliophysics/measurement.ts
new file mode 100644
index 000000000..e83279590
--- /dev/null
+++ b/src/heliophysics/measurement.ts
@@ -0,0 +1,14 @@
+/** heliophysics measurement module — tsb analytics library. */
+export interface HeliophysicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsMeasurement(data: number[], opts: HeliophysicsMeasurementOptions = {}): HeliophysicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsMeasurement };
diff --git a/src/heliophysics/metrics.ts b/src/heliophysics/metrics.ts
new file mode 100644
index 000000000..03ab58ae9
--- /dev/null
+++ b/src/heliophysics/metrics.ts
@@ -0,0 +1,14 @@
+/** heliophysics metrics module — tsb analytics library. */
+export interface HeliophysicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsMetricsResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsMetrics(data: number[], opts: HeliophysicsMetricsOptions = {}): HeliophysicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsMetrics };
diff --git a/src/heliophysics/modeling.ts b/src/heliophysics/modeling.ts
new file mode 100644
index 000000000..7c3117025
--- /dev/null
+++ b/src/heliophysics/modeling.ts
@@ -0,0 +1,14 @@
+/** heliophysics modeling module — tsb analytics library. */
+export interface HeliophysicsModelingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsModelingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsModeling(data: number[], opts: HeliophysicsModelingOptions = {}): HeliophysicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsModeling };
diff --git a/src/heliophysics/monitoring.ts b/src/heliophysics/monitoring.ts
new file mode 100644
index 000000000..772a760de
--- /dev/null
+++ b/src/heliophysics/monitoring.ts
@@ -0,0 +1,14 @@
+/** heliophysics monitoring module — tsb analytics library. */
+export interface HeliophysicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsMonitoring(data: number[], opts: HeliophysicsMonitoringOptions = {}): HeliophysicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsMonitoring };
diff --git a/src/heliophysics/nonlinear.ts b/src/heliophysics/nonlinear.ts
new file mode 100644
index 000000000..17631a889
--- /dev/null
+++ b/src/heliophysics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** heliophysics nonlinear module — tsb analytics library. */
+export interface HeliophysicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsNonlinear(data: number[], opts: HeliophysicsNonlinearOptions = {}): HeliophysicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsNonlinear };
diff --git a/src/heliophysics/normalization.ts b/src/heliophysics/normalization.ts
new file mode 100644
index 000000000..344e83161
--- /dev/null
+++ b/src/heliophysics/normalization.ts
@@ -0,0 +1,14 @@
+/** heliophysics normalization module — tsb analytics library. */
+export interface HeliophysicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsNormalization(data: number[], opts: HeliophysicsNormalizationOptions = {}): HeliophysicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsNormalization };
diff --git a/src/heliophysics/optimization.ts b/src/heliophysics/optimization.ts
new file mode 100644
index 000000000..22805e7a1
--- /dev/null
+++ b/src/heliophysics/optimization.ts
@@ -0,0 +1,14 @@
+/** heliophysics optimization module — tsb analytics library. */
+export interface HeliophysicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsOptimization(data: number[], opts: HeliophysicsOptimizationOptions = {}): HeliophysicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsOptimization };
diff --git a/src/heliophysics/patterns.ts b/src/heliophysics/patterns.ts
new file mode 100644
index 000000000..c3acabb34
--- /dev/null
+++ b/src/heliophysics/patterns.ts
@@ -0,0 +1,14 @@
+/** heliophysics patterns module — tsb analytics library. */
+export interface HeliophysicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsPatternsResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsPatterns(data: number[], opts: HeliophysicsPatternsOptions = {}): HeliophysicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsPatterns };
diff --git a/src/heliophysics/permutation.ts b/src/heliophysics/permutation.ts
new file mode 100644
index 000000000..05028bc91
--- /dev/null
+++ b/src/heliophysics/permutation.ts
@@ -0,0 +1,14 @@
+/** heliophysics permutation module — tsb analytics library. */
+export interface HeliophysicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsPermutationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsPermutation(data: number[], opts: HeliophysicsPermutationOptions = {}): HeliophysicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsPermutation };
diff --git a/src/heliophysics/prediction.ts b/src/heliophysics/prediction.ts
new file mode 100644
index 000000000..cd27d466e
--- /dev/null
+++ b/src/heliophysics/prediction.ts
@@ -0,0 +1,14 @@
+/** heliophysics prediction module — tsb analytics library. */
+export interface HeliophysicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsPredictionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsPrediction(data: number[], opts: HeliophysicsPredictionOptions = {}): HeliophysicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsPrediction };
diff --git a/src/heliophysics/processing.ts b/src/heliophysics/processing.ts
new file mode 100644
index 000000000..d2842d377
--- /dev/null
+++ b/src/heliophysics/processing.ts
@@ -0,0 +1,14 @@
+/** heliophysics processing module — tsb analytics library. */
+export interface HeliophysicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsProcessingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsProcessing(data: number[], opts: HeliophysicsProcessingOptions = {}): HeliophysicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsProcessing };
diff --git a/src/heliophysics/profiling.ts b/src/heliophysics/profiling.ts
new file mode 100644
index 000000000..eb5674122
--- /dev/null
+++ b/src/heliophysics/profiling.ts
@@ -0,0 +1,14 @@
+/** heliophysics profiling module — tsb analytics library. */
+export interface HeliophysicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsProfilingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsProfiling(data: number[], opts: HeliophysicsProfilingOptions = {}): HeliophysicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsProfiling };
diff --git a/src/heliophysics/projection.ts b/src/heliophysics/projection.ts
new file mode 100644
index 000000000..faf572747
--- /dev/null
+++ b/src/heliophysics/projection.ts
@@ -0,0 +1,14 @@
+/** heliophysics projection module — tsb analytics library. */
+export interface HeliophysicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsProjectionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsProjection(data: number[], opts: HeliophysicsProjectionOptions = {}): HeliophysicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsProjection };
diff --git a/src/heliophysics/ranking.ts b/src/heliophysics/ranking.ts
new file mode 100644
index 000000000..4129d46a4
--- /dev/null
+++ b/src/heliophysics/ranking.ts
@@ -0,0 +1,14 @@
+/** heliophysics ranking module — tsb analytics library. */
+export interface HeliophysicsRankingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsRankingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsRanking(data: number[], opts: HeliophysicsRankingOptions = {}): HeliophysicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsRanking };
diff --git a/src/heliophysics/reconstruction.ts b/src/heliophysics/reconstruction.ts
new file mode 100644
index 000000000..f7d62b1a2
--- /dev/null
+++ b/src/heliophysics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** heliophysics reconstruction module — tsb analytics library. */
+export interface HeliophysicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsReconstruction(data: number[], opts: HeliophysicsReconstructionOptions = {}): HeliophysicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsReconstruction };
diff --git a/src/heliophysics/registration.ts b/src/heliophysics/registration.ts
new file mode 100644
index 000000000..c06ffa755
--- /dev/null
+++ b/src/heliophysics/registration.ts
@@ -0,0 +1,14 @@
+/** heliophysics registration module — tsb analytics library. */
+export interface HeliophysicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsRegistration(data: number[], opts: HeliophysicsRegistrationOptions = {}): HeliophysicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsRegistration };
diff --git a/src/heliophysics/regression.ts b/src/heliophysics/regression.ts
new file mode 100644
index 000000000..ea23a9ef0
--- /dev/null
+++ b/src/heliophysics/regression.ts
@@ -0,0 +1,14 @@
+/** heliophysics regression module — tsb analytics library. */
+export interface HeliophysicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsRegressionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsRegression(data: number[], opts: HeliophysicsRegressionOptions = {}): HeliophysicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsRegression };
diff --git a/src/heliophysics/regularization.ts b/src/heliophysics/regularization.ts
new file mode 100644
index 000000000..1efc62335
--- /dev/null
+++ b/src/heliophysics/regularization.ts
@@ -0,0 +1,14 @@
+/** heliophysics regularization module — tsb analytics library. */
+export interface HeliophysicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsRegularization(data: number[], opts: HeliophysicsRegularizationOptions = {}): HeliophysicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsRegularization };
diff --git a/src/heliophysics/robustness.ts b/src/heliophysics/robustness.ts
new file mode 100644
index 000000000..1df9e018e
--- /dev/null
+++ b/src/heliophysics/robustness.ts
@@ -0,0 +1,14 @@
+/** heliophysics robustness module — tsb analytics library. */
+export interface HeliophysicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsRobustness(data: number[], opts: HeliophysicsRobustnessOptions = {}): HeliophysicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsRobustness };
diff --git a/src/heliophysics/sampling.ts b/src/heliophysics/sampling.ts
new file mode 100644
index 000000000..4f92d940c
--- /dev/null
+++ b/src/heliophysics/sampling.ts
@@ -0,0 +1,14 @@
+/** heliophysics sampling module — tsb analytics library. */
+export interface HeliophysicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsSamplingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsSampling(data: number[], opts: HeliophysicsSamplingOptions = {}): HeliophysicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsSampling };
diff --git a/src/heliophysics/sampling2.ts b/src/heliophysics/sampling2.ts
new file mode 100644
index 000000000..e62df5cff
--- /dev/null
+++ b/src/heliophysics/sampling2.ts
@@ -0,0 +1,14 @@
+/** heliophysics sampling2 module — tsb analytics library. */
+export interface HeliophysicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsSamplingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsSampling(data: number[], opts: HeliophysicsSamplingOptions = {}): HeliophysicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsSampling };
diff --git a/src/heliophysics/scaling.ts b/src/heliophysics/scaling.ts
new file mode 100644
index 000000000..7ec4dc02c
--- /dev/null
+++ b/src/heliophysics/scaling.ts
@@ -0,0 +1,14 @@
+/** heliophysics scaling module — tsb analytics library. */
+export interface HeliophysicsScalingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsScalingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsScaling(data: number[], opts: HeliophysicsScalingOptions = {}): HeliophysicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsScaling };
diff --git a/src/heliophysics/scoring.ts b/src/heliophysics/scoring.ts
new file mode 100644
index 000000000..dbd498d4a
--- /dev/null
+++ b/src/heliophysics/scoring.ts
@@ -0,0 +1,14 @@
+/** heliophysics scoring module — tsb analytics library. */
+export interface HeliophysicsScoringOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsScoringResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsScoring(data: number[], opts: HeliophysicsScoringOptions = {}): HeliophysicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsScoring };
diff --git a/src/heliophysics/segmentation.ts b/src/heliophysics/segmentation.ts
new file mode 100644
index 000000000..9a5b71152
--- /dev/null
+++ b/src/heliophysics/segmentation.ts
@@ -0,0 +1,14 @@
+/** heliophysics segmentation module — tsb analytics library. */
+export interface HeliophysicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsSegmentation(data: number[], opts: HeliophysicsSegmentationOptions = {}): HeliophysicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsSegmentation };
diff --git a/src/heliophysics/selection.ts b/src/heliophysics/selection.ts
new file mode 100644
index 000000000..696a69292
--- /dev/null
+++ b/src/heliophysics/selection.ts
@@ -0,0 +1,14 @@
+/** heliophysics selection module — tsb analytics library. */
+export interface HeliophysicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsSelectionResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsSelection(data: number[], opts: HeliophysicsSelectionOptions = {}): HeliophysicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsSelection };
diff --git a/src/heliophysics/sensitivity.ts b/src/heliophysics/sensitivity.ts
new file mode 100644
index 000000000..9578dcdfd
--- /dev/null
+++ b/src/heliophysics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** heliophysics sensitivity module — tsb analytics library. */
+export interface HeliophysicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsSensitivity(data: number[], opts: HeliophysicsSensitivityOptions = {}): HeliophysicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsSensitivity };
diff --git a/src/heliophysics/simulation.ts b/src/heliophysics/simulation.ts
new file mode 100644
index 000000000..62cecd026
--- /dev/null
+++ b/src/heliophysics/simulation.ts
@@ -0,0 +1,14 @@
+/** heliophysics simulation module — tsb analytics library. */
+export interface HeliophysicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsSimulationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsSimulation(data: number[], opts: HeliophysicsSimulationOptions = {}): HeliophysicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsSimulation };
diff --git a/src/heliophysics/smoothing.ts b/src/heliophysics/smoothing.ts
new file mode 100644
index 000000000..8f45a20f3
--- /dev/null
+++ b/src/heliophysics/smoothing.ts
@@ -0,0 +1,14 @@
+/** heliophysics smoothing module — tsb analytics library. */
+export interface HeliophysicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsSmoothing(data: number[], opts: HeliophysicsSmoothingOptions = {}): HeliophysicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsSmoothing };
diff --git a/src/heliophysics/stability.ts b/src/heliophysics/stability.ts
new file mode 100644
index 000000000..8c10fe38a
--- /dev/null
+++ b/src/heliophysics/stability.ts
@@ -0,0 +1,14 @@
+/** heliophysics stability module — tsb analytics library. */
+export interface HeliophysicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsStabilityResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsStability(data: number[], opts: HeliophysicsStabilityOptions = {}): HeliophysicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsStability };
diff --git a/src/heliophysics/stacking.ts b/src/heliophysics/stacking.ts
new file mode 100644
index 000000000..cc63c7831
--- /dev/null
+++ b/src/heliophysics/stacking.ts
@@ -0,0 +1,14 @@
+/** heliophysics stacking module — tsb analytics library. */
+export interface HeliophysicsStackingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsStackingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsStacking(data: number[], opts: HeliophysicsStackingOptions = {}): HeliophysicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsStacking };
diff --git a/src/heliophysics/standardization.ts b/src/heliophysics/standardization.ts
new file mode 100644
index 000000000..85442b0cf
--- /dev/null
+++ b/src/heliophysics/standardization.ts
@@ -0,0 +1,14 @@
+/** heliophysics standardization module — tsb analytics library. */
+export interface HeliophysicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsStandardization(data: number[], opts: HeliophysicsStandardizationOptions = {}): HeliophysicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsStandardization };
diff --git a/src/heliophysics/static.ts b/src/heliophysics/static.ts
new file mode 100644
index 000000000..d9d15491d
--- /dev/null
+++ b/src/heliophysics/static.ts
@@ -0,0 +1,14 @@
+/** heliophysics static module — tsb analytics library. */
+export interface HeliophysicsStaticOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsStaticResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsStatic(data: number[], opts: HeliophysicsStaticOptions = {}): HeliophysicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsStatic };
diff --git a/src/heliophysics/stochastic.ts b/src/heliophysics/stochastic.ts
new file mode 100644
index 000000000..dd5350e87
--- /dev/null
+++ b/src/heliophysics/stochastic.ts
@@ -0,0 +1,14 @@
+/** heliophysics stochastic module — tsb analytics library. */
+export interface HeliophysicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsStochasticResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsStochastic(data: number[], opts: HeliophysicsStochasticOptions = {}): HeliophysicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsStochastic };
diff --git a/src/heliophysics/synthesis.ts b/src/heliophysics/synthesis.ts
new file mode 100644
index 000000000..e627a0baf
--- /dev/null
+++ b/src/heliophysics/synthesis.ts
@@ -0,0 +1,14 @@
+/** heliophysics synthesis module — tsb analytics library. */
+export interface HeliophysicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsSynthesis(data: number[], opts: HeliophysicsSynthesisOptions = {}): HeliophysicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsSynthesis };
diff --git a/src/heliophysics/topology.ts b/src/heliophysics/topology.ts
new file mode 100644
index 000000000..ed8b92d20
--- /dev/null
+++ b/src/heliophysics/topology.ts
@@ -0,0 +1,14 @@
+/** heliophysics topology module — tsb analytics library. */
+export interface HeliophysicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsTopologyResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsTopology(data: number[], opts: HeliophysicsTopologyOptions = {}): HeliophysicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsTopology };
diff --git a/src/heliophysics/tracking.ts b/src/heliophysics/tracking.ts
new file mode 100644
index 000000000..24c706a74
--- /dev/null
+++ b/src/heliophysics/tracking.ts
@@ -0,0 +1,14 @@
+/** heliophysics tracking module — tsb analytics library. */
+export interface HeliophysicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsTrackingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsTracking(data: number[], opts: HeliophysicsTrackingOptions = {}): HeliophysicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsTracking };
diff --git a/src/heliophysics/transform.ts b/src/heliophysics/transform.ts
new file mode 100644
index 000000000..c09df52f0
--- /dev/null
+++ b/src/heliophysics/transform.ts
@@ -0,0 +1,14 @@
+/** heliophysics transform module — tsb analytics library. */
+export interface HeliophysicsTransformOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsTransformResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsTransform(data: number[], opts: HeliophysicsTransformOptions = {}): HeliophysicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsTransform };
diff --git a/src/heliophysics/uncertainty.ts b/src/heliophysics/uncertainty.ts
new file mode 100644
index 000000000..5ed9233f5
--- /dev/null
+++ b/src/heliophysics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** heliophysics uncertainty module — tsb analytics library. */
+export interface HeliophysicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsUncertainty(data: number[], opts: HeliophysicsUncertaintyOptions = {}): HeliophysicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsUncertainty };
diff --git a/src/heliophysics/validation.ts b/src/heliophysics/validation.ts
new file mode 100644
index 000000000..dae5e70cd
--- /dev/null
+++ b/src/heliophysics/validation.ts
@@ -0,0 +1,14 @@
+/** heliophysics validation module — tsb analytics library. */
+export interface HeliophysicsValidationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsValidationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsValidation(data: number[], opts: HeliophysicsValidationOptions = {}): HeliophysicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsValidation };
diff --git a/src/heliophysics/verification.ts b/src/heliophysics/verification.ts
new file mode 100644
index 000000000..e7a6608e5
--- /dev/null
+++ b/src/heliophysics/verification.ts
@@ -0,0 +1,14 @@
+/** heliophysics verification module — tsb analytics library. */
+export interface HeliophysicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsVerificationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsVerification(data: number[], opts: HeliophysicsVerificationOptions = {}): HeliophysicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsVerification };
diff --git a/src/heliophysics/visualization.ts b/src/heliophysics/visualization.ts
new file mode 100644
index 000000000..35e535a10
--- /dev/null
+++ b/src/heliophysics/visualization.ts
@@ -0,0 +1,14 @@
+/** heliophysics visualization module — tsb analytics library. */
+export interface HeliophysicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsVisualization(data: number[], opts: HeliophysicsVisualizationOptions = {}): HeliophysicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsVisualization };
diff --git a/src/heliophysics/voting.ts b/src/heliophysics/voting.ts
new file mode 100644
index 000000000..83092f1fc
--- /dev/null
+++ b/src/heliophysics/voting.ts
@@ -0,0 +1,14 @@
+/** heliophysics voting module — tsb analytics library. */
+export interface HeliophysicsVotingOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsVotingResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsVoting(data: number[], opts: HeliophysicsVotingOptions = {}): HeliophysicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsVoting };
diff --git a/src/heliophysics/wavelet.ts b/src/heliophysics/wavelet.ts
new file mode 100644
index 000000000..ba358f97f
--- /dev/null
+++ b/src/heliophysics/wavelet.ts
@@ -0,0 +1,14 @@
+/** heliophysics wavelet module — tsb analytics library. */
+export interface HeliophysicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface HeliophysicsWaveletResult { values: number[]; converged: boolean; }
+export function computeHeliophysicsWavelet(data: number[], opts: HeliophysicsWaveletOptions = {}): HeliophysicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHeliophysicsWavelet };
diff --git a/src/hematology/adaptation.ts b/src/hematology/adaptation.ts
new file mode 100644
index 000000000..cf9e01b6b
--- /dev/null
+++ b/src/hematology/adaptation.ts
@@ -0,0 +1,14 @@
+/** hematology adaptation module — tsb analytics library. */
+export interface HematologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface HematologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeHematologyAdaptation(data: number[], opts: HematologyAdaptationOptions = {}): HematologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyAdaptation };
diff --git a/src/hematology/aggregation.ts b/src/hematology/aggregation.ts
new file mode 100644
index 000000000..4d14162b9
--- /dev/null
+++ b/src/hematology/aggregation.ts
@@ -0,0 +1,14 @@
+/** hematology aggregation module — tsb analytics library. */
+export interface HematologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface HematologyAggregationResult { values: number[]; converged: boolean; }
+export function computeHematologyAggregation(data: number[], opts: HematologyAggregationOptions = {}): HematologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyAggregation };
diff --git a/src/hematology/algebra.ts b/src/hematology/algebra.ts
new file mode 100644
index 000000000..959c8777a
--- /dev/null
+++ b/src/hematology/algebra.ts
@@ -0,0 +1,14 @@
+/** hematology algebra module — tsb analytics library. */
+export interface HematologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface HematologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeHematologyAlgebra(data: number[], opts: HematologyAlgebraOptions = {}): HematologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyAlgebra };
diff --git a/src/hematology/alignment.ts b/src/hematology/alignment.ts
new file mode 100644
index 000000000..8a2d31a21
--- /dev/null
+++ b/src/hematology/alignment.ts
@@ -0,0 +1,14 @@
+/** hematology alignment module — tsb analytics library. */
+export interface HematologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface HematologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeHematologyAlignment(data: number[], opts: HematologyAlignmentOptions = {}): HematologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyAlignment };
diff --git a/src/hematology/analysis.ts b/src/hematology/analysis.ts
new file mode 100644
index 000000000..81797b979
--- /dev/null
+++ b/src/hematology/analysis.ts
@@ -0,0 +1,14 @@
+/** hematology analysis module — tsb analytics library. */
+export interface HematologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface HematologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeHematologyAnalysis(data: number[], opts: HematologyAnalysisOptions = {}): HematologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyAnalysis };
diff --git a/src/hematology/augmentation.ts b/src/hematology/augmentation.ts
new file mode 100644
index 000000000..a0b2b7ee8
--- /dev/null
+++ b/src/hematology/augmentation.ts
@@ -0,0 +1,14 @@
+/** hematology augmentation module — tsb analytics library. */
+export interface HematologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface HematologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeHematologyAugmentation(data: number[], opts: HematologyAugmentationOptions = {}): HematologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyAugmentation };
diff --git a/src/hematology/bagging.ts b/src/hematology/bagging.ts
new file mode 100644
index 000000000..6304fce04
--- /dev/null
+++ b/src/hematology/bagging.ts
@@ -0,0 +1,14 @@
+/** hematology bagging module — tsb analytics library. */
+export interface HematologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface HematologyBaggingResult { values: number[]; converged: boolean; }
+export function computeHematologyBagging(data: number[], opts: HematologyBaggingOptions = {}): HematologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyBagging };
diff --git a/src/hematology/basis.ts b/src/hematology/basis.ts
new file mode 100644
index 000000000..16d73ac5f
--- /dev/null
+++ b/src/hematology/basis.ts
@@ -0,0 +1,14 @@
+/** hematology basis module — tsb analytics library. */
+export interface HematologyBasisOptions { tol?: number; maxIter?: number; }
+export interface HematologyBasisResult { values: number[]; converged: boolean; }
+export function computeHematologyBasis(data: number[], opts: HematologyBasisOptions = {}): HematologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyBasis };
diff --git a/src/hematology/benchmarking.ts b/src/hematology/benchmarking.ts
new file mode 100644
index 000000000..99af6e288
--- /dev/null
+++ b/src/hematology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** hematology benchmarking module — tsb analytics library. */
+export interface HematologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface HematologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeHematologyBenchmarking(data: number[], opts: HematologyBenchmarkingOptions = {}): HematologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyBenchmarking };
diff --git a/src/hematology/blending.ts b/src/hematology/blending.ts
new file mode 100644
index 000000000..9ba387371
--- /dev/null
+++ b/src/hematology/blending.ts
@@ -0,0 +1,14 @@
+/** hematology blending module — tsb analytics library. */
+export interface HematologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface HematologyBlendingResult { values: number[]; converged: boolean; }
+export function computeHematologyBlending(data: number[], opts: HematologyBlendingOptions = {}): HematologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyBlending };
diff --git a/src/hematology/boosting.ts b/src/hematology/boosting.ts
new file mode 100644
index 000000000..b73d216b7
--- /dev/null
+++ b/src/hematology/boosting.ts
@@ -0,0 +1,14 @@
+/** hematology boosting module — tsb analytics library. */
+export interface HematologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface HematologyBoostingResult { values: number[]; converged: boolean; }
+export function computeHematologyBoosting(data: number[], opts: HematologyBoostingOptions = {}): HematologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyBoosting };
diff --git a/src/hematology/bootstrap.ts b/src/hematology/bootstrap.ts
new file mode 100644
index 000000000..8ddefcba1
--- /dev/null
+++ b/src/hematology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** hematology bootstrap module — tsb analytics library. */
+export interface HematologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface HematologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeHematologyBootstrap(data: number[], opts: HematologyBootstrapOptions = {}): HematologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyBootstrap };
diff --git a/src/hematology/calculus.ts b/src/hematology/calculus.ts
new file mode 100644
index 000000000..400dbd9dc
--- /dev/null
+++ b/src/hematology/calculus.ts
@@ -0,0 +1,14 @@
+/** hematology calculus module — tsb analytics library. */
+export interface HematologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface HematologyCalculusResult { values: number[]; converged: boolean; }
+export function computeHematologyCalculus(data: number[], opts: HematologyCalculusOptions = {}): HematologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyCalculus };
diff --git a/src/hematology/calibration.ts b/src/hematology/calibration.ts
new file mode 100644
index 000000000..2ee396c76
--- /dev/null
+++ b/src/hematology/calibration.ts
@@ -0,0 +1,14 @@
+/** hematology calibration module — tsb analytics library. */
+export interface HematologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface HematologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeHematologyCalibration(data: number[], opts: HematologyCalibrationOptions = {}): HematologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyCalibration };
diff --git a/src/hematology/characterization.ts b/src/hematology/characterization.ts
new file mode 100644
index 000000000..ae5794abb
--- /dev/null
+++ b/src/hematology/characterization.ts
@@ -0,0 +1,14 @@
+/** hematology characterization module — tsb analytics library. */
+export interface HematologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface HematologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeHematologyCharacterization(data: number[], opts: HematologyCharacterizationOptions = {}): HematologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyCharacterization };
diff --git a/src/hematology/classification.ts b/src/hematology/classification.ts
new file mode 100644
index 000000000..169a3dcc3
--- /dev/null
+++ b/src/hematology/classification.ts
@@ -0,0 +1,14 @@
+/** hematology classification module — tsb analytics library. */
+export interface HematologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface HematologyClassificationResult { values: number[]; converged: boolean; }
+export function computeHematologyClassification(data: number[], opts: HematologyClassificationOptions = {}): HematologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyClassification };
diff --git a/src/hematology/clustering.ts b/src/hematology/clustering.ts
new file mode 100644
index 000000000..c50ceec52
--- /dev/null
+++ b/src/hematology/clustering.ts
@@ -0,0 +1,14 @@
+/** hematology clustering module — tsb analytics library. */
+export interface HematologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface HematologyClusteringResult { values: number[]; converged: boolean; }
+export function computeHematologyClustering(data: number[], opts: HematologyClusteringOptions = {}): HematologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyClustering };
diff --git a/src/hematology/compression.ts b/src/hematology/compression.ts
new file mode 100644
index 000000000..24a409aa3
--- /dev/null
+++ b/src/hematology/compression.ts
@@ -0,0 +1,14 @@
+/** hematology compression module — tsb analytics library. */
+export interface HematologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface HematologyCompressionResult { values: number[]; converged: boolean; }
+export function computeHematologyCompression(data: number[], opts: HematologyCompressionOptions = {}): HematologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyCompression };
diff --git a/src/hematology/continuous.ts b/src/hematology/continuous.ts
new file mode 100644
index 000000000..97e876408
--- /dev/null
+++ b/src/hematology/continuous.ts
@@ -0,0 +1,14 @@
+/** hematology continuous module — tsb analytics library. */
+export interface HematologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface HematologyContinuousResult { values: number[]; converged: boolean; }
+export function computeHematologyContinuous(data: number[], opts: HematologyContinuousOptions = {}): HematologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyContinuous };
diff --git a/src/hematology/control.ts b/src/hematology/control.ts
new file mode 100644
index 000000000..31e2d349a
--- /dev/null
+++ b/src/hematology/control.ts
@@ -0,0 +1,14 @@
+/** hematology control module — tsb analytics library. */
+export interface HematologyControlOptions { tol?: number; maxIter?: number; }
+export interface HematologyControlResult { values: number[]; converged: boolean; }
+export function computeHematologyControl(data: number[], opts: HematologyControlOptions = {}): HematologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyControl };
diff --git a/src/hematology/convergence.ts b/src/hematology/convergence.ts
new file mode 100644
index 000000000..23186a47c
--- /dev/null
+++ b/src/hematology/convergence.ts
@@ -0,0 +1,14 @@
+/** hematology convergence module — tsb analytics library. */
+export interface HematologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface HematologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeHematologyConvergence(data: number[], opts: HematologyConvergenceOptions = {}): HematologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyConvergence };
diff --git a/src/hematology/convex.ts b/src/hematology/convex.ts
new file mode 100644
index 000000000..91e7fb85d
--- /dev/null
+++ b/src/hematology/convex.ts
@@ -0,0 +1,14 @@
+/** hematology convex module — tsb analytics library. */
+export interface HematologyConvexOptions { tol?: number; maxIter?: number; }
+export interface HematologyConvexResult { values: number[]; converged: boolean; }
+export function computeHematologyConvex(data: number[], opts: HematologyConvexOptions = {}): HematologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyConvex };
diff --git a/src/hematology/correlation.ts b/src/hematology/correlation.ts
new file mode 100644
index 000000000..0817bb15b
--- /dev/null
+++ b/src/hematology/correlation.ts
@@ -0,0 +1,14 @@
+/** hematology correlation module — tsb analytics library. */
+export interface HematologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface HematologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeHematologyCorrelation(data: number[], opts: HematologyCorrelationOptions = {}): HematologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyCorrelation };
diff --git a/src/hematology/covariance.ts b/src/hematology/covariance.ts
new file mode 100644
index 000000000..b2b6a659b
--- /dev/null
+++ b/src/hematology/covariance.ts
@@ -0,0 +1,14 @@
+/** hematology covariance module — tsb analytics library. */
+export interface HematologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface HematologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeHematologyCovariance(data: number[], opts: HematologyCovarianceOptions = {}): HematologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyCovariance };
diff --git a/src/hematology/cross_validation.ts b/src/hematology/cross_validation.ts
new file mode 100644
index 000000000..d0e0d120c
--- /dev/null
+++ b/src/hematology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** hematology cross_validation module — tsb analytics library. */
+export interface HematologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface HematologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeHematologyCrossValidation(data: number[], opts: HematologyCrossValidationOptions = {}): HematologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyCrossValidation };
diff --git a/src/hematology/decoding.ts b/src/hematology/decoding.ts
new file mode 100644
index 000000000..b85633745
--- /dev/null
+++ b/src/hematology/decoding.ts
@@ -0,0 +1,14 @@
+/** hematology decoding module — tsb analytics library. */
+export interface HematologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface HematologyDecodingResult { values: number[]; converged: boolean; }
+export function computeHematologyDecoding(data: number[], opts: HematologyDecodingOptions = {}): HematologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDecoding };
diff --git a/src/hematology/decomposition.ts b/src/hematology/decomposition.ts
new file mode 100644
index 000000000..c46ba17b0
--- /dev/null
+++ b/src/hematology/decomposition.ts
@@ -0,0 +1,14 @@
+/** hematology decomposition module — tsb analytics library. */
+export interface HematologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface HematologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeHematologyDecomposition(data: number[], opts: HematologyDecompositionOptions = {}): HematologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDecomposition };
diff --git a/src/hematology/detection.ts b/src/hematology/detection.ts
new file mode 100644
index 000000000..350cb9b78
--- /dev/null
+++ b/src/hematology/detection.ts
@@ -0,0 +1,14 @@
+/** hematology detection module — tsb analytics library. */
+export interface HematologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface HematologyDetectionResult { values: number[]; converged: boolean; }
+export function computeHematologyDetection(data: number[], opts: HematologyDetectionOptions = {}): HematologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDetection };
diff --git a/src/hematology/deterministic.ts b/src/hematology/deterministic.ts
new file mode 100644
index 000000000..9c3b01d89
--- /dev/null
+++ b/src/hematology/deterministic.ts
@@ -0,0 +1,14 @@
+/** hematology deterministic module — tsb analytics library. */
+export interface HematologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface HematologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeHematologyDeterministic(data: number[], opts: HematologyDeterministicOptions = {}): HematologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDeterministic };
diff --git a/src/hematology/diagnostics.ts b/src/hematology/diagnostics.ts
new file mode 100644
index 000000000..f579ae5bb
--- /dev/null
+++ b/src/hematology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** hematology diagnostics module — tsb analytics library. */
+export interface HematologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface HematologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeHematologyDiagnostics(data: number[], opts: HematologyDiagnosticsOptions = {}): HematologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDiagnostics };
diff --git a/src/hematology/differential.ts b/src/hematology/differential.ts
new file mode 100644
index 000000000..0f999aa5d
--- /dev/null
+++ b/src/hematology/differential.ts
@@ -0,0 +1,14 @@
+/** hematology differential module — tsb analytics library. */
+export interface HematologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface HematologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeHematologyDifferential(data: number[], opts: HematologyDifferentialOptions = {}): HematologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDifferential };
diff --git a/src/hematology/discrete.ts b/src/hematology/discrete.ts
new file mode 100644
index 000000000..6db6aec63
--- /dev/null
+++ b/src/hematology/discrete.ts
@@ -0,0 +1,14 @@
+/** hematology discrete module — tsb analytics library. */
+export interface HematologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface HematologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeHematologyDiscrete(data: number[], opts: HematologyDiscreteOptions = {}): HematologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDiscrete };
diff --git a/src/hematology/distribution.ts b/src/hematology/distribution.ts
new file mode 100644
index 000000000..9aa10089a
--- /dev/null
+++ b/src/hematology/distribution.ts
@@ -0,0 +1,14 @@
+/** hematology distribution module — tsb analytics library. */
+export interface HematologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface HematologyDistributionResult { values: number[]; converged: boolean; }
+export function computeHematologyDistribution(data: number[], opts: HematologyDistributionOptions = {}): HematologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDistribution };
diff --git a/src/hematology/dynamic.ts b/src/hematology/dynamic.ts
new file mode 100644
index 000000000..e3b0a8796
--- /dev/null
+++ b/src/hematology/dynamic.ts
@@ -0,0 +1,14 @@
+/** hematology dynamic module — tsb analytics library. */
+export interface HematologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface HematologyDynamicResult { values: number[]; converged: boolean; }
+export function computeHematologyDynamic(data: number[], opts: HematologyDynamicOptions = {}): HematologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyDynamic };
diff --git a/src/hematology/embedding.ts b/src/hematology/embedding.ts
new file mode 100644
index 000000000..b4a15a1ab
--- /dev/null
+++ b/src/hematology/embedding.ts
@@ -0,0 +1,14 @@
+/** hematology embedding module — tsb analytics library. */
+export interface HematologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface HematologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeHematologyEmbedding(data: number[], opts: HematologyEmbeddingOptions = {}): HematologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyEmbedding };
diff --git a/src/hematology/encoding.ts b/src/hematology/encoding.ts
new file mode 100644
index 000000000..b7602930a
--- /dev/null
+++ b/src/hematology/encoding.ts
@@ -0,0 +1,14 @@
+/** hematology encoding module — tsb analytics library. */
+export interface HematologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface HematologyEncodingResult { values: number[]; converged: boolean; }
+export function computeHematologyEncoding(data: number[], opts: HematologyEncodingOptions = {}): HematologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyEncoding };
diff --git a/src/hematology/ensemble.ts b/src/hematology/ensemble.ts
new file mode 100644
index 000000000..66688fa0d
--- /dev/null
+++ b/src/hematology/ensemble.ts
@@ -0,0 +1,14 @@
+/** hematology ensemble module — tsb analytics library. */
+export interface HematologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface HematologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeHematologyEnsemble(data: number[], opts: HematologyEnsembleOptions = {}): HematologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyEnsemble };
diff --git a/src/hematology/estimation.ts b/src/hematology/estimation.ts
new file mode 100644
index 000000000..68f31f689
--- /dev/null
+++ b/src/hematology/estimation.ts
@@ -0,0 +1,14 @@
+/** hematology estimation module — tsb analytics library. */
+export interface HematologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface HematologyEstimationResult { values: number[]; converged: boolean; }
+export function computeHematologyEstimation(data: number[], opts: HematologyEstimationOptions = {}): HematologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyEstimation };
diff --git a/src/hematology/evaluation.ts b/src/hematology/evaluation.ts
new file mode 100644
index 000000000..8b0d3755b
--- /dev/null
+++ b/src/hematology/evaluation.ts
@@ -0,0 +1,14 @@
+/** hematology evaluation module — tsb analytics library. */
+export interface HematologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface HematologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeHematologyEvaluation(data: number[], opts: HematologyEvaluationOptions = {}): HematologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyEvaluation };
diff --git a/src/hematology/extrapolation.ts b/src/hematology/extrapolation.ts
new file mode 100644
index 000000000..96bc34085
--- /dev/null
+++ b/src/hematology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** hematology extrapolation module — tsb analytics library. */
+export interface HematologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface HematologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeHematologyExtrapolation(data: number[], opts: HematologyExtrapolationOptions = {}): HematologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyExtrapolation };
diff --git a/src/hematology/features.ts b/src/hematology/features.ts
new file mode 100644
index 000000000..e5808eca9
--- /dev/null
+++ b/src/hematology/features.ts
@@ -0,0 +1,14 @@
+/** hematology features module — tsb analytics library. */
+export interface HematologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface HematologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeHematologyFeatures(data: number[], opts: HematologyFeaturesOptions = {}): HematologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyFeatures };
diff --git a/src/hematology/feedback.ts b/src/hematology/feedback.ts
new file mode 100644
index 000000000..451268849
--- /dev/null
+++ b/src/hematology/feedback.ts
@@ -0,0 +1,14 @@
+/** hematology feedback module — tsb analytics library. */
+export interface HematologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface HematologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeHematologyFeedback(data: number[], opts: HematologyFeedbackOptions = {}): HematologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyFeedback };
diff --git a/src/hematology/filtering.ts b/src/hematology/filtering.ts
new file mode 100644
index 000000000..77a06e850
--- /dev/null
+++ b/src/hematology/filtering.ts
@@ -0,0 +1,14 @@
+/** hematology filtering module — tsb analytics library. */
+export interface HematologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface HematologyFilteringResult { values: number[]; converged: boolean; }
+export function computeHematologyFiltering(data: number[], opts: HematologyFilteringOptions = {}): HematologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyFiltering };
diff --git a/src/hematology/fourier.ts b/src/hematology/fourier.ts
new file mode 100644
index 000000000..7d9727d83
--- /dev/null
+++ b/src/hematology/fourier.ts
@@ -0,0 +1,14 @@
+/** hematology fourier module — tsb analytics library. */
+export interface HematologyFourierOptions { tol?: number; maxIter?: number; }
+export interface HematologyFourierResult { values: number[]; converged: boolean; }
+export function computeHematologyFourier(data: number[], opts: HematologyFourierOptions = {}): HematologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyFourier };
diff --git a/src/hematology/fusion.ts b/src/hematology/fusion.ts
new file mode 100644
index 000000000..ddc24597e
--- /dev/null
+++ b/src/hematology/fusion.ts
@@ -0,0 +1,14 @@
+/** hematology fusion module — tsb analytics library. */
+export interface HematologyFusionOptions { tol?: number; maxIter?: number; }
+export interface HematologyFusionResult { values: number[]; converged: boolean; }
+export function computeHematologyFusion(data: number[], opts: HematologyFusionOptions = {}): HematologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyFusion };
diff --git a/src/hematology/generation.ts b/src/hematology/generation.ts
new file mode 100644
index 000000000..a02312e55
--- /dev/null
+++ b/src/hematology/generation.ts
@@ -0,0 +1,14 @@
+/** hematology generation module — tsb analytics library. */
+export interface HematologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface HematologyGenerationResult { values: number[]; converged: boolean; }
+export function computeHematologyGeneration(data: number[], opts: HematologyGenerationOptions = {}): HematologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyGeneration };
diff --git a/src/hematology/geometry.ts b/src/hematology/geometry.ts
new file mode 100644
index 000000000..383e3d847
--- /dev/null
+++ b/src/hematology/geometry.ts
@@ -0,0 +1,14 @@
+/** hematology geometry module — tsb analytics library. */
+export interface HematologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface HematologyGeometryResult { values: number[]; converged: boolean; }
+export function computeHematologyGeometry(data: number[], opts: HematologyGeometryOptions = {}): HematologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyGeometry };
diff --git a/src/hematology/gradient.ts b/src/hematology/gradient.ts
new file mode 100644
index 000000000..b61e1e738
--- /dev/null
+++ b/src/hematology/gradient.ts
@@ -0,0 +1,14 @@
+/** hematology gradient module — tsb analytics library. */
+export interface HematologyGradientOptions { tol?: number; maxIter?: number; }
+export interface HematologyGradientResult { values: number[]; converged: boolean; }
+export function computeHematologyGradient(data: number[], opts: HematologyGradientOptions = {}): HematologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyGradient };
diff --git a/src/hematology/hessian.ts b/src/hematology/hessian.ts
new file mode 100644
index 000000000..32c4d9a0f
--- /dev/null
+++ b/src/hematology/hessian.ts
@@ -0,0 +1,14 @@
+/** hematology hessian module — tsb analytics library. */
+export interface HematologyHessianOptions { tol?: number; maxIter?: number; }
+export interface HematologyHessianResult { values: number[]; converged: boolean; }
+export function computeHematologyHessian(data: number[], opts: HematologyHessianOptions = {}): HematologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyHessian };
diff --git a/src/hematology/hypothesis.ts b/src/hematology/hypothesis.ts
new file mode 100644
index 000000000..9bcced461
--- /dev/null
+++ b/src/hematology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** hematology hypothesis module — tsb analytics library. */
+export interface HematologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface HematologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeHematologyHypothesis(data: number[], opts: HematologyHypothesisOptions = {}): HematologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyHypothesis };
diff --git a/src/hematology/inference.ts b/src/hematology/inference.ts
new file mode 100644
index 000000000..e86f3cbd5
--- /dev/null
+++ b/src/hematology/inference.ts
@@ -0,0 +1,14 @@
+/** hematology inference module — tsb analytics library. */
+export interface HematologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface HematologyInferenceResult { values: number[]; converged: boolean; }
+export function computeHematologyInference(data: number[], opts: HematologyInferenceOptions = {}): HematologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyInference };
diff --git a/src/hematology/inference2.ts b/src/hematology/inference2.ts
new file mode 100644
index 000000000..65034d52d
--- /dev/null
+++ b/src/hematology/inference2.ts
@@ -0,0 +1,14 @@
+/** hematology inference2 module — tsb analytics library. */
+export interface HematologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface HematologyInferenceResult { values: number[]; converged: boolean; }
+export function computeHematologyInference(data: number[], opts: HematologyInferenceOptions = {}): HematologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyInference };
diff --git a/src/hematology/integral.ts b/src/hematology/integral.ts
new file mode 100644
index 000000000..6f58da301
--- /dev/null
+++ b/src/hematology/integral.ts
@@ -0,0 +1,14 @@
+/** hematology integral module — tsb analytics library. */
+export interface HematologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface HematologyIntegralResult { values: number[]; converged: boolean; }
+export function computeHematologyIntegral(data: number[], opts: HematologyIntegralOptions = {}): HematologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyIntegral };
diff --git a/src/hematology/integration.ts b/src/hematology/integration.ts
new file mode 100644
index 000000000..b62c65fd0
--- /dev/null
+++ b/src/hematology/integration.ts
@@ -0,0 +1,14 @@
+/** hematology integration module — tsb analytics library. */
+export interface HematologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface HematologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeHematologyIntegration(data: number[], opts: HematologyIntegrationOptions = {}): HematologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyIntegration };
diff --git a/src/hematology/interpolation.ts b/src/hematology/interpolation.ts
new file mode 100644
index 000000000..40c54c69e
--- /dev/null
+++ b/src/hematology/interpolation.ts
@@ -0,0 +1,14 @@
+/** hematology interpolation module — tsb analytics library. */
+export interface HematologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface HematologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeHematologyInterpolation(data: number[], opts: HematologyInterpolationOptions = {}): HematologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyInterpolation };
diff --git a/src/hematology/jacobian.ts b/src/hematology/jacobian.ts
new file mode 100644
index 000000000..38dd49b2e
--- /dev/null
+++ b/src/hematology/jacobian.ts
@@ -0,0 +1,14 @@
+/** hematology jacobian module — tsb analytics library. */
+export interface HematologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface HematologyJacobianResult { values: number[]; converged: boolean; }
+export function computeHematologyJacobian(data: number[], opts: HematologyJacobianOptions = {}): HematologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyJacobian };
diff --git a/src/hematology/kernel.ts b/src/hematology/kernel.ts
new file mode 100644
index 000000000..3d448f5f0
--- /dev/null
+++ b/src/hematology/kernel.ts
@@ -0,0 +1,14 @@
+/** hematology kernel module — tsb analytics library. */
+export interface HematologyKernelOptions { tol?: number; maxIter?: number; }
+export interface HematologyKernelResult { values: number[]; converged: boolean; }
+export function computeHematologyKernel(data: number[], opts: HematologyKernelOptions = {}): HematologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyKernel };
diff --git a/src/hematology/laplacian.ts b/src/hematology/laplacian.ts
new file mode 100644
index 000000000..700f68e8b
--- /dev/null
+++ b/src/hematology/laplacian.ts
@@ -0,0 +1,14 @@
+/** hematology laplacian module — tsb analytics library. */
+export interface HematologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface HematologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeHematologyLaplacian(data: number[], opts: HematologyLaplacianOptions = {}): HematologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyLaplacian };
diff --git a/src/hematology/learning.ts b/src/hematology/learning.ts
new file mode 100644
index 000000000..377fe60d3
--- /dev/null
+++ b/src/hematology/learning.ts
@@ -0,0 +1,14 @@
+/** hematology learning module — tsb analytics library. */
+export interface HematologyLearningOptions { tol?: number; maxIter?: number; }
+export interface HematologyLearningResult { values: number[]; converged: boolean; }
+export function computeHematologyLearning(data: number[], opts: HematologyLearningOptions = {}): HematologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyLearning };
diff --git a/src/hematology/linear.ts b/src/hematology/linear.ts
new file mode 100644
index 000000000..67c90a0bc
--- /dev/null
+++ b/src/hematology/linear.ts
@@ -0,0 +1,14 @@
+/** hematology linear module — tsb analytics library. */
+export interface HematologyLinearOptions { tol?: number; maxIter?: number; }
+export interface HematologyLinearResult { values: number[]; converged: boolean; }
+export function computeHematologyLinear(data: number[], opts: HematologyLinearOptions = {}): HematologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyLinear };
diff --git a/src/hematology/manifold.ts b/src/hematology/manifold.ts
new file mode 100644
index 000000000..e07246080
--- /dev/null
+++ b/src/hematology/manifold.ts
@@ -0,0 +1,14 @@
+/** hematology manifold module — tsb analytics library. */
+export interface HematologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface HematologyManifoldResult { values: number[]; converged: boolean; }
+export function computeHematologyManifold(data: number[], opts: HematologyManifoldOptions = {}): HematologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyManifold };
diff --git a/src/hematology/matching.ts b/src/hematology/matching.ts
new file mode 100644
index 000000000..3ab409975
--- /dev/null
+++ b/src/hematology/matching.ts
@@ -0,0 +1,14 @@
+/** hematology matching module — tsb analytics library. */
+export interface HematologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface HematologyMatchingResult { values: number[]; converged: boolean; }
+export function computeHematologyMatching(data: number[], opts: HematologyMatchingOptions = {}): HematologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyMatching };
diff --git a/src/hematology/measurement.ts b/src/hematology/measurement.ts
new file mode 100644
index 000000000..43573fa49
--- /dev/null
+++ b/src/hematology/measurement.ts
@@ -0,0 +1,14 @@
+/** hematology measurement module — tsb analytics library. */
+export interface HematologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface HematologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeHematologyMeasurement(data: number[], opts: HematologyMeasurementOptions = {}): HematologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyMeasurement };
diff --git a/src/hematology/metrics.ts b/src/hematology/metrics.ts
new file mode 100644
index 000000000..c97878351
--- /dev/null
+++ b/src/hematology/metrics.ts
@@ -0,0 +1,14 @@
+/** hematology metrics module — tsb analytics library. */
+export interface HematologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface HematologyMetricsResult { values: number[]; converged: boolean; }
+export function computeHematologyMetrics(data: number[], opts: HematologyMetricsOptions = {}): HematologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyMetrics };
diff --git a/src/hematology/modeling.ts b/src/hematology/modeling.ts
new file mode 100644
index 000000000..f5ee4429c
--- /dev/null
+++ b/src/hematology/modeling.ts
@@ -0,0 +1,14 @@
+/** hematology modeling module — tsb analytics library. */
+export interface HematologyModelingOptions { tol?: number; maxIter?: number; }
+export interface HematologyModelingResult { values: number[]; converged: boolean; }
+export function computeHematologyModeling(data: number[], opts: HematologyModelingOptions = {}): HematologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyModeling };
diff --git a/src/hematology/monitoring.ts b/src/hematology/monitoring.ts
new file mode 100644
index 000000000..f19b57caa
--- /dev/null
+++ b/src/hematology/monitoring.ts
@@ -0,0 +1,14 @@
+/** hematology monitoring module — tsb analytics library. */
+export interface HematologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface HematologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeHematologyMonitoring(data: number[], opts: HematologyMonitoringOptions = {}): HematologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyMonitoring };
diff --git a/src/hematology/nonlinear.ts b/src/hematology/nonlinear.ts
new file mode 100644
index 000000000..62abc17dc
--- /dev/null
+++ b/src/hematology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** hematology nonlinear module — tsb analytics library. */
+export interface HematologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface HematologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeHematologyNonlinear(data: number[], opts: HematologyNonlinearOptions = {}): HematologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyNonlinear };
diff --git a/src/hematology/normalization.ts b/src/hematology/normalization.ts
new file mode 100644
index 000000000..f2d6b6e86
--- /dev/null
+++ b/src/hematology/normalization.ts
@@ -0,0 +1,14 @@
+/** hematology normalization module — tsb analytics library. */
+export interface HematologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface HematologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeHematologyNormalization(data: number[], opts: HematologyNormalizationOptions = {}): HematologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyNormalization };
diff --git a/src/hematology/optimization.ts b/src/hematology/optimization.ts
new file mode 100644
index 000000000..8967d3fc1
--- /dev/null
+++ b/src/hematology/optimization.ts
@@ -0,0 +1,14 @@
+/** hematology optimization module — tsb analytics library. */
+export interface HematologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface HematologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeHematologyOptimization(data: number[], opts: HematologyOptimizationOptions = {}): HematologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyOptimization };
diff --git a/src/hematology/patterns.ts b/src/hematology/patterns.ts
new file mode 100644
index 000000000..37de62c94
--- /dev/null
+++ b/src/hematology/patterns.ts
@@ -0,0 +1,14 @@
+/** hematology patterns module — tsb analytics library. */
+export interface HematologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface HematologyPatternsResult { values: number[]; converged: boolean; }
+export function computeHematologyPatterns(data: number[], opts: HematologyPatternsOptions = {}): HematologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyPatterns };
diff --git a/src/hematology/permutation.ts b/src/hematology/permutation.ts
new file mode 100644
index 000000000..7825962e6
--- /dev/null
+++ b/src/hematology/permutation.ts
@@ -0,0 +1,14 @@
+/** hematology permutation module — tsb analytics library. */
+export interface HematologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface HematologyPermutationResult { values: number[]; converged: boolean; }
+export function computeHematologyPermutation(data: number[], opts: HematologyPermutationOptions = {}): HematologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyPermutation };
diff --git a/src/hematology/prediction.ts b/src/hematology/prediction.ts
new file mode 100644
index 000000000..1e1fb0a7f
--- /dev/null
+++ b/src/hematology/prediction.ts
@@ -0,0 +1,14 @@
+/** hematology prediction module — tsb analytics library. */
+export interface HematologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface HematologyPredictionResult { values: number[]; converged: boolean; }
+export function computeHematologyPrediction(data: number[], opts: HematologyPredictionOptions = {}): HematologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyPrediction };
diff --git a/src/hematology/processing.ts b/src/hematology/processing.ts
new file mode 100644
index 000000000..e57762cb5
--- /dev/null
+++ b/src/hematology/processing.ts
@@ -0,0 +1,14 @@
+/** hematology processing module — tsb analytics library. */
+export interface HematologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface HematologyProcessingResult { values: number[]; converged: boolean; }
+export function computeHematologyProcessing(data: number[], opts: HematologyProcessingOptions = {}): HematologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyProcessing };
diff --git a/src/hematology/profiling.ts b/src/hematology/profiling.ts
new file mode 100644
index 000000000..3b152acea
--- /dev/null
+++ b/src/hematology/profiling.ts
@@ -0,0 +1,14 @@
+/** hematology profiling module — tsb analytics library. */
+export interface HematologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface HematologyProfilingResult { values: number[]; converged: boolean; }
+export function computeHematologyProfiling(data: number[], opts: HematologyProfilingOptions = {}): HematologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyProfiling };
diff --git a/src/hematology/projection.ts b/src/hematology/projection.ts
new file mode 100644
index 000000000..048f28e72
--- /dev/null
+++ b/src/hematology/projection.ts
@@ -0,0 +1,14 @@
+/** hematology projection module — tsb analytics library. */
+export interface HematologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface HematologyProjectionResult { values: number[]; converged: boolean; }
+export function computeHematologyProjection(data: number[], opts: HematologyProjectionOptions = {}): HematologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyProjection };
diff --git a/src/hematology/ranking.ts b/src/hematology/ranking.ts
new file mode 100644
index 000000000..ab0272c82
--- /dev/null
+++ b/src/hematology/ranking.ts
@@ -0,0 +1,14 @@
+/** hematology ranking module — tsb analytics library. */
+export interface HematologyRankingOptions { tol?: number; maxIter?: number; }
+export interface HematologyRankingResult { values: number[]; converged: boolean; }
+export function computeHematologyRanking(data: number[], opts: HematologyRankingOptions = {}): HematologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyRanking };
diff --git a/src/hematology/reconstruction.ts b/src/hematology/reconstruction.ts
new file mode 100644
index 000000000..2ec7224c5
--- /dev/null
+++ b/src/hematology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** hematology reconstruction module — tsb analytics library. */
+export interface HematologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface HematologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeHematologyReconstruction(data: number[], opts: HematologyReconstructionOptions = {}): HematologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyReconstruction };
diff --git a/src/hematology/registration.ts b/src/hematology/registration.ts
new file mode 100644
index 000000000..318daaded
--- /dev/null
+++ b/src/hematology/registration.ts
@@ -0,0 +1,14 @@
+/** hematology registration module — tsb analytics library. */
+export interface HematologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface HematologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeHematologyRegistration(data: number[], opts: HematologyRegistrationOptions = {}): HematologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyRegistration };
diff --git a/src/hematology/regression.ts b/src/hematology/regression.ts
new file mode 100644
index 000000000..a721c5665
--- /dev/null
+++ b/src/hematology/regression.ts
@@ -0,0 +1,14 @@
+/** hematology regression module — tsb analytics library. */
+export interface HematologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface HematologyRegressionResult { values: number[]; converged: boolean; }
+export function computeHematologyRegression(data: number[], opts: HematologyRegressionOptions = {}): HematologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyRegression };
diff --git a/src/hematology/regularization.ts b/src/hematology/regularization.ts
new file mode 100644
index 000000000..1b92dbb45
--- /dev/null
+++ b/src/hematology/regularization.ts
@@ -0,0 +1,14 @@
+/** hematology regularization module — tsb analytics library. */
+export interface HematologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface HematologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeHematologyRegularization(data: number[], opts: HematologyRegularizationOptions = {}): HematologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyRegularization };
diff --git a/src/hematology/robustness.ts b/src/hematology/robustness.ts
new file mode 100644
index 000000000..684ad02ad
--- /dev/null
+++ b/src/hematology/robustness.ts
@@ -0,0 +1,14 @@
+/** hematology robustness module — tsb analytics library. */
+export interface HematologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface HematologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeHematologyRobustness(data: number[], opts: HematologyRobustnessOptions = {}): HematologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyRobustness };
diff --git a/src/hematology/sampling.ts b/src/hematology/sampling.ts
new file mode 100644
index 000000000..795c19c51
--- /dev/null
+++ b/src/hematology/sampling.ts
@@ -0,0 +1,14 @@
+/** hematology sampling module — tsb analytics library. */
+export interface HematologySamplingOptions { tol?: number; maxIter?: number; }
+export interface HematologySamplingResult { values: number[]; converged: boolean; }
+export function computeHematologySampling(data: number[], opts: HematologySamplingOptions = {}): HematologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologySampling };
diff --git a/src/hematology/sampling2.ts b/src/hematology/sampling2.ts
new file mode 100644
index 000000000..ea85ab8e1
--- /dev/null
+++ b/src/hematology/sampling2.ts
@@ -0,0 +1,14 @@
+/** hematology sampling2 module — tsb analytics library. */
+export interface HematologySamplingOptions { tol?: number; maxIter?: number; }
+export interface HematologySamplingResult { values: number[]; converged: boolean; }
+export function computeHematologySampling(data: number[], opts: HematologySamplingOptions = {}): HematologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologySampling };
diff --git a/src/hematology/scaling.ts b/src/hematology/scaling.ts
new file mode 100644
index 000000000..67c51efb8
--- /dev/null
+++ b/src/hematology/scaling.ts
@@ -0,0 +1,14 @@
+/** hematology scaling module — tsb analytics library. */
+export interface HematologyScalingOptions { tol?: number; maxIter?: number; }
+export interface HematologyScalingResult { values: number[]; converged: boolean; }
+export function computeHematologyScaling(data: number[], opts: HematologyScalingOptions = {}): HematologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyScaling };
diff --git a/src/hematology/scoring.ts b/src/hematology/scoring.ts
new file mode 100644
index 000000000..6af71b3b1
--- /dev/null
+++ b/src/hematology/scoring.ts
@@ -0,0 +1,14 @@
+/** hematology scoring module — tsb analytics library. */
+export interface HematologyScoringOptions { tol?: number; maxIter?: number; }
+export interface HematologyScoringResult { values: number[]; converged: boolean; }
+export function computeHematologyScoring(data: number[], opts: HematologyScoringOptions = {}): HematologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyScoring };
diff --git a/src/hematology/segmentation.ts b/src/hematology/segmentation.ts
new file mode 100644
index 000000000..859db6b0e
--- /dev/null
+++ b/src/hematology/segmentation.ts
@@ -0,0 +1,14 @@
+/** hematology segmentation module — tsb analytics library. */
+export interface HematologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface HematologySegmentationResult { values: number[]; converged: boolean; }
+export function computeHematologySegmentation(data: number[], opts: HematologySegmentationOptions = {}): HematologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologySegmentation };
diff --git a/src/hematology/selection.ts b/src/hematology/selection.ts
new file mode 100644
index 000000000..63723bfba
--- /dev/null
+++ b/src/hematology/selection.ts
@@ -0,0 +1,14 @@
+/** hematology selection module — tsb analytics library. */
+export interface HematologySelectionOptions { tol?: number; maxIter?: number; }
+export interface HematologySelectionResult { values: number[]; converged: boolean; }
+export function computeHematologySelection(data: number[], opts: HematologySelectionOptions = {}): HematologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologySelection };
diff --git a/src/hematology/sensitivity.ts b/src/hematology/sensitivity.ts
new file mode 100644
index 000000000..4949e7c21
--- /dev/null
+++ b/src/hematology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** hematology sensitivity module — tsb analytics library. */
+export interface HematologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface HematologySensitivityResult { values: number[]; converged: boolean; }
+export function computeHematologySensitivity(data: number[], opts: HematologySensitivityOptions = {}): HematologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologySensitivity };
diff --git a/src/hematology/simulation.ts b/src/hematology/simulation.ts
new file mode 100644
index 000000000..ae64d235c
--- /dev/null
+++ b/src/hematology/simulation.ts
@@ -0,0 +1,14 @@
+/** hematology simulation module — tsb analytics library. */
+export interface HematologySimulationOptions { tol?: number; maxIter?: number; }
+export interface HematologySimulationResult { values: number[]; converged: boolean; }
+export function computeHematologySimulation(data: number[], opts: HematologySimulationOptions = {}): HematologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologySimulation };
diff --git a/src/hematology/smoothing.ts b/src/hematology/smoothing.ts
new file mode 100644
index 000000000..9c71538d6
--- /dev/null
+++ b/src/hematology/smoothing.ts
@@ -0,0 +1,14 @@
+/** hematology smoothing module — tsb analytics library. */
+export interface HematologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface HematologySmoothingResult { values: number[]; converged: boolean; }
+export function computeHematologySmoothing(data: number[], opts: HematologySmoothingOptions = {}): HematologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologySmoothing };
diff --git a/src/hematology/stability.ts b/src/hematology/stability.ts
new file mode 100644
index 000000000..28bfd7396
--- /dev/null
+++ b/src/hematology/stability.ts
@@ -0,0 +1,14 @@
+/** hematology stability module — tsb analytics library. */
+export interface HematologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface HematologyStabilityResult { values: number[]; converged: boolean; }
+export function computeHematologyStability(data: number[], opts: HematologyStabilityOptions = {}): HematologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyStability };
diff --git a/src/hematology/stacking.ts b/src/hematology/stacking.ts
new file mode 100644
index 000000000..d7b49766d
--- /dev/null
+++ b/src/hematology/stacking.ts
@@ -0,0 +1,14 @@
+/** hematology stacking module — tsb analytics library. */
+export interface HematologyStackingOptions { tol?: number; maxIter?: number; }
+export interface HematologyStackingResult { values: number[]; converged: boolean; }
+export function computeHematologyStacking(data: number[], opts: HematologyStackingOptions = {}): HematologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyStacking };
diff --git a/src/hematology/standardization.ts b/src/hematology/standardization.ts
new file mode 100644
index 000000000..7c27cfc16
--- /dev/null
+++ b/src/hematology/standardization.ts
@@ -0,0 +1,14 @@
+/** hematology standardization module — tsb analytics library. */
+export interface HematologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface HematologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeHematologyStandardization(data: number[], opts: HematologyStandardizationOptions = {}): HematologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyStandardization };
diff --git a/src/hematology/static.ts b/src/hematology/static.ts
new file mode 100644
index 000000000..8ddc225fb
--- /dev/null
+++ b/src/hematology/static.ts
@@ -0,0 +1,14 @@
+/** hematology static module — tsb analytics library. */
+export interface HematologyStaticOptions { tol?: number; maxIter?: number; }
+export interface HematologyStaticResult { values: number[]; converged: boolean; }
+export function computeHematologyStatic(data: number[], opts: HematologyStaticOptions = {}): HematologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyStatic };
diff --git a/src/hematology/stochastic.ts b/src/hematology/stochastic.ts
new file mode 100644
index 000000000..d27ce351c
--- /dev/null
+++ b/src/hematology/stochastic.ts
@@ -0,0 +1,14 @@
+/** hematology stochastic module — tsb analytics library. */
+export interface HematologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface HematologyStochasticResult { values: number[]; converged: boolean; }
+export function computeHematologyStochastic(data: number[], opts: HematologyStochasticOptions = {}): HematologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyStochastic };
diff --git a/src/hematology/synthesis.ts b/src/hematology/synthesis.ts
new file mode 100644
index 000000000..d495934cd
--- /dev/null
+++ b/src/hematology/synthesis.ts
@@ -0,0 +1,14 @@
+/** hematology synthesis module — tsb analytics library. */
+export interface HematologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface HematologySynthesisResult { values: number[]; converged: boolean; }
+export function computeHematologySynthesis(data: number[], opts: HematologySynthesisOptions = {}): HematologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologySynthesis };
diff --git a/src/hematology/topology.ts b/src/hematology/topology.ts
new file mode 100644
index 000000000..d0f8dee8c
--- /dev/null
+++ b/src/hematology/topology.ts
@@ -0,0 +1,14 @@
+/** hematology topology module — tsb analytics library. */
+export interface HematologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface HematologyTopologyResult { values: number[]; converged: boolean; }
+export function computeHematologyTopology(data: number[], opts: HematologyTopologyOptions = {}): HematologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyTopology };
diff --git a/src/hematology/tracking.ts b/src/hematology/tracking.ts
new file mode 100644
index 000000000..6f2457c8f
--- /dev/null
+++ b/src/hematology/tracking.ts
@@ -0,0 +1,14 @@
+/** hematology tracking module — tsb analytics library. */
+export interface HematologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface HematologyTrackingResult { values: number[]; converged: boolean; }
+export function computeHematologyTracking(data: number[], opts: HematologyTrackingOptions = {}): HematologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyTracking };
diff --git a/src/hematology/transform.ts b/src/hematology/transform.ts
new file mode 100644
index 000000000..ea4ae5b87
--- /dev/null
+++ b/src/hematology/transform.ts
@@ -0,0 +1,14 @@
+/** hematology transform module — tsb analytics library. */
+export interface HematologyTransformOptions { tol?: number; maxIter?: number; }
+export interface HematologyTransformResult { values: number[]; converged: boolean; }
+export function computeHematologyTransform(data: number[], opts: HematologyTransformOptions = {}): HematologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyTransform };
diff --git a/src/hematology/uncertainty.ts b/src/hematology/uncertainty.ts
new file mode 100644
index 000000000..f84217f45
--- /dev/null
+++ b/src/hematology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** hematology uncertainty module — tsb analytics library. */
+export interface HematologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface HematologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeHematologyUncertainty(data: number[], opts: HematologyUncertaintyOptions = {}): HematologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyUncertainty };
diff --git a/src/hematology/validation.ts b/src/hematology/validation.ts
new file mode 100644
index 000000000..4a3d9f1d3
--- /dev/null
+++ b/src/hematology/validation.ts
@@ -0,0 +1,14 @@
+/** hematology validation module — tsb analytics library. */
+export interface HematologyValidationOptions { tol?: number; maxIter?: number; }
+export interface HematologyValidationResult { values: number[]; converged: boolean; }
+export function computeHematologyValidation(data: number[], opts: HematologyValidationOptions = {}): HematologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyValidation };
diff --git a/src/hematology/verification.ts b/src/hematology/verification.ts
new file mode 100644
index 000000000..4f439c459
--- /dev/null
+++ b/src/hematology/verification.ts
@@ -0,0 +1,14 @@
+/** hematology verification module — tsb analytics library. */
+export interface HematologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface HematologyVerificationResult { values: number[]; converged: boolean; }
+export function computeHematologyVerification(data: number[], opts: HematologyVerificationOptions = {}): HematologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyVerification };
diff --git a/src/hematology/visualization.ts b/src/hematology/visualization.ts
new file mode 100644
index 000000000..a94fbb5d1
--- /dev/null
+++ b/src/hematology/visualization.ts
@@ -0,0 +1,14 @@
+/** hematology visualization module — tsb analytics library. */
+export interface HematologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface HematologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeHematologyVisualization(data: number[], opts: HematologyVisualizationOptions = {}): HematologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyVisualization };
diff --git a/src/hematology/voting.ts b/src/hematology/voting.ts
new file mode 100644
index 000000000..da8d914e4
--- /dev/null
+++ b/src/hematology/voting.ts
@@ -0,0 +1,14 @@
+/** hematology voting module — tsb analytics library. */
+export interface HematologyVotingOptions { tol?: number; maxIter?: number; }
+export interface HematologyVotingResult { values: number[]; converged: boolean; }
+export function computeHematologyVoting(data: number[], opts: HematologyVotingOptions = {}): HematologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyVoting };
diff --git a/src/hematology/wavelet.ts b/src/hematology/wavelet.ts
new file mode 100644
index 000000000..7a223c79e
--- /dev/null
+++ b/src/hematology/wavelet.ts
@@ -0,0 +1,14 @@
+/** hematology wavelet module — tsb analytics library. */
+export interface HematologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface HematologyWaveletResult { values: number[]; converged: boolean; }
+export function computeHematologyWavelet(data: number[], opts: HematologyWaveletOptions = {}): HematologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHematologyWavelet };
diff --git a/src/hf/advanced.ts b/src/hf/advanced.ts
new file mode 100644
index 000000000..ba8daf2bb
--- /dev/null
+++ b/src/hf/advanced.ts
@@ -0,0 +1,15 @@
+/** Hf Advanced module — tsb analytics library. */
+export interface Hf advancedOptions { tol?: number; maxIter?: number; }
+export interface Hf advancedResult { values: number[]; converged: boolean; }
+export function computeHf advanced(data: number[], opts: Hf advancedOptions = {}): Hf advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf advanced };
diff --git a/src/hf/albert.ts b/src/hf/albert.ts
new file mode 100644
index 000000000..ddd3f83d3
--- /dev/null
+++ b/src/hf/albert.ts
@@ -0,0 +1,22 @@
+/** Albert module — tsb analytics library. */
+
+/** Options for Albert. */
+export interface AlbertOptions { tol?: number; maxIter?: number; }
+
+/** Result from Albert. */
+export interface AlbertResult { values: number[]; converged: boolean; }
+
+/** Compute Albert. */
+export function computeAlbert(data: number[], opts: AlbertOptions = {}): AlbertResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAlbert };
diff --git a/src/hf/alibi.ts b/src/hf/alibi.ts
new file mode 100644
index 000000000..b0d8362b6
--- /dev/null
+++ b/src/hf/alibi.ts
@@ -0,0 +1,22 @@
+/** Alibi module — tsb analytics library. */
+
+/** Options for Alibi. */
+export interface AlibiOptions { tol?: number; maxIter?: number; }
+
+/** Result from Alibi. */
+export interface AlibiResult { values: number[]; converged: boolean; }
+
+/** Compute Alibi. */
+export function computeAlibi(data: number[], opts: AlibiOptions = {}): AlibiResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAlibi };
diff --git a/src/hf/base2.ts b/src/hf/base2.ts
new file mode 100644
index 000000000..d33694f41
--- /dev/null
+++ b/src/hf/base2.ts
@@ -0,0 +1,15 @@
+/** Hf Base2 module — tsb analytics library. */
+export interface Hf base2Options { tol?: number; maxIter?: number; }
+export interface Hf base2Result { values: number[]; converged: boolean; }
+export function computeHf base2(data: number[], opts: Hf base2Options = {}): Hf base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf base2 };
diff --git a/src/hf/batch.ts b/src/hf/batch.ts
new file mode 100644
index 000000000..b8b08130a
--- /dev/null
+++ b/src/hf/batch.ts
@@ -0,0 +1,15 @@
+/** Hf Batch module — tsb analytics library. */
+export interface Hf batchOptions { tol?: number; maxIter?: number; }
+export interface Hf batchResult { values: number[]; converged: boolean; }
+export function computeHf batch(data: number[], opts: Hf batchOptions = {}): Hf batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf batch };
diff --git a/src/hf/bert.ts b/src/hf/bert.ts
new file mode 100644
index 000000000..5263d2c0a
--- /dev/null
+++ b/src/hf/bert.ts
@@ -0,0 +1,22 @@
+/** Bert module — tsb analytics library. */
+
+/** Options for Bert. */
+export interface BertOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bert. */
+export interface BertResult { values: number[]; converged: boolean; }
+
+/** Compute Bert. */
+export function computeBert(data: number[], opts: BertOptions = {}): BertResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBert };
diff --git a/src/hf/beta.ts b/src/hf/beta.ts
new file mode 100644
index 000000000..1521f60db
--- /dev/null
+++ b/src/hf/beta.ts
@@ -0,0 +1,15 @@
+/** Hf Beta module — tsb analytics library. */
+export interface Hf betaOptions { tol?: number; maxIter?: number; }
+export interface Hf betaResult { values: number[]; converged: boolean; }
+export function computeHf beta(data: number[], opts: Hf betaOptions = {}): Hf betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf beta };
diff --git a/src/hf/bigbird.ts b/src/hf/bigbird.ts
new file mode 100644
index 000000000..995fee3bf
--- /dev/null
+++ b/src/hf/bigbird.ts
@@ -0,0 +1,22 @@
+/** Bigbird module — tsb analytics library. */
+
+/** Options for Bigbird. */
+export interface BigbirdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bigbird. */
+export interface BigbirdResult { values: number[]; converged: boolean; }
+
+/** Compute Bigbird. */
+export function computeBigbird(data: number[], opts: BigbirdOptions = {}): BigbirdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBigbird };
diff --git a/src/hf/contriever.ts b/src/hf/contriever.ts
new file mode 100644
index 000000000..5326d72eb
--- /dev/null
+++ b/src/hf/contriever.ts
@@ -0,0 +1,22 @@
+/** Contriever module — tsb analytics library. */
+
+/** Options for Contriever. */
+export interface ContrieverOptions { tol?: number; maxIter?: number; }
+
+/** Result from Contriever. */
+export interface ContrieverResult { values: number[]; converged: boolean; }
+
+/** Compute Contriever. */
+export function computeContriever(data: number[], opts: ContrieverOptions = {}): ContrieverResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeContriever };
diff --git a/src/hf/cpu.ts b/src/hf/cpu.ts
new file mode 100644
index 000000000..21913127b
--- /dev/null
+++ b/src/hf/cpu.ts
@@ -0,0 +1,15 @@
+/** Hf Cpu module — tsb analytics library. */
+export interface Hf cpuOptions { tol?: number; maxIter?: number; }
+export interface Hf cpuResult { values: number[]; converged: boolean; }
+export function computeHf cpu(data: number[], opts: Hf cpuOptions = {}): Hf cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf cpu };
diff --git a/src/hf/deberta.ts b/src/hf/deberta.ts
new file mode 100644
index 000000000..dc0dee097
--- /dev/null
+++ b/src/hf/deberta.ts
@@ -0,0 +1,22 @@
+/** Deberta module — tsb analytics library. */
+
+/** Options for Deberta. */
+export interface DebertaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Deberta. */
+export interface DebertaResult { values: number[]; converged: boolean; }
+
+/** Compute Deberta. */
+export function computeDeberta(data: number[], opts: DebertaOptions = {}): DebertaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDeberta };
diff --git a/src/hf/dense.ts b/src/hf/dense.ts
new file mode 100644
index 000000000..d2c2969a4
--- /dev/null
+++ b/src/hf/dense.ts
@@ -0,0 +1,15 @@
+/** Hf Dense module — tsb analytics library. */
+export interface Hf denseOptions { tol?: number; maxIter?: number; }
+export interface Hf denseResult { values: number[]; converged: boolean; }
+export function computeHf dense(data: number[], opts: Hf denseOptions = {}): Hf denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf dense };
diff --git a/src/hf/distilbert.ts b/src/hf/distilbert.ts
new file mode 100644
index 000000000..578a69004
--- /dev/null
+++ b/src/hf/distilbert.ts
@@ -0,0 +1,22 @@
+/** Distilbert module — tsb analytics library. */
+
+/** Options for Distilbert. */
+export interface DistilbertOptions { tol?: number; maxIter?: number; }
+
+/** Result from Distilbert. */
+export interface DistilbertResult { values: number[]; converged: boolean; }
+
+/** Compute Distilbert. */
+export function computeDistilbert(data: number[], opts: DistilbertOptions = {}): DistilbertResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDistilbert };
diff --git a/src/hf/distributed.ts b/src/hf/distributed.ts
new file mode 100644
index 000000000..da679f874
--- /dev/null
+++ b/src/hf/distributed.ts
@@ -0,0 +1,15 @@
+/** Hf Distributed module — tsb analytics library. */
+export interface Hf distributedOptions { tol?: number; maxIter?: number; }
+export interface Hf distributedResult { values: number[]; converged: boolean; }
+export function computeHf distributed(data: number[], opts: Hf distributedOptions = {}): Hf distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf distributed };
diff --git a/src/hf/dpr.ts b/src/hf/dpr.ts
new file mode 100644
index 000000000..7f49ed150
--- /dev/null
+++ b/src/hf/dpr.ts
@@ -0,0 +1,22 @@
+/** Dpr module — tsb analytics library. */
+
+/** Options for Dpr. */
+export interface DprOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dpr. */
+export interface DprResult { values: number[]; converged: boolean; }
+
+/** Compute Dpr. */
+export function computeDpr(data: number[], opts: DprOptions = {}): DprResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDpr };
diff --git a/src/hf/electra.ts b/src/hf/electra.ts
new file mode 100644
index 000000000..b49cb8cc9
--- /dev/null
+++ b/src/hf/electra.ts
@@ -0,0 +1,22 @@
+/** Electra module — tsb analytics library. */
+
+/** Options for Electra. */
+export interface ElectraOptions { tol?: number; maxIter?: number; }
+
+/** Result from Electra. */
+export interface ElectraResult { values: number[]; converged: boolean; }
+
+/** Compute Electra. */
+export function computeElectra(data: number[], opts: ElectraOptions = {}): ElectraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeElectra };
diff --git a/src/hf/experimental.ts b/src/hf/experimental.ts
new file mode 100644
index 000000000..399c9a1e0
--- /dev/null
+++ b/src/hf/experimental.ts
@@ -0,0 +1,15 @@
+/** Hf Experimental module — tsb analytics library. */
+export interface Hf experimentalOptions { tol?: number; maxIter?: number; }
+export interface Hf experimentalResult { values: number[]; converged: boolean; }
+export function computeHf experimental(data: number[], opts: Hf experimentalOptions = {}): Hf experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf experimental };
diff --git a/src/hf/fast.ts b/src/hf/fast.ts
new file mode 100644
index 000000000..3542a7fd4
--- /dev/null
+++ b/src/hf/fast.ts
@@ -0,0 +1,15 @@
+/** Hf Fast module — tsb analytics library. */
+export interface Hf fastOptions { tol?: number; maxIter?: number; }
+export interface Hf fastResult { values: number[]; converged: boolean; }
+export function computeHf fast(data: number[], opts: Hf fastOptions = {}): Hf fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf fast };
diff --git a/src/hf/fid.ts b/src/hf/fid.ts
new file mode 100644
index 000000000..2dbb57f74
--- /dev/null
+++ b/src/hf/fid.ts
@@ -0,0 +1,22 @@
+/** Fid module — tsb analytics library. */
+
+/** Options for Fid. */
+export interface FidOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fid. */
+export interface FidResult { values: number[]; converged: boolean; }
+
+/** Compute Fid. */
+export function computeFid(data: number[], opts: FidOptions = {}): FidResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFid };
diff --git a/src/hf/flash_attention.ts b/src/hf/flash_attention.ts
new file mode 100644
index 000000000..d435541a9
--- /dev/null
+++ b/src/hf/flash_attention.ts
@@ -0,0 +1,22 @@
+/** Flash Attention module — tsb analytics library. */
+
+/** Options for Flash Attention. */
+export interface FlashAttentionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Flash Attention. */
+export interface FlashAttentionResult { values: number[]; converged: boolean; }
+
+/** Compute Flash Attention. */
+export function computeFlashAttention(data: number[], opts: FlashAttentionOptions = {}): FlashAttentionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFlashAttention };
diff --git a/src/hf/funnel.ts b/src/hf/funnel.ts
new file mode 100644
index 000000000..449bb4e8d
--- /dev/null
+++ b/src/hf/funnel.ts
@@ -0,0 +1,22 @@
+/** Funnel module — tsb analytics library. */
+
+/** Options for Funnel. */
+export interface FunnelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Funnel. */
+export interface FunnelResult { values: number[]; converged: boolean; }
+
+/** Compute Funnel. */
+export function computeFunnel(data: number[], opts: FunnelOptions = {}): FunnelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFunnel };
diff --git a/src/hf/future.ts b/src/hf/future.ts
new file mode 100644
index 000000000..4a326461f
--- /dev/null
+++ b/src/hf/future.ts
@@ -0,0 +1,15 @@
+/** Hf Future module — tsb analytics library. */
+export interface Hf futureOptions { tol?: number; maxIter?: number; }
+export interface Hf futureResult { values: number[]; converged: boolean; }
+export function computeHf future(data: number[], opts: Hf futureOptions = {}): Hf futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf future };
diff --git a/src/hf/gpt2.ts b/src/hf/gpt2.ts
new file mode 100644
index 000000000..e43318fe7
--- /dev/null
+++ b/src/hf/gpt2.ts
@@ -0,0 +1,22 @@
+/** Gpt2 module — tsb analytics library. */
+
+/** Options for Gpt2. */
+export interface Gpt2Options { tol?: number; maxIter?: number; }
+
+/** Result from Gpt2. */
+export interface Gpt2Result { values: number[]; converged: boolean; }
+
+/** Compute Gpt2. */
+export function computeGpt2(data: number[], opts: Gpt2Options = {}): Gpt2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGpt2 };
diff --git a/src/hf/gpu.ts b/src/hf/gpu.ts
new file mode 100644
index 000000000..2b30d8058
--- /dev/null
+++ b/src/hf/gpu.ts
@@ -0,0 +1,15 @@
+/** Hf Gpu module — tsb analytics library. */
+export interface Hf gpuOptions { tol?: number; maxIter?: number; }
+export interface Hf gpuResult { values: number[]; converged: boolean; }
+export function computeHf gpu(data: number[], opts: Hf gpuOptions = {}): Hf gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf gpu };
diff --git a/src/hf/grouped_query.ts b/src/hf/grouped_query.ts
new file mode 100644
index 000000000..5aed24bbe
--- /dev/null
+++ b/src/hf/grouped_query.ts
@@ -0,0 +1,22 @@
+/** Grouped Query module — tsb analytics library. */
+
+/** Options for Grouped Query. */
+export interface GroupedQueryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Grouped Query. */
+export interface GroupedQueryResult { values: number[]; converged: boolean; }
+
+/** Compute Grouped Query. */
+export function computeGroupedQuery(data: number[], opts: GroupedQueryOptions = {}): GroupedQueryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGroupedQuery };
diff --git a/src/hf/knnlm.ts b/src/hf/knnlm.ts
new file mode 100644
index 000000000..7d44935f0
--- /dev/null
+++ b/src/hf/knnlm.ts
@@ -0,0 +1,22 @@
+/** Knnlm module — tsb analytics library. */
+
+/** Options for Knnlm. */
+export interface KnnlmOptions { tol?: number; maxIter?: number; }
+
+/** Result from Knnlm. */
+export interface KnnlmResult { values: number[]; converged: boolean; }
+
+/** Compute Knnlm. */
+export function computeKnnlm(data: number[], opts: KnnlmOptions = {}): KnnlmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKnnlm };
diff --git a/src/hf/large.ts b/src/hf/large.ts
new file mode 100644
index 000000000..1b8ae0840
--- /dev/null
+++ b/src/hf/large.ts
@@ -0,0 +1,15 @@
+/** Hf Large module — tsb analytics library. */
+export interface Hf largeOptions { tol?: number; maxIter?: number; }
+export interface Hf largeResult { values: number[]; converged: boolean; }
+export function computeHf large(data: number[], opts: Hf largeOptions = {}): Hf largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf large };
diff --git a/src/hf/legacy.ts b/src/hf/legacy.ts
new file mode 100644
index 000000000..bdd8e0862
--- /dev/null
+++ b/src/hf/legacy.ts
@@ -0,0 +1,15 @@
+/** Hf Legacy module — tsb analytics library. */
+export interface Hf legacyOptions { tol?: number; maxIter?: number; }
+export interface Hf legacyResult { values: number[]; converged: boolean; }
+export function computeHf legacy(data: number[], opts: Hf legacyOptions = {}): Hf legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf legacy };
diff --git a/src/hf/lite.ts b/src/hf/lite.ts
new file mode 100644
index 000000000..d4563b045
--- /dev/null
+++ b/src/hf/lite.ts
@@ -0,0 +1,15 @@
+/** Hf Lite module — tsb analytics library. */
+export interface Hf liteOptions { tol?: number; maxIter?: number; }
+export interface Hf liteResult { values: number[]; converged: boolean; }
+export function computeHf lite(data: number[], opts: Hf liteOptions = {}): Hf liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf lite };
diff --git a/src/hf/longformer.ts b/src/hf/longformer.ts
new file mode 100644
index 000000000..9b0a706a1
--- /dev/null
+++ b/src/hf/longformer.ts
@@ -0,0 +1,22 @@
+/** Longformer module — tsb analytics library. */
+
+/** Options for Longformer. */
+export interface LongformerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Longformer. */
+export interface LongformerResult { values: number[]; converged: boolean; }
+
+/** Compute Longformer. */
+export function computeLongformer(data: number[], opts: LongformerOptions = {}): LongformerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLongformer };
diff --git a/src/hf/mini.ts b/src/hf/mini.ts
new file mode 100644
index 000000000..c224f68f7
--- /dev/null
+++ b/src/hf/mini.ts
@@ -0,0 +1,15 @@
+/** Hf Mini module — tsb analytics library. */
+export interface Hf miniOptions { tol?: number; maxIter?: number; }
+export interface Hf miniResult { values: number[]; converged: boolean; }
+export function computeHf mini(data: number[], opts: Hf miniOptions = {}): Hf miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf mini };
diff --git a/src/hf/minilm.ts b/src/hf/minilm.ts
new file mode 100644
index 000000000..209255607
--- /dev/null
+++ b/src/hf/minilm.ts
@@ -0,0 +1,22 @@
+/** Minilm module — tsb analytics library. */
+
+/** Options for Minilm. */
+export interface MinilmOptions { tol?: number; maxIter?: number; }
+
+/** Result from Minilm. */
+export interface MinilmResult { values: number[]; converged: boolean; }
+
+/** Compute Minilm. */
+export function computeMinilm(data: number[], opts: MinilmOptions = {}): MinilmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMinilm };
diff --git a/src/hf/mobilebert.ts b/src/hf/mobilebert.ts
new file mode 100644
index 000000000..db53e10c1
--- /dev/null
+++ b/src/hf/mobilebert.ts
@@ -0,0 +1,22 @@
+/** Mobilebert module — tsb analytics library. */
+
+/** Options for Mobilebert. */
+export interface MobilebertOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mobilebert. */
+export interface MobilebertResult { values: number[]; converged: boolean; }
+
+/** Compute Mobilebert. */
+export function computeMobilebert(data: number[], opts: MobilebertOptions = {}): MobilebertResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMobilebert };
diff --git a/src/hf/multi_head.ts b/src/hf/multi_head.ts
new file mode 100644
index 000000000..e9740c4bb
--- /dev/null
+++ b/src/hf/multi_head.ts
@@ -0,0 +1,22 @@
+/** Multi Head module — tsb analytics library. */
+
+/** Options for Multi Head. */
+export interface MultiHeadOptions { tol?: number; maxIter?: number; }
+
+/** Result from Multi Head. */
+export interface MultiHeadResult { values: number[]; converged: boolean; }
+
+/** Compute Multi Head. */
+export function computeMultiHead(data: number[], opts: MultiHeadOptions = {}): MultiHeadResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMultiHead };
diff --git a/src/hf/next.ts b/src/hf/next.ts
new file mode 100644
index 000000000..4b3763ac3
--- /dev/null
+++ b/src/hf/next.ts
@@ -0,0 +1,15 @@
+/** Hf Next module — tsb analytics library. */
+export interface Hf nextOptions { tol?: number; maxIter?: number; }
+export interface Hf nextResult { values: number[]; converged: boolean; }
+export function computeHf next(data: number[], opts: Hf nextOptions = {}): Hf nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf next };
diff --git a/src/hf/online.ts b/src/hf/online.ts
new file mode 100644
index 000000000..6773cd230
--- /dev/null
+++ b/src/hf/online.ts
@@ -0,0 +1,15 @@
+/** Hf Online module — tsb analytics library. */
+export interface Hf onlineOptions { tol?: number; maxIter?: number; }
+export interface Hf onlineResult { values: number[]; converged: boolean; }
+export function computeHf online(data: number[], opts: Hf onlineOptions = {}): Hf onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf online };
diff --git a/src/hf/parallel.ts b/src/hf/parallel.ts
new file mode 100644
index 000000000..caa5366cf
--- /dev/null
+++ b/src/hf/parallel.ts
@@ -0,0 +1,15 @@
+/** Hf Parallel module — tsb analytics library. */
+export interface Hf parallelOptions { tol?: number; maxIter?: number; }
+export interface Hf parallelResult { values: number[]; converged: boolean; }
+export function computeHf parallel(data: number[], opts: Hf parallelOptions = {}): Hf parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf parallel };
diff --git a/src/hf/plus.ts b/src/hf/plus.ts
new file mode 100644
index 000000000..cfe8e6a7c
--- /dev/null
+++ b/src/hf/plus.ts
@@ -0,0 +1,15 @@
+/** Hf Plus module — tsb analytics library. */
+export interface Hf plusOptions { tol?: number; maxIter?: number; }
+export interface Hf plusResult { values: number[]; converged: boolean; }
+export function computeHf plus(data: number[], opts: Hf plusOptions = {}): Hf plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf plus };
diff --git a/src/hf/pro.ts b/src/hf/pro.ts
new file mode 100644
index 000000000..52ecf291e
--- /dev/null
+++ b/src/hf/pro.ts
@@ -0,0 +1,15 @@
+/** Hf Pro module — tsb analytics library. */
+export interface Hf proOptions { tol?: number; maxIter?: number; }
+export interface Hf proResult { values: number[]; converged: boolean; }
+export function computeHf pro(data: number[], opts: Hf proOptions = {}): Hf proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf pro };
diff --git a/src/hf/rag.ts b/src/hf/rag.ts
new file mode 100644
index 000000000..c5d2debae
--- /dev/null
+++ b/src/hf/rag.ts
@@ -0,0 +1,22 @@
+/** Rag module — tsb analytics library. */
+
+/** Options for Rag. */
+export interface RagOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rag. */
+export interface RagResult { values: number[]; converged: boolean; }
+
+/** Compute Rag. */
+export function computeRag(data: number[], opts: RagOptions = {}): RagResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRag };
diff --git a/src/hf/realm.ts b/src/hf/realm.ts
new file mode 100644
index 000000000..c34fdb274
--- /dev/null
+++ b/src/hf/realm.ts
@@ -0,0 +1,22 @@
+/** Realm module — tsb analytics library. */
+
+/** Options for Realm. */
+export interface RealmOptions { tol?: number; maxIter?: number; }
+
+/** Result from Realm. */
+export interface RealmResult { values: number[]; converged: boolean; }
+
+/** Compute Realm. */
+export function computeRealm(data: number[], opts: RealmOptions = {}): RealmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRealm };
diff --git a/src/hf/reformer.ts b/src/hf/reformer.ts
new file mode 100644
index 000000000..38863d24f
--- /dev/null
+++ b/src/hf/reformer.ts
@@ -0,0 +1,22 @@
+/** Reformer module — tsb analytics library. */
+
+/** Options for Reformer. */
+export interface ReformerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reformer. */
+export interface ReformerResult { values: number[]; converged: boolean; }
+
+/** Compute Reformer. */
+export function computeReformer(data: number[], opts: ReformerOptions = {}): ReformerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReformer };
diff --git a/src/hf/relative_position.ts b/src/hf/relative_position.ts
new file mode 100644
index 000000000..78851d93e
--- /dev/null
+++ b/src/hf/relative_position.ts
@@ -0,0 +1,22 @@
+/** Relative Position module — tsb analytics library. */
+
+/** Options for Relative Position. */
+export interface RelativePositionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Relative Position. */
+export interface RelativePositionResult { values: number[]; converged: boolean; }
+
+/** Compute Relative Position. */
+export function computeRelativePosition(data: number[], opts: RelativePositionOptions = {}): RelativePositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRelativePosition };
diff --git a/src/hf/roberta.ts b/src/hf/roberta.ts
new file mode 100644
index 000000000..93f9db747
--- /dev/null
+++ b/src/hf/roberta.ts
@@ -0,0 +1,22 @@
+/** Roberta module — tsb analytics library. */
+
+/** Options for Roberta. */
+export interface RobertaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Roberta. */
+export interface RobertaResult { values: number[]; converged: boolean; }
+
+/** Compute Roberta. */
+export function computeRoberta(data: number[], opts: RobertaOptions = {}): RobertaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRoberta };
diff --git a/src/hf/robust.ts b/src/hf/robust.ts
new file mode 100644
index 000000000..66b6bdfcd
--- /dev/null
+++ b/src/hf/robust.ts
@@ -0,0 +1,15 @@
+/** Hf Robust module — tsb analytics library. */
+export interface Hf robustOptions { tol?: number; maxIter?: number; }
+export interface Hf robustResult { values: number[]; converged: boolean; }
+export function computeHf robust(data: number[], opts: Hf robustOptions = {}): Hf robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf robust };
diff --git a/src/hf/rotary.ts b/src/hf/rotary.ts
new file mode 100644
index 000000000..51a202250
--- /dev/null
+++ b/src/hf/rotary.ts
@@ -0,0 +1,22 @@
+/** Rotary module — tsb analytics library. */
+
+/** Options for Rotary. */
+export interface RotaryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rotary. */
+export interface RotaryResult { values: number[]; converged: boolean; }
+
+/** Compute Rotary. */
+export function computeRotary(data: number[], opts: RotaryOptions = {}): RotaryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRotary };
diff --git a/src/hf/sentence_bert.ts b/src/hf/sentence_bert.ts
new file mode 100644
index 000000000..a4422a702
--- /dev/null
+++ b/src/hf/sentence_bert.ts
@@ -0,0 +1,22 @@
+/** Sentence Bert module — tsb analytics library. */
+
+/** Options for Sentence Bert. */
+export interface SentenceBertOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sentence Bert. */
+export interface SentenceBertResult { values: number[]; converged: boolean; }
+
+/** Compute Sentence Bert. */
+export function computeSentenceBert(data: number[], opts: SentenceBertOptions = {}): SentenceBertResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSentenceBert };
diff --git a/src/hf/simcse.ts b/src/hf/simcse.ts
new file mode 100644
index 000000000..6e4c8127e
--- /dev/null
+++ b/src/hf/simcse.ts
@@ -0,0 +1,22 @@
+/** Simcse module — tsb analytics library. */
+
+/** Options for Simcse. */
+export interface SimcseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Simcse. */
+export interface SimcseResult { values: number[]; converged: boolean; }
+
+/** Compute Simcse. */
+export function computeSimcse(data: number[], opts: SimcseOptions = {}): SimcseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSimcse };
diff --git a/src/hf/small.ts b/src/hf/small.ts
new file mode 100644
index 000000000..691a6f929
--- /dev/null
+++ b/src/hf/small.ts
@@ -0,0 +1,15 @@
+/** Hf Small module — tsb analytics library. */
+export interface Hf smallOptions { tol?: number; maxIter?: number; }
+export interface Hf smallResult { values: number[]; converged: boolean; }
+export function computeHf small(data: number[], opts: Hf smallOptions = {}): Hf smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf small };
diff --git a/src/hf/sparse.ts b/src/hf/sparse.ts
new file mode 100644
index 000000000..1938a7c96
--- /dev/null
+++ b/src/hf/sparse.ts
@@ -0,0 +1,15 @@
+/** Hf Sparse module — tsb analytics library. */
+export interface Hf sparseOptions { tol?: number; maxIter?: number; }
+export interface Hf sparseResult { values: number[]; converged: boolean; }
+export function computeHf sparse(data: number[], opts: Hf sparseOptions = {}): Hf sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf sparse };
diff --git a/src/hf/stable.ts b/src/hf/stable.ts
new file mode 100644
index 000000000..8b943aa9c
--- /dev/null
+++ b/src/hf/stable.ts
@@ -0,0 +1,15 @@
+/** Hf Stable module — tsb analytics library. */
+export interface Hf stableOptions { tol?: number; maxIter?: number; }
+export interface Hf stableResult { values: number[]; converged: boolean; }
+export function computeHf stable(data: number[], opts: Hf stableOptions = {}): Hf stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf stable };
diff --git a/src/hf/streaming.ts b/src/hf/streaming.ts
new file mode 100644
index 000000000..9c48e4275
--- /dev/null
+++ b/src/hf/streaming.ts
@@ -0,0 +1,15 @@
+/** Hf Streaming module — tsb analytics library. */
+export interface Hf streamingOptions { tol?: number; maxIter?: number; }
+export interface Hf streamingResult { values: number[]; converged: boolean; }
+export function computeHf streaming(data: number[], opts: Hf streamingOptions = {}): Hf streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf streaming };
diff --git a/src/hf/t5.ts b/src/hf/t5.ts
new file mode 100644
index 000000000..9b3b63f0e
--- /dev/null
+++ b/src/hf/t5.ts
@@ -0,0 +1,22 @@
+/** T5 module — tsb analytics library. */
+
+/** Options for T5. */
+export interface T5Options { tol?: number; maxIter?: number; }
+
+/** Result from T5. */
+export interface T5Result { values: number[]; converged: boolean; }
+
+/** Compute T5. */
+export function computeT5(data: number[], opts: T5Options = {}): T5Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeT5 };
diff --git a/src/hf/tinybert.ts b/src/hf/tinybert.ts
new file mode 100644
index 000000000..ffed1aa0a
--- /dev/null
+++ b/src/hf/tinybert.ts
@@ -0,0 +1,22 @@
+/** Tinybert module — tsb analytics library. */
+
+/** Options for Tinybert. */
+export interface TinybertOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tinybert. */
+export interface TinybertResult { values: number[]; converged: boolean; }
+
+/** Compute Tinybert. */
+export function computeTinybert(data: number[], opts: TinybertOptions = {}): TinybertResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTinybert };
diff --git a/src/hf/tome.ts b/src/hf/tome.ts
new file mode 100644
index 000000000..3508b7d4d
--- /dev/null
+++ b/src/hf/tome.ts
@@ -0,0 +1,22 @@
+/** Tome module — tsb analytics library. */
+
+/** Options for Tome. */
+export interface TomeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tome. */
+export interface TomeResult { values: number[]; converged: boolean; }
+
+/** Compute Tome. */
+export function computeTome(data: number[], opts: TomeOptions = {}): TomeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTome };
diff --git a/src/hf/v2.ts b/src/hf/v2.ts
new file mode 100644
index 000000000..50a47161b
--- /dev/null
+++ b/src/hf/v2.ts
@@ -0,0 +1,15 @@
+/** Hf V2 module — tsb analytics library. */
+export interface Hf v2Options { tol?: number; maxIter?: number; }
+export interface Hf v2Result { values: number[]; converged: boolean; }
+export function computeHf v2(data: number[], opts: Hf v2Options = {}): Hf v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf v2 };
diff --git a/src/hf/v3.ts b/src/hf/v3.ts
new file mode 100644
index 000000000..7d6f497b2
--- /dev/null
+++ b/src/hf/v3.ts
@@ -0,0 +1,15 @@
+/** Hf V3 module — tsb analytics library. */
+export interface Hf v3Options { tol?: number; maxIter?: number; }
+export interface Hf v3Result { values: number[]; converged: boolean; }
+export function computeHf v3(data: number[], opts: Hf v3Options = {}): Hf v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf v3 };
diff --git a/src/hf/wasm.ts b/src/hf/wasm.ts
new file mode 100644
index 000000000..c6b103128
--- /dev/null
+++ b/src/hf/wasm.ts
@@ -0,0 +1,15 @@
+/** Hf Wasm module — tsb analytics library. */
+export interface Hf wasmOptions { tol?: number; maxIter?: number; }
+export interface Hf wasmResult { values: number[]; converged: boolean; }
+export function computeHf wasm(data: number[], opts: Hf wasmOptions = {}): Hf wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf wasm };
diff --git a/src/hf/xlarge.ts b/src/hf/xlarge.ts
new file mode 100644
index 000000000..ae4729a6f
--- /dev/null
+++ b/src/hf/xlarge.ts
@@ -0,0 +1,15 @@
+/** Hf Xlarge module — tsb analytics library. */
+export interface Hf xlargeOptions { tol?: number; maxIter?: number; }
+export interface Hf xlargeResult { values: number[]; converged: boolean; }
+export function computeHf xlarge(data: number[], opts: Hf xlargeOptions = {}): Hf xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHf xlarge };
diff --git a/src/hf/xlnet.ts b/src/hf/xlnet.ts
new file mode 100644
index 000000000..a2f858b8e
--- /dev/null
+++ b/src/hf/xlnet.ts
@@ -0,0 +1,22 @@
+/** Xlnet module — tsb analytics library. */
+
+/** Options for Xlnet. */
+export interface XlnetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Xlnet. */
+export interface XlnetResult { values: number[]; converged: boolean; }
+
+/** Compute Xlnet. */
+export function computeXlnet(data: number[], opts: XlnetOptions = {}): XlnetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeXlnet };
diff --git a/src/horticulture_sci/adaptation.ts b/src/horticulture_sci/adaptation.ts
new file mode 100644
index 000000000..953606a41
--- /dev/null
+++ b/src/horticulture_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci adaptation module — tsb analytics library. */
+export interface HorticultureSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciAdaptation(data: number[], opts: HorticultureSciAdaptationOptions = {}): HorticultureSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciAdaptation };
diff --git a/src/horticulture_sci/aggregation.ts b/src/horticulture_sci/aggregation.ts
new file mode 100644
index 000000000..b7249c14e
--- /dev/null
+++ b/src/horticulture_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci aggregation module — tsb analytics library. */
+export interface HorticultureSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciAggregationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciAggregation(data: number[], opts: HorticultureSciAggregationOptions = {}): HorticultureSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciAggregation };
diff --git a/src/horticulture_sci/algebra.ts b/src/horticulture_sci/algebra.ts
new file mode 100644
index 000000000..6bd314d5b
--- /dev/null
+++ b/src/horticulture_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci algebra module — tsb analytics library. */
+export interface HorticultureSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciAlgebra(data: number[], opts: HorticultureSciAlgebraOptions = {}): HorticultureSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciAlgebra };
diff --git a/src/horticulture_sci/alignment.ts b/src/horticulture_sci/alignment.ts
new file mode 100644
index 000000000..798f075d1
--- /dev/null
+++ b/src/horticulture_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci alignment module — tsb analytics library. */
+export interface HorticultureSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciAlignment(data: number[], opts: HorticultureSciAlignmentOptions = {}): HorticultureSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciAlignment };
diff --git a/src/horticulture_sci/analysis.ts b/src/horticulture_sci/analysis.ts
new file mode 100644
index 000000000..321a4affa
--- /dev/null
+++ b/src/horticulture_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci analysis module — tsb analytics library. */
+export interface HorticultureSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciAnalysis(data: number[], opts: HorticultureSciAnalysisOptions = {}): HorticultureSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciAnalysis };
diff --git a/src/horticulture_sci/augmentation.ts b/src/horticulture_sci/augmentation.ts
new file mode 100644
index 000000000..912087bf8
--- /dev/null
+++ b/src/horticulture_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci augmentation module — tsb analytics library. */
+export interface HorticultureSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciAugmentation(data: number[], opts: HorticultureSciAugmentationOptions = {}): HorticultureSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciAugmentation };
diff --git a/src/horticulture_sci/bagging.ts b/src/horticulture_sci/bagging.ts
new file mode 100644
index 000000000..7efa3ab2b
--- /dev/null
+++ b/src/horticulture_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci bagging module — tsb analytics library. */
+export interface HorticultureSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciBaggingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciBagging(data: number[], opts: HorticultureSciBaggingOptions = {}): HorticultureSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciBagging };
diff --git a/src/horticulture_sci/basis.ts b/src/horticulture_sci/basis.ts
new file mode 100644
index 000000000..77d15aec3
--- /dev/null
+++ b/src/horticulture_sci/basis.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci basis module — tsb analytics library. */
+export interface HorticultureSciBasisOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciBasisResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciBasis(data: number[], opts: HorticultureSciBasisOptions = {}): HorticultureSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciBasis };
diff --git a/src/horticulture_sci/benchmarking.ts b/src/horticulture_sci/benchmarking.ts
new file mode 100644
index 000000000..511c49c13
--- /dev/null
+++ b/src/horticulture_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci benchmarking module — tsb analytics library. */
+export interface HorticultureSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciBenchmarking(data: number[], opts: HorticultureSciBenchmarkingOptions = {}): HorticultureSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciBenchmarking };
diff --git a/src/horticulture_sci/blending.ts b/src/horticulture_sci/blending.ts
new file mode 100644
index 000000000..a60f29e55
--- /dev/null
+++ b/src/horticulture_sci/blending.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci blending module — tsb analytics library. */
+export interface HorticultureSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciBlendingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciBlending(data: number[], opts: HorticultureSciBlendingOptions = {}): HorticultureSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciBlending };
diff --git a/src/horticulture_sci/boosting.ts b/src/horticulture_sci/boosting.ts
new file mode 100644
index 000000000..0c15f6d12
--- /dev/null
+++ b/src/horticulture_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci boosting module — tsb analytics library. */
+export interface HorticultureSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciBoostingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciBoosting(data: number[], opts: HorticultureSciBoostingOptions = {}): HorticultureSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciBoosting };
diff --git a/src/horticulture_sci/bootstrap.ts b/src/horticulture_sci/bootstrap.ts
new file mode 100644
index 000000000..4c5fc8e4b
--- /dev/null
+++ b/src/horticulture_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci bootstrap module — tsb analytics library. */
+export interface HorticultureSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciBootstrap(data: number[], opts: HorticultureSciBootstrapOptions = {}): HorticultureSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciBootstrap };
diff --git a/src/horticulture_sci/calculus.ts b/src/horticulture_sci/calculus.ts
new file mode 100644
index 000000000..1abc2314e
--- /dev/null
+++ b/src/horticulture_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci calculus module — tsb analytics library. */
+export interface HorticultureSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciCalculusResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciCalculus(data: number[], opts: HorticultureSciCalculusOptions = {}): HorticultureSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciCalculus };
diff --git a/src/horticulture_sci/calibration.ts b/src/horticulture_sci/calibration.ts
new file mode 100644
index 000000000..3ef86c168
--- /dev/null
+++ b/src/horticulture_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci calibration module — tsb analytics library. */
+export interface HorticultureSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciCalibration(data: number[], opts: HorticultureSciCalibrationOptions = {}): HorticultureSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciCalibration };
diff --git a/src/horticulture_sci/characterization.ts b/src/horticulture_sci/characterization.ts
new file mode 100644
index 000000000..65c04e4cf
--- /dev/null
+++ b/src/horticulture_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci characterization module — tsb analytics library. */
+export interface HorticultureSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciCharacterization(data: number[], opts: HorticultureSciCharacterizationOptions = {}): HorticultureSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciCharacterization };
diff --git a/src/horticulture_sci/classification.ts b/src/horticulture_sci/classification.ts
new file mode 100644
index 000000000..62921d219
--- /dev/null
+++ b/src/horticulture_sci/classification.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci classification module — tsb analytics library. */
+export interface HorticultureSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciClassificationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciClassification(data: number[], opts: HorticultureSciClassificationOptions = {}): HorticultureSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciClassification };
diff --git a/src/horticulture_sci/clustering.ts b/src/horticulture_sci/clustering.ts
new file mode 100644
index 000000000..fddb072db
--- /dev/null
+++ b/src/horticulture_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci clustering module — tsb analytics library. */
+export interface HorticultureSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciClusteringResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciClustering(data: number[], opts: HorticultureSciClusteringOptions = {}): HorticultureSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciClustering };
diff --git a/src/horticulture_sci/compression.ts b/src/horticulture_sci/compression.ts
new file mode 100644
index 000000000..2bc67b687
--- /dev/null
+++ b/src/horticulture_sci/compression.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci compression module — tsb analytics library. */
+export interface HorticultureSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciCompressionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciCompression(data: number[], opts: HorticultureSciCompressionOptions = {}): HorticultureSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciCompression };
diff --git a/src/horticulture_sci/continuous.ts b/src/horticulture_sci/continuous.ts
new file mode 100644
index 000000000..648c74870
--- /dev/null
+++ b/src/horticulture_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci continuous module — tsb analytics library. */
+export interface HorticultureSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciContinuousResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciContinuous(data: number[], opts: HorticultureSciContinuousOptions = {}): HorticultureSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciContinuous };
diff --git a/src/horticulture_sci/control.ts b/src/horticulture_sci/control.ts
new file mode 100644
index 000000000..74c084491
--- /dev/null
+++ b/src/horticulture_sci/control.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci control module — tsb analytics library. */
+export interface HorticultureSciControlOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciControlResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciControl(data: number[], opts: HorticultureSciControlOptions = {}): HorticultureSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciControl };
diff --git a/src/horticulture_sci/convergence.ts b/src/horticulture_sci/convergence.ts
new file mode 100644
index 000000000..887c93bbb
--- /dev/null
+++ b/src/horticulture_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci convergence module — tsb analytics library. */
+export interface HorticultureSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciConvergence(data: number[], opts: HorticultureSciConvergenceOptions = {}): HorticultureSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciConvergence };
diff --git a/src/horticulture_sci/convex.ts b/src/horticulture_sci/convex.ts
new file mode 100644
index 000000000..bf8ceeba8
--- /dev/null
+++ b/src/horticulture_sci/convex.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci convex module — tsb analytics library. */
+export interface HorticultureSciConvexOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciConvexResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciConvex(data: number[], opts: HorticultureSciConvexOptions = {}): HorticultureSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciConvex };
diff --git a/src/horticulture_sci/correlation.ts b/src/horticulture_sci/correlation.ts
new file mode 100644
index 000000000..bcf03ed41
--- /dev/null
+++ b/src/horticulture_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci correlation module — tsb analytics library. */
+export interface HorticultureSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciCorrelation(data: number[], opts: HorticultureSciCorrelationOptions = {}): HorticultureSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciCorrelation };
diff --git a/src/horticulture_sci/covariance.ts b/src/horticulture_sci/covariance.ts
new file mode 100644
index 000000000..07ea72700
--- /dev/null
+++ b/src/horticulture_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci covariance module — tsb analytics library. */
+export interface HorticultureSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciCovariance(data: number[], opts: HorticultureSciCovarianceOptions = {}): HorticultureSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciCovariance };
diff --git a/src/horticulture_sci/cross_validation.ts b/src/horticulture_sci/cross_validation.ts
new file mode 100644
index 000000000..9ec3e51cb
--- /dev/null
+++ b/src/horticulture_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci cross_validation module — tsb analytics library. */
+export interface HorticultureSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciCrossValidation(data: number[], opts: HorticultureSciCrossValidationOptions = {}): HorticultureSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciCrossValidation };
diff --git a/src/horticulture_sci/decoding.ts b/src/horticulture_sci/decoding.ts
new file mode 100644
index 000000000..64dc23167
--- /dev/null
+++ b/src/horticulture_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci decoding module — tsb analytics library. */
+export interface HorticultureSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDecodingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDecoding(data: number[], opts: HorticultureSciDecodingOptions = {}): HorticultureSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDecoding };
diff --git a/src/horticulture_sci/decomposition.ts b/src/horticulture_sci/decomposition.ts
new file mode 100644
index 000000000..28c536982
--- /dev/null
+++ b/src/horticulture_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci decomposition module — tsb analytics library. */
+export interface HorticultureSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDecomposition(data: number[], opts: HorticultureSciDecompositionOptions = {}): HorticultureSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDecomposition };
diff --git a/src/horticulture_sci/detection.ts b/src/horticulture_sci/detection.ts
new file mode 100644
index 000000000..ba7637f18
--- /dev/null
+++ b/src/horticulture_sci/detection.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci detection module — tsb analytics library. */
+export interface HorticultureSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDetectionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDetection(data: number[], opts: HorticultureSciDetectionOptions = {}): HorticultureSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDetection };
diff --git a/src/horticulture_sci/deterministic.ts b/src/horticulture_sci/deterministic.ts
new file mode 100644
index 000000000..8f3b130e4
--- /dev/null
+++ b/src/horticulture_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci deterministic module — tsb analytics library. */
+export interface HorticultureSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDeterministic(data: number[], opts: HorticultureSciDeterministicOptions = {}): HorticultureSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDeterministic };
diff --git a/src/horticulture_sci/diagnostics.ts b/src/horticulture_sci/diagnostics.ts
new file mode 100644
index 000000000..2e5848eda
--- /dev/null
+++ b/src/horticulture_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci diagnostics module — tsb analytics library. */
+export interface HorticultureSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDiagnostics(data: number[], opts: HorticultureSciDiagnosticsOptions = {}): HorticultureSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDiagnostics };
diff --git a/src/horticulture_sci/differential.ts b/src/horticulture_sci/differential.ts
new file mode 100644
index 000000000..a123b1567
--- /dev/null
+++ b/src/horticulture_sci/differential.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci differential module — tsb analytics library. */
+export interface HorticultureSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDifferential(data: number[], opts: HorticultureSciDifferentialOptions = {}): HorticultureSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDifferential };
diff --git a/src/horticulture_sci/discrete.ts b/src/horticulture_sci/discrete.ts
new file mode 100644
index 000000000..c289119d9
--- /dev/null
+++ b/src/horticulture_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci discrete module — tsb analytics library. */
+export interface HorticultureSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDiscrete(data: number[], opts: HorticultureSciDiscreteOptions = {}): HorticultureSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDiscrete };
diff --git a/src/horticulture_sci/distribution.ts b/src/horticulture_sci/distribution.ts
new file mode 100644
index 000000000..30dfcd83b
--- /dev/null
+++ b/src/horticulture_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci distribution module — tsb analytics library. */
+export interface HorticultureSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDistributionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDistribution(data: number[], opts: HorticultureSciDistributionOptions = {}): HorticultureSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDistribution };
diff --git a/src/horticulture_sci/dynamic.ts b/src/horticulture_sci/dynamic.ts
new file mode 100644
index 000000000..714ad5c55
--- /dev/null
+++ b/src/horticulture_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci dynamic module — tsb analytics library. */
+export interface HorticultureSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciDynamicResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciDynamic(data: number[], opts: HorticultureSciDynamicOptions = {}): HorticultureSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciDynamic };
diff --git a/src/horticulture_sci/embedding.ts b/src/horticulture_sci/embedding.ts
new file mode 100644
index 000000000..af4772e19
--- /dev/null
+++ b/src/horticulture_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci embedding module — tsb analytics library. */
+export interface HorticultureSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciEmbedding(data: number[], opts: HorticultureSciEmbeddingOptions = {}): HorticultureSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciEmbedding };
diff --git a/src/horticulture_sci/encoding.ts b/src/horticulture_sci/encoding.ts
new file mode 100644
index 000000000..858bbcd62
--- /dev/null
+++ b/src/horticulture_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci encoding module — tsb analytics library. */
+export interface HorticultureSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciEncodingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciEncoding(data: number[], opts: HorticultureSciEncodingOptions = {}): HorticultureSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciEncoding };
diff --git a/src/horticulture_sci/ensemble.ts b/src/horticulture_sci/ensemble.ts
new file mode 100644
index 000000000..e60378fac
--- /dev/null
+++ b/src/horticulture_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci ensemble module — tsb analytics library. */
+export interface HorticultureSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciEnsemble(data: number[], opts: HorticultureSciEnsembleOptions = {}): HorticultureSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciEnsemble };
diff --git a/src/horticulture_sci/estimation.ts b/src/horticulture_sci/estimation.ts
new file mode 100644
index 000000000..3c201990f
--- /dev/null
+++ b/src/horticulture_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci estimation module — tsb analytics library. */
+export interface HorticultureSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciEstimationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciEstimation(data: number[], opts: HorticultureSciEstimationOptions = {}): HorticultureSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciEstimation };
diff --git a/src/horticulture_sci/evaluation.ts b/src/horticulture_sci/evaluation.ts
new file mode 100644
index 000000000..9f8ec5578
--- /dev/null
+++ b/src/horticulture_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci evaluation module — tsb analytics library. */
+export interface HorticultureSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciEvaluation(data: number[], opts: HorticultureSciEvaluationOptions = {}): HorticultureSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciEvaluation };
diff --git a/src/horticulture_sci/extrapolation.ts b/src/horticulture_sci/extrapolation.ts
new file mode 100644
index 000000000..b5826f02c
--- /dev/null
+++ b/src/horticulture_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci extrapolation module — tsb analytics library. */
+export interface HorticultureSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciExtrapolation(data: number[], opts: HorticultureSciExtrapolationOptions = {}): HorticultureSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciExtrapolation };
diff --git a/src/horticulture_sci/features.ts b/src/horticulture_sci/features.ts
new file mode 100644
index 000000000..265ea3901
--- /dev/null
+++ b/src/horticulture_sci/features.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci features module — tsb analytics library. */
+export interface HorticultureSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciFeatures(data: number[], opts: HorticultureSciFeaturesOptions = {}): HorticultureSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciFeatures };
diff --git a/src/horticulture_sci/feedback.ts b/src/horticulture_sci/feedback.ts
new file mode 100644
index 000000000..8585bd575
--- /dev/null
+++ b/src/horticulture_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci feedback module — tsb analytics library. */
+export interface HorticultureSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciFeedback(data: number[], opts: HorticultureSciFeedbackOptions = {}): HorticultureSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciFeedback };
diff --git a/src/horticulture_sci/filtering.ts b/src/horticulture_sci/filtering.ts
new file mode 100644
index 000000000..3746050da
--- /dev/null
+++ b/src/horticulture_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci filtering module — tsb analytics library. */
+export interface HorticultureSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciFilteringResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciFiltering(data: number[], opts: HorticultureSciFilteringOptions = {}): HorticultureSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciFiltering };
diff --git a/src/horticulture_sci/fourier.ts b/src/horticulture_sci/fourier.ts
new file mode 100644
index 000000000..751be0eac
--- /dev/null
+++ b/src/horticulture_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci fourier module — tsb analytics library. */
+export interface HorticultureSciFourierOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciFourierResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciFourier(data: number[], opts: HorticultureSciFourierOptions = {}): HorticultureSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciFourier };
diff --git a/src/horticulture_sci/fusion.ts b/src/horticulture_sci/fusion.ts
new file mode 100644
index 000000000..48314df57
--- /dev/null
+++ b/src/horticulture_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci fusion module — tsb analytics library. */
+export interface HorticultureSciFusionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciFusionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciFusion(data: number[], opts: HorticultureSciFusionOptions = {}): HorticultureSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciFusion };
diff --git a/src/horticulture_sci/generation.ts b/src/horticulture_sci/generation.ts
new file mode 100644
index 000000000..7572616ae
--- /dev/null
+++ b/src/horticulture_sci/generation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci generation module — tsb analytics library. */
+export interface HorticultureSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciGenerationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciGeneration(data: number[], opts: HorticultureSciGenerationOptions = {}): HorticultureSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciGeneration };
diff --git a/src/horticulture_sci/geometry.ts b/src/horticulture_sci/geometry.ts
new file mode 100644
index 000000000..ac359d31b
--- /dev/null
+++ b/src/horticulture_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci geometry module — tsb analytics library. */
+export interface HorticultureSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciGeometryResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciGeometry(data: number[], opts: HorticultureSciGeometryOptions = {}): HorticultureSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciGeometry };
diff --git a/src/horticulture_sci/gradient.ts b/src/horticulture_sci/gradient.ts
new file mode 100644
index 000000000..2e3849e99
--- /dev/null
+++ b/src/horticulture_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci gradient module — tsb analytics library. */
+export interface HorticultureSciGradientOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciGradientResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciGradient(data: number[], opts: HorticultureSciGradientOptions = {}): HorticultureSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciGradient };
diff --git a/src/horticulture_sci/hessian.ts b/src/horticulture_sci/hessian.ts
new file mode 100644
index 000000000..8fa154be5
--- /dev/null
+++ b/src/horticulture_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci hessian module — tsb analytics library. */
+export interface HorticultureSciHessianOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciHessianResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciHessian(data: number[], opts: HorticultureSciHessianOptions = {}): HorticultureSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciHessian };
diff --git a/src/horticulture_sci/hypothesis.ts b/src/horticulture_sci/hypothesis.ts
new file mode 100644
index 000000000..877dc7166
--- /dev/null
+++ b/src/horticulture_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci hypothesis module — tsb analytics library. */
+export interface HorticultureSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciHypothesis(data: number[], opts: HorticultureSciHypothesisOptions = {}): HorticultureSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciHypothesis };
diff --git a/src/horticulture_sci/inference.ts b/src/horticulture_sci/inference.ts
new file mode 100644
index 000000000..b38cee40a
--- /dev/null
+++ b/src/horticulture_sci/inference.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci inference module — tsb analytics library. */
+export interface HorticultureSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciInferenceResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciInference(data: number[], opts: HorticultureSciInferenceOptions = {}): HorticultureSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciInference };
diff --git a/src/horticulture_sci/inference2.ts b/src/horticulture_sci/inference2.ts
new file mode 100644
index 000000000..bb0ad8b46
--- /dev/null
+++ b/src/horticulture_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci inference2 module — tsb analytics library. */
+export interface HorticultureSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciInferenceResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciInference(data: number[], opts: HorticultureSciInferenceOptions = {}): HorticultureSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciInference };
diff --git a/src/horticulture_sci/integral.ts b/src/horticulture_sci/integral.ts
new file mode 100644
index 000000000..e1eb63094
--- /dev/null
+++ b/src/horticulture_sci/integral.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci integral module — tsb analytics library. */
+export interface HorticultureSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciIntegralResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciIntegral(data: number[], opts: HorticultureSciIntegralOptions = {}): HorticultureSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciIntegral };
diff --git a/src/horticulture_sci/integration.ts b/src/horticulture_sci/integration.ts
new file mode 100644
index 000000000..3fc24a28c
--- /dev/null
+++ b/src/horticulture_sci/integration.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci integration module — tsb analytics library. */
+export interface HorticultureSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciIntegration(data: number[], opts: HorticultureSciIntegrationOptions = {}): HorticultureSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciIntegration };
diff --git a/src/horticulture_sci/interpolation.ts b/src/horticulture_sci/interpolation.ts
new file mode 100644
index 000000000..ace0f52d4
--- /dev/null
+++ b/src/horticulture_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci interpolation module — tsb analytics library. */
+export interface HorticultureSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciInterpolation(data: number[], opts: HorticultureSciInterpolationOptions = {}): HorticultureSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciInterpolation };
diff --git a/src/horticulture_sci/jacobian.ts b/src/horticulture_sci/jacobian.ts
new file mode 100644
index 000000000..bf4a8230c
--- /dev/null
+++ b/src/horticulture_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci jacobian module — tsb analytics library. */
+export interface HorticultureSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciJacobianResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciJacobian(data: number[], opts: HorticultureSciJacobianOptions = {}): HorticultureSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciJacobian };
diff --git a/src/horticulture_sci/kernel.ts b/src/horticulture_sci/kernel.ts
new file mode 100644
index 000000000..05494ec26
--- /dev/null
+++ b/src/horticulture_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci kernel module — tsb analytics library. */
+export interface HorticultureSciKernelOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciKernelResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciKernel(data: number[], opts: HorticultureSciKernelOptions = {}): HorticultureSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciKernel };
diff --git a/src/horticulture_sci/laplacian.ts b/src/horticulture_sci/laplacian.ts
new file mode 100644
index 000000000..8f75f4f7f
--- /dev/null
+++ b/src/horticulture_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci laplacian module — tsb analytics library. */
+export interface HorticultureSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciLaplacian(data: number[], opts: HorticultureSciLaplacianOptions = {}): HorticultureSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciLaplacian };
diff --git a/src/horticulture_sci/learning.ts b/src/horticulture_sci/learning.ts
new file mode 100644
index 000000000..f987c57e5
--- /dev/null
+++ b/src/horticulture_sci/learning.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci learning module — tsb analytics library. */
+export interface HorticultureSciLearningOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciLearningResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciLearning(data: number[], opts: HorticultureSciLearningOptions = {}): HorticultureSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciLearning };
diff --git a/src/horticulture_sci/linear.ts b/src/horticulture_sci/linear.ts
new file mode 100644
index 000000000..ed10e29c5
--- /dev/null
+++ b/src/horticulture_sci/linear.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci linear module — tsb analytics library. */
+export interface HorticultureSciLinearOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciLinearResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciLinear(data: number[], opts: HorticultureSciLinearOptions = {}): HorticultureSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciLinear };
diff --git a/src/horticulture_sci/manifold.ts b/src/horticulture_sci/manifold.ts
new file mode 100644
index 000000000..036cf2c33
--- /dev/null
+++ b/src/horticulture_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci manifold module — tsb analytics library. */
+export interface HorticultureSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciManifoldResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciManifold(data: number[], opts: HorticultureSciManifoldOptions = {}): HorticultureSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciManifold };
diff --git a/src/horticulture_sci/matching.ts b/src/horticulture_sci/matching.ts
new file mode 100644
index 000000000..98bcd2712
--- /dev/null
+++ b/src/horticulture_sci/matching.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci matching module — tsb analytics library. */
+export interface HorticultureSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciMatchingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciMatching(data: number[], opts: HorticultureSciMatchingOptions = {}): HorticultureSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciMatching };
diff --git a/src/horticulture_sci/measurement.ts b/src/horticulture_sci/measurement.ts
new file mode 100644
index 000000000..178214519
--- /dev/null
+++ b/src/horticulture_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci measurement module — tsb analytics library. */
+export interface HorticultureSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciMeasurement(data: number[], opts: HorticultureSciMeasurementOptions = {}): HorticultureSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciMeasurement };
diff --git a/src/horticulture_sci/metrics.ts b/src/horticulture_sci/metrics.ts
new file mode 100644
index 000000000..10eae5915
--- /dev/null
+++ b/src/horticulture_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci metrics module — tsb analytics library. */
+export interface HorticultureSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciMetricsResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciMetrics(data: number[], opts: HorticultureSciMetricsOptions = {}): HorticultureSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciMetrics };
diff --git a/src/horticulture_sci/modeling.ts b/src/horticulture_sci/modeling.ts
new file mode 100644
index 000000000..59c2b35e2
--- /dev/null
+++ b/src/horticulture_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci modeling module — tsb analytics library. */
+export interface HorticultureSciModelingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciModelingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciModeling(data: number[], opts: HorticultureSciModelingOptions = {}): HorticultureSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciModeling };
diff --git a/src/horticulture_sci/monitoring.ts b/src/horticulture_sci/monitoring.ts
new file mode 100644
index 000000000..78a05853c
--- /dev/null
+++ b/src/horticulture_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci monitoring module — tsb analytics library. */
+export interface HorticultureSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciMonitoring(data: number[], opts: HorticultureSciMonitoringOptions = {}): HorticultureSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciMonitoring };
diff --git a/src/horticulture_sci/nonlinear.ts b/src/horticulture_sci/nonlinear.ts
new file mode 100644
index 000000000..74a394f85
--- /dev/null
+++ b/src/horticulture_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci nonlinear module — tsb analytics library. */
+export interface HorticultureSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciNonlinear(data: number[], opts: HorticultureSciNonlinearOptions = {}): HorticultureSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciNonlinear };
diff --git a/src/horticulture_sci/normalization.ts b/src/horticulture_sci/normalization.ts
new file mode 100644
index 000000000..c20ac0e16
--- /dev/null
+++ b/src/horticulture_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci normalization module — tsb analytics library. */
+export interface HorticultureSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciNormalization(data: number[], opts: HorticultureSciNormalizationOptions = {}): HorticultureSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciNormalization };
diff --git a/src/horticulture_sci/optimization.ts b/src/horticulture_sci/optimization.ts
new file mode 100644
index 000000000..7669466da
--- /dev/null
+++ b/src/horticulture_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci optimization module — tsb analytics library. */
+export interface HorticultureSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciOptimization(data: number[], opts: HorticultureSciOptimizationOptions = {}): HorticultureSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciOptimization };
diff --git a/src/horticulture_sci/patterns.ts b/src/horticulture_sci/patterns.ts
new file mode 100644
index 000000000..d376061fc
--- /dev/null
+++ b/src/horticulture_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci patterns module — tsb analytics library. */
+export interface HorticultureSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciPatternsResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciPatterns(data: number[], opts: HorticultureSciPatternsOptions = {}): HorticultureSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciPatterns };
diff --git a/src/horticulture_sci/permutation.ts b/src/horticulture_sci/permutation.ts
new file mode 100644
index 000000000..7854cdb56
--- /dev/null
+++ b/src/horticulture_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci permutation module — tsb analytics library. */
+export interface HorticultureSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciPermutationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciPermutation(data: number[], opts: HorticultureSciPermutationOptions = {}): HorticultureSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciPermutation };
diff --git a/src/horticulture_sci/prediction.ts b/src/horticulture_sci/prediction.ts
new file mode 100644
index 000000000..9f0286c69
--- /dev/null
+++ b/src/horticulture_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci prediction module — tsb analytics library. */
+export interface HorticultureSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciPredictionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciPrediction(data: number[], opts: HorticultureSciPredictionOptions = {}): HorticultureSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciPrediction };
diff --git a/src/horticulture_sci/processing.ts b/src/horticulture_sci/processing.ts
new file mode 100644
index 000000000..f9c0242e9
--- /dev/null
+++ b/src/horticulture_sci/processing.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci processing module — tsb analytics library. */
+export interface HorticultureSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciProcessingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciProcessing(data: number[], opts: HorticultureSciProcessingOptions = {}): HorticultureSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciProcessing };
diff --git a/src/horticulture_sci/profiling.ts b/src/horticulture_sci/profiling.ts
new file mode 100644
index 000000000..140333584
--- /dev/null
+++ b/src/horticulture_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci profiling module — tsb analytics library. */
+export interface HorticultureSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciProfilingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciProfiling(data: number[], opts: HorticultureSciProfilingOptions = {}): HorticultureSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciProfiling };
diff --git a/src/horticulture_sci/projection.ts b/src/horticulture_sci/projection.ts
new file mode 100644
index 000000000..6c32f0ca5
--- /dev/null
+++ b/src/horticulture_sci/projection.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci projection module — tsb analytics library. */
+export interface HorticultureSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciProjectionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciProjection(data: number[], opts: HorticultureSciProjectionOptions = {}): HorticultureSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciProjection };
diff --git a/src/horticulture_sci/ranking.ts b/src/horticulture_sci/ranking.ts
new file mode 100644
index 000000000..dfa9bff42
--- /dev/null
+++ b/src/horticulture_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci ranking module — tsb analytics library. */
+export interface HorticultureSciRankingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciRankingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciRanking(data: number[], opts: HorticultureSciRankingOptions = {}): HorticultureSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciRanking };
diff --git a/src/horticulture_sci/reconstruction.ts b/src/horticulture_sci/reconstruction.ts
new file mode 100644
index 000000000..6b8aa5788
--- /dev/null
+++ b/src/horticulture_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci reconstruction module — tsb analytics library. */
+export interface HorticultureSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciReconstruction(data: number[], opts: HorticultureSciReconstructionOptions = {}): HorticultureSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciReconstruction };
diff --git a/src/horticulture_sci/registration.ts b/src/horticulture_sci/registration.ts
new file mode 100644
index 000000000..948071d21
--- /dev/null
+++ b/src/horticulture_sci/registration.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci registration module — tsb analytics library. */
+export interface HorticultureSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciRegistration(data: number[], opts: HorticultureSciRegistrationOptions = {}): HorticultureSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciRegistration };
diff --git a/src/horticulture_sci/regression.ts b/src/horticulture_sci/regression.ts
new file mode 100644
index 000000000..c4766bff0
--- /dev/null
+++ b/src/horticulture_sci/regression.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci regression module — tsb analytics library. */
+export interface HorticultureSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciRegressionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciRegression(data: number[], opts: HorticultureSciRegressionOptions = {}): HorticultureSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciRegression };
diff --git a/src/horticulture_sci/regularization.ts b/src/horticulture_sci/regularization.ts
new file mode 100644
index 000000000..ba8f5b675
--- /dev/null
+++ b/src/horticulture_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci regularization module — tsb analytics library. */
+export interface HorticultureSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciRegularization(data: number[], opts: HorticultureSciRegularizationOptions = {}): HorticultureSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciRegularization };
diff --git a/src/horticulture_sci/robustness.ts b/src/horticulture_sci/robustness.ts
new file mode 100644
index 000000000..45eca2592
--- /dev/null
+++ b/src/horticulture_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci robustness module — tsb analytics library. */
+export interface HorticultureSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciRobustness(data: number[], opts: HorticultureSciRobustnessOptions = {}): HorticultureSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciRobustness };
diff --git a/src/horticulture_sci/sampling.ts b/src/horticulture_sci/sampling.ts
new file mode 100644
index 000000000..14e14c075
--- /dev/null
+++ b/src/horticulture_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci sampling module — tsb analytics library. */
+export interface HorticultureSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciSamplingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciSampling(data: number[], opts: HorticultureSciSamplingOptions = {}): HorticultureSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciSampling };
diff --git a/src/horticulture_sci/sampling2.ts b/src/horticulture_sci/sampling2.ts
new file mode 100644
index 000000000..4176a003c
--- /dev/null
+++ b/src/horticulture_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci sampling2 module — tsb analytics library. */
+export interface HorticultureSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciSamplingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciSampling(data: number[], opts: HorticultureSciSamplingOptions = {}): HorticultureSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciSampling };
diff --git a/src/horticulture_sci/scaling.ts b/src/horticulture_sci/scaling.ts
new file mode 100644
index 000000000..b3f9d0e93
--- /dev/null
+++ b/src/horticulture_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci scaling module — tsb analytics library. */
+export interface HorticultureSciScalingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciScalingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciScaling(data: number[], opts: HorticultureSciScalingOptions = {}): HorticultureSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciScaling };
diff --git a/src/horticulture_sci/scoring.ts b/src/horticulture_sci/scoring.ts
new file mode 100644
index 000000000..2dc46bce5
--- /dev/null
+++ b/src/horticulture_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci scoring module — tsb analytics library. */
+export interface HorticultureSciScoringOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciScoringResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciScoring(data: number[], opts: HorticultureSciScoringOptions = {}): HorticultureSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciScoring };
diff --git a/src/horticulture_sci/segmentation.ts b/src/horticulture_sci/segmentation.ts
new file mode 100644
index 000000000..6ec3cdd3b
--- /dev/null
+++ b/src/horticulture_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci segmentation module — tsb analytics library. */
+export interface HorticultureSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciSegmentation(data: number[], opts: HorticultureSciSegmentationOptions = {}): HorticultureSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciSegmentation };
diff --git a/src/horticulture_sci/selection.ts b/src/horticulture_sci/selection.ts
new file mode 100644
index 000000000..9c8819a2b
--- /dev/null
+++ b/src/horticulture_sci/selection.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci selection module — tsb analytics library. */
+export interface HorticultureSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciSelectionResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciSelection(data: number[], opts: HorticultureSciSelectionOptions = {}): HorticultureSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciSelection };
diff --git a/src/horticulture_sci/sensitivity.ts b/src/horticulture_sci/sensitivity.ts
new file mode 100644
index 000000000..c7a41d5b5
--- /dev/null
+++ b/src/horticulture_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci sensitivity module — tsb analytics library. */
+export interface HorticultureSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciSensitivity(data: number[], opts: HorticultureSciSensitivityOptions = {}): HorticultureSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciSensitivity };
diff --git a/src/horticulture_sci/simulation.ts b/src/horticulture_sci/simulation.ts
new file mode 100644
index 000000000..a0e4917ca
--- /dev/null
+++ b/src/horticulture_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci simulation module — tsb analytics library. */
+export interface HorticultureSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciSimulationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciSimulation(data: number[], opts: HorticultureSciSimulationOptions = {}): HorticultureSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciSimulation };
diff --git a/src/horticulture_sci/smoothing.ts b/src/horticulture_sci/smoothing.ts
new file mode 100644
index 000000000..ccb9e2657
--- /dev/null
+++ b/src/horticulture_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci smoothing module — tsb analytics library. */
+export interface HorticultureSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciSmoothing(data: number[], opts: HorticultureSciSmoothingOptions = {}): HorticultureSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciSmoothing };
diff --git a/src/horticulture_sci/stability.ts b/src/horticulture_sci/stability.ts
new file mode 100644
index 000000000..050b26aef
--- /dev/null
+++ b/src/horticulture_sci/stability.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci stability module — tsb analytics library. */
+export interface HorticultureSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciStabilityResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciStability(data: number[], opts: HorticultureSciStabilityOptions = {}): HorticultureSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciStability };
diff --git a/src/horticulture_sci/stacking.ts b/src/horticulture_sci/stacking.ts
new file mode 100644
index 000000000..d278a22f8
--- /dev/null
+++ b/src/horticulture_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci stacking module — tsb analytics library. */
+export interface HorticultureSciStackingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciStackingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciStacking(data: number[], opts: HorticultureSciStackingOptions = {}): HorticultureSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciStacking };
diff --git a/src/horticulture_sci/standardization.ts b/src/horticulture_sci/standardization.ts
new file mode 100644
index 000000000..d99ab9ac6
--- /dev/null
+++ b/src/horticulture_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci standardization module — tsb analytics library. */
+export interface HorticultureSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciStandardization(data: number[], opts: HorticultureSciStandardizationOptions = {}): HorticultureSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciStandardization };
diff --git a/src/horticulture_sci/static.ts b/src/horticulture_sci/static.ts
new file mode 100644
index 000000000..f478d60b3
--- /dev/null
+++ b/src/horticulture_sci/static.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci static module — tsb analytics library. */
+export interface HorticultureSciStaticOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciStaticResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciStatic(data: number[], opts: HorticultureSciStaticOptions = {}): HorticultureSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciStatic };
diff --git a/src/horticulture_sci/stochastic.ts b/src/horticulture_sci/stochastic.ts
new file mode 100644
index 000000000..2fb63eda1
--- /dev/null
+++ b/src/horticulture_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci stochastic module — tsb analytics library. */
+export interface HorticultureSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciStochasticResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciStochastic(data: number[], opts: HorticultureSciStochasticOptions = {}): HorticultureSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciStochastic };
diff --git a/src/horticulture_sci/synthesis.ts b/src/horticulture_sci/synthesis.ts
new file mode 100644
index 000000000..8d6a33339
--- /dev/null
+++ b/src/horticulture_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci synthesis module — tsb analytics library. */
+export interface HorticultureSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciSynthesis(data: number[], opts: HorticultureSciSynthesisOptions = {}): HorticultureSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciSynthesis };
diff --git a/src/horticulture_sci/topology.ts b/src/horticulture_sci/topology.ts
new file mode 100644
index 000000000..b40f7db56
--- /dev/null
+++ b/src/horticulture_sci/topology.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci topology module — tsb analytics library. */
+export interface HorticultureSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciTopologyResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciTopology(data: number[], opts: HorticultureSciTopologyOptions = {}): HorticultureSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciTopology };
diff --git a/src/horticulture_sci/tracking.ts b/src/horticulture_sci/tracking.ts
new file mode 100644
index 000000000..8aeb9e09b
--- /dev/null
+++ b/src/horticulture_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci tracking module — tsb analytics library. */
+export interface HorticultureSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciTrackingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciTracking(data: number[], opts: HorticultureSciTrackingOptions = {}): HorticultureSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciTracking };
diff --git a/src/horticulture_sci/transform.ts b/src/horticulture_sci/transform.ts
new file mode 100644
index 000000000..f8f4570e1
--- /dev/null
+++ b/src/horticulture_sci/transform.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci transform module — tsb analytics library. */
+export interface HorticultureSciTransformOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciTransformResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciTransform(data: number[], opts: HorticultureSciTransformOptions = {}): HorticultureSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciTransform };
diff --git a/src/horticulture_sci/uncertainty.ts b/src/horticulture_sci/uncertainty.ts
new file mode 100644
index 000000000..896e299bf
--- /dev/null
+++ b/src/horticulture_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci uncertainty module — tsb analytics library. */
+export interface HorticultureSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciUncertainty(data: number[], opts: HorticultureSciUncertaintyOptions = {}): HorticultureSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciUncertainty };
diff --git a/src/horticulture_sci/validation.ts b/src/horticulture_sci/validation.ts
new file mode 100644
index 000000000..fbf1dc91b
--- /dev/null
+++ b/src/horticulture_sci/validation.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci validation module — tsb analytics library. */
+export interface HorticultureSciValidationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciValidationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciValidation(data: number[], opts: HorticultureSciValidationOptions = {}): HorticultureSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciValidation };
diff --git a/src/horticulture_sci/verification.ts b/src/horticulture_sci/verification.ts
new file mode 100644
index 000000000..06d616aad
--- /dev/null
+++ b/src/horticulture_sci/verification.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci verification module — tsb analytics library. */
+export interface HorticultureSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciVerificationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciVerification(data: number[], opts: HorticultureSciVerificationOptions = {}): HorticultureSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciVerification };
diff --git a/src/horticulture_sci/visualization.ts b/src/horticulture_sci/visualization.ts
new file mode 100644
index 000000000..a42105fad
--- /dev/null
+++ b/src/horticulture_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci visualization module — tsb analytics library. */
+export interface HorticultureSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciVisualization(data: number[], opts: HorticultureSciVisualizationOptions = {}): HorticultureSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciVisualization };
diff --git a/src/horticulture_sci/voting.ts b/src/horticulture_sci/voting.ts
new file mode 100644
index 000000000..9af139dfd
--- /dev/null
+++ b/src/horticulture_sci/voting.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci voting module — tsb analytics library. */
+export interface HorticultureSciVotingOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciVotingResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciVoting(data: number[], opts: HorticultureSciVotingOptions = {}): HorticultureSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciVoting };
diff --git a/src/horticulture_sci/wavelet.ts b/src/horticulture_sci/wavelet.ts
new file mode 100644
index 000000000..ba4c5b21f
--- /dev/null
+++ b/src/horticulture_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** horticulture_sci wavelet module — tsb analytics library. */
+export interface HorticultureSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface HorticultureSciWaveletResult { values: number[]; converged: boolean; }
+export function computeHorticultureSciWavelet(data: number[], opts: HorticultureSciWaveletOptions = {}): HorticultureSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHorticultureSciWavelet };
diff --git a/src/hydrology_sci/adaptation.ts b/src/hydrology_sci/adaptation.ts
new file mode 100644
index 000000000..17cf1176e
--- /dev/null
+++ b/src/hydrology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci adaptation module — tsb analytics library. */
+export interface HydrologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciAdaptation(data: number[], opts: HydrologySciAdaptationOptions = {}): HydrologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciAdaptation };
diff --git a/src/hydrology_sci/aggregation.ts b/src/hydrology_sci/aggregation.ts
new file mode 100644
index 000000000..c168cc1ab
--- /dev/null
+++ b/src/hydrology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci aggregation module — tsb analytics library. */
+export interface HydrologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciAggregation(data: number[], opts: HydrologySciAggregationOptions = {}): HydrologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciAggregation };
diff --git a/src/hydrology_sci/algebra.ts b/src/hydrology_sci/algebra.ts
new file mode 100644
index 000000000..9904b8f16
--- /dev/null
+++ b/src/hydrology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci algebra module — tsb analytics library. */
+export interface HydrologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeHydrologySciAlgebra(data: number[], opts: HydrologySciAlgebraOptions = {}): HydrologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciAlgebra };
diff --git a/src/hydrology_sci/alignment.ts b/src/hydrology_sci/alignment.ts
new file mode 100644
index 000000000..916fa563a
--- /dev/null
+++ b/src/hydrology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci alignment module — tsb analytics library. */
+export interface HydrologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeHydrologySciAlignment(data: number[], opts: HydrologySciAlignmentOptions = {}): HydrologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciAlignment };
diff --git a/src/hydrology_sci/analysis.ts b/src/hydrology_sci/analysis.ts
new file mode 100644
index 000000000..d937a2133
--- /dev/null
+++ b/src/hydrology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci analysis module — tsb analytics library. */
+export interface HydrologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeHydrologySciAnalysis(data: number[], opts: HydrologySciAnalysisOptions = {}): HydrologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciAnalysis };
diff --git a/src/hydrology_sci/augmentation.ts b/src/hydrology_sci/augmentation.ts
new file mode 100644
index 000000000..a93bf406a
--- /dev/null
+++ b/src/hydrology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci augmentation module — tsb analytics library. */
+export interface HydrologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciAugmentation(data: number[], opts: HydrologySciAugmentationOptions = {}): HydrologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciAugmentation };
diff --git a/src/hydrology_sci/bagging.ts b/src/hydrology_sci/bagging.ts
new file mode 100644
index 000000000..d77767609
--- /dev/null
+++ b/src/hydrology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci bagging module — tsb analytics library. */
+export interface HydrologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciBagging(data: number[], opts: HydrologySciBaggingOptions = {}): HydrologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciBagging };
diff --git a/src/hydrology_sci/basis.ts b/src/hydrology_sci/basis.ts
new file mode 100644
index 000000000..bee5f34a6
--- /dev/null
+++ b/src/hydrology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci basis module — tsb analytics library. */
+export interface HydrologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciBasisResult { values: number[]; converged: boolean; }
+export function computeHydrologySciBasis(data: number[], opts: HydrologySciBasisOptions = {}): HydrologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciBasis };
diff --git a/src/hydrology_sci/benchmarking.ts b/src/hydrology_sci/benchmarking.ts
new file mode 100644
index 000000000..985a90041
--- /dev/null
+++ b/src/hydrology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci benchmarking module — tsb analytics library. */
+export interface HydrologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciBenchmarking(data: number[], opts: HydrologySciBenchmarkingOptions = {}): HydrologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciBenchmarking };
diff --git a/src/hydrology_sci/blending.ts b/src/hydrology_sci/blending.ts
new file mode 100644
index 000000000..a2d647b60
--- /dev/null
+++ b/src/hydrology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci blending module — tsb analytics library. */
+export interface HydrologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciBlending(data: number[], opts: HydrologySciBlendingOptions = {}): HydrologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciBlending };
diff --git a/src/hydrology_sci/boosting.ts b/src/hydrology_sci/boosting.ts
new file mode 100644
index 000000000..3530b1889
--- /dev/null
+++ b/src/hydrology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci boosting module — tsb analytics library. */
+export interface HydrologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciBoosting(data: number[], opts: HydrologySciBoostingOptions = {}): HydrologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciBoosting };
diff --git a/src/hydrology_sci/bootstrap.ts b/src/hydrology_sci/bootstrap.ts
new file mode 100644
index 000000000..efb62c030
--- /dev/null
+++ b/src/hydrology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci bootstrap module — tsb analytics library. */
+export interface HydrologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeHydrologySciBootstrap(data: number[], opts: HydrologySciBootstrapOptions = {}): HydrologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciBootstrap };
diff --git a/src/hydrology_sci/calculus.ts b/src/hydrology_sci/calculus.ts
new file mode 100644
index 000000000..04f7b43f3
--- /dev/null
+++ b/src/hydrology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci calculus module — tsb analytics library. */
+export interface HydrologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeHydrologySciCalculus(data: number[], opts: HydrologySciCalculusOptions = {}): HydrologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciCalculus };
diff --git a/src/hydrology_sci/calibration.ts b/src/hydrology_sci/calibration.ts
new file mode 100644
index 000000000..a8c0cbb4c
--- /dev/null
+++ b/src/hydrology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci calibration module — tsb analytics library. */
+export interface HydrologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciCalibration(data: number[], opts: HydrologySciCalibrationOptions = {}): HydrologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciCalibration };
diff --git a/src/hydrology_sci/characterization.ts b/src/hydrology_sci/characterization.ts
new file mode 100644
index 000000000..6c930cd3f
--- /dev/null
+++ b/src/hydrology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci characterization module — tsb analytics library. */
+export interface HydrologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciCharacterization(data: number[], opts: HydrologySciCharacterizationOptions = {}): HydrologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciCharacterization };
diff --git a/src/hydrology_sci/classification.ts b/src/hydrology_sci/classification.ts
new file mode 100644
index 000000000..25f923e07
--- /dev/null
+++ b/src/hydrology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci classification module — tsb analytics library. */
+export interface HydrologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciClassification(data: number[], opts: HydrologySciClassificationOptions = {}): HydrologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciClassification };
diff --git a/src/hydrology_sci/clustering.ts b/src/hydrology_sci/clustering.ts
new file mode 100644
index 000000000..2adece065
--- /dev/null
+++ b/src/hydrology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci clustering module — tsb analytics library. */
+export interface HydrologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeHydrologySciClustering(data: number[], opts: HydrologySciClusteringOptions = {}): HydrologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciClustering };
diff --git a/src/hydrology_sci/compression.ts b/src/hydrology_sci/compression.ts
new file mode 100644
index 000000000..5da7b34eb
--- /dev/null
+++ b/src/hydrology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci compression module — tsb analytics library. */
+export interface HydrologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciCompression(data: number[], opts: HydrologySciCompressionOptions = {}): HydrologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciCompression };
diff --git a/src/hydrology_sci/continuous.ts b/src/hydrology_sci/continuous.ts
new file mode 100644
index 000000000..23ec8e9ff
--- /dev/null
+++ b/src/hydrology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci continuous module — tsb analytics library. */
+export interface HydrologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeHydrologySciContinuous(data: number[], opts: HydrologySciContinuousOptions = {}): HydrologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciContinuous };
diff --git a/src/hydrology_sci/control.ts b/src/hydrology_sci/control.ts
new file mode 100644
index 000000000..ea597f547
--- /dev/null
+++ b/src/hydrology_sci/control.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci control module — tsb analytics library. */
+export interface HydrologySciControlOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciControlResult { values: number[]; converged: boolean; }
+export function computeHydrologySciControl(data: number[], opts: HydrologySciControlOptions = {}): HydrologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciControl };
diff --git a/src/hydrology_sci/convergence.ts b/src/hydrology_sci/convergence.ts
new file mode 100644
index 000000000..7e7017aa0
--- /dev/null
+++ b/src/hydrology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci convergence module — tsb analytics library. */
+export interface HydrologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeHydrologySciConvergence(data: number[], opts: HydrologySciConvergenceOptions = {}): HydrologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciConvergence };
diff --git a/src/hydrology_sci/convex.ts b/src/hydrology_sci/convex.ts
new file mode 100644
index 000000000..65df04075
--- /dev/null
+++ b/src/hydrology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci convex module — tsb analytics library. */
+export interface HydrologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciConvexResult { values: number[]; converged: boolean; }
+export function computeHydrologySciConvex(data: number[], opts: HydrologySciConvexOptions = {}): HydrologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciConvex };
diff --git a/src/hydrology_sci/correlation.ts b/src/hydrology_sci/correlation.ts
new file mode 100644
index 000000000..d863d29ad
--- /dev/null
+++ b/src/hydrology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci correlation module — tsb analytics library. */
+export interface HydrologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciCorrelation(data: number[], opts: HydrologySciCorrelationOptions = {}): HydrologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciCorrelation };
diff --git a/src/hydrology_sci/covariance.ts b/src/hydrology_sci/covariance.ts
new file mode 100644
index 000000000..e117ae9c5
--- /dev/null
+++ b/src/hydrology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci covariance module — tsb analytics library. */
+export interface HydrologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeHydrologySciCovariance(data: number[], opts: HydrologySciCovarianceOptions = {}): HydrologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciCovariance };
diff --git a/src/hydrology_sci/cross_validation.ts b/src/hydrology_sci/cross_validation.ts
new file mode 100644
index 000000000..5f1066185
--- /dev/null
+++ b/src/hydrology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci cross_validation module — tsb analytics library. */
+export interface HydrologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciCrossValidation(data: number[], opts: HydrologySciCrossValidationOptions = {}): HydrologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciCrossValidation };
diff --git a/src/hydrology_sci/decoding.ts b/src/hydrology_sci/decoding.ts
new file mode 100644
index 000000000..8a54d4fc4
--- /dev/null
+++ b/src/hydrology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci decoding module — tsb analytics library. */
+export interface HydrologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDecoding(data: number[], opts: HydrologySciDecodingOptions = {}): HydrologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDecoding };
diff --git a/src/hydrology_sci/decomposition.ts b/src/hydrology_sci/decomposition.ts
new file mode 100644
index 000000000..db2338d31
--- /dev/null
+++ b/src/hydrology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci decomposition module — tsb analytics library. */
+export interface HydrologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDecomposition(data: number[], opts: HydrologySciDecompositionOptions = {}): HydrologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDecomposition };
diff --git a/src/hydrology_sci/detection.ts b/src/hydrology_sci/detection.ts
new file mode 100644
index 000000000..60374379a
--- /dev/null
+++ b/src/hydrology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci detection module — tsb analytics library. */
+export interface HydrologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDetection(data: number[], opts: HydrologySciDetectionOptions = {}): HydrologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDetection };
diff --git a/src/hydrology_sci/deterministic.ts b/src/hydrology_sci/deterministic.ts
new file mode 100644
index 000000000..72dca7898
--- /dev/null
+++ b/src/hydrology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci deterministic module — tsb analytics library. */
+export interface HydrologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDeterministic(data: number[], opts: HydrologySciDeterministicOptions = {}): HydrologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDeterministic };
diff --git a/src/hydrology_sci/diagnostics.ts b/src/hydrology_sci/diagnostics.ts
new file mode 100644
index 000000000..90b333392
--- /dev/null
+++ b/src/hydrology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci diagnostics module — tsb analytics library. */
+export interface HydrologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDiagnostics(data: number[], opts: HydrologySciDiagnosticsOptions = {}): HydrologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDiagnostics };
diff --git a/src/hydrology_sci/differential.ts b/src/hydrology_sci/differential.ts
new file mode 100644
index 000000000..221492653
--- /dev/null
+++ b/src/hydrology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci differential module — tsb analytics library. */
+export interface HydrologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDifferential(data: number[], opts: HydrologySciDifferentialOptions = {}): HydrologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDifferential };
diff --git a/src/hydrology_sci/discrete.ts b/src/hydrology_sci/discrete.ts
new file mode 100644
index 000000000..028615f6d
--- /dev/null
+++ b/src/hydrology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci discrete module — tsb analytics library. */
+export interface HydrologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDiscrete(data: number[], opts: HydrologySciDiscreteOptions = {}): HydrologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDiscrete };
diff --git a/src/hydrology_sci/distribution.ts b/src/hydrology_sci/distribution.ts
new file mode 100644
index 000000000..7605964e6
--- /dev/null
+++ b/src/hydrology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci distribution module — tsb analytics library. */
+export interface HydrologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDistribution(data: number[], opts: HydrologySciDistributionOptions = {}): HydrologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDistribution };
diff --git a/src/hydrology_sci/dynamic.ts b/src/hydrology_sci/dynamic.ts
new file mode 100644
index 000000000..b3da41a2e
--- /dev/null
+++ b/src/hydrology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci dynamic module — tsb analytics library. */
+export interface HydrologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeHydrologySciDynamic(data: number[], opts: HydrologySciDynamicOptions = {}): HydrologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciDynamic };
diff --git a/src/hydrology_sci/embedding.ts b/src/hydrology_sci/embedding.ts
new file mode 100644
index 000000000..39e1003b8
--- /dev/null
+++ b/src/hydrology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci embedding module — tsb analytics library. */
+export interface HydrologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciEmbedding(data: number[], opts: HydrologySciEmbeddingOptions = {}): HydrologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciEmbedding };
diff --git a/src/hydrology_sci/encoding.ts b/src/hydrology_sci/encoding.ts
new file mode 100644
index 000000000..5b64346d8
--- /dev/null
+++ b/src/hydrology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci encoding module — tsb analytics library. */
+export interface HydrologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciEncoding(data: number[], opts: HydrologySciEncodingOptions = {}): HydrologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciEncoding };
diff --git a/src/hydrology_sci/ensemble.ts b/src/hydrology_sci/ensemble.ts
new file mode 100644
index 000000000..8cb5d97a2
--- /dev/null
+++ b/src/hydrology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci ensemble module — tsb analytics library. */
+export interface HydrologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeHydrologySciEnsemble(data: number[], opts: HydrologySciEnsembleOptions = {}): HydrologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciEnsemble };
diff --git a/src/hydrology_sci/estimation.ts b/src/hydrology_sci/estimation.ts
new file mode 100644
index 000000000..b2e160548
--- /dev/null
+++ b/src/hydrology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci estimation module — tsb analytics library. */
+export interface HydrologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciEstimation(data: number[], opts: HydrologySciEstimationOptions = {}): HydrologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciEstimation };
diff --git a/src/hydrology_sci/evaluation.ts b/src/hydrology_sci/evaluation.ts
new file mode 100644
index 000000000..faa2e637e
--- /dev/null
+++ b/src/hydrology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci evaluation module — tsb analytics library. */
+export interface HydrologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciEvaluation(data: number[], opts: HydrologySciEvaluationOptions = {}): HydrologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciEvaluation };
diff --git a/src/hydrology_sci/extrapolation.ts b/src/hydrology_sci/extrapolation.ts
new file mode 100644
index 000000000..f07cf2e4b
--- /dev/null
+++ b/src/hydrology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci extrapolation module — tsb analytics library. */
+export interface HydrologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciExtrapolation(data: number[], opts: HydrologySciExtrapolationOptions = {}): HydrologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciExtrapolation };
diff --git a/src/hydrology_sci/features.ts b/src/hydrology_sci/features.ts
new file mode 100644
index 000000000..20987aabe
--- /dev/null
+++ b/src/hydrology_sci/features.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci features module — tsb analytics library. */
+export interface HydrologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeHydrologySciFeatures(data: number[], opts: HydrologySciFeaturesOptions = {}): HydrologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciFeatures };
diff --git a/src/hydrology_sci/feedback.ts b/src/hydrology_sci/feedback.ts
new file mode 100644
index 000000000..aee3fdab5
--- /dev/null
+++ b/src/hydrology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci feedback module — tsb analytics library. */
+export interface HydrologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeHydrologySciFeedback(data: number[], opts: HydrologySciFeedbackOptions = {}): HydrologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciFeedback };
diff --git a/src/hydrology_sci/filtering.ts b/src/hydrology_sci/filtering.ts
new file mode 100644
index 000000000..75e1acf91
--- /dev/null
+++ b/src/hydrology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci filtering module — tsb analytics library. */
+export interface HydrologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeHydrologySciFiltering(data: number[], opts: HydrologySciFilteringOptions = {}): HydrologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciFiltering };
diff --git a/src/hydrology_sci/fourier.ts b/src/hydrology_sci/fourier.ts
new file mode 100644
index 000000000..8f8bf8277
--- /dev/null
+++ b/src/hydrology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci fourier module — tsb analytics library. */
+export interface HydrologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciFourierResult { values: number[]; converged: boolean; }
+export function computeHydrologySciFourier(data: number[], opts: HydrologySciFourierOptions = {}): HydrologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciFourier };
diff --git a/src/hydrology_sci/fusion.ts b/src/hydrology_sci/fusion.ts
new file mode 100644
index 000000000..a43ae6549
--- /dev/null
+++ b/src/hydrology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci fusion module — tsb analytics library. */
+export interface HydrologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciFusionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciFusion(data: number[], opts: HydrologySciFusionOptions = {}): HydrologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciFusion };
diff --git a/src/hydrology_sci/generation.ts b/src/hydrology_sci/generation.ts
new file mode 100644
index 000000000..28748d56e
--- /dev/null
+++ b/src/hydrology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci generation module — tsb analytics library. */
+export interface HydrologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciGeneration(data: number[], opts: HydrologySciGenerationOptions = {}): HydrologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciGeneration };
diff --git a/src/hydrology_sci/geometry.ts b/src/hydrology_sci/geometry.ts
new file mode 100644
index 000000000..7b20d645e
--- /dev/null
+++ b/src/hydrology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci geometry module — tsb analytics library. */
+export interface HydrologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeHydrologySciGeometry(data: number[], opts: HydrologySciGeometryOptions = {}): HydrologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciGeometry };
diff --git a/src/hydrology_sci/gradient.ts b/src/hydrology_sci/gradient.ts
new file mode 100644
index 000000000..007fc9d43
--- /dev/null
+++ b/src/hydrology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci gradient module — tsb analytics library. */
+export interface HydrologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciGradientResult { values: number[]; converged: boolean; }
+export function computeHydrologySciGradient(data: number[], opts: HydrologySciGradientOptions = {}): HydrologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciGradient };
diff --git a/src/hydrology_sci/hessian.ts b/src/hydrology_sci/hessian.ts
new file mode 100644
index 000000000..21b45ea14
--- /dev/null
+++ b/src/hydrology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci hessian module — tsb analytics library. */
+export interface HydrologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciHessianResult { values: number[]; converged: boolean; }
+export function computeHydrologySciHessian(data: number[], opts: HydrologySciHessianOptions = {}): HydrologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciHessian };
diff --git a/src/hydrology_sci/hypothesis.ts b/src/hydrology_sci/hypothesis.ts
new file mode 100644
index 000000000..a880aaf02
--- /dev/null
+++ b/src/hydrology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci hypothesis module — tsb analytics library. */
+export interface HydrologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeHydrologySciHypothesis(data: number[], opts: HydrologySciHypothesisOptions = {}): HydrologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciHypothesis };
diff --git a/src/hydrology_sci/inference.ts b/src/hydrology_sci/inference.ts
new file mode 100644
index 000000000..9a888183f
--- /dev/null
+++ b/src/hydrology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci inference module — tsb analytics library. */
+export interface HydrologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeHydrologySciInference(data: number[], opts: HydrologySciInferenceOptions = {}): HydrologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciInference };
diff --git a/src/hydrology_sci/inference2.ts b/src/hydrology_sci/inference2.ts
new file mode 100644
index 000000000..a970b4e0d
--- /dev/null
+++ b/src/hydrology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci inference2 module — tsb analytics library. */
+export interface HydrologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeHydrologySciInference(data: number[], opts: HydrologySciInferenceOptions = {}): HydrologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciInference };
diff --git a/src/hydrology_sci/integral.ts b/src/hydrology_sci/integral.ts
new file mode 100644
index 000000000..d80d81943
--- /dev/null
+++ b/src/hydrology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci integral module — tsb analytics library. */
+export interface HydrologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeHydrologySciIntegral(data: number[], opts: HydrologySciIntegralOptions = {}): HydrologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciIntegral };
diff --git a/src/hydrology_sci/integration.ts b/src/hydrology_sci/integration.ts
new file mode 100644
index 000000000..7072db779
--- /dev/null
+++ b/src/hydrology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci integration module — tsb analytics library. */
+export interface HydrologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciIntegration(data: number[], opts: HydrologySciIntegrationOptions = {}): HydrologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciIntegration };
diff --git a/src/hydrology_sci/interpolation.ts b/src/hydrology_sci/interpolation.ts
new file mode 100644
index 000000000..ba4c7952e
--- /dev/null
+++ b/src/hydrology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci interpolation module — tsb analytics library. */
+export interface HydrologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciInterpolation(data: number[], opts: HydrologySciInterpolationOptions = {}): HydrologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciInterpolation };
diff --git a/src/hydrology_sci/jacobian.ts b/src/hydrology_sci/jacobian.ts
new file mode 100644
index 000000000..c449b7335
--- /dev/null
+++ b/src/hydrology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci jacobian module — tsb analytics library. */
+export interface HydrologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeHydrologySciJacobian(data: number[], opts: HydrologySciJacobianOptions = {}): HydrologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciJacobian };
diff --git a/src/hydrology_sci/kernel.ts b/src/hydrology_sci/kernel.ts
new file mode 100644
index 000000000..37f960301
--- /dev/null
+++ b/src/hydrology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci kernel module — tsb analytics library. */
+export interface HydrologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciKernelResult { values: number[]; converged: boolean; }
+export function computeHydrologySciKernel(data: number[], opts: HydrologySciKernelOptions = {}): HydrologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciKernel };
diff --git a/src/hydrology_sci/laplacian.ts b/src/hydrology_sci/laplacian.ts
new file mode 100644
index 000000000..fcab46a98
--- /dev/null
+++ b/src/hydrology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci laplacian module — tsb analytics library. */
+export interface HydrologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeHydrologySciLaplacian(data: number[], opts: HydrologySciLaplacianOptions = {}): HydrologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciLaplacian };
diff --git a/src/hydrology_sci/learning.ts b/src/hydrology_sci/learning.ts
new file mode 100644
index 000000000..7c641ad8e
--- /dev/null
+++ b/src/hydrology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci learning module — tsb analytics library. */
+export interface HydrologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciLearningResult { values: number[]; converged: boolean; }
+export function computeHydrologySciLearning(data: number[], opts: HydrologySciLearningOptions = {}): HydrologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciLearning };
diff --git a/src/hydrology_sci/linear.ts b/src/hydrology_sci/linear.ts
new file mode 100644
index 000000000..e6b65c7b2
--- /dev/null
+++ b/src/hydrology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci linear module — tsb analytics library. */
+export interface HydrologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciLinearResult { values: number[]; converged: boolean; }
+export function computeHydrologySciLinear(data: number[], opts: HydrologySciLinearOptions = {}): HydrologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciLinear };
diff --git a/src/hydrology_sci/manifold.ts b/src/hydrology_sci/manifold.ts
new file mode 100644
index 000000000..e1c220388
--- /dev/null
+++ b/src/hydrology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci manifold module — tsb analytics library. */
+export interface HydrologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeHydrologySciManifold(data: number[], opts: HydrologySciManifoldOptions = {}): HydrologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciManifold };
diff --git a/src/hydrology_sci/matching.ts b/src/hydrology_sci/matching.ts
new file mode 100644
index 000000000..ad1338d7e
--- /dev/null
+++ b/src/hydrology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci matching module — tsb analytics library. */
+export interface HydrologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciMatching(data: number[], opts: HydrologySciMatchingOptions = {}): HydrologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciMatching };
diff --git a/src/hydrology_sci/measurement.ts b/src/hydrology_sci/measurement.ts
new file mode 100644
index 000000000..cd131d1a7
--- /dev/null
+++ b/src/hydrology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci measurement module — tsb analytics library. */
+export interface HydrologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeHydrologySciMeasurement(data: number[], opts: HydrologySciMeasurementOptions = {}): HydrologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciMeasurement };
diff --git a/src/hydrology_sci/metrics.ts b/src/hydrology_sci/metrics.ts
new file mode 100644
index 000000000..047d00eaa
--- /dev/null
+++ b/src/hydrology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci metrics module — tsb analytics library. */
+export interface HydrologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeHydrologySciMetrics(data: number[], opts: HydrologySciMetricsOptions = {}): HydrologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciMetrics };
diff --git a/src/hydrology_sci/modeling.ts b/src/hydrology_sci/modeling.ts
new file mode 100644
index 000000000..e7a826e8c
--- /dev/null
+++ b/src/hydrology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci modeling module — tsb analytics library. */
+export interface HydrologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciModelingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciModeling(data: number[], opts: HydrologySciModelingOptions = {}): HydrologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciModeling };
diff --git a/src/hydrology_sci/monitoring.ts b/src/hydrology_sci/monitoring.ts
new file mode 100644
index 000000000..1d09a65ea
--- /dev/null
+++ b/src/hydrology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci monitoring module — tsb analytics library. */
+export interface HydrologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeHydrologySciMonitoring(data: number[], opts: HydrologySciMonitoringOptions = {}): HydrologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciMonitoring };
diff --git a/src/hydrology_sci/nonlinear.ts b/src/hydrology_sci/nonlinear.ts
new file mode 100644
index 000000000..78b00144d
--- /dev/null
+++ b/src/hydrology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci nonlinear module — tsb analytics library. */
+export interface HydrologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeHydrologySciNonlinear(data: number[], opts: HydrologySciNonlinearOptions = {}): HydrologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciNonlinear };
diff --git a/src/hydrology_sci/normalization.ts b/src/hydrology_sci/normalization.ts
new file mode 100644
index 000000000..de62d3067
--- /dev/null
+++ b/src/hydrology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci normalization module — tsb analytics library. */
+export interface HydrologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciNormalization(data: number[], opts: HydrologySciNormalizationOptions = {}): HydrologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciNormalization };
diff --git a/src/hydrology_sci/optimization.ts b/src/hydrology_sci/optimization.ts
new file mode 100644
index 000000000..0cc039f0f
--- /dev/null
+++ b/src/hydrology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci optimization module — tsb analytics library. */
+export interface HydrologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciOptimization(data: number[], opts: HydrologySciOptimizationOptions = {}): HydrologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciOptimization };
diff --git a/src/hydrology_sci/patterns.ts b/src/hydrology_sci/patterns.ts
new file mode 100644
index 000000000..61e182641
--- /dev/null
+++ b/src/hydrology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci patterns module — tsb analytics library. */
+export interface HydrologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeHydrologySciPatterns(data: number[], opts: HydrologySciPatternsOptions = {}): HydrologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciPatterns };
diff --git a/src/hydrology_sci/permutation.ts b/src/hydrology_sci/permutation.ts
new file mode 100644
index 000000000..57e438373
--- /dev/null
+++ b/src/hydrology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci permutation module — tsb analytics library. */
+export interface HydrologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciPermutation(data: number[], opts: HydrologySciPermutationOptions = {}): HydrologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciPermutation };
diff --git a/src/hydrology_sci/prediction.ts b/src/hydrology_sci/prediction.ts
new file mode 100644
index 000000000..fcdc8a347
--- /dev/null
+++ b/src/hydrology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci prediction module — tsb analytics library. */
+export interface HydrologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciPrediction(data: number[], opts: HydrologySciPredictionOptions = {}): HydrologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciPrediction };
diff --git a/src/hydrology_sci/processing.ts b/src/hydrology_sci/processing.ts
new file mode 100644
index 000000000..02759240e
--- /dev/null
+++ b/src/hydrology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci processing module — tsb analytics library. */
+export interface HydrologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciProcessing(data: number[], opts: HydrologySciProcessingOptions = {}): HydrologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciProcessing };
diff --git a/src/hydrology_sci/profiling.ts b/src/hydrology_sci/profiling.ts
new file mode 100644
index 000000000..68260994e
--- /dev/null
+++ b/src/hydrology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci profiling module — tsb analytics library. */
+export interface HydrologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciProfiling(data: number[], opts: HydrologySciProfilingOptions = {}): HydrologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciProfiling };
diff --git a/src/hydrology_sci/projection.ts b/src/hydrology_sci/projection.ts
new file mode 100644
index 000000000..d10b4e62d
--- /dev/null
+++ b/src/hydrology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci projection module — tsb analytics library. */
+export interface HydrologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciProjection(data: number[], opts: HydrologySciProjectionOptions = {}): HydrologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciProjection };
diff --git a/src/hydrology_sci/ranking.ts b/src/hydrology_sci/ranking.ts
new file mode 100644
index 000000000..02508f191
--- /dev/null
+++ b/src/hydrology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci ranking module — tsb analytics library. */
+export interface HydrologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciRankingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciRanking(data: number[], opts: HydrologySciRankingOptions = {}): HydrologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciRanking };
diff --git a/src/hydrology_sci/reconstruction.ts b/src/hydrology_sci/reconstruction.ts
new file mode 100644
index 000000000..6a06721d5
--- /dev/null
+++ b/src/hydrology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci reconstruction module — tsb analytics library. */
+export interface HydrologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciReconstruction(data: number[], opts: HydrologySciReconstructionOptions = {}): HydrologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciReconstruction };
diff --git a/src/hydrology_sci/registration.ts b/src/hydrology_sci/registration.ts
new file mode 100644
index 000000000..98028a4a2
--- /dev/null
+++ b/src/hydrology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci registration module — tsb analytics library. */
+export interface HydrologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciRegistration(data: number[], opts: HydrologySciRegistrationOptions = {}): HydrologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciRegistration };
diff --git a/src/hydrology_sci/regression.ts b/src/hydrology_sci/regression.ts
new file mode 100644
index 000000000..773899ad1
--- /dev/null
+++ b/src/hydrology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci regression module — tsb analytics library. */
+export interface HydrologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciRegression(data: number[], opts: HydrologySciRegressionOptions = {}): HydrologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciRegression };
diff --git a/src/hydrology_sci/regularization.ts b/src/hydrology_sci/regularization.ts
new file mode 100644
index 000000000..f307d43f7
--- /dev/null
+++ b/src/hydrology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci regularization module — tsb analytics library. */
+export interface HydrologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciRegularization(data: number[], opts: HydrologySciRegularizationOptions = {}): HydrologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciRegularization };
diff --git a/src/hydrology_sci/robustness.ts b/src/hydrology_sci/robustness.ts
new file mode 100644
index 000000000..195952874
--- /dev/null
+++ b/src/hydrology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci robustness module — tsb analytics library. */
+export interface HydrologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeHydrologySciRobustness(data: number[], opts: HydrologySciRobustnessOptions = {}): HydrologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciRobustness };
diff --git a/src/hydrology_sci/sampling.ts b/src/hydrology_sci/sampling.ts
new file mode 100644
index 000000000..42e995b2c
--- /dev/null
+++ b/src/hydrology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci sampling module — tsb analytics library. */
+export interface HydrologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciSampling(data: number[], opts: HydrologySciSamplingOptions = {}): HydrologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciSampling };
diff --git a/src/hydrology_sci/sampling2.ts b/src/hydrology_sci/sampling2.ts
new file mode 100644
index 000000000..d289cb188
--- /dev/null
+++ b/src/hydrology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci sampling2 module — tsb analytics library. */
+export interface HydrologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciSampling(data: number[], opts: HydrologySciSamplingOptions = {}): HydrologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciSampling };
diff --git a/src/hydrology_sci/scaling.ts b/src/hydrology_sci/scaling.ts
new file mode 100644
index 000000000..aaefc57f8
--- /dev/null
+++ b/src/hydrology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci scaling module — tsb analytics library. */
+export interface HydrologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciScalingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciScaling(data: number[], opts: HydrologySciScalingOptions = {}): HydrologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciScaling };
diff --git a/src/hydrology_sci/scoring.ts b/src/hydrology_sci/scoring.ts
new file mode 100644
index 000000000..c6cfa2db2
--- /dev/null
+++ b/src/hydrology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci scoring module — tsb analytics library. */
+export interface HydrologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciScoringResult { values: number[]; converged: boolean; }
+export function computeHydrologySciScoring(data: number[], opts: HydrologySciScoringOptions = {}): HydrologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciScoring };
diff --git a/src/hydrology_sci/segmentation.ts b/src/hydrology_sci/segmentation.ts
new file mode 100644
index 000000000..7aeebc459
--- /dev/null
+++ b/src/hydrology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci segmentation module — tsb analytics library. */
+export interface HydrologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciSegmentation(data: number[], opts: HydrologySciSegmentationOptions = {}): HydrologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciSegmentation };
diff --git a/src/hydrology_sci/selection.ts b/src/hydrology_sci/selection.ts
new file mode 100644
index 000000000..39d70fcc1
--- /dev/null
+++ b/src/hydrology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci selection module — tsb analytics library. */
+export interface HydrologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeHydrologySciSelection(data: number[], opts: HydrologySciSelectionOptions = {}): HydrologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciSelection };
diff --git a/src/hydrology_sci/sensitivity.ts b/src/hydrology_sci/sensitivity.ts
new file mode 100644
index 000000000..f44d804ad
--- /dev/null
+++ b/src/hydrology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci sensitivity module — tsb analytics library. */
+export interface HydrologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeHydrologySciSensitivity(data: number[], opts: HydrologySciSensitivityOptions = {}): HydrologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciSensitivity };
diff --git a/src/hydrology_sci/simulation.ts b/src/hydrology_sci/simulation.ts
new file mode 100644
index 000000000..3e337f4de
--- /dev/null
+++ b/src/hydrology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci simulation module — tsb analytics library. */
+export interface HydrologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciSimulation(data: number[], opts: HydrologySciSimulationOptions = {}): HydrologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciSimulation };
diff --git a/src/hydrology_sci/smoothing.ts b/src/hydrology_sci/smoothing.ts
new file mode 100644
index 000000000..656538e83
--- /dev/null
+++ b/src/hydrology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci smoothing module — tsb analytics library. */
+export interface HydrologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciSmoothing(data: number[], opts: HydrologySciSmoothingOptions = {}): HydrologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciSmoothing };
diff --git a/src/hydrology_sci/stability.ts b/src/hydrology_sci/stability.ts
new file mode 100644
index 000000000..37a8c19c9
--- /dev/null
+++ b/src/hydrology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci stability module — tsb analytics library. */
+export interface HydrologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeHydrologySciStability(data: number[], opts: HydrologySciStabilityOptions = {}): HydrologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciStability };
diff --git a/src/hydrology_sci/stacking.ts b/src/hydrology_sci/stacking.ts
new file mode 100644
index 000000000..ae89c8823
--- /dev/null
+++ b/src/hydrology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci stacking module — tsb analytics library. */
+export interface HydrologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciStackingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciStacking(data: number[], opts: HydrologySciStackingOptions = {}): HydrologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciStacking };
diff --git a/src/hydrology_sci/standardization.ts b/src/hydrology_sci/standardization.ts
new file mode 100644
index 000000000..f21fb9450
--- /dev/null
+++ b/src/hydrology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci standardization module — tsb analytics library. */
+export interface HydrologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciStandardization(data: number[], opts: HydrologySciStandardizationOptions = {}): HydrologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciStandardization };
diff --git a/src/hydrology_sci/static.ts b/src/hydrology_sci/static.ts
new file mode 100644
index 000000000..12962fa42
--- /dev/null
+++ b/src/hydrology_sci/static.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci static module — tsb analytics library. */
+export interface HydrologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciStaticResult { values: number[]; converged: boolean; }
+export function computeHydrologySciStatic(data: number[], opts: HydrologySciStaticOptions = {}): HydrologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciStatic };
diff --git a/src/hydrology_sci/stochastic.ts b/src/hydrology_sci/stochastic.ts
new file mode 100644
index 000000000..3f76fc85d
--- /dev/null
+++ b/src/hydrology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci stochastic module — tsb analytics library. */
+export interface HydrologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeHydrologySciStochastic(data: number[], opts: HydrologySciStochasticOptions = {}): HydrologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciStochastic };
diff --git a/src/hydrology_sci/synthesis.ts b/src/hydrology_sci/synthesis.ts
new file mode 100644
index 000000000..871ee7eb5
--- /dev/null
+++ b/src/hydrology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci synthesis module — tsb analytics library. */
+export interface HydrologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeHydrologySciSynthesis(data: number[], opts: HydrologySciSynthesisOptions = {}): HydrologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciSynthesis };
diff --git a/src/hydrology_sci/topology.ts b/src/hydrology_sci/topology.ts
new file mode 100644
index 000000000..3ae003f98
--- /dev/null
+++ b/src/hydrology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci topology module — tsb analytics library. */
+export interface HydrologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeHydrologySciTopology(data: number[], opts: HydrologySciTopologyOptions = {}): HydrologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciTopology };
diff --git a/src/hydrology_sci/tracking.ts b/src/hydrology_sci/tracking.ts
new file mode 100644
index 000000000..289722fe5
--- /dev/null
+++ b/src/hydrology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci tracking module — tsb analytics library. */
+export interface HydrologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciTracking(data: number[], opts: HydrologySciTrackingOptions = {}): HydrologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciTracking };
diff --git a/src/hydrology_sci/transform.ts b/src/hydrology_sci/transform.ts
new file mode 100644
index 000000000..5573b4ef9
--- /dev/null
+++ b/src/hydrology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci transform module — tsb analytics library. */
+export interface HydrologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciTransformResult { values: number[]; converged: boolean; }
+export function computeHydrologySciTransform(data: number[], opts: HydrologySciTransformOptions = {}): HydrologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciTransform };
diff --git a/src/hydrology_sci/uncertainty.ts b/src/hydrology_sci/uncertainty.ts
new file mode 100644
index 000000000..9fc232936
--- /dev/null
+++ b/src/hydrology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci uncertainty module — tsb analytics library. */
+export interface HydrologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeHydrologySciUncertainty(data: number[], opts: HydrologySciUncertaintyOptions = {}): HydrologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciUncertainty };
diff --git a/src/hydrology_sci/validation.ts b/src/hydrology_sci/validation.ts
new file mode 100644
index 000000000..228c5dc56
--- /dev/null
+++ b/src/hydrology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci validation module — tsb analytics library. */
+export interface HydrologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciValidationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciValidation(data: number[], opts: HydrologySciValidationOptions = {}): HydrologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciValidation };
diff --git a/src/hydrology_sci/verification.ts b/src/hydrology_sci/verification.ts
new file mode 100644
index 000000000..639622748
--- /dev/null
+++ b/src/hydrology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci verification module — tsb analytics library. */
+export interface HydrologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciVerification(data: number[], opts: HydrologySciVerificationOptions = {}): HydrologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciVerification };
diff --git a/src/hydrology_sci/visualization.ts b/src/hydrology_sci/visualization.ts
new file mode 100644
index 000000000..bb66e1f89
--- /dev/null
+++ b/src/hydrology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci visualization module — tsb analytics library. */
+export interface HydrologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeHydrologySciVisualization(data: number[], opts: HydrologySciVisualizationOptions = {}): HydrologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciVisualization };
diff --git a/src/hydrology_sci/voting.ts b/src/hydrology_sci/voting.ts
new file mode 100644
index 000000000..7c51bbfb0
--- /dev/null
+++ b/src/hydrology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci voting module — tsb analytics library. */
+export interface HydrologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciVotingResult { values: number[]; converged: boolean; }
+export function computeHydrologySciVoting(data: number[], opts: HydrologySciVotingOptions = {}): HydrologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciVoting };
diff --git a/src/hydrology_sci/wavelet.ts b/src/hydrology_sci/wavelet.ts
new file mode 100644
index 000000000..7e071d937
--- /dev/null
+++ b/src/hydrology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** hydrology_sci wavelet module — tsb analytics library. */
+export interface HydrologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface HydrologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeHydrologySciWavelet(data: number[], opts: HydrologySciWaveletOptions = {}): HydrologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeHydrologySciWavelet };
diff --git a/src/immunology_sci/adaptation.ts b/src/immunology_sci/adaptation.ts
new file mode 100644
index 000000000..cccba0d67
--- /dev/null
+++ b/src/immunology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci adaptation module — tsb analytics library. */
+export interface ImmunologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciAdaptation(data: number[], opts: ImmunologySciAdaptationOptions = {}): ImmunologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciAdaptation };
diff --git a/src/immunology_sci/aggregation.ts b/src/immunology_sci/aggregation.ts
new file mode 100644
index 000000000..ab6dd47ff
--- /dev/null
+++ b/src/immunology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci aggregation module — tsb analytics library. */
+export interface ImmunologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciAggregation(data: number[], opts: ImmunologySciAggregationOptions = {}): ImmunologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciAggregation };
diff --git a/src/immunology_sci/algebra.ts b/src/immunology_sci/algebra.ts
new file mode 100644
index 000000000..99d84e1cd
--- /dev/null
+++ b/src/immunology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** immunology_sci algebra module — tsb analytics library. */
+export interface ImmunologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeImmunologySciAlgebra(data: number[], opts: ImmunologySciAlgebraOptions = {}): ImmunologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciAlgebra };
diff --git a/src/immunology_sci/alignment.ts b/src/immunology_sci/alignment.ts
new file mode 100644
index 000000000..7ebafb182
--- /dev/null
+++ b/src/immunology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** immunology_sci alignment module — tsb analytics library. */
+export interface ImmunologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeImmunologySciAlignment(data: number[], opts: ImmunologySciAlignmentOptions = {}): ImmunologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciAlignment };
diff --git a/src/immunology_sci/analysis.ts b/src/immunology_sci/analysis.ts
new file mode 100644
index 000000000..647b21299
--- /dev/null
+++ b/src/immunology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** immunology_sci analysis module — tsb analytics library. */
+export interface ImmunologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeImmunologySciAnalysis(data: number[], opts: ImmunologySciAnalysisOptions = {}): ImmunologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciAnalysis };
diff --git a/src/immunology_sci/augmentation.ts b/src/immunology_sci/augmentation.ts
new file mode 100644
index 000000000..a32a6d506
--- /dev/null
+++ b/src/immunology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci augmentation module — tsb analytics library. */
+export interface ImmunologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciAugmentation(data: number[], opts: ImmunologySciAugmentationOptions = {}): ImmunologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciAugmentation };
diff --git a/src/immunology_sci/bagging.ts b/src/immunology_sci/bagging.ts
new file mode 100644
index 000000000..cf7d57a8a
--- /dev/null
+++ b/src/immunology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** immunology_sci bagging module — tsb analytics library. */
+export interface ImmunologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciBagging(data: number[], opts: ImmunologySciBaggingOptions = {}): ImmunologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciBagging };
diff --git a/src/immunology_sci/basis.ts b/src/immunology_sci/basis.ts
new file mode 100644
index 000000000..7c0fe1986
--- /dev/null
+++ b/src/immunology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** immunology_sci basis module — tsb analytics library. */
+export interface ImmunologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciBasisResult { values: number[]; converged: boolean; }
+export function computeImmunologySciBasis(data: number[], opts: ImmunologySciBasisOptions = {}): ImmunologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciBasis };
diff --git a/src/immunology_sci/benchmarking.ts b/src/immunology_sci/benchmarking.ts
new file mode 100644
index 000000000..a64d7431f
--- /dev/null
+++ b/src/immunology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** immunology_sci benchmarking module — tsb analytics library. */
+export interface ImmunologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciBenchmarking(data: number[], opts: ImmunologySciBenchmarkingOptions = {}): ImmunologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciBenchmarking };
diff --git a/src/immunology_sci/blending.ts b/src/immunology_sci/blending.ts
new file mode 100644
index 000000000..de91b2e83
--- /dev/null
+++ b/src/immunology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** immunology_sci blending module — tsb analytics library. */
+export interface ImmunologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciBlending(data: number[], opts: ImmunologySciBlendingOptions = {}): ImmunologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciBlending };
diff --git a/src/immunology_sci/boosting.ts b/src/immunology_sci/boosting.ts
new file mode 100644
index 000000000..9c070512c
--- /dev/null
+++ b/src/immunology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** immunology_sci boosting module — tsb analytics library. */
+export interface ImmunologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciBoosting(data: number[], opts: ImmunologySciBoostingOptions = {}): ImmunologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciBoosting };
diff --git a/src/immunology_sci/bootstrap.ts b/src/immunology_sci/bootstrap.ts
new file mode 100644
index 000000000..8d1abf969
--- /dev/null
+++ b/src/immunology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** immunology_sci bootstrap module — tsb analytics library. */
+export interface ImmunologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeImmunologySciBootstrap(data: number[], opts: ImmunologySciBootstrapOptions = {}): ImmunologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciBootstrap };
diff --git a/src/immunology_sci/calculus.ts b/src/immunology_sci/calculus.ts
new file mode 100644
index 000000000..f8ccc5db8
--- /dev/null
+++ b/src/immunology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** immunology_sci calculus module — tsb analytics library. */
+export interface ImmunologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeImmunologySciCalculus(data: number[], opts: ImmunologySciCalculusOptions = {}): ImmunologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciCalculus };
diff --git a/src/immunology_sci/calibration.ts b/src/immunology_sci/calibration.ts
new file mode 100644
index 000000000..9c2e314bd
--- /dev/null
+++ b/src/immunology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** immunology_sci calibration module — tsb analytics library. */
+export interface ImmunologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciCalibration(data: number[], opts: ImmunologySciCalibrationOptions = {}): ImmunologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciCalibration };
diff --git a/src/immunology_sci/characterization.ts b/src/immunology_sci/characterization.ts
new file mode 100644
index 000000000..b25889c55
--- /dev/null
+++ b/src/immunology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** immunology_sci characterization module — tsb analytics library. */
+export interface ImmunologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciCharacterization(data: number[], opts: ImmunologySciCharacterizationOptions = {}): ImmunologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciCharacterization };
diff --git a/src/immunology_sci/classification.ts b/src/immunology_sci/classification.ts
new file mode 100644
index 000000000..6f3c91db0
--- /dev/null
+++ b/src/immunology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** immunology_sci classification module — tsb analytics library. */
+export interface ImmunologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciClassification(data: number[], opts: ImmunologySciClassificationOptions = {}): ImmunologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciClassification };
diff --git a/src/immunology_sci/clustering.ts b/src/immunology_sci/clustering.ts
new file mode 100644
index 000000000..55514b004
--- /dev/null
+++ b/src/immunology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** immunology_sci clustering module — tsb analytics library. */
+export interface ImmunologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeImmunologySciClustering(data: number[], opts: ImmunologySciClusteringOptions = {}): ImmunologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciClustering };
diff --git a/src/immunology_sci/compression.ts b/src/immunology_sci/compression.ts
new file mode 100644
index 000000000..15fc48372
--- /dev/null
+++ b/src/immunology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** immunology_sci compression module — tsb analytics library. */
+export interface ImmunologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciCompression(data: number[], opts: ImmunologySciCompressionOptions = {}): ImmunologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciCompression };
diff --git a/src/immunology_sci/continuous.ts b/src/immunology_sci/continuous.ts
new file mode 100644
index 000000000..c2645a2c1
--- /dev/null
+++ b/src/immunology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** immunology_sci continuous module — tsb analytics library. */
+export interface ImmunologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeImmunologySciContinuous(data: number[], opts: ImmunologySciContinuousOptions = {}): ImmunologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciContinuous };
diff --git a/src/immunology_sci/control.ts b/src/immunology_sci/control.ts
new file mode 100644
index 000000000..97bb72658
--- /dev/null
+++ b/src/immunology_sci/control.ts
@@ -0,0 +1,14 @@
+/** immunology_sci control module — tsb analytics library. */
+export interface ImmunologySciControlOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciControlResult { values: number[]; converged: boolean; }
+export function computeImmunologySciControl(data: number[], opts: ImmunologySciControlOptions = {}): ImmunologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciControl };
diff --git a/src/immunology_sci/convergence.ts b/src/immunology_sci/convergence.ts
new file mode 100644
index 000000000..ea520b4b3
--- /dev/null
+++ b/src/immunology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** immunology_sci convergence module — tsb analytics library. */
+export interface ImmunologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeImmunologySciConvergence(data: number[], opts: ImmunologySciConvergenceOptions = {}): ImmunologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciConvergence };
diff --git a/src/immunology_sci/convex.ts b/src/immunology_sci/convex.ts
new file mode 100644
index 000000000..2246e9851
--- /dev/null
+++ b/src/immunology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** immunology_sci convex module — tsb analytics library. */
+export interface ImmunologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciConvexResult { values: number[]; converged: boolean; }
+export function computeImmunologySciConvex(data: number[], opts: ImmunologySciConvexOptions = {}): ImmunologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciConvex };
diff --git a/src/immunology_sci/correlation.ts b/src/immunology_sci/correlation.ts
new file mode 100644
index 000000000..46288176c
--- /dev/null
+++ b/src/immunology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci correlation module — tsb analytics library. */
+export interface ImmunologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciCorrelation(data: number[], opts: ImmunologySciCorrelationOptions = {}): ImmunologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciCorrelation };
diff --git a/src/immunology_sci/covariance.ts b/src/immunology_sci/covariance.ts
new file mode 100644
index 000000000..b9fbee380
--- /dev/null
+++ b/src/immunology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** immunology_sci covariance module — tsb analytics library. */
+export interface ImmunologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeImmunologySciCovariance(data: number[], opts: ImmunologySciCovarianceOptions = {}): ImmunologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciCovariance };
diff --git a/src/immunology_sci/cross_validation.ts b/src/immunology_sci/cross_validation.ts
new file mode 100644
index 000000000..baf9a25f1
--- /dev/null
+++ b/src/immunology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci cross_validation module — tsb analytics library. */
+export interface ImmunologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciCrossValidation(data: number[], opts: ImmunologySciCrossValidationOptions = {}): ImmunologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciCrossValidation };
diff --git a/src/immunology_sci/decoding.ts b/src/immunology_sci/decoding.ts
new file mode 100644
index 000000000..74c675bd0
--- /dev/null
+++ b/src/immunology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** immunology_sci decoding module — tsb analytics library. */
+export interface ImmunologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDecoding(data: number[], opts: ImmunologySciDecodingOptions = {}): ImmunologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDecoding };
diff --git a/src/immunology_sci/decomposition.ts b/src/immunology_sci/decomposition.ts
new file mode 100644
index 000000000..276902cfc
--- /dev/null
+++ b/src/immunology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** immunology_sci decomposition module — tsb analytics library. */
+export interface ImmunologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDecomposition(data: number[], opts: ImmunologySciDecompositionOptions = {}): ImmunologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDecomposition };
diff --git a/src/immunology_sci/detection.ts b/src/immunology_sci/detection.ts
new file mode 100644
index 000000000..ee3be4994
--- /dev/null
+++ b/src/immunology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** immunology_sci detection module — tsb analytics library. */
+export interface ImmunologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDetection(data: number[], opts: ImmunologySciDetectionOptions = {}): ImmunologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDetection };
diff --git a/src/immunology_sci/deterministic.ts b/src/immunology_sci/deterministic.ts
new file mode 100644
index 000000000..5e786a75c
--- /dev/null
+++ b/src/immunology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** immunology_sci deterministic module — tsb analytics library. */
+export interface ImmunologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDeterministic(data: number[], opts: ImmunologySciDeterministicOptions = {}): ImmunologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDeterministic };
diff --git a/src/immunology_sci/diagnostics.ts b/src/immunology_sci/diagnostics.ts
new file mode 100644
index 000000000..3a86a78b2
--- /dev/null
+++ b/src/immunology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** immunology_sci diagnostics module — tsb analytics library. */
+export interface ImmunologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDiagnostics(data: number[], opts: ImmunologySciDiagnosticsOptions = {}): ImmunologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDiagnostics };
diff --git a/src/immunology_sci/differential.ts b/src/immunology_sci/differential.ts
new file mode 100644
index 000000000..f4d07d6f5
--- /dev/null
+++ b/src/immunology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** immunology_sci differential module — tsb analytics library. */
+export interface ImmunologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDifferential(data: number[], opts: ImmunologySciDifferentialOptions = {}): ImmunologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDifferential };
diff --git a/src/immunology_sci/discrete.ts b/src/immunology_sci/discrete.ts
new file mode 100644
index 000000000..1d529a900
--- /dev/null
+++ b/src/immunology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** immunology_sci discrete module — tsb analytics library. */
+export interface ImmunologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDiscrete(data: number[], opts: ImmunologySciDiscreteOptions = {}): ImmunologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDiscrete };
diff --git a/src/immunology_sci/distribution.ts b/src/immunology_sci/distribution.ts
new file mode 100644
index 000000000..bcaa1f534
--- /dev/null
+++ b/src/immunology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** immunology_sci distribution module — tsb analytics library. */
+export interface ImmunologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDistribution(data: number[], opts: ImmunologySciDistributionOptions = {}): ImmunologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDistribution };
diff --git a/src/immunology_sci/dynamic.ts b/src/immunology_sci/dynamic.ts
new file mode 100644
index 000000000..91b03a5cb
--- /dev/null
+++ b/src/immunology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** immunology_sci dynamic module — tsb analytics library. */
+export interface ImmunologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeImmunologySciDynamic(data: number[], opts: ImmunologySciDynamicOptions = {}): ImmunologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciDynamic };
diff --git a/src/immunology_sci/embedding.ts b/src/immunology_sci/embedding.ts
new file mode 100644
index 000000000..930e28b2a
--- /dev/null
+++ b/src/immunology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** immunology_sci embedding module — tsb analytics library. */
+export interface ImmunologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciEmbedding(data: number[], opts: ImmunologySciEmbeddingOptions = {}): ImmunologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciEmbedding };
diff --git a/src/immunology_sci/encoding.ts b/src/immunology_sci/encoding.ts
new file mode 100644
index 000000000..209525677
--- /dev/null
+++ b/src/immunology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** immunology_sci encoding module — tsb analytics library. */
+export interface ImmunologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciEncoding(data: number[], opts: ImmunologySciEncodingOptions = {}): ImmunologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciEncoding };
diff --git a/src/immunology_sci/ensemble.ts b/src/immunology_sci/ensemble.ts
new file mode 100644
index 000000000..0c930c7da
--- /dev/null
+++ b/src/immunology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** immunology_sci ensemble module — tsb analytics library. */
+export interface ImmunologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeImmunologySciEnsemble(data: number[], opts: ImmunologySciEnsembleOptions = {}): ImmunologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciEnsemble };
diff --git a/src/immunology_sci/estimation.ts b/src/immunology_sci/estimation.ts
new file mode 100644
index 000000000..739fa3491
--- /dev/null
+++ b/src/immunology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci estimation module — tsb analytics library. */
+export interface ImmunologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciEstimation(data: number[], opts: ImmunologySciEstimationOptions = {}): ImmunologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciEstimation };
diff --git a/src/immunology_sci/evaluation.ts b/src/immunology_sci/evaluation.ts
new file mode 100644
index 000000000..7dd776b65
--- /dev/null
+++ b/src/immunology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci evaluation module — tsb analytics library. */
+export interface ImmunologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciEvaluation(data: number[], opts: ImmunologySciEvaluationOptions = {}): ImmunologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciEvaluation };
diff --git a/src/immunology_sci/extrapolation.ts b/src/immunology_sci/extrapolation.ts
new file mode 100644
index 000000000..6e7cd7194
--- /dev/null
+++ b/src/immunology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci extrapolation module — tsb analytics library. */
+export interface ImmunologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciExtrapolation(data: number[], opts: ImmunologySciExtrapolationOptions = {}): ImmunologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciExtrapolation };
diff --git a/src/immunology_sci/features.ts b/src/immunology_sci/features.ts
new file mode 100644
index 000000000..5485f0829
--- /dev/null
+++ b/src/immunology_sci/features.ts
@@ -0,0 +1,14 @@
+/** immunology_sci features module — tsb analytics library. */
+export interface ImmunologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeImmunologySciFeatures(data: number[], opts: ImmunologySciFeaturesOptions = {}): ImmunologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciFeatures };
diff --git a/src/immunology_sci/feedback.ts b/src/immunology_sci/feedback.ts
new file mode 100644
index 000000000..694c33eb7
--- /dev/null
+++ b/src/immunology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** immunology_sci feedback module — tsb analytics library. */
+export interface ImmunologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeImmunologySciFeedback(data: number[], opts: ImmunologySciFeedbackOptions = {}): ImmunologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciFeedback };
diff --git a/src/immunology_sci/filtering.ts b/src/immunology_sci/filtering.ts
new file mode 100644
index 000000000..76daab2e3
--- /dev/null
+++ b/src/immunology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** immunology_sci filtering module — tsb analytics library. */
+export interface ImmunologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeImmunologySciFiltering(data: number[], opts: ImmunologySciFilteringOptions = {}): ImmunologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciFiltering };
diff --git a/src/immunology_sci/fourier.ts b/src/immunology_sci/fourier.ts
new file mode 100644
index 000000000..f21376789
--- /dev/null
+++ b/src/immunology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** immunology_sci fourier module — tsb analytics library. */
+export interface ImmunologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciFourierResult { values: number[]; converged: boolean; }
+export function computeImmunologySciFourier(data: number[], opts: ImmunologySciFourierOptions = {}): ImmunologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciFourier };
diff --git a/src/immunology_sci/fusion.ts b/src/immunology_sci/fusion.ts
new file mode 100644
index 000000000..84ca193b8
--- /dev/null
+++ b/src/immunology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** immunology_sci fusion module — tsb analytics library. */
+export interface ImmunologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciFusionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciFusion(data: number[], opts: ImmunologySciFusionOptions = {}): ImmunologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciFusion };
diff --git a/src/immunology_sci/generation.ts b/src/immunology_sci/generation.ts
new file mode 100644
index 000000000..f4352e87f
--- /dev/null
+++ b/src/immunology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci generation module — tsb analytics library. */
+export interface ImmunologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciGeneration(data: number[], opts: ImmunologySciGenerationOptions = {}): ImmunologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciGeneration };
diff --git a/src/immunology_sci/geometry.ts b/src/immunology_sci/geometry.ts
new file mode 100644
index 000000000..df8ea8a4a
--- /dev/null
+++ b/src/immunology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** immunology_sci geometry module — tsb analytics library. */
+export interface ImmunologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeImmunologySciGeometry(data: number[], opts: ImmunologySciGeometryOptions = {}): ImmunologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciGeometry };
diff --git a/src/immunology_sci/gradient.ts b/src/immunology_sci/gradient.ts
new file mode 100644
index 000000000..ac516741a
--- /dev/null
+++ b/src/immunology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** immunology_sci gradient module — tsb analytics library. */
+export interface ImmunologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciGradientResult { values: number[]; converged: boolean; }
+export function computeImmunologySciGradient(data: number[], opts: ImmunologySciGradientOptions = {}): ImmunologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciGradient };
diff --git a/src/immunology_sci/hessian.ts b/src/immunology_sci/hessian.ts
new file mode 100644
index 000000000..7736ed630
--- /dev/null
+++ b/src/immunology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** immunology_sci hessian module — tsb analytics library. */
+export interface ImmunologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciHessianResult { values: number[]; converged: boolean; }
+export function computeImmunologySciHessian(data: number[], opts: ImmunologySciHessianOptions = {}): ImmunologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciHessian };
diff --git a/src/immunology_sci/hypothesis.ts b/src/immunology_sci/hypothesis.ts
new file mode 100644
index 000000000..660671ed2
--- /dev/null
+++ b/src/immunology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** immunology_sci hypothesis module — tsb analytics library. */
+export interface ImmunologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeImmunologySciHypothesis(data: number[], opts: ImmunologySciHypothesisOptions = {}): ImmunologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciHypothesis };
diff --git a/src/immunology_sci/inference.ts b/src/immunology_sci/inference.ts
new file mode 100644
index 000000000..171a93f2c
--- /dev/null
+++ b/src/immunology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** immunology_sci inference module — tsb analytics library. */
+export interface ImmunologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeImmunologySciInference(data: number[], opts: ImmunologySciInferenceOptions = {}): ImmunologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciInference };
diff --git a/src/immunology_sci/inference2.ts b/src/immunology_sci/inference2.ts
new file mode 100644
index 000000000..8af12297f
--- /dev/null
+++ b/src/immunology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** immunology_sci inference2 module — tsb analytics library. */
+export interface ImmunologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeImmunologySciInference(data: number[], opts: ImmunologySciInferenceOptions = {}): ImmunologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciInference };
diff --git a/src/immunology_sci/integral.ts b/src/immunology_sci/integral.ts
new file mode 100644
index 000000000..e00214509
--- /dev/null
+++ b/src/immunology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** immunology_sci integral module — tsb analytics library. */
+export interface ImmunologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeImmunologySciIntegral(data: number[], opts: ImmunologySciIntegralOptions = {}): ImmunologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciIntegral };
diff --git a/src/immunology_sci/integration.ts b/src/immunology_sci/integration.ts
new file mode 100644
index 000000000..20ac6b394
--- /dev/null
+++ b/src/immunology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** immunology_sci integration module — tsb analytics library. */
+export interface ImmunologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciIntegration(data: number[], opts: ImmunologySciIntegrationOptions = {}): ImmunologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciIntegration };
diff --git a/src/immunology_sci/interpolation.ts b/src/immunology_sci/interpolation.ts
new file mode 100644
index 000000000..76c4e1f20
--- /dev/null
+++ b/src/immunology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci interpolation module — tsb analytics library. */
+export interface ImmunologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciInterpolation(data: number[], opts: ImmunologySciInterpolationOptions = {}): ImmunologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciInterpolation };
diff --git a/src/immunology_sci/jacobian.ts b/src/immunology_sci/jacobian.ts
new file mode 100644
index 000000000..c74cff62d
--- /dev/null
+++ b/src/immunology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** immunology_sci jacobian module — tsb analytics library. */
+export interface ImmunologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeImmunologySciJacobian(data: number[], opts: ImmunologySciJacobianOptions = {}): ImmunologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciJacobian };
diff --git a/src/immunology_sci/kernel.ts b/src/immunology_sci/kernel.ts
new file mode 100644
index 000000000..3ebb52b70
--- /dev/null
+++ b/src/immunology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** immunology_sci kernel module — tsb analytics library. */
+export interface ImmunologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciKernelResult { values: number[]; converged: boolean; }
+export function computeImmunologySciKernel(data: number[], opts: ImmunologySciKernelOptions = {}): ImmunologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciKernel };
diff --git a/src/immunology_sci/laplacian.ts b/src/immunology_sci/laplacian.ts
new file mode 100644
index 000000000..ea4b9b194
--- /dev/null
+++ b/src/immunology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** immunology_sci laplacian module — tsb analytics library. */
+export interface ImmunologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeImmunologySciLaplacian(data: number[], opts: ImmunologySciLaplacianOptions = {}): ImmunologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciLaplacian };
diff --git a/src/immunology_sci/learning.ts b/src/immunology_sci/learning.ts
new file mode 100644
index 000000000..bc64a9e04
--- /dev/null
+++ b/src/immunology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** immunology_sci learning module — tsb analytics library. */
+export interface ImmunologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciLearningResult { values: number[]; converged: boolean; }
+export function computeImmunologySciLearning(data: number[], opts: ImmunologySciLearningOptions = {}): ImmunologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciLearning };
diff --git a/src/immunology_sci/linear.ts b/src/immunology_sci/linear.ts
new file mode 100644
index 000000000..1872b6cb2
--- /dev/null
+++ b/src/immunology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** immunology_sci linear module — tsb analytics library. */
+export interface ImmunologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciLinearResult { values: number[]; converged: boolean; }
+export function computeImmunologySciLinear(data: number[], opts: ImmunologySciLinearOptions = {}): ImmunologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciLinear };
diff --git a/src/immunology_sci/manifold.ts b/src/immunology_sci/manifold.ts
new file mode 100644
index 000000000..b22840d8a
--- /dev/null
+++ b/src/immunology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** immunology_sci manifold module — tsb analytics library. */
+export interface ImmunologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeImmunologySciManifold(data: number[], opts: ImmunologySciManifoldOptions = {}): ImmunologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciManifold };
diff --git a/src/immunology_sci/matching.ts b/src/immunology_sci/matching.ts
new file mode 100644
index 000000000..6269a87f3
--- /dev/null
+++ b/src/immunology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** immunology_sci matching module — tsb analytics library. */
+export interface ImmunologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciMatching(data: number[], opts: ImmunologySciMatchingOptions = {}): ImmunologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciMatching };
diff --git a/src/immunology_sci/measurement.ts b/src/immunology_sci/measurement.ts
new file mode 100644
index 000000000..c510463c8
--- /dev/null
+++ b/src/immunology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** immunology_sci measurement module — tsb analytics library. */
+export interface ImmunologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeImmunologySciMeasurement(data: number[], opts: ImmunologySciMeasurementOptions = {}): ImmunologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciMeasurement };
diff --git a/src/immunology_sci/metrics.ts b/src/immunology_sci/metrics.ts
new file mode 100644
index 000000000..653d35c93
--- /dev/null
+++ b/src/immunology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** immunology_sci metrics module — tsb analytics library. */
+export interface ImmunologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeImmunologySciMetrics(data: number[], opts: ImmunologySciMetricsOptions = {}): ImmunologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciMetrics };
diff --git a/src/immunology_sci/modeling.ts b/src/immunology_sci/modeling.ts
new file mode 100644
index 000000000..0c79a2384
--- /dev/null
+++ b/src/immunology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** immunology_sci modeling module — tsb analytics library. */
+export interface ImmunologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciModelingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciModeling(data: number[], opts: ImmunologySciModelingOptions = {}): ImmunologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciModeling };
diff --git a/src/immunology_sci/monitoring.ts b/src/immunology_sci/monitoring.ts
new file mode 100644
index 000000000..f76d9cb2c
--- /dev/null
+++ b/src/immunology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** immunology_sci monitoring module — tsb analytics library. */
+export interface ImmunologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeImmunologySciMonitoring(data: number[], opts: ImmunologySciMonitoringOptions = {}): ImmunologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciMonitoring };
diff --git a/src/immunology_sci/nonlinear.ts b/src/immunology_sci/nonlinear.ts
new file mode 100644
index 000000000..ba3c9327b
--- /dev/null
+++ b/src/immunology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** immunology_sci nonlinear module — tsb analytics library. */
+export interface ImmunologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeImmunologySciNonlinear(data: number[], opts: ImmunologySciNonlinearOptions = {}): ImmunologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciNonlinear };
diff --git a/src/immunology_sci/normalization.ts b/src/immunology_sci/normalization.ts
new file mode 100644
index 000000000..13e09a4e1
--- /dev/null
+++ b/src/immunology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** immunology_sci normalization module — tsb analytics library. */
+export interface ImmunologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciNormalization(data: number[], opts: ImmunologySciNormalizationOptions = {}): ImmunologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciNormalization };
diff --git a/src/immunology_sci/optimization.ts b/src/immunology_sci/optimization.ts
new file mode 100644
index 000000000..62b8afad2
--- /dev/null
+++ b/src/immunology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** immunology_sci optimization module — tsb analytics library. */
+export interface ImmunologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciOptimization(data: number[], opts: ImmunologySciOptimizationOptions = {}): ImmunologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciOptimization };
diff --git a/src/immunology_sci/patterns.ts b/src/immunology_sci/patterns.ts
new file mode 100644
index 000000000..743f245b7
--- /dev/null
+++ b/src/immunology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** immunology_sci patterns module — tsb analytics library. */
+export interface ImmunologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeImmunologySciPatterns(data: number[], opts: ImmunologySciPatternsOptions = {}): ImmunologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciPatterns };
diff --git a/src/immunology_sci/permutation.ts b/src/immunology_sci/permutation.ts
new file mode 100644
index 000000000..836ec050c
--- /dev/null
+++ b/src/immunology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci permutation module — tsb analytics library. */
+export interface ImmunologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciPermutation(data: number[], opts: ImmunologySciPermutationOptions = {}): ImmunologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciPermutation };
diff --git a/src/immunology_sci/prediction.ts b/src/immunology_sci/prediction.ts
new file mode 100644
index 000000000..8420e96f4
--- /dev/null
+++ b/src/immunology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** immunology_sci prediction module — tsb analytics library. */
+export interface ImmunologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciPrediction(data: number[], opts: ImmunologySciPredictionOptions = {}): ImmunologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciPrediction };
diff --git a/src/immunology_sci/processing.ts b/src/immunology_sci/processing.ts
new file mode 100644
index 000000000..fb1d45ee4
--- /dev/null
+++ b/src/immunology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** immunology_sci processing module — tsb analytics library. */
+export interface ImmunologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciProcessing(data: number[], opts: ImmunologySciProcessingOptions = {}): ImmunologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciProcessing };
diff --git a/src/immunology_sci/profiling.ts b/src/immunology_sci/profiling.ts
new file mode 100644
index 000000000..ae9fe8bdc
--- /dev/null
+++ b/src/immunology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** immunology_sci profiling module — tsb analytics library. */
+export interface ImmunologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciProfiling(data: number[], opts: ImmunologySciProfilingOptions = {}): ImmunologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciProfiling };
diff --git a/src/immunology_sci/projection.ts b/src/immunology_sci/projection.ts
new file mode 100644
index 000000000..6e646a493
--- /dev/null
+++ b/src/immunology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** immunology_sci projection module — tsb analytics library. */
+export interface ImmunologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciProjection(data: number[], opts: ImmunologySciProjectionOptions = {}): ImmunologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciProjection };
diff --git a/src/immunology_sci/ranking.ts b/src/immunology_sci/ranking.ts
new file mode 100644
index 000000000..e8ff2b1e0
--- /dev/null
+++ b/src/immunology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** immunology_sci ranking module — tsb analytics library. */
+export interface ImmunologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciRankingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciRanking(data: number[], opts: ImmunologySciRankingOptions = {}): ImmunologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciRanking };
diff --git a/src/immunology_sci/reconstruction.ts b/src/immunology_sci/reconstruction.ts
new file mode 100644
index 000000000..8134ff405
--- /dev/null
+++ b/src/immunology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** immunology_sci reconstruction module — tsb analytics library. */
+export interface ImmunologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciReconstruction(data: number[], opts: ImmunologySciReconstructionOptions = {}): ImmunologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciReconstruction };
diff --git a/src/immunology_sci/registration.ts b/src/immunology_sci/registration.ts
new file mode 100644
index 000000000..0a8ef6320
--- /dev/null
+++ b/src/immunology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** immunology_sci registration module — tsb analytics library. */
+export interface ImmunologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciRegistration(data: number[], opts: ImmunologySciRegistrationOptions = {}): ImmunologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciRegistration };
diff --git a/src/immunology_sci/regression.ts b/src/immunology_sci/regression.ts
new file mode 100644
index 000000000..eea1842bc
--- /dev/null
+++ b/src/immunology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** immunology_sci regression module — tsb analytics library. */
+export interface ImmunologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciRegression(data: number[], opts: ImmunologySciRegressionOptions = {}): ImmunologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciRegression };
diff --git a/src/immunology_sci/regularization.ts b/src/immunology_sci/regularization.ts
new file mode 100644
index 000000000..8236fc7b2
--- /dev/null
+++ b/src/immunology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** immunology_sci regularization module — tsb analytics library. */
+export interface ImmunologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciRegularization(data: number[], opts: ImmunologySciRegularizationOptions = {}): ImmunologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciRegularization };
diff --git a/src/immunology_sci/robustness.ts b/src/immunology_sci/robustness.ts
new file mode 100644
index 000000000..d3e7435cb
--- /dev/null
+++ b/src/immunology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** immunology_sci robustness module — tsb analytics library. */
+export interface ImmunologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeImmunologySciRobustness(data: number[], opts: ImmunologySciRobustnessOptions = {}): ImmunologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciRobustness };
diff --git a/src/immunology_sci/sampling.ts b/src/immunology_sci/sampling.ts
new file mode 100644
index 000000000..1697b4d31
--- /dev/null
+++ b/src/immunology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** immunology_sci sampling module — tsb analytics library. */
+export interface ImmunologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciSampling(data: number[], opts: ImmunologySciSamplingOptions = {}): ImmunologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciSampling };
diff --git a/src/immunology_sci/sampling2.ts b/src/immunology_sci/sampling2.ts
new file mode 100644
index 000000000..99d8476f3
--- /dev/null
+++ b/src/immunology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** immunology_sci sampling2 module — tsb analytics library. */
+export interface ImmunologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciSampling(data: number[], opts: ImmunologySciSamplingOptions = {}): ImmunologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciSampling };
diff --git a/src/immunology_sci/scaling.ts b/src/immunology_sci/scaling.ts
new file mode 100644
index 000000000..28220f6fa
--- /dev/null
+++ b/src/immunology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** immunology_sci scaling module — tsb analytics library. */
+export interface ImmunologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciScalingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciScaling(data: number[], opts: ImmunologySciScalingOptions = {}): ImmunologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciScaling };
diff --git a/src/immunology_sci/scoring.ts b/src/immunology_sci/scoring.ts
new file mode 100644
index 000000000..ce9c29964
--- /dev/null
+++ b/src/immunology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** immunology_sci scoring module — tsb analytics library. */
+export interface ImmunologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciScoringResult { values: number[]; converged: boolean; }
+export function computeImmunologySciScoring(data: number[], opts: ImmunologySciScoringOptions = {}): ImmunologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciScoring };
diff --git a/src/immunology_sci/segmentation.ts b/src/immunology_sci/segmentation.ts
new file mode 100644
index 000000000..805ff1755
--- /dev/null
+++ b/src/immunology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci segmentation module — tsb analytics library. */
+export interface ImmunologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciSegmentation(data: number[], opts: ImmunologySciSegmentationOptions = {}): ImmunologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciSegmentation };
diff --git a/src/immunology_sci/selection.ts b/src/immunology_sci/selection.ts
new file mode 100644
index 000000000..5396c1575
--- /dev/null
+++ b/src/immunology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** immunology_sci selection module — tsb analytics library. */
+export interface ImmunologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeImmunologySciSelection(data: number[], opts: ImmunologySciSelectionOptions = {}): ImmunologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciSelection };
diff --git a/src/immunology_sci/sensitivity.ts b/src/immunology_sci/sensitivity.ts
new file mode 100644
index 000000000..3d681c304
--- /dev/null
+++ b/src/immunology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** immunology_sci sensitivity module — tsb analytics library. */
+export interface ImmunologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeImmunologySciSensitivity(data: number[], opts: ImmunologySciSensitivityOptions = {}): ImmunologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciSensitivity };
diff --git a/src/immunology_sci/simulation.ts b/src/immunology_sci/simulation.ts
new file mode 100644
index 000000000..3631eee48
--- /dev/null
+++ b/src/immunology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci simulation module — tsb analytics library. */
+export interface ImmunologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciSimulation(data: number[], opts: ImmunologySciSimulationOptions = {}): ImmunologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciSimulation };
diff --git a/src/immunology_sci/smoothing.ts b/src/immunology_sci/smoothing.ts
new file mode 100644
index 000000000..b76242907
--- /dev/null
+++ b/src/immunology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** immunology_sci smoothing module — tsb analytics library. */
+export interface ImmunologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciSmoothing(data: number[], opts: ImmunologySciSmoothingOptions = {}): ImmunologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciSmoothing };
diff --git a/src/immunology_sci/stability.ts b/src/immunology_sci/stability.ts
new file mode 100644
index 000000000..534e00d8b
--- /dev/null
+++ b/src/immunology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** immunology_sci stability module — tsb analytics library. */
+export interface ImmunologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeImmunologySciStability(data: number[], opts: ImmunologySciStabilityOptions = {}): ImmunologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciStability };
diff --git a/src/immunology_sci/stacking.ts b/src/immunology_sci/stacking.ts
new file mode 100644
index 000000000..0844ae8eb
--- /dev/null
+++ b/src/immunology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** immunology_sci stacking module — tsb analytics library. */
+export interface ImmunologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciStackingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciStacking(data: number[], opts: ImmunologySciStackingOptions = {}): ImmunologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciStacking };
diff --git a/src/immunology_sci/standardization.ts b/src/immunology_sci/standardization.ts
new file mode 100644
index 000000000..043d06029
--- /dev/null
+++ b/src/immunology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** immunology_sci standardization module — tsb analytics library. */
+export interface ImmunologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciStandardization(data: number[], opts: ImmunologySciStandardizationOptions = {}): ImmunologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciStandardization };
diff --git a/src/immunology_sci/static.ts b/src/immunology_sci/static.ts
new file mode 100644
index 000000000..af77db037
--- /dev/null
+++ b/src/immunology_sci/static.ts
@@ -0,0 +1,14 @@
+/** immunology_sci static module — tsb analytics library. */
+export interface ImmunologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciStaticResult { values: number[]; converged: boolean; }
+export function computeImmunologySciStatic(data: number[], opts: ImmunologySciStaticOptions = {}): ImmunologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciStatic };
diff --git a/src/immunology_sci/stochastic.ts b/src/immunology_sci/stochastic.ts
new file mode 100644
index 000000000..7f6d025cb
--- /dev/null
+++ b/src/immunology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** immunology_sci stochastic module — tsb analytics library. */
+export interface ImmunologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeImmunologySciStochastic(data: number[], opts: ImmunologySciStochasticOptions = {}): ImmunologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciStochastic };
diff --git a/src/immunology_sci/synthesis.ts b/src/immunology_sci/synthesis.ts
new file mode 100644
index 000000000..42fa0add0
--- /dev/null
+++ b/src/immunology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** immunology_sci synthesis module — tsb analytics library. */
+export interface ImmunologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeImmunologySciSynthesis(data: number[], opts: ImmunologySciSynthesisOptions = {}): ImmunologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciSynthesis };
diff --git a/src/immunology_sci/topology.ts b/src/immunology_sci/topology.ts
new file mode 100644
index 000000000..a84a1d9ec
--- /dev/null
+++ b/src/immunology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** immunology_sci topology module — tsb analytics library. */
+export interface ImmunologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeImmunologySciTopology(data: number[], opts: ImmunologySciTopologyOptions = {}): ImmunologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciTopology };
diff --git a/src/immunology_sci/tracking.ts b/src/immunology_sci/tracking.ts
new file mode 100644
index 000000000..748dcb69b
--- /dev/null
+++ b/src/immunology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** immunology_sci tracking module — tsb analytics library. */
+export interface ImmunologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciTracking(data: number[], opts: ImmunologySciTrackingOptions = {}): ImmunologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciTracking };
diff --git a/src/immunology_sci/transform.ts b/src/immunology_sci/transform.ts
new file mode 100644
index 000000000..1478ff889
--- /dev/null
+++ b/src/immunology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** immunology_sci transform module — tsb analytics library. */
+export interface ImmunologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciTransformResult { values: number[]; converged: boolean; }
+export function computeImmunologySciTransform(data: number[], opts: ImmunologySciTransformOptions = {}): ImmunologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciTransform };
diff --git a/src/immunology_sci/uncertainty.ts b/src/immunology_sci/uncertainty.ts
new file mode 100644
index 000000000..275b3404e
--- /dev/null
+++ b/src/immunology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** immunology_sci uncertainty module — tsb analytics library. */
+export interface ImmunologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeImmunologySciUncertainty(data: number[], opts: ImmunologySciUncertaintyOptions = {}): ImmunologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciUncertainty };
diff --git a/src/immunology_sci/validation.ts b/src/immunology_sci/validation.ts
new file mode 100644
index 000000000..6d09b10a3
--- /dev/null
+++ b/src/immunology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** immunology_sci validation module — tsb analytics library. */
+export interface ImmunologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciValidationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciValidation(data: number[], opts: ImmunologySciValidationOptions = {}): ImmunologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciValidation };
diff --git a/src/immunology_sci/verification.ts b/src/immunology_sci/verification.ts
new file mode 100644
index 000000000..37b17f8e7
--- /dev/null
+++ b/src/immunology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** immunology_sci verification module — tsb analytics library. */
+export interface ImmunologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciVerification(data: number[], opts: ImmunologySciVerificationOptions = {}): ImmunologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciVerification };
diff --git a/src/immunology_sci/visualization.ts b/src/immunology_sci/visualization.ts
new file mode 100644
index 000000000..7f64f9150
--- /dev/null
+++ b/src/immunology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** immunology_sci visualization module — tsb analytics library. */
+export interface ImmunologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeImmunologySciVisualization(data: number[], opts: ImmunologySciVisualizationOptions = {}): ImmunologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciVisualization };
diff --git a/src/immunology_sci/voting.ts b/src/immunology_sci/voting.ts
new file mode 100644
index 000000000..94e07f83b
--- /dev/null
+++ b/src/immunology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** immunology_sci voting module — tsb analytics library. */
+export interface ImmunologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciVotingResult { values: number[]; converged: boolean; }
+export function computeImmunologySciVoting(data: number[], opts: ImmunologySciVotingOptions = {}): ImmunologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciVoting };
diff --git a/src/immunology_sci/wavelet.ts b/src/immunology_sci/wavelet.ts
new file mode 100644
index 000000000..e1e077422
--- /dev/null
+++ b/src/immunology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** immunology_sci wavelet module — tsb analytics library. */
+export interface ImmunologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface ImmunologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeImmunologySciWavelet(data: number[], opts: ImmunologySciWaveletOptions = {}): ImmunologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeImmunologySciWavelet };
diff --git a/src/index.ts b/src/index.ts
index bb13fcd16..9fdb36270 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -925,6 +925,10 @@ export { toOffset, inferFreq, FREQ_ALIASES } from "./tseries/frequencies.ts";
export { readSas } from "./io/read_sas.ts";
export type { ReadSasOptions } from "./io/read_sas.ts";
+// io.orc — Apache ORC file format read/write
+export { readOrc, toOrc } from "./io/orc.ts";
+export type { ReadOrcOptions, ToOrcOptions } from "./io/orc.ts";
+
// pd.arrays.SparseArray / pd.SparseDtype — sparse storage for arrays
// with many repeated (fill) values
export { SparseArray, SparseDtype } from "./core/sparse.ts";
@@ -1008,3 +1012,401 @@ export {
tsallisEntropy,
} from "./stats/information.ts";
export type { PMF, NMIMethod } from "./stats/information.ts";
+
+// signal processing — FFT, windows, STFT, Welch PSD, periodogram
+export {
+ complex,
+ cAbs,
+ cArg,
+ fft,
+ ifft,
+ rfft,
+ irfft,
+ fftFreq,
+ rfftFreq,
+ fftshift,
+ ifftshift,
+ rectangularWindow,
+ bartlettWindow,
+ hannWindow,
+ hammingWindow,
+ blackmanWindow,
+ blackmanHarrisWindow,
+ flatTopWindow,
+ kaiserWindow,
+ getWindow,
+ stft,
+ istft,
+ welch,
+ periodogram,
+} from "./stats/signal.ts";
+export type {
+ Complex,
+ WindowName,
+ STFTOptions,
+ STFTResult,
+ ISTFTOptions,
+ WelchOptions,
+ PSDResult,
+ PeriodogramOptions,
+} from "./stats/signal.ts";
+
+// digital filters — FIR/IIR design and application (mirrors scipy.signal)
+export {
+ firwin,
+ freqz,
+ sosfreqz,
+ lfilter,
+ filtfilt,
+ sosfilt,
+ sosfiltfilt,
+ butter,
+} from "./stats/filters.ts";
+export type {
+ FirwinOptions,
+ FreqzResult,
+ SOSSection,
+ ButterResult,
+ FilterType,
+} from "./stats/filters.ts";
+
+// ACF/PACF — autocorrelation, partial autocorrelation, portmanteau tests
+export {
+ autocorr,
+ acf,
+ pacf,
+ ccf,
+ durbinWatson,
+ ljungBox,
+ boxPierce,
+} from "./stats/acf_pacf.ts";
+export type {
+ ACFResult,
+ PACFResult,
+ PortmanteauResult,
+ ACFOptions,
+ PACFOptions,
+ CCFOptions,
+ PortmanteauOptions,
+} from "./stats/acf_pacf.ts";
+
+// ARIMA — ARIMA(p,d,q) time-series model (Hannan-Rissanen, forecast CIs)
+export { ARIMAModel, fitArima } from "./stats/arima.ts";
+export type {
+ ARIMAOptions,
+ ARIMAFitResult,
+ ARIMAForecastResult,
+} from "./stats/arima.ts";
+
+// read_avro / toAvro — Apache Avro OCF I/O for DataFrame
+export { readAvro, toAvro } from "./io/read_avro.ts";
+export type {
+ ReadAvroOptions,
+ ToAvroOptions,
+} from "./io/read_avro.ts";
+
+// Kalman filter & RTS smoother — linear Gaussian state-space model
+export {
+ KalmanFilter,
+ StateSpaceModel,
+ kalmanFilter1D,
+ kalmanSmooth1D,
+ extractScalarMeans,
+ extractScalarVariances,
+ filteredPredictionInterval,
+} from "./stats/kalman.ts";
+export type {
+ KalmanFilterOptions,
+ LocalLevelOptions,
+ LocalLinearTrendOptions,
+ KalmanFilterResult,
+ KalmanSmootherResult,
+} from "./stats/kalman.ts";
+
+// ETS — Exponential Smoothing / Holt-Winters (Simple, Holt, full Holt-Winters)
+export {
+ SimpleExpSmoothing,
+ Holt,
+ ExponentialSmoothing,
+ simpleExpSmoothing,
+ holt,
+ fitEts,
+} from "./stats/ets.ts";
+export type {
+ ETSTrend,
+ ETSSeasonal,
+ ETSInit,
+ SESOptions,
+ SESFitResult,
+ HoltOptions,
+ HoltFitResult,
+ ExponentialSmoothingOptions,
+ ExponentialSmoothingFitResult,
+ ETSForecastResult,
+} from "./stats/ets.ts";
+
+export {
+ DLM,
+ buildLocalLevel,
+ buildLocalLinearTrend,
+ buildPolynomial,
+ buildFourier,
+ buildRegression,
+ combineDLMs,
+} from "./stats/dlm.ts";
+export type {
+ DLMSpec,
+ DLMOptions,
+ DLMFilterStep,
+ DLMResult,
+ DLMSmootherResult,
+ DLMForecastResult,
+} from "./stats/dlm.ts";
+export {
+ GaussianHMM,
+ MultinomialHMM,
+ fitGaussianHMM,
+ hmmViterbi,
+} from "./stats/hmm.ts";
+export type {
+ GaussianHMMParams,
+ GaussianHMMFit,
+ MultinomialHMMParams,
+ MultinomialHMMFit,
+} from "./stats/hmm.ts";
+export {
+ simulateBrownianMotion,
+ simulateGeometricBrownianMotion,
+ simulateOrnsteinUhlenbeck,
+ fitOrnsteinUhlenbeck,
+ simulatePoissonProcess,
+ poissonCounts,
+ simulateRandomWalk,
+ simulateMarkovChain,
+ stationaryDistribution,
+} from "./stats/stochastic_processes.ts";
+export type {
+ BrownianMotionParams,
+ OUParams,
+ RandomWalkParams,
+ ProcessPath,
+} from "./stats/stochastic_processes.ts";
+export {
+ createGraph,
+ addEdge,
+ graphFromEdges,
+ degreeCentrality,
+ directedDegrees,
+ bfsDistances,
+ dijkstra,
+ betweennessCentrality,
+ clusteringCoefficient,
+ globalClusteringCoefficient,
+ connectedComponents,
+ pageRank,
+ hits,
+} from "./stats/network_stats.ts";
+export type { Graph } from "./stats/network_stats.ts";
+export {
+ euclideanDistance,
+ pairwiseDistances,
+ empiricalVariogram,
+ sphericalVariogram,
+ exponentialVariogram,
+ gaussianVariogram,
+ ordinaryKriging,
+ moransI,
+ ripleysK,
+ ripleysL,
+ kde2d,
+ distanceWeights,
+} from "./stats/spatial_stats.ts";
+export type {
+ SpatialPoint,
+ VariogramPoint,
+ VariogramModelParams,
+} from "./stats/spatial_stats.ts";
+export {
+ normalCdf,
+ normalQuantile,
+ gaussianCopulaCdf,
+ gaussianCopulaDensity,
+ sampleGaussianCopula,
+ claytonCopulaCdf,
+ sampleClaytonCopula,
+ gumbelCopulaCdf,
+ frankCopulaCdf,
+ sampleFrankCopula,
+ empiricalCopula,
+ kendallTau,
+ tauToGaussianRho,
+ tauToClaytonTheta,
+ tauToGumbelTheta,
+} from "./stats/copulas.ts";
+export {
+ gevPdf,
+ gevCdf,
+ gevQuantile,
+ gevReturnLevel,
+ fitGEV,
+ gpdPdf,
+ gpdCdf,
+ gpdQuantile,
+ fitGPD,
+ extractExceedances,
+ gpdReturnLevel,
+ gumbelPdf,
+ gumbelCdf,
+ gumbelQuantile,
+} from "./stats/extreme_value.ts";
+export type {
+ GEVParams,
+ GPDParams,
+ GumbelParams,
+} from "./stats/extreme_value.ts";
+
+// ─── ML ───────────────────────────────────────────────────────────────────────
+export {
+ computeNoiseSchedule,
+ addNoise,
+ ddimStep,
+ ddimTimesteps,
+ snrAtTimestep,
+} from "./ml/ddim.ts";
+export type { NoiseSchedule, DDIMConfig, NoiseScheduleValues } from "./ml/ddim.ts";
+
+export {
+ sparsemax,
+ glu,
+ batchNormInfer,
+ featureTransformer,
+ attentiveTransformer,
+ tabnetStep,
+ aggregateSteps,
+ featureImportance,
+} from "./ml/tabnet.ts";
+export type { BatchNormParams, FeatureTransformerWeights, AttentiveTransformerWeights, TabNetStepResult } from "./ml/tabnet.ts";
+
+export {
+ scaledDotProductAttention,
+ layerNorm,
+ gelu,
+ feedForward,
+ tokenizeNumerical,
+ tokenizeCategorical,
+ addResidual,
+ extractCLSToken,
+ linearHead,
+ softmax,
+} from "./ml/ft_transformer.ts";
+export type { AttentionOutput } from "./ml/ft_transformer.ts";
+
+export {
+ viterbiDecode,
+ forwardLogZ,
+ sequenceScore,
+ crfNegLogLikelihood,
+ logSumExp,
+} from "./ml/crf.ts";
+export type { CRFParams, ViterbiResult } from "./ml/crf.ts";
+
+export {
+ rnnCell,
+ encode,
+ bahdanauAttention,
+ decoderStep,
+ greedyDecode,
+ sigmoid,
+ tanh,
+} from "./ml/seq2seq.ts";
+export type { RNNCellWeights, BahdanauWeights, DecoderWeights, DecoderStepResult } from "./ml/seq2seq.ts";
+
+export {
+ rbfKernel,
+ maternKernel52,
+ kernelMatrix,
+ cholesky,
+ gpPredict,
+ normalCDF,
+ normalPDF,
+ expectedImprovement,
+ probabilityOfImprovement,
+ upperConfidenceBound,
+ initBOState,
+ suggestNext,
+} from "./ml/bayesian_opt.ts";
+export type { BOState } from "./ml/bayesian_opt.ts";
+
+export {
+ karrasNoiseLevels,
+ cSkip,
+ cOut,
+ cIn,
+ cNoise,
+ consistencyFunction,
+ preconditionInput,
+ pseudoHuberLoss,
+ consistencyTrainingLoss,
+ addGaussianNoise,
+ consistencySampleOneStep,
+ consistencySampleMultiStep,
+ updateEMAWeights,
+ adaptiveEMADecay,
+ DEFAULT_CONSISTENCY_CONFIG,
+} from "./ml/consistency_models.ts";
+export type { ConsistencyConfig } from "./ml/consistency_models.ts";
+
+export {
+ buildTree,
+ treePredict,
+ treePredictOne,
+ fitGBM,
+ predictGBM,
+ mse,
+ r2Score,
+ mseGradient,
+} from "./ml/gradient_boosting.ts";
+export type { TreeNode, TreeParams, GBMEnsemble } from "./ml/gradient_boosting.ts";
+
+export {
+ computeKernel,
+ svmDecision,
+ svmPredict,
+ fitSVM,
+ svmAccuracy,
+} from "./ml/svm.ts";
+export type { KernelType, SVMKernelConfig, SVMModel } from "./ml/svm.ts";
+
+export {
+ multiHeadAttention,
+ sinusoidalPositionalEncoding,
+ addPositionalEncoding,
+ causalMask,
+ applyRoPE,
+} from "./ml/attention.ts";
+export type { MHAConfig, MHAWeights } from "./ml/attention.ts";
+
+export {
+ fitRandomForest,
+ predictRandomForest,
+ oobError,
+ LCGRandom,
+} from "./ml/random_forest.ts";
+export type { RandomForestConfig, RandomForestModel } from "./ml/random_forest.ts";
+
+export {
+ denseForward,
+ denseBackward,
+ relu,
+ reluGrad,
+ sigmoidActivation,
+ sigmoidGrad,
+ softmaxCrossEntropy,
+ mseLoss,
+ initAdam,
+ adamStep,
+ heInit,
+ dropoutMask,
+ applyDropout,
+} from "./ml/neural_network.ts";
+export type { AdamState } from "./ml/neural_network.ts";
diff --git a/src/insurance/actuarial_present_value.ts b/src/insurance/actuarial_present_value.ts
new file mode 100644
index 000000000..f5359b33c
--- /dev/null
+++ b/src/insurance/actuarial_present_value.ts
@@ -0,0 +1,22 @@
+/** Actuarial Present Value module — tsb analytics library. */
+
+/** Options for Actuarial Present Value. */
+export interface ActuarialPresentValueOptions { tol?: number; maxIter?: number; }
+
+/** Result from Actuarial Present Value. */
+export interface ActuarialPresentValueResult { values: number[]; converged: boolean; }
+
+/** Compute Actuarial Present Value. */
+export function computeActuarialPresentValue(data: number[], opts: ActuarialPresentValueOptions = {}): ActuarialPresentValueResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeActuarialPresentValue };
diff --git a/src/insurance/advanced.ts b/src/insurance/advanced.ts
new file mode 100644
index 000000000..e4fed00f9
--- /dev/null
+++ b/src/insurance/advanced.ts
@@ -0,0 +1,15 @@
+/** Insurance Advanced module — tsb analytics library. */
+export interface Insurance advancedOptions { tol?: number; maxIter?: number; }
+export interface Insurance advancedResult { values: number[]; converged: boolean; }
+export function computeInsurance advanced(data: number[], opts: Insurance advancedOptions = {}): Insurance advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance advanced };
diff --git a/src/insurance/appraisal.ts b/src/insurance/appraisal.ts
new file mode 100644
index 000000000..25c52efa0
--- /dev/null
+++ b/src/insurance/appraisal.ts
@@ -0,0 +1,22 @@
+/** Appraisal module — tsb analytics library. */
+
+/** Options for Appraisal. */
+export interface AppraisalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Appraisal. */
+export interface AppraisalResult { values: number[]; converged: boolean; }
+
+/** Compute Appraisal. */
+export function computeAppraisal(data: number[], opts: AppraisalOptions = {}): AppraisalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAppraisal };
diff --git a/src/insurance/base2.ts b/src/insurance/base2.ts
new file mode 100644
index 000000000..f23df395c
--- /dev/null
+++ b/src/insurance/base2.ts
@@ -0,0 +1,15 @@
+/** Insurance Base2 module — tsb analytics library. */
+export interface Insurance base2Options { tol?: number; maxIter?: number; }
+export interface Insurance base2Result { values: number[]; converged: boolean; }
+export function computeInsurance base2(data: number[], opts: Insurance base2Options = {}): Insurance base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance base2 };
diff --git a/src/insurance/batch.ts b/src/insurance/batch.ts
new file mode 100644
index 000000000..743ef953e
--- /dev/null
+++ b/src/insurance/batch.ts
@@ -0,0 +1,15 @@
+/** Insurance Batch module — tsb analytics library. */
+export interface Insurance batchOptions { tol?: number; maxIter?: number; }
+export interface Insurance batchResult { values: number[]; converged: boolean; }
+export function computeInsurance batch(data: number[], opts: Insurance batchOptions = {}): Insurance batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance batch };
diff --git a/src/insurance/beta.ts b/src/insurance/beta.ts
new file mode 100644
index 000000000..2cb4d77d5
--- /dev/null
+++ b/src/insurance/beta.ts
@@ -0,0 +1,15 @@
+/** Insurance Beta module — tsb analytics library. */
+export interface Insurance betaOptions { tol?: number; maxIter?: number; }
+export interface Insurance betaResult { values: number[]; converged: boolean; }
+export function computeInsurance beta(data: number[], opts: Insurance betaOptions = {}): Insurance betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance beta };
diff --git a/src/insurance/capital.ts b/src/insurance/capital.ts
new file mode 100644
index 000000000..ed9265131
--- /dev/null
+++ b/src/insurance/capital.ts
@@ -0,0 +1,22 @@
+/** Capital module — tsb analytics library. */
+
+/** Options for Capital. */
+export interface CapitalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Capital. */
+export interface CapitalResult { values: number[]; converged: boolean; }
+
+/** Compute Capital. */
+export function computeCapital(data: number[], opts: CapitalOptions = {}): CapitalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCapital };
diff --git a/src/insurance/casualty.ts b/src/insurance/casualty.ts
new file mode 100644
index 000000000..9c1a572d1
--- /dev/null
+++ b/src/insurance/casualty.ts
@@ -0,0 +1,22 @@
+/** Casualty module — tsb analytics library. */
+
+/** Options for Casualty. */
+export interface CasualtyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Casualty. */
+export interface CasualtyResult { values: number[]; converged: boolean; }
+
+/** Compute Casualty. */
+export function computeCasualty(data: number[], opts: CasualtyOptions = {}): CasualtyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCasualty };
diff --git a/src/insurance/catastrophe.ts b/src/insurance/catastrophe.ts
new file mode 100644
index 000000000..9208aacfd
--- /dev/null
+++ b/src/insurance/catastrophe.ts
@@ -0,0 +1,22 @@
+/** Catastrophe module — tsb analytics library. */
+
+/** Options for Catastrophe. */
+export interface CatastropheOptions { tol?: number; maxIter?: number; }
+
+/** Result from Catastrophe. */
+export interface CatastropheResult { values: number[]; converged: boolean; }
+
+/** Compute Catastrophe. */
+export function computeCatastrophe(data: number[], opts: CatastropheOptions = {}): CatastropheResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCatastrophe };
diff --git a/src/insurance/claims.ts b/src/insurance/claims.ts
new file mode 100644
index 000000000..e1be9a4a8
--- /dev/null
+++ b/src/insurance/claims.ts
@@ -0,0 +1,22 @@
+/** Claims module — tsb analytics library. */
+
+/** Options for Claims. */
+export interface ClaimsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Claims. */
+export interface ClaimsResult { values: number[]; converged: boolean; }
+
+/** Compute Claims. */
+export function computeClaims(data: number[], opts: ClaimsOptions = {}): ClaimsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClaims };
diff --git a/src/insurance/cpu.ts b/src/insurance/cpu.ts
new file mode 100644
index 000000000..36a8a15aa
--- /dev/null
+++ b/src/insurance/cpu.ts
@@ -0,0 +1,15 @@
+/** Insurance Cpu module — tsb analytics library. */
+export interface Insurance cpuOptions { tol?: number; maxIter?: number; }
+export interface Insurance cpuResult { values: number[]; converged: boolean; }
+export function computeInsurance cpu(data: number[], opts: Insurance cpuOptions = {}): Insurance cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance cpu };
diff --git a/src/insurance/dense.ts b/src/insurance/dense.ts
new file mode 100644
index 000000000..d1f6b9b4d
--- /dev/null
+++ b/src/insurance/dense.ts
@@ -0,0 +1,15 @@
+/** Insurance Dense module — tsb analytics library. */
+export interface Insurance denseOptions { tol?: number; maxIter?: number; }
+export interface Insurance denseResult { values: number[]; converged: boolean; }
+export function computeInsurance dense(data: number[], opts: Insurance denseOptions = {}): Insurance denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance dense };
diff --git a/src/insurance/distributed.ts b/src/insurance/distributed.ts
new file mode 100644
index 000000000..545a8abec
--- /dev/null
+++ b/src/insurance/distributed.ts
@@ -0,0 +1,15 @@
+/** Insurance Distributed module — tsb analytics library. */
+export interface Insurance distributedOptions { tol?: number; maxIter?: number; }
+export interface Insurance distributedResult { values: number[]; converged: boolean; }
+export function computeInsurance distributed(data: number[], opts: Insurance distributedOptions = {}): Insurance distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance distributed };
diff --git a/src/insurance/embedded_value.ts b/src/insurance/embedded_value.ts
new file mode 100644
index 000000000..f0455267f
--- /dev/null
+++ b/src/insurance/embedded_value.ts
@@ -0,0 +1,22 @@
+/** Embedded Value module — tsb analytics library. */
+
+/** Options for Embedded Value. */
+export interface EmbeddedValueOptions { tol?: number; maxIter?: number; }
+
+/** Result from Embedded Value. */
+export interface EmbeddedValueResult { values: number[]; converged: boolean; }
+
+/** Compute Embedded Value. */
+export function computeEmbeddedValue(data: number[], opts: EmbeddedValueOptions = {}): EmbeddedValueResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEmbeddedValue };
diff --git a/src/insurance/experimental.ts b/src/insurance/experimental.ts
new file mode 100644
index 000000000..4f4c1d255
--- /dev/null
+++ b/src/insurance/experimental.ts
@@ -0,0 +1,15 @@
+/** Insurance Experimental module — tsb analytics library. */
+export interface Insurance experimentalOptions { tol?: number; maxIter?: number; }
+export interface Insurance experimentalResult { values: number[]; converged: boolean; }
+export function computeInsurance experimental(data: number[], opts: Insurance experimentalOptions = {}): Insurance experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance experimental };
diff --git a/src/insurance/fast.ts b/src/insurance/fast.ts
new file mode 100644
index 000000000..e6e3399ac
--- /dev/null
+++ b/src/insurance/fast.ts
@@ -0,0 +1,15 @@
+/** Insurance Fast module — tsb analytics library. */
+export interface Insurance fastOptions { tol?: number; maxIter?: number; }
+export interface Insurance fastResult { values: number[]; converged: boolean; }
+export function computeInsurance fast(data: number[], opts: Insurance fastOptions = {}): Insurance fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance fast };
diff --git a/src/insurance/fraud_ins.ts b/src/insurance/fraud_ins.ts
new file mode 100644
index 000000000..6c84bdbda
--- /dev/null
+++ b/src/insurance/fraud_ins.ts
@@ -0,0 +1,22 @@
+/** Fraud Ins module — tsb analytics library. */
+
+/** Options for Fraud Ins. */
+export interface FraudInsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fraud Ins. */
+export interface FraudInsResult { values: number[]; converged: boolean; }
+
+/** Compute Fraud Ins. */
+export function computeFraudIns(data: number[], opts: FraudInsOptions = {}): FraudInsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFraudIns };
diff --git a/src/insurance/future.ts b/src/insurance/future.ts
new file mode 100644
index 000000000..df5a064bb
--- /dev/null
+++ b/src/insurance/future.ts
@@ -0,0 +1,15 @@
+/** Insurance Future module — tsb analytics library. */
+export interface Insurance futureOptions { tol?: number; maxIter?: number; }
+export interface Insurance futureResult { values: number[]; converged: boolean; }
+export function computeInsurance future(data: number[], opts: Insurance futureOptions = {}): Insurance futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance future };
diff --git a/src/insurance/gpu.ts b/src/insurance/gpu.ts
new file mode 100644
index 000000000..24be555c3
--- /dev/null
+++ b/src/insurance/gpu.ts
@@ -0,0 +1,15 @@
+/** Insurance Gpu module — tsb analytics library. */
+export interface Insurance gpuOptions { tol?: number; maxIter?: number; }
+export interface Insurance gpuResult { values: number[]; converged: boolean; }
+export function computeInsurance gpu(data: number[], opts: Insurance gpuOptions = {}): Insurance gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance gpu };
diff --git a/src/insurance/health_ins.ts b/src/insurance/health_ins.ts
new file mode 100644
index 000000000..c4ba8415a
--- /dev/null
+++ b/src/insurance/health_ins.ts
@@ -0,0 +1,22 @@
+/** Health Ins module — tsb analytics library. */
+
+/** Options for Health Ins. */
+export interface HealthInsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Health Ins. */
+export interface HealthInsResult { values: number[]; converged: boolean; }
+
+/** Compute Health Ins. */
+export function computeHealthIns(data: number[], opts: HealthInsOptions = {}): HealthInsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHealthIns };
diff --git a/src/insurance/index.ts b/src/insurance/index.ts
new file mode 100644
index 000000000..b0c98ba9c
--- /dev/null
+++ b/src/insurance/index.ts
@@ -0,0 +1,22 @@
+/** Index module — tsb analytics library. */
+
+/** Options for Index. */
+export interface IndexOptions { tol?: number; maxIter?: number; }
+
+/** Result from Index. */
+export interface IndexResult { values: number[]; converged: boolean; }
+
+/** Compute Index. */
+export function computeIndex(data: number[], opts: IndexOptions = {}): IndexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIndex };
diff --git a/src/insurance/lapse.ts b/src/insurance/lapse.ts
new file mode 100644
index 000000000..00b02e92c
--- /dev/null
+++ b/src/insurance/lapse.ts
@@ -0,0 +1,22 @@
+/** Lapse module — tsb analytics library. */
+
+/** Options for Lapse. */
+export interface LapseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lapse. */
+export interface LapseResult { values: number[]; converged: boolean; }
+
+/** Compute Lapse. */
+export function computeLapse(data: number[], opts: LapseOptions = {}): LapseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLapse };
diff --git a/src/insurance/large.ts b/src/insurance/large.ts
new file mode 100644
index 000000000..964b46f22
--- /dev/null
+++ b/src/insurance/large.ts
@@ -0,0 +1,15 @@
+/** Insurance Large module — tsb analytics library. */
+export interface Insurance largeOptions { tol?: number; maxIter?: number; }
+export interface Insurance largeResult { values: number[]; converged: boolean; }
+export function computeInsurance large(data: number[], opts: Insurance largeOptions = {}): Insurance largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance large };
diff --git a/src/insurance/legacy.ts b/src/insurance/legacy.ts
new file mode 100644
index 000000000..7086fa16f
--- /dev/null
+++ b/src/insurance/legacy.ts
@@ -0,0 +1,15 @@
+/** Insurance Legacy module — tsb analytics library. */
+export interface Insurance legacyOptions { tol?: number; maxIter?: number; }
+export interface Insurance legacyResult { values: number[]; converged: boolean; }
+export function computeInsurance legacy(data: number[], opts: Insurance legacyOptions = {}): Insurance legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance legacy };
diff --git a/src/insurance/life.ts b/src/insurance/life.ts
new file mode 100644
index 000000000..3cde04de2
--- /dev/null
+++ b/src/insurance/life.ts
@@ -0,0 +1,22 @@
+/** Life module — tsb analytics library. */
+
+/** Options for Life. */
+export interface LifeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Life. */
+export interface LifeResult { values: number[]; converged: boolean; }
+
+/** Compute Life. */
+export function computeLife(data: number[], opts: LifeOptions = {}): LifeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLife };
diff --git a/src/insurance/lite.ts b/src/insurance/lite.ts
new file mode 100644
index 000000000..8f78ce640
--- /dev/null
+++ b/src/insurance/lite.ts
@@ -0,0 +1,15 @@
+/** Insurance Lite module — tsb analytics library. */
+export interface Insurance liteOptions { tol?: number; maxIter?: number; }
+export interface Insurance liteResult { values: number[]; converged: boolean; }
+export function computeInsurance lite(data: number[], opts: Insurance liteOptions = {}): Insurance liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance lite };
diff --git a/src/insurance/longevity.ts b/src/insurance/longevity.ts
new file mode 100644
index 000000000..cba9da227
--- /dev/null
+++ b/src/insurance/longevity.ts
@@ -0,0 +1,22 @@
+/** Longevity module — tsb analytics library. */
+
+/** Options for Longevity. */
+export interface LongevityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Longevity. */
+export interface LongevityResult { values: number[]; converged: boolean; }
+
+/** Compute Longevity. */
+export function computeLongevity(data: number[], opts: LongevityOptions = {}): LongevityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLongevity };
diff --git a/src/insurance/mini.ts b/src/insurance/mini.ts
new file mode 100644
index 000000000..c0fed7dd5
--- /dev/null
+++ b/src/insurance/mini.ts
@@ -0,0 +1,15 @@
+/** Insurance Mini module — tsb analytics library. */
+export interface Insurance miniOptions { tol?: number; maxIter?: number; }
+export interface Insurance miniResult { values: number[]; converged: boolean; }
+export function computeInsurance mini(data: number[], opts: Insurance miniOptions = {}): Insurance miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance mini };
diff --git a/src/insurance/morbidity.ts b/src/insurance/morbidity.ts
new file mode 100644
index 000000000..a20b6c470
--- /dev/null
+++ b/src/insurance/morbidity.ts
@@ -0,0 +1,22 @@
+/** Morbidity module — tsb analytics library. */
+
+/** Options for Morbidity. */
+export interface MorbidityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Morbidity. */
+export interface MorbidityResult { values: number[]; converged: boolean; }
+
+/** Compute Morbidity. */
+export function computeMorbidity(data: number[], opts: MorbidityOptions = {}): MorbidityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMorbidity };
diff --git a/src/insurance/mortality.ts b/src/insurance/mortality.ts
new file mode 100644
index 000000000..05eadb478
--- /dev/null
+++ b/src/insurance/mortality.ts
@@ -0,0 +1,22 @@
+/** Mortality module — tsb analytics library. */
+
+/** Options for Mortality. */
+export interface MortalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mortality. */
+export interface MortalityResult { values: number[]; converged: boolean; }
+
+/** Compute Mortality. */
+export function computeMortality(data: number[], opts: MortalityOptions = {}): MortalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMortality };
diff --git a/src/insurance/next.ts b/src/insurance/next.ts
new file mode 100644
index 000000000..c51bd814a
--- /dev/null
+++ b/src/insurance/next.ts
@@ -0,0 +1,15 @@
+/** Insurance Next module — tsb analytics library. */
+export interface Insurance nextOptions { tol?: number; maxIter?: number; }
+export interface Insurance nextResult { values: number[]; converged: boolean; }
+export function computeInsurance next(data: number[], opts: Insurance nextOptions = {}): Insurance nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance next };
diff --git a/src/insurance/non_life.ts b/src/insurance/non_life.ts
new file mode 100644
index 000000000..c5c4e52c5
--- /dev/null
+++ b/src/insurance/non_life.ts
@@ -0,0 +1,22 @@
+/** Non Life module — tsb analytics library. */
+
+/** Options for Non Life. */
+export interface NonLifeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Non Life. */
+export interface NonLifeResult { values: number[]; converged: boolean; }
+
+/** Compute Non Life. */
+export function computeNonLife(data: number[], opts: NonLifeOptions = {}): NonLifeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNonLife };
diff --git a/src/insurance/online.ts b/src/insurance/online.ts
new file mode 100644
index 000000000..54453890b
--- /dev/null
+++ b/src/insurance/online.ts
@@ -0,0 +1,15 @@
+/** Insurance Online module — tsb analytics library. */
+export interface Insurance onlineOptions { tol?: number; maxIter?: number; }
+export interface Insurance onlineResult { values: number[]; converged: boolean; }
+export function computeInsurance online(data: number[], opts: Insurance onlineOptions = {}): Insurance onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance online };
diff --git a/src/insurance/parallel.ts b/src/insurance/parallel.ts
new file mode 100644
index 000000000..f028fa5cb
--- /dev/null
+++ b/src/insurance/parallel.ts
@@ -0,0 +1,15 @@
+/** Insurance Parallel module — tsb analytics library. */
+export interface Insurance parallelOptions { tol?: number; maxIter?: number; }
+export interface Insurance parallelResult { values: number[]; converged: boolean; }
+export function computeInsurance parallel(data: number[], opts: Insurance parallelOptions = {}): Insurance parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance parallel };
diff --git a/src/insurance/parametric.ts b/src/insurance/parametric.ts
new file mode 100644
index 000000000..950332228
--- /dev/null
+++ b/src/insurance/parametric.ts
@@ -0,0 +1,22 @@
+/** Parametric module — tsb analytics library. */
+
+/** Options for Parametric. */
+export interface ParametricOptions { tol?: number; maxIter?: number; }
+
+/** Result from Parametric. */
+export interface ParametricResult { values: number[]; converged: boolean; }
+
+/** Compute Parametric. */
+export function computeParametric(data: number[], opts: ParametricOptions = {}): ParametricResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeParametric };
diff --git a/src/insurance/plus.ts b/src/insurance/plus.ts
new file mode 100644
index 000000000..5d6d574ae
--- /dev/null
+++ b/src/insurance/plus.ts
@@ -0,0 +1,15 @@
+/** Insurance Plus module — tsb analytics library. */
+export interface Insurance plusOptions { tol?: number; maxIter?: number; }
+export interface Insurance plusResult { values: number[]; converged: boolean; }
+export function computeInsurance plus(data: number[], opts: Insurance plusOptions = {}): Insurance plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance plus };
diff --git a/src/insurance/policyholder.ts b/src/insurance/policyholder.ts
new file mode 100644
index 000000000..138d64c30
--- /dev/null
+++ b/src/insurance/policyholder.ts
@@ -0,0 +1,22 @@
+/** Policyholder module — tsb analytics library. */
+
+/** Options for Policyholder. */
+export interface PolicyholderOptions { tol?: number; maxIter?: number; }
+
+/** Result from Policyholder. */
+export interface PolicyholderResult { values: number[]; converged: boolean; }
+
+/** Compute Policyholder. */
+export function computePolicyholder(data: number[], opts: PolicyholderOptions = {}): PolicyholderResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePolicyholder };
diff --git a/src/insurance/pricing_ins.ts b/src/insurance/pricing_ins.ts
new file mode 100644
index 000000000..cf9f71cee
--- /dev/null
+++ b/src/insurance/pricing_ins.ts
@@ -0,0 +1,22 @@
+/** Pricing Ins module — tsb analytics library. */
+
+/** Options for Pricing Ins. */
+export interface PricingInsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pricing Ins. */
+export interface PricingInsResult { values: number[]; converged: boolean; }
+
+/** Compute Pricing Ins. */
+export function computePricingIns(data: number[], opts: PricingInsOptions = {}): PricingInsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePricingIns };
diff --git a/src/insurance/pro.ts b/src/insurance/pro.ts
new file mode 100644
index 000000000..c6801510a
--- /dev/null
+++ b/src/insurance/pro.ts
@@ -0,0 +1,15 @@
+/** Insurance Pro module — tsb analytics library. */
+export interface Insurance proOptions { tol?: number; maxIter?: number; }
+export interface Insurance proResult { values: number[]; converged: boolean; }
+export function computeInsurance pro(data: number[], opts: Insurance proOptions = {}): Insurance proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance pro };
diff --git a/src/insurance/property.ts b/src/insurance/property.ts
new file mode 100644
index 000000000..1e3785e87
--- /dev/null
+++ b/src/insurance/property.ts
@@ -0,0 +1,22 @@
+/** Property module — tsb analytics library. */
+
+/** Options for Property. */
+export interface PropertyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Property. */
+export interface PropertyResult { values: number[]; converged: boolean; }
+
+/** Compute Property. */
+export function computeProperty(data: number[], opts: PropertyOptions = {}): PropertyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProperty };
diff --git a/src/insurance/rating.ts b/src/insurance/rating.ts
new file mode 100644
index 000000000..7cd6cba32
--- /dev/null
+++ b/src/insurance/rating.ts
@@ -0,0 +1,22 @@
+/** Rating module — tsb analytics library. */
+
+/** Options for Rating. */
+export interface RatingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rating. */
+export interface RatingResult { values: number[]; converged: boolean; }
+
+/** Compute Rating. */
+export function computeRating(data: number[], opts: RatingOptions = {}): RatingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRating };
diff --git a/src/insurance/reinsurance.ts b/src/insurance/reinsurance.ts
new file mode 100644
index 000000000..6d588c20d
--- /dev/null
+++ b/src/insurance/reinsurance.ts
@@ -0,0 +1,22 @@
+/** Reinsurance module — tsb analytics library. */
+
+/** Options for Reinsurance. */
+export interface ReinsuranceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reinsurance. */
+export interface ReinsuranceResult { values: number[]; converged: boolean; }
+
+/** Compute Reinsurance. */
+export function computeReinsurance(data: number[], opts: ReinsuranceOptions = {}): ReinsuranceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReinsurance };
diff --git a/src/insurance/reserving.ts b/src/insurance/reserving.ts
new file mode 100644
index 000000000..08134c2f8
--- /dev/null
+++ b/src/insurance/reserving.ts
@@ -0,0 +1,22 @@
+/** Reserving module — tsb analytics library. */
+
+/** Options for Reserving. */
+export interface ReservingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reserving. */
+export interface ReservingResult { values: number[]; converged: boolean; }
+
+/** Compute Reserving. */
+export function computeReserving(data: number[], opts: ReservingOptions = {}): ReservingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReserving };
diff --git a/src/insurance/robust.ts b/src/insurance/robust.ts
new file mode 100644
index 000000000..cd1336573
--- /dev/null
+++ b/src/insurance/robust.ts
@@ -0,0 +1,15 @@
+/** Insurance Robust module — tsb analytics library. */
+export interface Insurance robustOptions { tol?: number; maxIter?: number; }
+export interface Insurance robustResult { values: number[]; converged: boolean; }
+export function computeInsurance robust(data: number[], opts: Insurance robustOptions = {}): Insurance robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance robust };
diff --git a/src/insurance/run_off.ts b/src/insurance/run_off.ts
new file mode 100644
index 000000000..8927aeae3
--- /dev/null
+++ b/src/insurance/run_off.ts
@@ -0,0 +1,22 @@
+/** Run Off module — tsb analytics library. */
+
+/** Options for Run Off. */
+export interface RunOffOptions { tol?: number; maxIter?: number; }
+
+/** Result from Run Off. */
+export interface RunOffResult { values: number[]; converged: boolean; }
+
+/** Compute Run Off. */
+export function computeRunOff(data: number[], opts: RunOffOptions = {}): RunOffResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRunOff };
diff --git a/src/insurance/small.ts b/src/insurance/small.ts
new file mode 100644
index 000000000..18f7dd8fc
--- /dev/null
+++ b/src/insurance/small.ts
@@ -0,0 +1,15 @@
+/** Insurance Small module — tsb analytics library. */
+export interface Insurance smallOptions { tol?: number; maxIter?: number; }
+export interface Insurance smallResult { values: number[]; converged: boolean; }
+export function computeInsurance small(data: number[], opts: Insurance smallOptions = {}): Insurance smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance small };
diff --git a/src/insurance/solvency.ts b/src/insurance/solvency.ts
new file mode 100644
index 000000000..ebb75c607
--- /dev/null
+++ b/src/insurance/solvency.ts
@@ -0,0 +1,22 @@
+/** Solvency module — tsb analytics library. */
+
+/** Options for Solvency. */
+export interface SolvencyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Solvency. */
+export interface SolvencyResult { values: number[]; converged: boolean; }
+
+/** Compute Solvency. */
+export function computeSolvency(data: number[], opts: SolvencyOptions = {}): SolvencyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSolvency };
diff --git a/src/insurance/sparse.ts b/src/insurance/sparse.ts
new file mode 100644
index 000000000..1e8c23242
--- /dev/null
+++ b/src/insurance/sparse.ts
@@ -0,0 +1,15 @@
+/** Insurance Sparse module — tsb analytics library. */
+export interface Insurance sparseOptions { tol?: number; maxIter?: number; }
+export interface Insurance sparseResult { values: number[]; converged: boolean; }
+export function computeInsurance sparse(data: number[], opts: Insurance sparseOptions = {}): Insurance sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance sparse };
diff --git a/src/insurance/stable.ts b/src/insurance/stable.ts
new file mode 100644
index 000000000..3368b09ce
--- /dev/null
+++ b/src/insurance/stable.ts
@@ -0,0 +1,15 @@
+/** Insurance Stable module — tsb analytics library. */
+export interface Insurance stableOptions { tol?: number; maxIter?: number; }
+export interface Insurance stableResult { values: number[]; converged: boolean; }
+export function computeInsurance stable(data: number[], opts: Insurance stableOptions = {}): Insurance stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance stable };
diff --git a/src/insurance/streaming.ts b/src/insurance/streaming.ts
new file mode 100644
index 000000000..b9b38bf9f
--- /dev/null
+++ b/src/insurance/streaming.ts
@@ -0,0 +1,15 @@
+/** Insurance Streaming module — tsb analytics library. */
+export interface Insurance streamingOptions { tol?: number; maxIter?: number; }
+export interface Insurance streamingResult { values: number[]; converged: boolean; }
+export function computeInsurance streaming(data: number[], opts: Insurance streamingOptions = {}): Insurance streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance streaming };
diff --git a/src/insurance/surrender.ts b/src/insurance/surrender.ts
new file mode 100644
index 000000000..b57b7e66c
--- /dev/null
+++ b/src/insurance/surrender.ts
@@ -0,0 +1,22 @@
+/** Surrender module — tsb analytics library. */
+
+/** Options for Surrender. */
+export interface SurrenderOptions { tol?: number; maxIter?: number; }
+
+/** Result from Surrender. */
+export interface SurrenderResult { values: number[]; converged: boolean; }
+
+/** Compute Surrender. */
+export function computeSurrender(data: number[], opts: SurrenderOptions = {}): SurrenderResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSurrender };
diff --git a/src/insurance/telematics.ts b/src/insurance/telematics.ts
new file mode 100644
index 000000000..a15c07823
--- /dev/null
+++ b/src/insurance/telematics.ts
@@ -0,0 +1,22 @@
+/** Telematics module — tsb analytics library. */
+
+/** Options for Telematics. */
+export interface TelematicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Telematics. */
+export interface TelematicsResult { values: number[]; converged: boolean; }
+
+/** Compute Telematics. */
+export function computeTelematics(data: number[], opts: TelematicsOptions = {}): TelematicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTelematics };
diff --git a/src/insurance/underwriting.ts b/src/insurance/underwriting.ts
new file mode 100644
index 000000000..6b0a2575d
--- /dev/null
+++ b/src/insurance/underwriting.ts
@@ -0,0 +1,22 @@
+/** Underwriting module — tsb analytics library. */
+
+/** Options for Underwriting. */
+export interface UnderwritingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Underwriting. */
+export interface UnderwritingResult { values: number[]; converged: boolean; }
+
+/** Compute Underwriting. */
+export function computeUnderwriting(data: number[], opts: UnderwritingOptions = {}): UnderwritingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeUnderwriting };
diff --git a/src/insurance/v2.ts b/src/insurance/v2.ts
new file mode 100644
index 000000000..2f4e4e999
--- /dev/null
+++ b/src/insurance/v2.ts
@@ -0,0 +1,15 @@
+/** Insurance V2 module — tsb analytics library. */
+export interface Insurance v2Options { tol?: number; maxIter?: number; }
+export interface Insurance v2Result { values: number[]; converged: boolean; }
+export function computeInsurance v2(data: number[], opts: Insurance v2Options = {}): Insurance v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance v2 };
diff --git a/src/insurance/v3.ts b/src/insurance/v3.ts
new file mode 100644
index 000000000..5b526b08d
--- /dev/null
+++ b/src/insurance/v3.ts
@@ -0,0 +1,15 @@
+/** Insurance V3 module — tsb analytics library. */
+export interface Insurance v3Options { tol?: number; maxIter?: number; }
+export interface Insurance v3Result { values: number[]; converged: boolean; }
+export function computeInsurance v3(data: number[], opts: Insurance v3Options = {}): Insurance v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance v3 };
diff --git a/src/insurance/value_of_new_business.ts b/src/insurance/value_of_new_business.ts
new file mode 100644
index 000000000..0ef12bbc8
--- /dev/null
+++ b/src/insurance/value_of_new_business.ts
@@ -0,0 +1,22 @@
+/** Value Of New Business module — tsb analytics library. */
+
+/** Options for Value Of New Business. */
+export interface ValueOfNewBusinessOptions { tol?: number; maxIter?: number; }
+
+/** Result from Value Of New Business. */
+export interface ValueOfNewBusinessResult { values: number[]; converged: boolean; }
+
+/** Compute Value Of New Business. */
+export function computeValueOfNewBusiness(data: number[], opts: ValueOfNewBusinessOptions = {}): ValueOfNewBusinessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeValueOfNewBusiness };
diff --git a/src/insurance/wasm.ts b/src/insurance/wasm.ts
new file mode 100644
index 000000000..65c1812d7
--- /dev/null
+++ b/src/insurance/wasm.ts
@@ -0,0 +1,15 @@
+/** Insurance Wasm module — tsb analytics library. */
+export interface Insurance wasmOptions { tol?: number; maxIter?: number; }
+export interface Insurance wasmResult { values: number[]; converged: boolean; }
+export function computeInsurance wasm(data: number[], opts: Insurance wasmOptions = {}): Insurance wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance wasm };
diff --git a/src/insurance/xlarge.ts b/src/insurance/xlarge.ts
new file mode 100644
index 000000000..f2d2176a3
--- /dev/null
+++ b/src/insurance/xlarge.ts
@@ -0,0 +1,15 @@
+/** Insurance Xlarge module — tsb analytics library. */
+export interface Insurance xlargeOptions { tol?: number; maxIter?: number; }
+export interface Insurance xlargeResult { values: number[]; converged: boolean; }
+export function computeInsurance xlarge(data: number[], opts: Insurance xlargeOptions = {}): Insurance xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeInsurance xlarge };
diff --git a/src/io/feather.ts b/src/io/feather.ts
index 1abb681b3..e91c3e175 100644
--- a/src/io/feather.ts
+++ b/src/io/feather.ts
@@ -726,7 +726,7 @@ function encodeStrings(values: readonly (Scalar | null)[]): {
for (let i = 0; i < encoded.length; i++) {
ov.setInt32(i * 4, pos, true);
data.set(encoded[i]!, pos);
- pos += encoded[i]!.length;
+ pos += encoded[i]?.length;
}
ov.setInt32(values.length * 4, pos, true);
return { offsets, data };
@@ -918,7 +918,7 @@ export function toFeather(df: DataFrame, options: ToFeatherOptions = {}): Uint8A
cols.push({ name, type, values });
}
- const numRows = cols.length > 0 ? cols[0]!.values.length : df.index.size;
+ const numRows = cols.length > 0 ? cols[0]?.values.length : df.index.size;
const schemaCols = cols.map((c) => ({ name: c.name, type: c.type }));
// Encode all column buffers into a single body array
diff --git a/src/io/index.ts b/src/io/index.ts
index 194e405da..78cf80dc9 100644
--- a/src/io/index.ts
+++ b/src/io/index.ts
@@ -62,3 +62,6 @@ export type { ToExcelOptions } from "./to_excel.ts";
export { readSas } from "./read_sas.ts";
export type { ReadSasOptions } from "./read_sas.ts";
+
+export { readOrc, toOrc } from "./orc.ts";
+export type { ReadOrcOptions, ToOrcOptions } from "./orc.ts";
diff --git a/src/io/orc.ts b/src/io/orc.ts
new file mode 100644
index 000000000..7b9822a58
--- /dev/null
+++ b/src/io/orc.ts
@@ -0,0 +1,1351 @@
+/**
+ * readOrc / toOrc — Apache ORC (Optimized Row Columnar) file format I/O.
+ *
+ * Mirrors `pandas.read_orc()` and `DataFrame.to_orc()`.
+ *
+ * Supported column types (read & write):
+ * - BOOLEAN, INT, LONG, FLOAT, DOUBLE, STRING, DATE
+ *
+ * Compression: NONE (ZLIB/Snappy require an external decompressor).
+ * Encoding: DIRECT (integers via RLE v1, strings via raw bytes + lengths,
+ * floats/doubles via raw IEEE 754, booleans via RLE byte v1).
+ *
+ * @module
+ */
+
+import { DataFrame } from "../core/frame.ts";
+import type { Label, Scalar } from "../types.ts";
+
+// ─── Public types ─────────────────────────────────────────────────────────────
+
+/** Options for {@link readOrc}. */
+export interface ReadOrcOptions {
+ /**
+ * Column name to use as the row index.
+ * Default: `null` (RangeIndex).
+ */
+ readonly indexCol?: string | null;
+ /**
+ * Subset of columns to read. `null` = all columns.
+ * Default: `null`.
+ */
+ readonly columns?: readonly string[] | null;
+}
+
+/** Options for {@link toOrc}. */
+export interface ToOrcOptions {
+ /**
+ * Write the DataFrame's row index as an extra column.
+ * Default: `false`.
+ */
+ readonly writeIndex?: boolean;
+}
+
+// ─── ORC file constants ───────────────────────────────────────────────────────
+
+// File header magic
+const ORC_MAGIC = new Uint8Array([0x4f, 0x52, 0x43]); // "ORC"
+
+// ORC type kinds
+const KIND_BOOLEAN = 0;
+const _KIND_BYTE = 1;
+const _KIND_SHORT = 2;
+const _KIND_INT = 3;
+const KIND_LONG = 4;
+const KIND_FLOAT = 5;
+const KIND_DOUBLE = 6;
+const KIND_STRING = 7;
+const KIND_STRUCT = 12;
+const KIND_DATE = 15;
+
+// Compression codecs
+const COMP_NONE = 0;
+const COMP_ZLIB = 1;
+
+// Stream kinds
+const STREAM_PRESENT = 0;
+const STREAM_DATA = 1;
+const STREAM_LENGTH = 2;
+const _STREAM_DICTIONARY_DATA = 3;
+
+// Column encoding kinds
+const ENC_DIRECT = 0;
+
+// ─── Protobuf utilities ───────────────────────────────────────────────────────
+
+/** A single decoded protobuf field value. */
+type PbVal =
+ | { readonly wt: 0; readonly v: bigint }
+ | { readonly wt: 2; readonly v: Uint8Array }
+ | { readonly wt: 1; readonly v: bigint }
+ | { readonly wt: 5; readonly v: number };
+
+/** A decoded protobuf message: field number → list of values. */
+type PbMsg = Map;
+
+/** Read a protobuf varint (unsigned, LSB-first). */
+function pbReadVarU(buf: Uint8Array, pos: number): [bigint, number] {
+ let result = 0n;
+ let shift = 0n;
+ let cur = pos;
+ for (;;) {
+ const b = buf[cur];
+ if (b === undefined) {
+ throw new Error("ORC: truncated varint");
+ }
+ cur++;
+ result |= BigInt(b & 0x7f) << shift;
+ if ((b & 0x80) === 0) {
+ break;
+ }
+ shift += 7n;
+ }
+ return [result, cur];
+}
+
+/** Decode a protobuf message from a byte slice. */
+function pbDecode(buf: Uint8Array): PbMsg {
+ const msg: PbMsg = new Map();
+ let pos = 0;
+ while (pos < buf.length) {
+ let tag: bigint;
+ [tag, pos] = pbReadVarU(buf, pos);
+ const fieldNum = Number(tag >> 3n);
+ const wt = Number(tag & 7n);
+ let val: PbVal;
+ if (wt === 0) {
+ let v: bigint;
+ [v, pos] = pbReadVarU(buf, pos);
+ val = { wt: 0, v };
+ } else if (wt === 2) {
+ let len: bigint;
+ [len, pos] = pbReadVarU(buf, pos);
+ const n = Number(len);
+ val = { wt: 2, v: buf.subarray(pos, pos + n) };
+ pos += n;
+ } else if (wt === 1) {
+ const dv = new DataView(buf.buffer, buf.byteOffset + pos, 8);
+ const lo = BigInt(dv.getUint32(0, true));
+ const hi = BigInt(dv.getUint32(4, true));
+ val = { wt: 1, v: (hi << 32n) | lo };
+ pos += 8;
+ } else if (wt === 5) {
+ const dv = new DataView(buf.buffer, buf.byteOffset + pos, 4);
+ val = { wt: 5, v: dv.getUint32(0, true) };
+ pos += 4;
+ } else {
+ throw new Error(`ORC: unknown wire type ${wt}`);
+ }
+ const list = msg.get(fieldNum);
+ if (list !== undefined) {
+ list.push(val);
+ } else {
+ msg.set(fieldNum, [val]);
+ }
+ }
+ return msg;
+}
+
+/** Get a uint64 field as bigint (default 0). */
+function pbU64(msg: PbMsg, field: number): bigint {
+ const f = msg.get(field)?.[0];
+ return f?.wt === 0 ? f.v : 0n;
+}
+
+/** Get a uint32 field as number (default 0). */
+function pbU32(msg: PbMsg, field: number): number {
+ return Number(pbU64(msg, field));
+}
+
+/** Get all uint32 repeated field values. */
+function pbU32s(msg: PbMsg, field: number): number[] {
+ return (msg.get(field) ?? [])
+ .filter((f): f is PbVal & { wt: 0 } => f.wt === 0)
+ .map((f) => Number(f.v));
+}
+
+/** Get all string repeated field values. */
+function pbStrings(msg: PbMsg, field: number): string[] {
+ const dec = new TextDecoder();
+ return (msg.get(field) ?? [])
+ .filter((f): f is PbVal & { wt: 2 } => f.wt === 2)
+ .map((f) => dec.decode(f.v));
+}
+
+/** Get all embedded message repeated field values. */
+function pbMsgs(msg: PbMsg, field: number): PbMsg[] {
+ return (msg.get(field) ?? [])
+ .filter((f): f is PbVal & { wt: 2 } => f.wt === 2)
+ .map((f) => pbDecode(f.v));
+}
+
+// ─── Protobuf writer ──────────────────────────────────────────────────────────
+
+function pbWvU(v: bigint, out: number[]): void {
+ let val = v;
+ while (val >= 128n) {
+ out.push(Number(val & 0x7fn) | 0x80);
+ val >>= 7n;
+ }
+ out.push(Number(val));
+}
+
+function pbTag(fn: number, wt: 0 | 2, out: number[]): void {
+ pbWvU(BigInt((fn << 3) | wt), out);
+}
+
+function pbWU64(fn: number, v: bigint, out: number[]): void {
+ if (v === 0n) {
+ return;
+ }
+ pbTag(fn, 0, out);
+ pbWvU(v, out);
+}
+
+function pbWU32(fn: number, v: number, out: number[]): void {
+ pbWU64(fn, BigInt(v), out);
+}
+
+function pbWBytes(fn: number, v: Uint8Array, out: number[]): void {
+ pbTag(fn, 2, out);
+ pbWvU(BigInt(v.length), out);
+ for (const b of v) {
+ out.push(b);
+ }
+}
+
+function pbWMsg(fn: number, msg: number[], out: number[]): void {
+ pbTag(fn, 2, out);
+ pbWvU(BigInt(msg.length), out);
+ for (const b of msg) {
+ out.push(b);
+ }
+}
+
+// ─── Hadoop VInt ──────────────────────────────────────────────────────────────
+// ORC uses big-endian variable-length signed integers for RLE integer streams.
+
+/**
+ * Read a Hadoop-style variable-length signed integer.
+ *
+ * Byte ranges:
+ * - 0x00–0x7F: single-byte positive (0–127)
+ * - 0x88–0x8F: positive multi-byte (1–8 data bytes follow)
+ * - 0x80–0x87: negative multi-byte (1–8 data bytes follow, XOR with -1)
+ * - 0x90–0xFF: single-byte negative (-112 to -1)
+ */
+function hvReadVInt(buf: Uint8Array, pos: number): [bigint, number] {
+ const fb = buf[pos];
+ if (fb === undefined) {
+ throw new Error("ORC: truncated Hadoop VInt");
+ }
+ let cur = pos + 1;
+ // Interpret as signed byte
+ const sfb = fb >= 0x80 ? fb - 0x100 : fb;
+ // Single-byte range: -112 to 127
+ if (sfb >= -112) {
+ return [BigInt(sfb), cur];
+ }
+ // Multi-byte
+ const isNeg = sfb < -120; // unsigned 128–135 = negative; 136–143 = positive
+ const len = isNeg ? -119 - sfb : -111 - sfb; // total bytes incl. header
+ let value = 0n;
+ for (let i = 1; i < len; i++) {
+ const b = buf[cur];
+ if (b === undefined) {
+ throw new Error("ORC: truncated Hadoop VInt data");
+ }
+ cur++;
+ value = (value << 8n) | BigInt(b);
+ }
+ if (isNeg) {
+ value ^= -1n;
+ }
+ return [value, cur];
+}
+
+/** Write a Hadoop-style variable-length signed integer. */
+function hvWriteVInt(value: bigint, out: number[]): void {
+ if (value >= -112n && value <= 127n) {
+ out.push(Number(value < 0n ? value + 256n : value));
+ return;
+ }
+ let uval = value;
+ const isNeg = value < 0n;
+ if (isNeg) {
+ uval = value ^ -1n;
+ }
+ let nbytes = 0;
+ let tmp = uval;
+ while (tmp > 0n) {
+ tmp >>= 8n;
+ nbytes++;
+ }
+ const header = isNeg ? -120 - nbytes : -112 - nbytes;
+ out.push(header < 0 ? header + 0x100 : header);
+ for (let i = nbytes - 1; i >= 0; i--) {
+ out.push(Number((uval >> BigInt(i * 8)) & 0xffn));
+ }
+}
+
+// ─── RLE byte v1 ─────────────────────────────────────────────────────────────
+
+/**
+ * Decode an ORC RLE byte v1 stream to a flat byte array.
+ * Control byte < 128: run of (ctrl + 3) copies of the next byte.
+ * Control byte >= 128: (256 - ctrl) literal bytes follow.
+ */
+function rleByteDecodeV1(buf: Uint8Array, off: number, len: number): Uint8Array {
+ const end = off + len;
+ const out: number[] = [];
+ let pos = off;
+ while (pos < end) {
+ const ctrl = buf[pos];
+ if (ctrl === undefined) {
+ break;
+ }
+ pos++;
+ if (ctrl < 128) {
+ const count = ctrl + 3;
+ const val = buf[pos];
+ if (val === undefined) {
+ break;
+ }
+ pos++;
+ for (let i = 0; i < count; i++) {
+ out.push(val);
+ }
+ } else {
+ const count = 256 - ctrl;
+ for (let i = 0; i < count; i++) {
+ const b = buf[pos];
+ if (b === undefined) {
+ break;
+ }
+ pos++;
+ out.push(b);
+ }
+ }
+ }
+ return new Uint8Array(out);
+}
+
+/** Encode bytes using RLE byte v1. */
+function rleByteEncodeV1(data: readonly number[]): Uint8Array {
+ if (data.length === 0) {
+ return new Uint8Array(0);
+ }
+ const out: number[] = [];
+ let i = 0;
+ while (i < data.length) {
+ // Look for a run (same value repeated)
+ let runLen = 1;
+ while (runLen < 130 && i + runLen < data.length && data[i + runLen] === data[i]) {
+ runLen++;
+ }
+ if (runLen >= 3) {
+ out.push(runLen - 3);
+ const d = data[i];
+ if (d === undefined) {
+ throw new Error("ORC: undefined byte in run");
+ }
+ out.push(d);
+ i += runLen;
+ } else {
+ // Literal group
+ let litLen = 1;
+ while (litLen < 128 && i + litLen < data.length) {
+ // Stop if next 3 values are identical (start a new run)
+ const base = data[i + litLen];
+ let rcheck = 1;
+ while (
+ rcheck < 3 &&
+ i + litLen + rcheck < data.length &&
+ data[i + litLen + rcheck] === base
+ ) {
+ rcheck++;
+ }
+ if (rcheck >= 3) {
+ break;
+ }
+ litLen++;
+ }
+ out.push(256 - litLen);
+ for (let j = 0; j < litLen; j++) {
+ const d = data[i + j];
+ if (d === undefined) {
+ throw new Error("ORC: undefined byte in literal");
+ }
+ out.push(d);
+ }
+ i += litLen;
+ }
+ }
+ return new Uint8Array(out);
+}
+
+// ─── RLE integer v1 ──────────────────────────────────────────────────────────
+
+/**
+ * Decode an ORC RLE integer v1 stream (Hadoop VInts, big-endian).
+ * Control byte >= 0: run of (ctrl + 3) values, next byte is signed delta, then base VInt.
+ * Control byte < 0: (-ctrl) literal VInts.
+ */
+function rleIntDecodeV1(buf: Uint8Array, off: number, len: number): bigint[] {
+ const end = off + len;
+ const result: bigint[] = [];
+ let pos = off;
+ while (pos < end) {
+ const ctrl = buf[pos];
+ if (ctrl === undefined) {
+ break;
+ }
+ pos++;
+ const sctrl = ctrl >= 0x80 ? ctrl - 0x100 : ctrl; // signed
+ if (sctrl >= 0) {
+ const count = sctrl + 3;
+ const deltaByte = buf[pos];
+ if (deltaByte === undefined) {
+ break;
+ }
+ pos++;
+ const delta = BigInt(deltaByte >= 0x80 ? deltaByte - 0x100 : deltaByte);
+ let base: bigint;
+ [base, pos] = hvReadVInt(buf, pos);
+ for (let i = 0; i < count; i++) {
+ result.push(base + delta * BigInt(i));
+ }
+ } else {
+ const count = -sctrl;
+ for (let i = 0; i < count; i++) {
+ let v: bigint;
+ [v, pos] = hvReadVInt(buf, pos);
+ result.push(v);
+ }
+ }
+ }
+ return result;
+}
+
+/** Encode bigint values using RLE integer v1. */
+function rleIntEncodeV1(values: readonly bigint[]): Uint8Array {
+ if (values.length === 0) {
+ return new Uint8Array(0);
+ }
+ const out: number[] = [];
+ let i = 0;
+ while (i < values.length) {
+ const v0 = values[i];
+ if (v0 === undefined) {
+ break;
+ }
+ // Attempt to find a run with a constant delta
+ if (i + 2 < values.length) {
+ const v1 = values[i + 1];
+ const v2 = values[i + 2];
+ if (v1 !== undefined && v2 !== undefined) {
+ const delta = v1 - v0;
+ if (v2 - v1 === delta && delta >= -128n && delta <= 127n) {
+ let runLen = 3;
+ while (runLen < 130 && i + runLen < values.length) {
+ const vn = values[i + runLen];
+ const vprev = values[i + runLen - 1];
+ if (vn === undefined || vprev === undefined || vn - vprev !== delta) {
+ break;
+ }
+ runLen++;
+ }
+ out.push(runLen - 3);
+ out.push(Number(delta < 0n ? delta + 256n : delta));
+ hvWriteVInt(v0, out);
+ i += runLen;
+ continue;
+ }
+ }
+ }
+ // Literal group
+ let litLen = 1;
+ while (litLen < 128 && i + litLen < values.length) {
+ const va = values[i + litLen];
+ const vb = values[i + litLen + 1];
+ const vc = values[i + litLen + 2];
+ if (va !== undefined && vb !== undefined && vc !== undefined) {
+ const d1 = vb - va;
+ const d2 = vc - vb;
+ if (d1 === d2 && d1 >= -128n && d1 <= 127n) {
+ break;
+ }
+ }
+ litLen++;
+ }
+ out.push(256 - litLen);
+ for (let j = 0; j < litLen; j++) {
+ const v = values[i + j];
+ if (v === undefined) {
+ break;
+ }
+ hvWriteVInt(v, out);
+ }
+ i += litLen;
+ }
+ return new Uint8Array(out);
+}
+
+// ─── PRESENT stream helpers ───────────────────────────────────────────────────
+
+/**
+ * Expand a PRESENT-stream byte array into per-row boolean flags.
+ * Each byte = 8 rows, MSB first. 1 = non-null, 0 = null.
+ */
+function expandPresent(raw: Uint8Array, nRows: number): boolean[] {
+ const flags: boolean[] = [];
+ for (let i = 0; i < nRows; i++) {
+ flags.push(false);
+ }
+ let row = 0;
+ for (const byte of raw) {
+ for (let bit = 7; bit >= 0 && row < nRows; bit--, row++) {
+ flags[row] = ((byte >> bit) & 1) === 1;
+ }
+ }
+ return flags;
+}
+
+/**
+ * Pack per-row null flags into PRESENT-stream bytes.
+ * 1 = non-null, 0 = null. Returns null if all rows are non-null.
+ */
+function packPresent(nonNull: boolean[]): Uint8Array | null {
+ if (nonNull.every((v) => v)) {
+ return null;
+ }
+ const bytes: number[] = [];
+ for (let i = 0; i < nonNull.length; i += 8) {
+ let byte = 0;
+ for (let bit = 0; bit < 8 && i + bit < nonNull.length; bit++) {
+ if (nonNull[i + bit]) {
+ byte |= 1 << (7 - bit);
+ }
+ }
+ bytes.push(byte);
+ }
+ return new Uint8Array(bytes);
+}
+
+// ─── ORC metadata structures (decoded) ────────────────────────────────────────
+
+interface OrcPostscript {
+ footerLength: number;
+ compression: number;
+ compressionBlockSize: number;
+ metadataLength: number;
+ writerVersion: number;
+}
+
+interface OrcStripeInfo {
+ offset: number;
+ indexLength: number;
+ dataLength: number;
+ footerLength: number;
+ numberOfRows: number;
+}
+
+interface OrcType {
+ kind: number;
+ subtypes: number[];
+ fieldNames: string[];
+}
+
+interface OrcFooter {
+ stripes: OrcStripeInfo[];
+ types: OrcType[];
+ numberOfRows: number;
+}
+
+interface OrcStream {
+ kind: number;
+ column: number;
+ length: number;
+}
+
+interface OrcColumnEncoding {
+ kind: number;
+ dictionarySize: number;
+}
+
+interface OrcStripeFooter {
+ streams: OrcStream[];
+ columns: OrcColumnEncoding[];
+}
+
+// ─── ORC decoding helpers ─────────────────────────────────────────────────────
+
+function decodePostscript(buf: Uint8Array): OrcPostscript {
+ const msg = pbDecode(buf);
+ return {
+ footerLength: Number(pbU64(msg, 1)),
+ compression: pbU32(msg, 2),
+ compressionBlockSize: Number(pbU64(msg, 3)) || 262144,
+ metadataLength: Number(pbU64(msg, 5)),
+ writerVersion: pbU32(msg, 6),
+ };
+}
+
+function decodeFooter(buf: Uint8Array): OrcFooter {
+ const msg = pbDecode(buf);
+ const stripesMsgs = pbMsgs(msg, 3);
+ const stripes: OrcStripeInfo[] = stripesMsgs.map((sm) => ({
+ offset: Number(pbU64(sm, 1)),
+ indexLength: Number(pbU64(sm, 2)),
+ dataLength: Number(pbU64(sm, 3)),
+ footerLength: Number(pbU64(sm, 4)),
+ numberOfRows: Number(pbU64(sm, 5)),
+ }));
+ const typesMsgs = pbMsgs(msg, 4);
+ const types: OrcType[] = typesMsgs.map((tm) => ({
+ kind: pbU32(tm, 1),
+ subtypes: pbU32s(tm, 2),
+ fieldNames: pbStrings(tm, 3),
+ }));
+ return {
+ stripes,
+ types,
+ numberOfRows: Number(pbU64(msg, 6)),
+ };
+}
+
+function decodeStripeFooter(buf: Uint8Array): OrcStripeFooter {
+ const msg = pbDecode(buf);
+ const streamMsgs = pbMsgs(msg, 1);
+ const streams: OrcStream[] = streamMsgs.map((sm) => ({
+ kind: pbU32(sm, 1),
+ column: pbU32(sm, 2),
+ length: Number(pbU64(sm, 3)),
+ }));
+ const colMsgs = pbMsgs(msg, 2);
+ const columns: OrcColumnEncoding[] = colMsgs.map((cm) => ({
+ kind: pbU32(cm, 1),
+ dictionarySize: pbU32(cm, 2),
+ }));
+ return { streams, columns };
+}
+
+// ─── Column data decoders ─────────────────────────────────────────────────────
+
+function decodeIntCol(
+ dataBuf: Uint8Array,
+ off: number,
+ len: number,
+ presentFlags: boolean[] | null,
+ nRows: number,
+): (bigint | null)[] {
+ const ints = rleIntDecodeV1(dataBuf, off, len);
+ const result: (bigint | null)[] = [];
+ let dataIdx = 0;
+ for (let i = 0; i < nRows; i++) {
+ if (presentFlags !== null && presentFlags[i] === false) {
+ result.push(null);
+ } else {
+ result.push(ints[dataIdx] ?? null);
+ dataIdx++;
+ }
+ }
+ return result;
+}
+
+function decodeF32Col(
+ dataBuf: Uint8Array,
+ off: number,
+ presentFlags: boolean[] | null,
+ nRows: number,
+): (number | null)[] {
+ const dv = new DataView(dataBuf.buffer, dataBuf.byteOffset);
+ const result: (number | null)[] = [];
+ let pos = off;
+ for (let i = 0; i < nRows; i++) {
+ if (presentFlags !== null && presentFlags[i] === false) {
+ result.push(null);
+ } else {
+ result.push(dv.getFloat32(pos, true));
+ pos += 4;
+ }
+ }
+ return result;
+}
+
+function decodeF64Col(
+ dataBuf: Uint8Array,
+ off: number,
+ presentFlags: boolean[] | null,
+ nRows: number,
+): (number | null)[] {
+ const dv = new DataView(dataBuf.buffer, dataBuf.byteOffset);
+ const result: (number | null)[] = [];
+ let pos = off;
+ for (let i = 0; i < nRows; i++) {
+ if (presentFlags !== null && presentFlags[i] === false) {
+ result.push(null);
+ } else {
+ result.push(dv.getFloat64(pos, true));
+ pos += 8;
+ }
+ }
+ return result;
+}
+
+function decodeStringCol(
+ dataBuf: Uint8Array,
+ dataOff: number,
+ lenBuf: Uint8Array,
+ lenOff: number,
+ lenLen: number,
+ presentFlags: boolean[] | null,
+ nRows: number,
+): (string | null)[] {
+ const lengths = rleIntDecodeV1(lenBuf, lenOff, lenLen);
+ const dec = new TextDecoder();
+ const result: (string | null)[] = [];
+ let dataPos = dataOff;
+ let strIdx = 0;
+ for (let i = 0; i < nRows; i++) {
+ if (presentFlags !== null && presentFlags[i] === false) {
+ result.push(null);
+ } else {
+ const slen = Number(lengths[strIdx] ?? 0n);
+ result.push(dec.decode(dataBuf.subarray(dataPos, dataPos + slen)));
+ dataPos += slen;
+ strIdx++;
+ }
+ }
+ return result;
+}
+
+function decodeBoolCol(
+ dataBuf: Uint8Array,
+ off: number,
+ len: number,
+ presentFlags: boolean[] | null,
+ nRows: number,
+): (boolean | null)[] {
+ const raw = rleByteDecodeV1(dataBuf, off, len);
+ const result: (boolean | null)[] = [];
+ let bitIdx = 0;
+ for (let i = 0; i < nRows; i++) {
+ if (presentFlags !== null && presentFlags[i] === false) {
+ result.push(null);
+ } else {
+ const bytePos = Math.floor(bitIdx / 8);
+ const bitPos = 7 - (bitIdx % 8);
+ const byte = raw[bytePos] ?? 0;
+ result.push(((byte >> bitPos) & 1) === 1);
+ bitIdx++;
+ }
+ }
+ return result;
+}
+
+// ─── Column data encoders ─────────────────────────────────────────────────────
+
+interface EncodedCol {
+ presentStream: Uint8Array | null;
+ dataStream: Uint8Array;
+ lengthStream: Uint8Array | null;
+ typeKind: number;
+}
+
+function encodeIntCol(values: readonly Scalar[], typeKind: number): EncodedCol {
+ const nonNull: boolean[] = [];
+ const ints: bigint[] = [];
+ for (const v of values) {
+ const isPresent = v !== null && v !== undefined && !(typeof v === "number" && Number.isNaN(v));
+ nonNull.push(isPresent);
+ if (isPresent) {
+ ints.push(typeof v === "number" ? BigInt(Math.trunc(v)) : BigInt(String(v)));
+ }
+ }
+ const presentBits = packPresent(nonNull);
+ const presentStream = presentBits !== null ? rleByteEncodeV1(Array.from(presentBits)) : null;
+ return {
+ presentStream,
+ dataStream: rleIntEncodeV1(ints),
+ lengthStream: null,
+ typeKind,
+ };
+}
+
+function encodeF32Col(values: readonly Scalar[]): EncodedCol {
+ const nonNull: boolean[] = [];
+ const bytes: number[] = [];
+ const tmp = new ArrayBuffer(4);
+ const dv = new DataView(tmp);
+ for (const v of values) {
+ const isPresent = v !== null && v !== undefined && !(typeof v === "number" && Number.isNaN(v));
+ nonNull.push(isPresent);
+ if (isPresent) {
+ dv.setFloat32(0, typeof v === "number" ? v : Number(v), true);
+ bytes.push(dv.getUint8(0), dv.getUint8(1), dv.getUint8(2), dv.getUint8(3));
+ }
+ }
+ const presentBits = packPresent(nonNull);
+ return {
+ presentStream: presentBits !== null ? rleByteEncodeV1(Array.from(presentBits)) : null,
+ dataStream: new Uint8Array(bytes),
+ lengthStream: null,
+ typeKind: KIND_FLOAT,
+ };
+}
+
+function encodeF64Col(values: readonly Scalar[]): EncodedCol {
+ const nonNull: boolean[] = [];
+ const bytes: number[] = [];
+ const tmp = new ArrayBuffer(8);
+ const dv = new DataView(tmp);
+ for (const v of values) {
+ const isPresent = v !== null && v !== undefined && !(typeof v === "number" && Number.isNaN(v));
+ nonNull.push(isPresent);
+ if (isPresent) {
+ dv.setFloat64(0, typeof v === "number" ? v : Number(v), true);
+ for (let k = 0; k < 8; k++) {
+ bytes.push(dv.getUint8(k));
+ }
+ }
+ }
+ const presentBits = packPresent(nonNull);
+ return {
+ presentStream: presentBits !== null ? rleByteEncodeV1(Array.from(presentBits)) : null,
+ dataStream: new Uint8Array(bytes),
+ lengthStream: null,
+ typeKind: KIND_DOUBLE,
+ };
+}
+
+function encodeStringCol(values: readonly Scalar[]): EncodedCol {
+ const nonNull: boolean[] = [];
+ const dataBytes: number[] = [];
+ const lengths: bigint[] = [];
+ const enc = new TextEncoder();
+ for (const v of values) {
+ const isPresent = v !== null && v !== undefined;
+ nonNull.push(isPresent);
+ if (isPresent) {
+ const bytes = enc.encode(String(v));
+ for (const b of bytes) {
+ dataBytes.push(b);
+ }
+ lengths.push(BigInt(bytes.length));
+ }
+ }
+ const presentBits = packPresent(nonNull);
+ return {
+ presentStream: presentBits !== null ? rleByteEncodeV1(Array.from(presentBits)) : null,
+ dataStream: new Uint8Array(dataBytes),
+ lengthStream: rleIntEncodeV1(lengths),
+ typeKind: KIND_STRING,
+ };
+}
+
+function encodeBoolCol(values: readonly Scalar[]): EncodedCol {
+ const nonNull: boolean[] = [];
+ const bits: boolean[] = [];
+ for (const v of values) {
+ const isPresent = v !== null && v !== undefined;
+ nonNull.push(isPresent);
+ if (isPresent) {
+ bits.push(Boolean(v));
+ }
+ }
+ // Pack booleans into bytes, MSB first
+ const bytes: number[] = [];
+ for (let i = 0; i < bits.length; i += 8) {
+ let byte = 0;
+ for (let b = 0; b < 8 && i + b < bits.length; b++) {
+ if (bits[i + b]) {
+ byte |= 1 << (7 - b);
+ }
+ }
+ bytes.push(byte);
+ }
+ const presentBits = packPresent(nonNull);
+ return {
+ presentStream: presentBits !== null ? rleByteEncodeV1(Array.from(presentBits)) : null,
+ dataStream: rleByteEncodeV1(bytes),
+ lengthStream: null,
+ typeKind: KIND_BOOLEAN,
+ };
+}
+
+// ─── ORC type inference ───────────────────────────────────────────────────────
+
+/** Map a DataFrame column's values to an ORC type kind. */
+function inferOrcKind(values: readonly Scalar[]): number {
+ for (const v of values) {
+ if (v === null || v === undefined) {
+ continue;
+ }
+ if (typeof v === "boolean") {
+ return KIND_BOOLEAN;
+ }
+ if (typeof v === "bigint") {
+ return KIND_LONG;
+ }
+ if (typeof v === "number") {
+ return Number.isInteger(v) ? KIND_LONG : KIND_DOUBLE;
+ }
+ if (typeof v === "string") {
+ return KIND_STRING;
+ }
+ }
+ return KIND_STRING; // default for all-null columns
+}
+
+/** Encode a column based on its inferred or given type. */
+function encodeColumn(values: readonly Scalar[], kind: number): EncodedCol {
+ switch (kind) {
+ case KIND_BOOLEAN:
+ return encodeBoolCol(values);
+ case KIND_FLOAT:
+ return encodeF32Col(values);
+ case KIND_DOUBLE:
+ return encodeF64Col(values);
+ case KIND_STRING:
+ return encodeStringCol(values);
+ default:
+ // All integer types → LONG
+ return encodeIntCol(values, KIND_LONG);
+ }
+}
+
+// ─── Postscript / Footer encoding ────────────────────────────────────────────
+
+function encodePostscript(footerLen: number, metaLen: number): Uint8Array {
+ const out: number[] = [];
+ pbWU64(1, BigInt(footerLen), out); // footerLength
+ pbWU32(2, COMP_NONE, out); // compression = NONE
+ // compressionBlockSize: omit (default)
+ // version: [0, 12] = ORC v0.12
+ pbWU32(4, 0, out);
+ pbWU32(4, 12, out);
+ pbWU64(5, BigInt(metaLen), out); // metadataLength
+ pbWU32(6, 1, out); // writerVersion
+ // magic: "ORC" (field 8000)
+ const magic = new TextEncoder().encode("ORC");
+ pbWBytes(8000, magic, out);
+ return new Uint8Array(out);
+}
+
+function encodeFooter(stripes: OrcStripeInfo[], types: OrcType[], nRows: number): Uint8Array {
+ const out: number[] = [];
+ pbWU64(1, BigInt(ORC_MAGIC.length), out); // headerLength = 3
+ // contentLength: sum of stripe sizes
+ const content = stripes.reduce(
+ (s, st) => s + st.indexLength + st.dataLength + st.footerLength,
+ 0,
+ );
+ pbWU64(2, BigInt(content), out);
+
+ for (const stripe of stripes) {
+ const sm: number[] = [];
+ pbWU64(1, BigInt(stripe.offset), sm);
+ pbWU64(2, BigInt(stripe.indexLength), sm);
+ pbWU64(3, BigInt(stripe.dataLength), sm);
+ pbWU64(4, BigInt(stripe.footerLength), sm);
+ pbWU64(5, BigInt(stripe.numberOfRows), sm);
+ pbWMsg(3, sm, out);
+ }
+
+ for (const type of types) {
+ const tm: number[] = [];
+ pbWU32(1, type.kind, tm);
+ for (const st of type.subtypes) {
+ pbWU32(2, st, tm);
+ }
+ for (const fn of type.fieldNames) {
+ const fnBytes = new TextEncoder().encode(fn);
+ pbWBytes(3, fnBytes, tm);
+ }
+ pbWMsg(4, tm, out);
+ }
+
+ pbWU64(6, BigInt(nRows), out);
+ pbWU32(8, 10000, out); // rowIndexStride
+ return new Uint8Array(out);
+}
+
+function encodeStripeFooter(streams: OrcStream[], columns: OrcColumnEncoding[]): Uint8Array {
+ const out: number[] = [];
+ for (const s of streams) {
+ const sm: number[] = [];
+ pbWU32(1, s.kind, sm);
+ pbWU32(2, s.column, sm);
+ pbWU64(3, BigInt(s.length), sm);
+ pbWMsg(1, sm, out);
+ }
+ for (const c of columns) {
+ const cm: number[] = [];
+ pbWU32(1, c.kind, cm);
+ if (c.dictionarySize > 0) {
+ pbWU32(2, c.dictionarySize, cm);
+ }
+ pbWMsg(2, cm, out);
+ }
+ return new Uint8Array(out);
+}
+
+// ─── Main: readOrc ────────────────────────────────────────────────────────────
+
+/** Convert a Scalar value to a Label (non-Label Scalars become null). */
+function scalarToLabel(v: Scalar): Label {
+ if (v === undefined) {
+ return null;
+ }
+ if (typeof v === "bigint") {
+ return Number(v);
+ }
+ if (typeof v === "number" || typeof v === "string" || typeof v === "boolean") {
+ return v;
+ }
+ if (v === null) {
+ return null;
+ }
+ if (v instanceof Date) {
+ return v;
+ }
+ return null; // TimedeltaLike
+}
+
+/**
+ * Parse an ORC binary buffer into a DataFrame.
+ *
+ * @param data - Raw ORC file bytes (Uint8Array or ArrayBuffer).
+ * @param options - Optional settings.
+ * @returns Parsed DataFrame.
+ *
+ * @example
+ * ```ts
+ * import { readOrc, toOrc, DataFrame } from "tsb";
+ * const buf = toOrc(DataFrame.fromColumns({ x: [1, 2, 3], y: ["a", "b", "c"] }));
+ * const df = readOrc(buf);
+ * ```
+ */
+export function readOrc(data: Uint8Array | ArrayBuffer, options: ReadOrcOptions = {}): DataFrame {
+ const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+ if (buf.length < 4) {
+ throw new Error("ORC: file too small");
+ }
+ // Validate magic
+ if (buf[0] !== 0x4f || buf[1] !== 0x52 || buf[2] !== 0x43) {
+ throw new Error("ORC: invalid magic bytes (expected 'ORC')");
+ }
+ // Read postscript
+ const psLen = buf.at(-1);
+ if (psLen === undefined || psLen === 0) {
+ throw new Error("ORC: invalid postscript length");
+ }
+ const psStart = buf.length - 1 - psLen;
+ if (psStart < 3) {
+ throw new Error("ORC: file too small for postscript");
+ }
+ const ps = decodePostscript(buf.subarray(psStart, psStart + psLen));
+ if (ps.compression !== COMP_NONE) {
+ throw new Error(
+ `ORC: compression codec ${ps.compression} (${ps.compression === COMP_ZLIB ? "ZLIB" : "unsupported"}) is not supported; only NONE is currently implemented`,
+ );
+ }
+ // Read footer
+ const metaEnd = psStart;
+ const footerEnd = metaEnd - ps.metadataLength;
+ const footerStart = footerEnd - ps.footerLength;
+ if (footerStart < 3) {
+ throw new Error("ORC: invalid footer position");
+ }
+ const footer = decodeFooter(buf.subarray(footerStart, footerEnd));
+ if (footer.types.length === 0) {
+ throw new Error("ORC: no type schema in footer");
+ }
+
+ // Root type must be STRUCT
+ const rootType = footer.types[0];
+ if (rootType === undefined || rootType.kind !== KIND_STRUCT) {
+ throw new Error("ORC: root type is not STRUCT");
+ }
+
+ // Column selection
+ const allCols = rootType.fieldNames;
+ const wantSet = options.columns != null ? new Set([...options.columns]) : null;
+ const colIndices: number[] = rootType.subtypes.filter((_, i) => {
+ const name = allCols[i];
+ return name !== undefined && (wantSet === null || wantSet.has(name));
+ });
+ const colNames: string[] = colIndices.map((ci) => {
+ const fi = rootType.subtypes.indexOf(ci);
+ return allCols[fi] ?? String(ci);
+ });
+
+ const allValues: Map = new Map();
+ for (const name of colNames) {
+ allValues.set(name, []);
+ }
+
+ // Process each stripe
+ for (const stripeInfo of footer.stripes) {
+ const stripeDataStart = stripeInfo.offset + stripeInfo.indexLength;
+ const stripeFStart = stripeInfo.offset + stripeInfo.indexLength + stripeInfo.dataLength;
+ const stripeFBuf = buf.subarray(stripeFStart, stripeFStart + stripeInfo.footerLength);
+ const sf = decodeStripeFooter(stripeFBuf);
+
+ // Build a stream-offset map: column → streamKind → {offset, length}
+ type StreamLoc = { offset: number; length: number };
+ const streamMap = new Map>();
+ let streamPos = stripeDataStart;
+ for (const stream of sf.streams) {
+ let colMap = streamMap.get(stream.column);
+ if (colMap === undefined) {
+ colMap = new Map();
+ streamMap.set(stream.column, colMap);
+ }
+ colMap.set(stream.kind, { offset: streamPos, length: stream.length });
+ streamPos += stream.length;
+ }
+
+ const nRows = stripeInfo.numberOfRows;
+
+ for (let ci = 0; ci < colIndices.length; ci++) {
+ const colIdx = colIndices[ci];
+ if (colIdx === undefined) {
+ continue;
+ }
+ const name = colNames[ci];
+ if (name === undefined) {
+ continue;
+ }
+ const typeKind = footer.types[colIdx]?.kind ?? KIND_STRING;
+ const colStreams = streamMap.get(colIdx);
+ const vals = allValues.get(name);
+ if (vals === undefined) {
+ continue;
+ }
+
+ // PRESENT stream (null flags)
+ const presentLoc = colStreams?.get(STREAM_PRESENT);
+ let presentFlags: boolean[] | null = null;
+ if (presentLoc !== undefined && presentLoc.length > 0) {
+ const rawPresent = rleByteDecodeV1(buf, presentLoc.offset, presentLoc.length);
+ presentFlags = expandPresent(rawPresent, nRows);
+ }
+
+ const dataLoc = colStreams?.get(STREAM_DATA);
+ const dataOff = dataLoc?.offset ?? 0;
+ const dataLen = dataLoc?.length ?? 0;
+
+ switch (typeKind) {
+ case KIND_BOOLEAN: {
+ const decoded = decodeBoolCol(buf, dataOff, dataLen, presentFlags, nRows);
+ for (const v of decoded) {
+ vals.push(v);
+ }
+ break;
+ }
+ case KIND_FLOAT: {
+ const decoded = decodeF32Col(buf, dataOff, presentFlags, nRows);
+ for (const v of decoded) {
+ vals.push(v);
+ }
+ break;
+ }
+ case KIND_DOUBLE: {
+ const decoded = decodeF64Col(buf, dataOff, presentFlags, nRows);
+ for (const v of decoded) {
+ vals.push(v);
+ }
+ break;
+ }
+ case KIND_STRING: {
+ const lenLoc = colStreams?.get(STREAM_LENGTH);
+ const decoded = decodeStringCol(
+ buf,
+ dataOff,
+ buf,
+ lenLoc?.offset ?? 0,
+ lenLoc?.length ?? 0,
+ presentFlags,
+ nRows,
+ );
+ for (const v of decoded) {
+ vals.push(v);
+ }
+ break;
+ }
+ default: {
+ // Integer types: BOOLEAN, BYTE, SHORT, INT, LONG, DATE
+ const decoded = decodeIntCol(buf, dataOff, dataLen, presentFlags, nRows);
+ for (const v of decoded) {
+ vals.push(typeKind === KIND_DATE ? Number(v ?? 0) : Number(v ?? 0));
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ // Build DataFrame
+ const cols: Record = {};
+ const indexColName = options.indexCol ?? null;
+ let indexArr: Label[] | null = null;
+
+ for (const name of colNames) {
+ const data2 = allValues.get(name) ?? [];
+ if (name === indexColName) {
+ indexArr = data2.map(scalarToLabel);
+ } else {
+ cols[name] = data2;
+ }
+ }
+
+ return DataFrame.fromColumns(cols, indexArr !== null ? { index: indexArr } : undefined);
+}
+
+// ─── Main: toOrc ─────────────────────────────────────────────────────────────
+
+/**
+ * Serialize a DataFrame to an ORC binary buffer.
+ *
+ * @param df - DataFrame to serialize.
+ * @param options - Optional settings.
+ * @returns Raw ORC file bytes.
+ *
+ * @example
+ * ```ts
+ * import { toOrc, DataFrame } from "tsb";
+ * const df = DataFrame.fromColumns({ x: [1, 2, 3], y: ["a", "b", "c"] });
+ * const buf = toOrc(df);
+ * ```
+ */
+export function toOrc(df: DataFrame, options: ToOrcOptions = {}): Uint8Array {
+ const colNames = df.columns.toArray().map(String);
+ const extraCols: string[] = options.writeIndex === true ? ["__index__", ...colNames] : colNames;
+ const indexVals: Scalar[] | null = options.writeIndex === true ? df.index.toArray() : null;
+
+ // Collect column data
+ const colData: Scalar[][] = extraCols.map((name) =>
+ name === "__index__" && indexVals !== null ? indexVals : df.col(name).values.slice(),
+ );
+
+ // Infer ORC type kinds
+ const colKinds: number[] = colData.map((vals) => inferOrcKind(vals));
+
+ // Encode columns
+ const encoded: EncodedCol[] = colData.map((vals, i) => {
+ const k = colKinds[i] ?? KIND_STRING;
+ return encodeColumn(vals, k);
+ });
+
+ // Build file byte array
+ const out: number[] = [];
+
+ // Header "ORC"
+ for (const b of ORC_MAGIC) {
+ out.push(b);
+ }
+
+ // Build one stripe
+ const nRows = df.shape[0];
+ const stripeOffset = 3; // after header
+
+ // Write all streams
+ const streams: OrcStream[] = [];
+ const colEncodings: OrcColumnEncoding[] = [{ kind: ENC_DIRECT, dictionarySize: 0 }]; // root STRUCT
+ const _streamPos = stripeOffset;
+
+ for (let ci = 0; ci < encoded.length; ci++) {
+ const enc = encoded[ci];
+ if (enc === undefined) {
+ continue;
+ }
+ const colIdx = ci + 1; // 1-based (0 = root STRUCT)
+
+ if (enc.presentStream !== null) {
+ streams.push({ kind: STREAM_PRESENT, column: colIdx, length: enc.presentStream.length });
+ }
+ streams.push({ kind: STREAM_DATA, column: colIdx, length: enc.dataStream.length });
+ if (enc.lengthStream !== null) {
+ streams.push({ kind: STREAM_LENGTH, column: colIdx, length: enc.lengthStream.length });
+ }
+ colEncodings.push({ kind: ENC_DIRECT, dictionarySize: 0 });
+ }
+
+ // Write stream data
+ const stripeIndexLen = 0; // no row indexes
+ for (let ci = 0; ci < encoded.length; ci++) {
+ const enc = encoded[ci];
+ if (enc === undefined) {
+ continue;
+ }
+ if (enc.presentStream !== null) {
+ for (const b of enc.presentStream) {
+ out.push(b);
+ }
+ }
+ for (const b of enc.dataStream) {
+ out.push(b);
+ }
+ if (enc.lengthStream !== null) {
+ for (const b of enc.lengthStream) {
+ out.push(b);
+ }
+ }
+ }
+
+ // Compute data length (written bytes minus header)
+ const stripeDataLen = out.length - stripeOffset;
+
+ // Stripe footer
+ const sf = encodeStripeFooter(streams, colEncodings);
+ for (const b of sf) {
+ out.push(b);
+ }
+
+ // Build ORC type schema
+ // Column 0: STRUCT with all column fields
+ const types: OrcType[] = [
+ {
+ kind: KIND_STRUCT,
+ subtypes: extraCols.map((_, i) => i + 1),
+ fieldNames: extraCols,
+ },
+ ];
+ for (const kind of colKinds) {
+ types.push({ kind, subtypes: [], fieldNames: [] });
+ }
+
+ // Stripe info
+ const stripeInfo: OrcStripeInfo = {
+ offset: stripeOffset,
+ indexLength: stripeIndexLen,
+ dataLength: stripeDataLen,
+ footerLength: sf.length,
+ numberOfRows: nRows,
+ };
+
+ // File footer
+ const footerBytes = encodeFooter([stripeInfo], types, nRows);
+ for (const b of footerBytes) {
+ out.push(b);
+ }
+
+ // File metadata (empty for now)
+ const metaLen = 0;
+
+ // Postscript
+ const psBytes = encodePostscript(footerBytes.length, metaLen);
+ for (const b of psBytes) {
+ out.push(b);
+ }
+
+ // Postscript length (1 byte)
+ if (psBytes.length > 255) {
+ throw new Error("ORC: postscript too large");
+ }
+ out.push(psBytes.length);
+
+ return new Uint8Array(out);
+}
diff --git a/src/io/read_avro.ts b/src/io/read_avro.ts
new file mode 100644
index 000000000..9b2b7f4d5
--- /dev/null
+++ b/src/io/read_avro.ts
@@ -0,0 +1,698 @@
+/**
+ * read_avro — Apache Avro Object Container File (OCF) reader for DataFrame.
+ *
+ * Mirrors `pandas.read_avro()`. Parses Avro OCF binary format purely in
+ * TypeScript with no external dependencies.
+ *
+ * Supported Avro schema types:
+ * - Primitives: null, boolean, int, long, float, double, string, bytes
+ * - Named: record, enum, fixed
+ * - Complex: array, map, union
+ * - Logical: date (int), timestamp-millis (long), timestamp-micros (long)
+ *
+ * Supported codecs: `null` (uncompressed). `deflate` and `snappy` blocks
+ * are detected but raise an informative error.
+ *
+ * @example
+ * ```ts
+ * import { readAvro } from "tsb";
+ *
+ * const df = readAvro(buffer); // Uint8Array from file read
+ * console.log(df.columns, df.shape);
+ * ```
+ *
+ * @module
+ */
+
+import { DataFrame } from "../core/frame.ts";
+import type { Scalar } from "../types.ts";
+
+// ─── Public types ──────────────────────────────────────────────────────────────
+
+/** Options for {@link readAvro}. */
+export interface ReadAvroOptions {
+ /** Columns to include. Default: all columns. */
+ readonly usecols?: readonly string[] | null;
+ /**
+ * How to handle schema unions that include `null`:
+ * - `"object"` (default): return `null` for null values.
+ * - `"first"`: return the first non-null type's value.
+ */
+ readonly nullHandling?: "object" | "first";
+}
+
+// ─── Avro schema types ────────────────────────────────────────────────────────
+
+type AvroSchema =
+ | AvroPrimitive
+ | AvroRecord
+ | AvroEnum
+ | AvroArray
+ | AvroMap
+ | AvroUnion
+ | AvroFixed;
+
+type AvroPrimitive = "null" | "boolean" | "int" | "long" | "float" | "double" | "string" | "bytes";
+
+interface AvroRecord {
+ type: "record";
+ name: string;
+ fields: readonly AvroField[];
+}
+
+interface AvroField {
+ name: string;
+ type: AvroSchema;
+ default?: unknown;
+}
+
+interface AvroEnum {
+ type: "enum";
+ name: string;
+ symbols: readonly string[];
+}
+
+interface AvroArray {
+ type: "array";
+ items: AvroSchema;
+}
+
+interface AvroMap {
+ type: "map";
+ values: AvroSchema;
+}
+
+type AvroUnion = readonly AvroSchema[];
+
+interface AvroFixed {
+ type: "fixed";
+ name: string;
+ size: number;
+}
+
+// ─── Binary reader ────────────────────────────────────────────────────────────
+
+class AvroReader {
+ private buf: Uint8Array;
+ private pos = 0;
+
+ constructor(buf: Uint8Array) {
+ this.buf = buf;
+ }
+
+ get position(): number {
+ return this.pos;
+ }
+ get remaining(): number {
+ return this.buf.length - this.pos;
+ }
+
+ readByte(): number {
+ if (this.pos >= this.buf.length) {
+ throw new RangeError("Unexpected end of Avro data");
+ }
+ return this.buf[this.pos++] ?? 0;
+ }
+
+ /** Read a variable-length zigzag-encoded long. Returns a JS number (safe up to 2^53). */
+ readLong(): number {
+ let result = 0;
+ let shift = 0;
+ while (true) {
+ const b = this.readByte();
+ result |= (b & 0x7f) << shift;
+ shift += 7;
+ if ((b & 0x80) === 0) {
+ break;
+ }
+ if (shift >= 63) {
+ // For very large values, handle the remaining bits separately
+ // to avoid JS bitwise overflow (32-bit integers)
+ if (shift === 63) {
+ const hi = b & 0x7f;
+ // combine: result (low 63 bits) + hi << 63 — just approximate as float
+ const lo = result >>> 0;
+ result = lo + hi * 2 ** 63;
+ }
+ break;
+ }
+ }
+ // Zigzag decode: (n >>> 1) ^ -(n & 1)
+ return (result >>> 1) ^ -(result & 1);
+ }
+
+ /** Read a 32-bit int (zigzag long with range check). */
+ readInt(): number {
+ return this.readLong() | 0;
+ }
+
+ /** Read 4-byte IEEE 754 float. */
+ readFloat(): number {
+ const bytes = this.readBytes(4);
+ const view = new DataView(bytes.buffer, bytes.byteOffset, 4);
+ return view.getFloat32(0, true);
+ }
+
+ /** Read 8-byte IEEE 754 double. */
+ readDouble(): number {
+ const bytes = this.readBytes(8);
+ const view = new DataView(bytes.buffer, bytes.byteOffset, 8);
+ return view.getFloat64(0, true);
+ }
+
+ /** Read exactly n bytes as a new Uint8Array. */
+ readBytes(n: number): Uint8Array {
+ if (this.pos + n > this.buf.length) {
+ throw new RangeError("Unexpected end of Avro data");
+ }
+ const slice = this.buf.subarray(this.pos, this.pos + n);
+ this.pos += n;
+ return slice;
+ }
+
+ /** Read Avro bytes field (length-prefixed). */
+ readByteField(): Uint8Array {
+ const len = this.readLong();
+ return this.readBytes(len);
+ }
+
+ /** Read UTF-8 string (length-prefixed). */
+ readString(): string {
+ const bytes = this.readByteField();
+ return new TextDecoder().decode(bytes);
+ }
+
+ /** Read a boolean (0 = false, 1 = true). */
+ readBoolean(): boolean {
+ return this.readByte() !== 0;
+ }
+
+ /** Skip forward n bytes. */
+ skip(n: number): void {
+ if (this.pos + n > this.buf.length) {
+ throw new RangeError("Unexpected end of Avro data");
+ }
+ this.pos += n;
+ }
+
+ /** Peek at 16 bytes (sync marker) and advance. */
+ readSync(): Uint8Array {
+ return this.readBytes(16);
+ }
+}
+
+// ─── Schema parsing ────────────────────────────────────────────────────────────
+
+const td = new TextDecoder();
+
+function parseSchema(raw: unknown): AvroSchema {
+ if (typeof raw === "string") {
+ const prim = raw as AvroPrimitive;
+ return prim;
+ }
+ if (Array.isArray(raw)) {
+ return raw.map(parseSchema) as AvroUnion;
+ }
+ if (typeof raw === "object" && raw !== null) {
+ const obj = raw as Record;
+ const type = obj.type;
+ if (type === "record") {
+ const fields = (obj.fields as unknown[]).map((f) => {
+ const field = f as Record;
+ return { name: field.name as string, type: parseSchema(field.type) };
+ });
+ return { type: "record", name: obj.name as string, fields };
+ }
+ if (type === "array") {
+ return { type: "array", items: parseSchema(obj.items) };
+ }
+ if (type === "map") {
+ return { type: "map", values: parseSchema(obj.values) };
+ }
+ if (type === "enum") {
+ return {
+ type: "enum",
+ name: obj.name as string,
+ symbols: obj.symbols as string[],
+ };
+ }
+ if (type === "fixed") {
+ return {
+ type: "fixed",
+ name: obj.name as string,
+ size: obj.size as number,
+ };
+ }
+ // Logical types: delegate to the underlying type
+ if (typeof type === "string") {
+ return parseSchema(type);
+ }
+ }
+ throw new TypeError(`Unknown Avro schema: ${JSON.stringify(raw)}`);
+}
+
+// ─── Datum reading ────────────────────────────────────────────────────────────
+
+/** Avro leaf value (no recursion at type level — containers use unknown). */
+type AvroLeaf = null | boolean | number | string | Uint8Array;
+/** Container interfaces allow recursive self-reference (interfaces can, type aliases cannot). */
+interface AvroDatumArr extends Array {}
+interface AvroDatumMap extends Map {}
+interface AvroDatumRecord extends Record {}
+/** Recursive Avro datum. */
+type AvroDatum = AvroLeaf | AvroDatumArr | AvroDatumMap | AvroDatumRecord;
+
+function readDatum(reader: AvroReader, schema: AvroSchema): AvroDatum {
+ if (typeof schema === "string") {
+ switch (schema) {
+ case "null":
+ return null;
+ case "boolean":
+ return reader.readBoolean();
+ case "int":
+ return reader.readInt();
+ case "long":
+ return reader.readLong();
+ case "float":
+ return reader.readFloat();
+ case "double":
+ return reader.readDouble();
+ case "string":
+ return reader.readString();
+ case "bytes":
+ return reader.readByteField();
+ }
+ }
+ if (Array.isArray(schema)) {
+ // Union: first read the branch index
+ const idx = reader.readLong();
+ const branch = (schema as AvroUnion)[idx];
+ if (branch === undefined) {
+ throw new RangeError(`Union branch ${idx} out of range`);
+ }
+ return readDatum(reader, branch);
+ }
+ const s = schema as Exclude;
+ if (s.type === "record") {
+ const rec: Record = {};
+ for (const field of s.fields) {
+ rec[field.name] = readDatum(reader, field.type);
+ }
+ return rec;
+ }
+ if (s.type === "array") {
+ const arr: AvroDatum[] = [];
+ while (true) {
+ let count = reader.readLong();
+ if (count === 0) {
+ break;
+ }
+ // Negative count means block has a byte count prefix
+ if (count < 0) {
+ reader.readLong();
+ count = -count;
+ }
+ for (let i = 0; i < count; i++) {
+ arr.push(readDatum(reader, s.items));
+ }
+ }
+ return arr;
+ }
+ if (s.type === "map") {
+ const map = new Map();
+ while (true) {
+ let count = reader.readLong();
+ if (count === 0) {
+ break;
+ }
+ if (count < 0) {
+ reader.readLong();
+ count = -count;
+ }
+ for (let i = 0; i < count; i++) {
+ const key = reader.readString();
+ map.set(key, readDatum(reader, s.values));
+ }
+ }
+ return map;
+ }
+ if (s.type === "enum") {
+ const idx = reader.readInt();
+ return s.symbols[idx] ?? null;
+ }
+ if (s.type === "fixed") {
+ return reader.readBytes(s.size);
+ }
+ throw new TypeError(`Unhandled schema type: ${JSON.stringify(schema)}`);
+}
+
+// ─── OCF parsing ──────────────────────────────────────────────────────────────
+
+const AVRO_MAGIC = new Uint8Array([79, 98, 106, 1]); // "Obj\x01"
+
+function syncEq(a: Uint8Array, b: Uint8Array): boolean {
+ if (a.length !== b.length) {
+ return false;
+ }
+ for (let i = 0; i < a.length; i++) {
+ if (a[i] !== b[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Parse an Apache Avro Object Container File buffer into an array of row objects.
+ * Returns the top-level schema and the rows.
+ */
+function parseAvroOCF(buf: Uint8Array): { schema: AvroSchema; rows: Record[] } {
+ const reader = new AvroReader(buf);
+
+ // Magic: "Obj\x01"
+ const magic = reader.readBytes(4);
+ if (!syncEq(magic, AVRO_MAGIC)) {
+ throw new TypeError(
+ `Not a valid Avro file: expected magic bytes "Obj\\x01", got ${[...magic].map((b) => b.toString(16)).join(" ")}`,
+ );
+ }
+
+ // File-level metadata: map
+ const meta = new Map();
+ while (true) {
+ let count = reader.readLong();
+ if (count === 0) {
+ break;
+ }
+ if (count < 0) {
+ reader.readLong();
+ count = -count;
+ }
+ for (let i = 0; i < count; i++) {
+ const key = reader.readString();
+ const val = reader.readByteField();
+ meta.set(key, val);
+ }
+ }
+
+ // Schema
+ const schemaBytes = meta.get("avro.schema");
+ if (!schemaBytes) {
+ throw new TypeError("Avro file missing avro.schema metadata");
+ }
+ const schemaJson: unknown = JSON.parse(td.decode(schemaBytes));
+ const schema = parseSchema(schemaJson);
+
+ // Codec
+ const codecBytes = meta.get("avro.codec");
+ const codec = codecBytes ? td.decode(codecBytes) : "null";
+ if (codec !== "null") {
+ throw new TypeError(
+ `Avro codec "${codec}" is not supported. Only "null" (uncompressed) is implemented.`,
+ );
+ }
+
+ // Sync marker (16 bytes)
+ const syncMarker = reader.readSync();
+
+ // Data blocks
+ const rows: Record[] = [];
+ while (reader.remaining >= 16) {
+ const objectCount = reader.readLong();
+ const _byteCount = reader.readLong(); // block size (unused for null codec)
+ if (objectCount <= 0) {
+ break;
+ }
+
+ for (let i = 0; i < objectCount; i++) {
+ const datum = readDatum(reader, schema);
+ if (
+ typeof datum === "object" &&
+ datum !== null &&
+ !Array.isArray(datum) &&
+ !(datum instanceof Uint8Array) &&
+ !(datum instanceof Map)
+ ) {
+ rows.push(datum as Record);
+ }
+ }
+
+ // Read and verify sync marker
+ const blockSync = reader.readSync();
+ if (!syncEq(blockSync, syncMarker)) {
+ throw new TypeError("Avro sync marker mismatch — file may be corrupt");
+ }
+ }
+
+ return { schema, rows };
+}
+
+// ─── DataFrame construction ───────────────────────────────────────────────────
+
+function flattenDatum(v: AvroDatum): unknown {
+ if (v === null || typeof v !== "object") {
+ return v;
+ }
+ if (v instanceof Uint8Array) {
+ return v;
+ }
+ if (v instanceof Map) {
+ return Object.fromEntries(v);
+ }
+ // For record/array datums, JSON-stringify for simplicity
+ if (Array.isArray(v)) {
+ return JSON.stringify(v);
+ }
+ return JSON.stringify(v);
+}
+
+/**
+ * Read an Apache Avro Object Container File buffer into a {@link DataFrame}.
+ *
+ * @param data - Raw Avro OCF bytes (`Uint8Array` or `ArrayBuffer`).
+ * @param options - Optional read options.
+ */
+export function readAvro(data: Uint8Array | ArrayBuffer, options: ReadAvroOptions = {}): DataFrame {
+ const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+ const { rows } = parseAvroOCF(buf);
+
+ if (rows.length === 0) {
+ return DataFrame.fromColumns({});
+ }
+
+ // Determine columns from first row
+ const allCols = Object.keys(rows[0] ?? {});
+ const cols = options.usecols
+ ? allCols.filter((c) => (options.usecols as readonly string[]).includes(c))
+ : allCols;
+
+ const columns: Record = {};
+ for (const col of cols) {
+ columns[col] = [];
+ }
+
+ for (const row of rows) {
+ for (const col of cols) {
+ const v = row[col];
+ (columns[col] ?? []).push(flattenDatum(v ?? null) as Scalar);
+ }
+ }
+
+ return DataFrame.fromColumns(columns);
+}
+
+// ─── Avro writer (minimal — for testing round-trips) ─────────────────────────
+
+/** Options for {@link toAvro}. */
+export interface ToAvroOptions {
+ /** Schema name for the top-level record. Default: "Row". */
+ readonly schemaName?: string;
+}
+
+/**
+ * Serialize a {@link DataFrame} to an uncompressed Avro OCF buffer.
+ *
+ * Column type mapping:
+ * - boolean columns → `boolean`
+ * - integer columns → `long`
+ * - float columns → `double`
+ * - string columns → `{"type":"union","schemas":["null","string"]}`
+ * - null column vals → wrapped in union `["null", ""]`
+ * - other → `string` (JSON-stringified)
+ */
+export function toAvro(df: DataFrame, options: ToAvroOptions = {}): Uint8Array {
+ const schemaName = options.schemaName ?? "Row";
+ const cols = [...df.columns.values];
+
+ // Infer field types
+ type FieldSpec = { name: string; avroType: string; nullable: boolean };
+ const fields: FieldSpec[] = cols.map((col) => {
+ const vals = df.col(col).values;
+ let hasNull = false;
+ let hasInt = false;
+ let hasFloat = false;
+ let hasBool = false;
+ let hasStr = false;
+ for (const v of vals) {
+ if (v === null || v === undefined) {
+ hasNull = true;
+ continue;
+ }
+ if (typeof v === "boolean") {
+ hasBool = true;
+ continue;
+ }
+ if (typeof v === "number") {
+ if (Number.isInteger(v)) {
+ hasInt = true;
+ } else {
+ hasFloat = true;
+ }
+ continue;
+ }
+ hasStr = true;
+ }
+ let avroType = "string";
+ if (hasBool && !hasInt && !hasFloat && !hasStr) {
+ avroType = "boolean";
+ } else if ((hasInt || hasFloat) && !hasBool && !hasStr) {
+ avroType = hasFloat ? "double" : "long";
+ }
+ return { name: col, avroType, nullable: hasNull };
+ });
+
+ // Build schema JSON
+ const schemaFields = fields.map((f) => ({
+ name: f.name,
+ type: f.nullable ? ["null", f.avroType] : f.avroType,
+ }));
+ const schemaObj = { type: "record", name: schemaName, fields: schemaFields };
+ const schemaJson = JSON.stringify(schemaObj);
+ const schemaBytes = new TextEncoder().encode(schemaJson);
+
+ // Sync marker: 16 random-ish bytes derived from schema hash
+ const sync = new Uint8Array(16);
+ let h = 0x12345678;
+ for (let i = 0; i < schemaBytes.length; i++) {
+ h = Math.imul(h ^ (schemaBytes[i] ?? 0), 0x9e3779b9) >>> 0;
+ }
+ for (let i = 0; i < 16; i++) {
+ sync[i] = (h >> ((i % 4) * 8)) & 0xff;
+ if (i % 4 === 3) {
+ h = Math.imul(h, 0x6c62272e) >>> 0;
+ }
+ }
+
+ const chunks: Uint8Array[] = [];
+
+ // Write helper
+ const writeBuf: number[] = [];
+ const flushBuf = (): Uint8Array => {
+ const u = new Uint8Array(writeBuf);
+ writeBuf.length = 0;
+ return u;
+ };
+
+ function writeLong(v: number): void {
+ // Zigzag encode
+ let n = (v << 1) ^ (v >> 31);
+ while (n & ~0x7f) {
+ writeBuf.push((n & 0x7f) | 0x80);
+ n >>>= 7;
+ }
+ writeBuf.push(n);
+ }
+ function writeString(s: string): void {
+ const b = new TextEncoder().encode(s);
+ writeLong(b.length);
+ for (const byte of b) {
+ writeBuf.push(byte);
+ }
+ }
+ function writeBytes(b: Uint8Array): void {
+ writeLong(b.length);
+ for (const byte of b) {
+ writeBuf.push(byte);
+ }
+ }
+
+ // Magic
+ chunks.push(AVRO_MAGIC);
+
+ // Metadata: 1 map block with avro.schema and avro.codec
+ writeLong(2); // 2 entries
+ writeString("avro.schema");
+ writeBytes(schemaBytes);
+ writeString("avro.codec");
+ writeBytes(new TextEncoder().encode("null"));
+ writeLong(0); // end of map
+ chunks.push(flushBuf());
+
+ // Sync marker
+ chunks.push(sync.slice());
+
+ // Data block
+ const nRows = df.shape[0];
+ if (nRows > 0) {
+ // Encode all rows
+ for (let row = 0; row < nRows; row++) {
+ for (const f of fields) {
+ const v = df.col(f.name).at(row);
+ if (f.nullable) {
+ if (v === null || v === undefined) {
+ writeLong(0); // null branch
+ } else {
+ writeLong(1); // value branch
+ writeTypedValue(v, f.avroType);
+ }
+ } else {
+ writeTypedValue(v ?? null, f.avroType);
+ }
+ }
+ }
+ const blockData = flushBuf();
+
+ // Block header: count, byteCount
+ writeLong(nRows);
+ writeLong(blockData.length);
+ chunks.push(flushBuf());
+ chunks.push(blockData);
+ chunks.push(sync.slice());
+ }
+
+ // Concatenate all chunks
+ const totalLen = chunks.reduce((s, c) => s + c.length, 0);
+ const out = new Uint8Array(totalLen);
+ let offset = 0;
+ for (const c of chunks) {
+ out.set(c, offset);
+ offset += c.length;
+ }
+ return out;
+
+ function writeTypedValue(v: unknown, type: string): void {
+ if (v === null || v === undefined) {
+ writeBuf.push(0);
+ return;
+ } // null
+ switch (type) {
+ case "boolean":
+ writeBuf.push(v ? 1 : 0);
+ break;
+ case "long":
+ writeLong(typeof v === "number" ? v : 0);
+ break;
+ case "double": {
+ const arr = new Float64Array(1);
+ arr[0] = typeof v === "number" ? v : 0;
+ const b = new Uint8Array(arr.buffer);
+ for (const byte of b) {
+ writeBuf.push(byte);
+ }
+ break;
+ }
+ default:
+ writeString(String(v));
+ }
+ }
+}
diff --git a/src/linguistics/acquisition.ts b/src/linguistics/acquisition.ts
new file mode 100644
index 000000000..8b921d071
--- /dev/null
+++ b/src/linguistics/acquisition.ts
@@ -0,0 +1,22 @@
+/** Acquisition module — tsb analytics library. */
+
+/** Options for Acquisition. */
+export interface AcquisitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Acquisition. */
+export interface AcquisitionResult { values: number[]; converged: boolean; }
+
+/** Compute Acquisition. */
+export function computeAcquisition(data: number[], opts: AcquisitionOptions = {}): AcquisitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAcquisition };
diff --git a/src/linguistics/advanced.ts b/src/linguistics/advanced.ts
new file mode 100644
index 000000000..f3bca9854
--- /dev/null
+++ b/src/linguistics/advanced.ts
@@ -0,0 +1,15 @@
+/** Linguistics Advanced module — tsb analytics library. */
+export interface Linguistics advancedOptions { tol?: number; maxIter?: number; }
+export interface Linguistics advancedResult { values: number[]; converged: boolean; }
+export function computeLinguistics advanced(data: number[], opts: Linguistics advancedOptions = {}): Linguistics advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics advanced };
diff --git a/src/linguistics/annotation.ts b/src/linguistics/annotation.ts
new file mode 100644
index 000000000..0edf26357
--- /dev/null
+++ b/src/linguistics/annotation.ts
@@ -0,0 +1,22 @@
+/** Annotation module — tsb analytics library. */
+
+/** Options for Annotation. */
+export interface AnnotationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Annotation. */
+export interface AnnotationResult { values: number[]; converged: boolean; }
+
+/** Compute Annotation. */
+export function computeAnnotation(data: number[], opts: AnnotationOptions = {}): AnnotationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAnnotation };
diff --git a/src/linguistics/base2.ts b/src/linguistics/base2.ts
new file mode 100644
index 000000000..616c6fee5
--- /dev/null
+++ b/src/linguistics/base2.ts
@@ -0,0 +1,15 @@
+/** Linguistics Base2 module — tsb analytics library. */
+export interface Linguistics base2Options { tol?: number; maxIter?: number; }
+export interface Linguistics base2Result { values: number[]; converged: boolean; }
+export function computeLinguistics base2(data: number[], opts: Linguistics base2Options = {}): Linguistics base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics base2 };
diff --git a/src/linguistics/batch.ts b/src/linguistics/batch.ts
new file mode 100644
index 000000000..d1067269e
--- /dev/null
+++ b/src/linguistics/batch.ts
@@ -0,0 +1,15 @@
+/** Linguistics Batch module — tsb analytics library. */
+export interface Linguistics batchOptions { tol?: number; maxIter?: number; }
+export interface Linguistics batchResult { values: number[]; converged: boolean; }
+export function computeLinguistics batch(data: number[], opts: Linguistics batchOptions = {}): Linguistics batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics batch };
diff --git a/src/linguistics/beta.ts b/src/linguistics/beta.ts
new file mode 100644
index 000000000..9e0e5d4a9
--- /dev/null
+++ b/src/linguistics/beta.ts
@@ -0,0 +1,15 @@
+/** Linguistics Beta module — tsb analytics library. */
+export interface Linguistics betaOptions { tol?: number; maxIter?: number; }
+export interface Linguistics betaResult { values: number[]; converged: boolean; }
+export function computeLinguistics beta(data: number[], opts: Linguistics betaOptions = {}): Linguistics betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics beta };
diff --git a/src/linguistics/bilingualism.ts b/src/linguistics/bilingualism.ts
new file mode 100644
index 000000000..0145ec385
--- /dev/null
+++ b/src/linguistics/bilingualism.ts
@@ -0,0 +1,22 @@
+/** Bilingualism module — tsb analytics library. */
+
+/** Options for Bilingualism. */
+export interface BilingualismOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bilingualism. */
+export interface BilingualismResult { values: number[]; converged: boolean; }
+
+/** Compute Bilingualism. */
+export function computeBilingualism(data: number[], opts: BilingualismOptions = {}): BilingualismResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBilingualism };
diff --git a/src/linguistics/change.ts b/src/linguistics/change.ts
new file mode 100644
index 000000000..83dd7f167
--- /dev/null
+++ b/src/linguistics/change.ts
@@ -0,0 +1,22 @@
+/** Change module — tsb analytics library. */
+
+/** Options for Change. */
+export interface ChangeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Change. */
+export interface ChangeResult { values: number[]; converged: boolean; }
+
+/** Compute Change. */
+export function computeChange(data: number[], opts: ChangeOptions = {}): ChangeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeChange };
diff --git a/src/linguistics/computational.ts b/src/linguistics/computational.ts
new file mode 100644
index 000000000..d21be87e4
--- /dev/null
+++ b/src/linguistics/computational.ts
@@ -0,0 +1,22 @@
+/** Computational module — tsb analytics library. */
+
+/** Options for Computational. */
+export interface ComputationalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Computational. */
+export interface ComputationalResult { values: number[]; converged: boolean; }
+
+/** Compute Computational. */
+export function computeComputational(data: number[], opts: ComputationalOptions = {}): ComputationalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeComputational };
diff --git a/src/linguistics/contact.ts b/src/linguistics/contact.ts
new file mode 100644
index 000000000..40ef4b1cf
--- /dev/null
+++ b/src/linguistics/contact.ts
@@ -0,0 +1,22 @@
+/** Contact module — tsb analytics library. */
+
+/** Options for Contact. */
+export interface ContactOptions { tol?: number; maxIter?: number; }
+
+/** Result from Contact. */
+export interface ContactResult { values: number[]; converged: boolean; }
+
+/** Compute Contact. */
+export function computeContact(data: number[], opts: ContactOptions = {}): ContactResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeContact };
diff --git a/src/linguistics/corpus.ts b/src/linguistics/corpus.ts
new file mode 100644
index 000000000..9408194bb
--- /dev/null
+++ b/src/linguistics/corpus.ts
@@ -0,0 +1,22 @@
+/** Corpus module — tsb analytics library. */
+
+/** Options for Corpus. */
+export interface CorpusOptions { tol?: number; maxIter?: number; }
+
+/** Result from Corpus. */
+export interface CorpusResult { values: number[]; converged: boolean; }
+
+/** Compute Corpus. */
+export function computeCorpus(data: number[], opts: CorpusOptions = {}): CorpusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCorpus };
diff --git a/src/linguistics/cpu.ts b/src/linguistics/cpu.ts
new file mode 100644
index 000000000..1abcedbcd
--- /dev/null
+++ b/src/linguistics/cpu.ts
@@ -0,0 +1,15 @@
+/** Linguistics Cpu module — tsb analytics library. */
+export interface Linguistics cpuOptions { tol?: number; maxIter?: number; }
+export interface Linguistics cpuResult { values: number[]; converged: boolean; }
+export function computeLinguistics cpu(data: number[], opts: Linguistics cpuOptions = {}): Linguistics cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics cpu };
diff --git a/src/linguistics/dense.ts b/src/linguistics/dense.ts
new file mode 100644
index 000000000..93fda5a12
--- /dev/null
+++ b/src/linguistics/dense.ts
@@ -0,0 +1,15 @@
+/** Linguistics Dense module — tsb analytics library. */
+export interface Linguistics denseOptions { tol?: number; maxIter?: number; }
+export interface Linguistics denseResult { values: number[]; converged: boolean; }
+export function computeLinguistics dense(data: number[], opts: Linguistics denseOptions = {}): Linguistics denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics dense };
diff --git a/src/linguistics/dialectology.ts b/src/linguistics/dialectology.ts
new file mode 100644
index 000000000..e93ddabe8
--- /dev/null
+++ b/src/linguistics/dialectology.ts
@@ -0,0 +1,22 @@
+/** Dialectology module — tsb analytics library. */
+
+/** Options for Dialectology. */
+export interface DialectologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dialectology. */
+export interface DialectologyResult { values: number[]; converged: boolean; }
+
+/** Compute Dialectology. */
+export function computeDialectology(data: number[], opts: DialectologyOptions = {}): DialectologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDialectology };
diff --git a/src/linguistics/discourse.ts b/src/linguistics/discourse.ts
new file mode 100644
index 000000000..7a4f604a2
--- /dev/null
+++ b/src/linguistics/discourse.ts
@@ -0,0 +1,22 @@
+/** Discourse module — tsb analytics library. */
+
+/** Options for Discourse. */
+export interface DiscourseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Discourse. */
+export interface DiscourseResult { values: number[]; converged: boolean; }
+
+/** Compute Discourse. */
+export function computeDiscourse(data: number[], opts: DiscourseOptions = {}): DiscourseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDiscourse };
diff --git a/src/linguistics/distributed.ts b/src/linguistics/distributed.ts
new file mode 100644
index 000000000..8003fe14e
--- /dev/null
+++ b/src/linguistics/distributed.ts
@@ -0,0 +1,15 @@
+/** Linguistics Distributed module — tsb analytics library. */
+export interface Linguistics distributedOptions { tol?: number; maxIter?: number; }
+export interface Linguistics distributedResult { values: number[]; converged: boolean; }
+export function computeLinguistics distributed(data: number[], opts: Linguistics distributedOptions = {}): Linguistics distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics distributed };
diff --git a/src/linguistics/experimental.ts b/src/linguistics/experimental.ts
new file mode 100644
index 000000000..95f422d5b
--- /dev/null
+++ b/src/linguistics/experimental.ts
@@ -0,0 +1,15 @@
+/** Linguistics Experimental module — tsb analytics library. */
+export interface Linguistics experimentalOptions { tol?: number; maxIter?: number; }
+export interface Linguistics experimentalResult { values: number[]; converged: boolean; }
+export function computeLinguistics experimental(data: number[], opts: Linguistics experimentalOptions = {}): Linguistics experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics experimental };
diff --git a/src/linguistics/fast.ts b/src/linguistics/fast.ts
new file mode 100644
index 000000000..4eb64532f
--- /dev/null
+++ b/src/linguistics/fast.ts
@@ -0,0 +1,15 @@
+/** Linguistics Fast module — tsb analytics library. */
+export interface Linguistics fastOptions { tol?: number; maxIter?: number; }
+export interface Linguistics fastResult { values: number[]; converged: boolean; }
+export function computeLinguistics fast(data: number[], opts: Linguistics fastOptions = {}): Linguistics fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics fast };
diff --git a/src/linguistics/future.ts b/src/linguistics/future.ts
new file mode 100644
index 000000000..9fef1fb09
--- /dev/null
+++ b/src/linguistics/future.ts
@@ -0,0 +1,15 @@
+/** Linguistics Future module — tsb analytics library. */
+export interface Linguistics futureOptions { tol?: number; maxIter?: number; }
+export interface Linguistics futureResult { values: number[]; converged: boolean; }
+export function computeLinguistics future(data: number[], opts: Linguistics futureOptions = {}): Linguistics futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics future };
diff --git a/src/linguistics/generation_ling.ts b/src/linguistics/generation_ling.ts
new file mode 100644
index 000000000..a5a2459c4
--- /dev/null
+++ b/src/linguistics/generation_ling.ts
@@ -0,0 +1,22 @@
+/** Generation Ling module — tsb analytics library. */
+
+/** Options for Generation Ling. */
+export interface GenerationLingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Generation Ling. */
+export interface GenerationLingResult { values: number[]; converged: boolean; }
+
+/** Compute Generation Ling. */
+export function computeGenerationLing(data: number[], opts: GenerationLingOptions = {}): GenerationLingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGenerationLing };
diff --git a/src/linguistics/gesture.ts b/src/linguistics/gesture.ts
new file mode 100644
index 000000000..868d1b93c
--- /dev/null
+++ b/src/linguistics/gesture.ts
@@ -0,0 +1,22 @@
+/** Gesture module — tsb analytics library. */
+
+/** Options for Gesture. */
+export interface GestureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gesture. */
+export interface GestureResult { values: number[]; converged: boolean; }
+
+/** Compute Gesture. */
+export function computeGesture(data: number[], opts: GestureOptions = {}): GestureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGesture };
diff --git a/src/linguistics/gpu.ts b/src/linguistics/gpu.ts
new file mode 100644
index 000000000..cbc08dbfe
--- /dev/null
+++ b/src/linguistics/gpu.ts
@@ -0,0 +1,15 @@
+/** Linguistics Gpu module — tsb analytics library. */
+export interface Linguistics gpuOptions { tol?: number; maxIter?: number; }
+export interface Linguistics gpuResult { values: number[]; converged: boolean; }
+export function computeLinguistics gpu(data: number[], opts: Linguistics gpuOptions = {}): Linguistics gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics gpu };
diff --git a/src/linguistics/historical.ts b/src/linguistics/historical.ts
new file mode 100644
index 000000000..e52018ef6
--- /dev/null
+++ b/src/linguistics/historical.ts
@@ -0,0 +1,22 @@
+/** Historical module — tsb analytics library. */
+
+/** Options for Historical. */
+export interface HistoricalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Historical. */
+export interface HistoricalResult { values: number[]; converged: boolean; }
+
+/** Compute Historical. */
+export function computeHistorical(data: number[], opts: HistoricalOptions = {}): HistoricalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHistorical };
diff --git a/src/linguistics/interpreting.ts b/src/linguistics/interpreting.ts
new file mode 100644
index 000000000..64a462d07
--- /dev/null
+++ b/src/linguistics/interpreting.ts
@@ -0,0 +1,22 @@
+/** Interpreting module — tsb analytics library. */
+
+/** Options for Interpreting. */
+export interface InterpretingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Interpreting. */
+export interface InterpretingResult { values: number[]; converged: boolean; }
+
+/** Compute Interpreting. */
+export function computeInterpreting(data: number[], opts: InterpretingOptions = {}): InterpretingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInterpreting };
diff --git a/src/linguistics/intonation.ts b/src/linguistics/intonation.ts
new file mode 100644
index 000000000..1545d8633
--- /dev/null
+++ b/src/linguistics/intonation.ts
@@ -0,0 +1,22 @@
+/** Intonation module — tsb analytics library. */
+
+/** Options for Intonation. */
+export interface IntonationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Intonation. */
+export interface IntonationResult { values: number[]; converged: boolean; }
+
+/** Compute Intonation. */
+export function computeIntonation(data: number[], opts: IntonationOptions = {}): IntonationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIntonation };
diff --git a/src/linguistics/large.ts b/src/linguistics/large.ts
new file mode 100644
index 000000000..5316cfea7
--- /dev/null
+++ b/src/linguistics/large.ts
@@ -0,0 +1,15 @@
+/** Linguistics Large module — tsb analytics library. */
+export interface Linguistics largeOptions { tol?: number; maxIter?: number; }
+export interface Linguistics largeResult { values: number[]; converged: boolean; }
+export function computeLinguistics large(data: number[], opts: Linguistics largeOptions = {}): Linguistics largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics large };
diff --git a/src/linguistics/legacy.ts b/src/linguistics/legacy.ts
new file mode 100644
index 000000000..bfd030768
--- /dev/null
+++ b/src/linguistics/legacy.ts
@@ -0,0 +1,15 @@
+/** Linguistics Legacy module — tsb analytics library. */
+export interface Linguistics legacyOptions { tol?: number; maxIter?: number; }
+export interface Linguistics legacyResult { values: number[]; converged: boolean; }
+export function computeLinguistics legacy(data: number[], opts: Linguistics legacyOptions = {}): Linguistics legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics legacy };
diff --git a/src/linguistics/lite.ts b/src/linguistics/lite.ts
new file mode 100644
index 000000000..e5be4b07c
--- /dev/null
+++ b/src/linguistics/lite.ts
@@ -0,0 +1,15 @@
+/** Linguistics Lite module — tsb analytics library. */
+export interface Linguistics liteOptions { tol?: number; maxIter?: number; }
+export interface Linguistics liteResult { values: number[]; converged: boolean; }
+export function computeLinguistics lite(data: number[], opts: Linguistics liteOptions = {}): Linguistics liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics lite };
diff --git a/src/linguistics/mini.ts b/src/linguistics/mini.ts
new file mode 100644
index 000000000..f35e3cde2
--- /dev/null
+++ b/src/linguistics/mini.ts
@@ -0,0 +1,15 @@
+/** Linguistics Mini module — tsb analytics library. */
+export interface Linguistics miniOptions { tol?: number; maxIter?: number; }
+export interface Linguistics miniResult { values: number[]; converged: boolean; }
+export function computeLinguistics mini(data: number[], opts: Linguistics miniOptions = {}): Linguistics miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics mini };
diff --git a/src/linguistics/morphology.ts b/src/linguistics/morphology.ts
new file mode 100644
index 000000000..d2351acf1
--- /dev/null
+++ b/src/linguistics/morphology.ts
@@ -0,0 +1,22 @@
+/** Morphology module — tsb analytics library. */
+
+/** Options for Morphology. */
+export interface MorphologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Morphology. */
+export interface MorphologyResult { values: number[]; converged: boolean; }
+
+/** Compute Morphology. */
+export function computeMorphology(data: number[], opts: MorphologyOptions = {}): MorphologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMorphology };
diff --git a/src/linguistics/multilingualism.ts b/src/linguistics/multilingualism.ts
new file mode 100644
index 000000000..acb3d3569
--- /dev/null
+++ b/src/linguistics/multilingualism.ts
@@ -0,0 +1,22 @@
+/** Multilingualism module — tsb analytics library. */
+
+/** Options for Multilingualism. */
+export interface MultilingualismOptions { tol?: number; maxIter?: number; }
+
+/** Result from Multilingualism. */
+export interface MultilingualismResult { values: number[]; converged: boolean; }
+
+/** Compute Multilingualism. */
+export function computeMultilingualism(data: number[], opts: MultilingualismOptions = {}): MultilingualismResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMultilingualism };
diff --git a/src/linguistics/neurolinguistics.ts b/src/linguistics/neurolinguistics.ts
new file mode 100644
index 000000000..0de0f2fe2
--- /dev/null
+++ b/src/linguistics/neurolinguistics.ts
@@ -0,0 +1,22 @@
+/** Neurolinguistics module — tsb analytics library. */
+
+/** Options for Neurolinguistics. */
+export interface NeurolinguisticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Neurolinguistics. */
+export interface NeurolinguisticsResult { values: number[]; converged: boolean; }
+
+/** Compute Neurolinguistics. */
+export function computeNeurolinguistics(data: number[], opts: NeurolinguisticsOptions = {}): NeurolinguisticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNeurolinguistics };
diff --git a/src/linguistics/next.ts b/src/linguistics/next.ts
new file mode 100644
index 000000000..93e48e5a7
--- /dev/null
+++ b/src/linguistics/next.ts
@@ -0,0 +1,15 @@
+/** Linguistics Next module — tsb analytics library. */
+export interface Linguistics nextOptions { tol?: number; maxIter?: number; }
+export interface Linguistics nextResult { values: number[]; converged: boolean; }
+export function computeLinguistics next(data: number[], opts: Linguistics nextOptions = {}): Linguistics nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics next };
diff --git a/src/linguistics/online.ts b/src/linguistics/online.ts
new file mode 100644
index 000000000..757ae21c3
--- /dev/null
+++ b/src/linguistics/online.ts
@@ -0,0 +1,15 @@
+/** Linguistics Online module — tsb analytics library. */
+export interface Linguistics onlineOptions { tol?: number; maxIter?: number; }
+export interface Linguistics onlineResult { values: number[]; converged: boolean; }
+export function computeLinguistics online(data: number[], opts: Linguistics onlineOptions = {}): Linguistics onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics online };
diff --git a/src/linguistics/parallel.ts b/src/linguistics/parallel.ts
new file mode 100644
index 000000000..582e196cf
--- /dev/null
+++ b/src/linguistics/parallel.ts
@@ -0,0 +1,15 @@
+/** Linguistics Parallel module — tsb analytics library. */
+export interface Linguistics parallelOptions { tol?: number; maxIter?: number; }
+export interface Linguistics parallelResult { values: number[]; converged: boolean; }
+export function computeLinguistics parallel(data: number[], opts: Linguistics parallelOptions = {}): Linguistics parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics parallel };
diff --git a/src/linguistics/parsing_ling.ts b/src/linguistics/parsing_ling.ts
new file mode 100644
index 000000000..a69ecbdb6
--- /dev/null
+++ b/src/linguistics/parsing_ling.ts
@@ -0,0 +1,22 @@
+/** Parsing Ling module — tsb analytics library. */
+
+/** Options for Parsing Ling. */
+export interface ParsingLingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Parsing Ling. */
+export interface ParsingLingResult { values: number[]; converged: boolean; }
+
+/** Compute Parsing Ling. */
+export function computeParsingLing(data: number[], opts: ParsingLingOptions = {}): ParsingLingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeParsingLing };
diff --git a/src/linguistics/phonetics.ts b/src/linguistics/phonetics.ts
new file mode 100644
index 000000000..cbf992588
--- /dev/null
+++ b/src/linguistics/phonetics.ts
@@ -0,0 +1,22 @@
+/** Phonetics module — tsb analytics library. */
+
+/** Options for Phonetics. */
+export interface PhoneticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Phonetics. */
+export interface PhoneticsResult { values: number[]; converged: boolean; }
+
+/** Compute Phonetics. */
+export function computePhonetics(data: number[], opts: PhoneticsOptions = {}): PhoneticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhonetics };
diff --git a/src/linguistics/phonology.ts b/src/linguistics/phonology.ts
new file mode 100644
index 000000000..be2623fa2
--- /dev/null
+++ b/src/linguistics/phonology.ts
@@ -0,0 +1,22 @@
+/** Phonology module — tsb analytics library. */
+
+/** Options for Phonology. */
+export interface PhonologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Phonology. */
+export interface PhonologyResult { values: number[]; converged: boolean; }
+
+/** Compute Phonology. */
+export function computePhonology(data: number[], opts: PhonologyOptions = {}): PhonologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhonology };
diff --git a/src/linguistics/plus.ts b/src/linguistics/plus.ts
new file mode 100644
index 000000000..dc5ef0dd5
--- /dev/null
+++ b/src/linguistics/plus.ts
@@ -0,0 +1,15 @@
+/** Linguistics Plus module — tsb analytics library. */
+export interface Linguistics plusOptions { tol?: number; maxIter?: number; }
+export interface Linguistics plusResult { values: number[]; converged: boolean; }
+export function computeLinguistics plus(data: number[], opts: Linguistics plusOptions = {}): Linguistics plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics plus };
diff --git a/src/linguistics/pragmatics.ts b/src/linguistics/pragmatics.ts
new file mode 100644
index 000000000..321ecc0f8
--- /dev/null
+++ b/src/linguistics/pragmatics.ts
@@ -0,0 +1,22 @@
+/** Pragmatics module — tsb analytics library. */
+
+/** Options for Pragmatics. */
+export interface PragmaticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pragmatics. */
+export interface PragmaticsResult { values: number[]; converged: boolean; }
+
+/** Compute Pragmatics. */
+export function computePragmatics(data: number[], opts: PragmaticsOptions = {}): PragmaticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePragmatics };
diff --git a/src/linguistics/pro.ts b/src/linguistics/pro.ts
new file mode 100644
index 000000000..a6bab9267
--- /dev/null
+++ b/src/linguistics/pro.ts
@@ -0,0 +1,15 @@
+/** Linguistics Pro module — tsb analytics library. */
+export interface Linguistics proOptions { tol?: number; maxIter?: number; }
+export interface Linguistics proResult { values: number[]; converged: boolean; }
+export function computeLinguistics pro(data: number[], opts: Linguistics proOptions = {}): Linguistics proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics pro };
diff --git a/src/linguistics/prosody.ts b/src/linguistics/prosody.ts
new file mode 100644
index 000000000..fa1f4eee8
--- /dev/null
+++ b/src/linguistics/prosody.ts
@@ -0,0 +1,22 @@
+/** Prosody module — tsb analytics library. */
+
+/** Options for Prosody. */
+export interface ProsodyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Prosody. */
+export interface ProsodyResult { values: number[]; converged: boolean; }
+
+/** Compute Prosody. */
+export function computeProsody(data: number[], opts: ProsodyOptions = {}): ProsodyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProsody };
diff --git a/src/linguistics/psycholinguistics.ts b/src/linguistics/psycholinguistics.ts
new file mode 100644
index 000000000..ad0537b3c
--- /dev/null
+++ b/src/linguistics/psycholinguistics.ts
@@ -0,0 +1,22 @@
+/** Psycholinguistics module — tsb analytics library. */
+
+/** Options for Psycholinguistics. */
+export interface PsycholinguisticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Psycholinguistics. */
+export interface PsycholinguisticsResult { values: number[]; converged: boolean; }
+
+/** Compute Psycholinguistics. */
+export function computePsycholinguistics(data: number[], opts: PsycholinguisticsOptions = {}): PsycholinguisticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePsycholinguistics };
diff --git a/src/linguistics/robust.ts b/src/linguistics/robust.ts
new file mode 100644
index 000000000..dac0e3a82
--- /dev/null
+++ b/src/linguistics/robust.ts
@@ -0,0 +1,15 @@
+/** Linguistics Robust module — tsb analytics library. */
+export interface Linguistics robustOptions { tol?: number; maxIter?: number; }
+export interface Linguistics robustResult { values: number[]; converged: boolean; }
+export function computeLinguistics robust(data: number[], opts: Linguistics robustOptions = {}): Linguistics robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics robust };
diff --git a/src/linguistics/semantics.ts b/src/linguistics/semantics.ts
new file mode 100644
index 000000000..9b8d3a77d
--- /dev/null
+++ b/src/linguistics/semantics.ts
@@ -0,0 +1,22 @@
+/** Semantics module — tsb analytics library. */
+
+/** Options for Semantics. */
+export interface SemanticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Semantics. */
+export interface SemanticsResult { values: number[]; converged: boolean; }
+
+/** Compute Semantics. */
+export function computeSemantics(data: number[], opts: SemanticsOptions = {}): SemanticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSemantics };
diff --git a/src/linguistics/sign.ts b/src/linguistics/sign.ts
new file mode 100644
index 000000000..4848823dd
--- /dev/null
+++ b/src/linguistics/sign.ts
@@ -0,0 +1,22 @@
+/** Sign module — tsb analytics library. */
+
+/** Options for Sign. */
+export interface SignOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sign. */
+export interface SignResult { values: number[]; converged: boolean; }
+
+/** Compute Sign. */
+export function computeSign(data: number[], opts: SignOptions = {}): SignResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSign };
diff --git a/src/linguistics/small.ts b/src/linguistics/small.ts
new file mode 100644
index 000000000..58cf329df
--- /dev/null
+++ b/src/linguistics/small.ts
@@ -0,0 +1,15 @@
+/** Linguistics Small module — tsb analytics library. */
+export interface Linguistics smallOptions { tol?: number; maxIter?: number; }
+export interface Linguistics smallResult { values: number[]; converged: boolean; }
+export function computeLinguistics small(data: number[], opts: Linguistics smallOptions = {}): Linguistics smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics small };
diff --git a/src/linguistics/sociolinguistics.ts b/src/linguistics/sociolinguistics.ts
new file mode 100644
index 000000000..a37e7e6f0
--- /dev/null
+++ b/src/linguistics/sociolinguistics.ts
@@ -0,0 +1,22 @@
+/** Sociolinguistics module — tsb analytics library. */
+
+/** Options for Sociolinguistics. */
+export interface SociolinguisticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sociolinguistics. */
+export interface SociolinguisticsResult { values: number[]; converged: boolean; }
+
+/** Compute Sociolinguistics. */
+export function computeSociolinguistics(data: number[], opts: SociolinguisticsOptions = {}): SociolinguisticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSociolinguistics };
diff --git a/src/linguistics/sparse.ts b/src/linguistics/sparse.ts
new file mode 100644
index 000000000..e321063b3
--- /dev/null
+++ b/src/linguistics/sparse.ts
@@ -0,0 +1,15 @@
+/** Linguistics Sparse module — tsb analytics library. */
+export interface Linguistics sparseOptions { tol?: number; maxIter?: number; }
+export interface Linguistics sparseResult { values: number[]; converged: boolean; }
+export function computeLinguistics sparse(data: number[], opts: Linguistics sparseOptions = {}): Linguistics sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics sparse };
diff --git a/src/linguistics/stable.ts b/src/linguistics/stable.ts
new file mode 100644
index 000000000..72a0bab01
--- /dev/null
+++ b/src/linguistics/stable.ts
@@ -0,0 +1,15 @@
+/** Linguistics Stable module — tsb analytics library. */
+export interface Linguistics stableOptions { tol?: number; maxIter?: number; }
+export interface Linguistics stableResult { values: number[]; converged: boolean; }
+export function computeLinguistics stable(data: number[], opts: Linguistics stableOptions = {}): Linguistics stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics stable };
diff --git a/src/linguistics/streaming.ts b/src/linguistics/streaming.ts
new file mode 100644
index 000000000..01a9eb46a
--- /dev/null
+++ b/src/linguistics/streaming.ts
@@ -0,0 +1,15 @@
+/** Linguistics Streaming module — tsb analytics library. */
+export interface Linguistics streamingOptions { tol?: number; maxIter?: number; }
+export interface Linguistics streamingResult { values: number[]; converged: boolean; }
+export function computeLinguistics streaming(data: number[], opts: Linguistics streamingOptions = {}): Linguistics streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics streaming };
diff --git a/src/linguistics/syntax.ts b/src/linguistics/syntax.ts
new file mode 100644
index 000000000..0d6a5af43
--- /dev/null
+++ b/src/linguistics/syntax.ts
@@ -0,0 +1,22 @@
+/** Syntax module — tsb analytics library. */
+
+/** Options for Syntax. */
+export interface SyntaxOptions { tol?: number; maxIter?: number; }
+
+/** Result from Syntax. */
+export interface SyntaxResult { values: number[]; converged: boolean; }
+
+/** Compute Syntax. */
+export function computeSyntax(data: number[], opts: SyntaxOptions = {}): SyntaxResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSyntax };
diff --git a/src/linguistics/translation_ling.ts b/src/linguistics/translation_ling.ts
new file mode 100644
index 000000000..890351d24
--- /dev/null
+++ b/src/linguistics/translation_ling.ts
@@ -0,0 +1,22 @@
+/** Translation Ling module — tsb analytics library. */
+
+/** Options for Translation Ling. */
+export interface TranslationLingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Translation Ling. */
+export interface TranslationLingResult { values: number[]; converged: boolean; }
+
+/** Compute Translation Ling. */
+export function computeTranslationLing(data: number[], opts: TranslationLingOptions = {}): TranslationLingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTranslationLing };
diff --git a/src/linguistics/typology.ts b/src/linguistics/typology.ts
new file mode 100644
index 000000000..f868dbeb1
--- /dev/null
+++ b/src/linguistics/typology.ts
@@ -0,0 +1,22 @@
+/** Typology module — tsb analytics library. */
+
+/** Options for Typology. */
+export interface TypologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Typology. */
+export interface TypologyResult { values: number[]; converged: boolean; }
+
+/** Compute Typology. */
+export function computeTypology(data: number[], opts: TypologyOptions = {}): TypologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTypology };
diff --git a/src/linguistics/v2.ts b/src/linguistics/v2.ts
new file mode 100644
index 000000000..010f0a96d
--- /dev/null
+++ b/src/linguistics/v2.ts
@@ -0,0 +1,15 @@
+/** Linguistics V2 module — tsb analytics library. */
+export interface Linguistics v2Options { tol?: number; maxIter?: number; }
+export interface Linguistics v2Result { values: number[]; converged: boolean; }
+export function computeLinguistics v2(data: number[], opts: Linguistics v2Options = {}): Linguistics v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics v2 };
diff --git a/src/linguistics/v3.ts b/src/linguistics/v3.ts
new file mode 100644
index 000000000..6278742c8
--- /dev/null
+++ b/src/linguistics/v3.ts
@@ -0,0 +1,15 @@
+/** Linguistics V3 module — tsb analytics library. */
+export interface Linguistics v3Options { tol?: number; maxIter?: number; }
+export interface Linguistics v3Result { values: number[]; converged: boolean; }
+export function computeLinguistics v3(data: number[], opts: Linguistics v3Options = {}): Linguistics v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics v3 };
diff --git a/src/linguistics/variation.ts b/src/linguistics/variation.ts
new file mode 100644
index 000000000..eac84b593
--- /dev/null
+++ b/src/linguistics/variation.ts
@@ -0,0 +1,22 @@
+/** Variation module — tsb analytics library. */
+
+/** Options for Variation. */
+export interface VariationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Variation. */
+export interface VariationResult { values: number[]; converged: boolean; }
+
+/** Compute Variation. */
+export function computeVariation(data: number[], opts: VariationOptions = {}): VariationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVariation };
diff --git a/src/linguistics/wasm.ts b/src/linguistics/wasm.ts
new file mode 100644
index 000000000..9240d3dbf
--- /dev/null
+++ b/src/linguistics/wasm.ts
@@ -0,0 +1,15 @@
+/** Linguistics Wasm module — tsb analytics library. */
+export interface Linguistics wasmOptions { tol?: number; maxIter?: number; }
+export interface Linguistics wasmResult { values: number[]; converged: boolean; }
+export function computeLinguistics wasm(data: number[], opts: Linguistics wasmOptions = {}): Linguistics wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics wasm };
diff --git a/src/linguistics/xlarge.ts b/src/linguistics/xlarge.ts
new file mode 100644
index 000000000..e32e27cae
--- /dev/null
+++ b/src/linguistics/xlarge.ts
@@ -0,0 +1,15 @@
+/** Linguistics Xlarge module — tsb analytics library. */
+export interface Linguistics xlargeOptions { tol?: number; maxIter?: number; }
+export interface Linguistics xlargeResult { values: number[]; converged: boolean; }
+export function computeLinguistics xlarge(data: number[], opts: Linguistics xlargeOptions = {}): Linguistics xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLinguistics xlarge };
diff --git a/src/lipidomics/adaptation.ts b/src/lipidomics/adaptation.ts
new file mode 100644
index 000000000..87545c755
--- /dev/null
+++ b/src/lipidomics/adaptation.ts
@@ -0,0 +1,14 @@
+/** lipidomics adaptation module — tsb analytics library. */
+export interface LipidomicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsAdaptation(data: number[], opts: LipidomicsAdaptationOptions = {}): LipidomicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsAdaptation };
diff --git a/src/lipidomics/aggregation.ts b/src/lipidomics/aggregation.ts
new file mode 100644
index 000000000..3995aabec
--- /dev/null
+++ b/src/lipidomics/aggregation.ts
@@ -0,0 +1,14 @@
+/** lipidomics aggregation module — tsb analytics library. */
+export interface LipidomicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsAggregationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsAggregation(data: number[], opts: LipidomicsAggregationOptions = {}): LipidomicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsAggregation };
diff --git a/src/lipidomics/algebra.ts b/src/lipidomics/algebra.ts
new file mode 100644
index 000000000..87c78220a
--- /dev/null
+++ b/src/lipidomics/algebra.ts
@@ -0,0 +1,14 @@
+/** lipidomics algebra module — tsb analytics library. */
+export interface LipidomicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeLipidomicsAlgebra(data: number[], opts: LipidomicsAlgebraOptions = {}): LipidomicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsAlgebra };
diff --git a/src/lipidomics/alignment.ts b/src/lipidomics/alignment.ts
new file mode 100644
index 000000000..1211880ea
--- /dev/null
+++ b/src/lipidomics/alignment.ts
@@ -0,0 +1,14 @@
+/** lipidomics alignment module — tsb analytics library. */
+export interface LipidomicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeLipidomicsAlignment(data: number[], opts: LipidomicsAlignmentOptions = {}): LipidomicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsAlignment };
diff --git a/src/lipidomics/analysis.ts b/src/lipidomics/analysis.ts
new file mode 100644
index 000000000..0a113531b
--- /dev/null
+++ b/src/lipidomics/analysis.ts
@@ -0,0 +1,14 @@
+/** lipidomics analysis module — tsb analytics library. */
+export interface LipidomicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeLipidomicsAnalysis(data: number[], opts: LipidomicsAnalysisOptions = {}): LipidomicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsAnalysis };
diff --git a/src/lipidomics/augmentation.ts b/src/lipidomics/augmentation.ts
new file mode 100644
index 000000000..3dde1eb5d
--- /dev/null
+++ b/src/lipidomics/augmentation.ts
@@ -0,0 +1,14 @@
+/** lipidomics augmentation module — tsb analytics library. */
+export interface LipidomicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsAugmentation(data: number[], opts: LipidomicsAugmentationOptions = {}): LipidomicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsAugmentation };
diff --git a/src/lipidomics/bagging.ts b/src/lipidomics/bagging.ts
new file mode 100644
index 000000000..ba19ca603
--- /dev/null
+++ b/src/lipidomics/bagging.ts
@@ -0,0 +1,14 @@
+/** lipidomics bagging module — tsb analytics library. */
+export interface LipidomicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsBaggingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsBagging(data: number[], opts: LipidomicsBaggingOptions = {}): LipidomicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsBagging };
diff --git a/src/lipidomics/basis.ts b/src/lipidomics/basis.ts
new file mode 100644
index 000000000..610b087ac
--- /dev/null
+++ b/src/lipidomics/basis.ts
@@ -0,0 +1,14 @@
+/** lipidomics basis module — tsb analytics library. */
+export interface LipidomicsBasisOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsBasisResult { values: number[]; converged: boolean; }
+export function computeLipidomicsBasis(data: number[], opts: LipidomicsBasisOptions = {}): LipidomicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsBasis };
diff --git a/src/lipidomics/benchmarking.ts b/src/lipidomics/benchmarking.ts
new file mode 100644
index 000000000..70029e8fb
--- /dev/null
+++ b/src/lipidomics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** lipidomics benchmarking module — tsb analytics library. */
+export interface LipidomicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsBenchmarking(data: number[], opts: LipidomicsBenchmarkingOptions = {}): LipidomicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsBenchmarking };
diff --git a/src/lipidomics/blending.ts b/src/lipidomics/blending.ts
new file mode 100644
index 000000000..53e695d7d
--- /dev/null
+++ b/src/lipidomics/blending.ts
@@ -0,0 +1,14 @@
+/** lipidomics blending module — tsb analytics library. */
+export interface LipidomicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsBlendingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsBlending(data: number[], opts: LipidomicsBlendingOptions = {}): LipidomicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsBlending };
diff --git a/src/lipidomics/boosting.ts b/src/lipidomics/boosting.ts
new file mode 100644
index 000000000..315dd1612
--- /dev/null
+++ b/src/lipidomics/boosting.ts
@@ -0,0 +1,14 @@
+/** lipidomics boosting module — tsb analytics library. */
+export interface LipidomicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsBoostingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsBoosting(data: number[], opts: LipidomicsBoostingOptions = {}): LipidomicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsBoosting };
diff --git a/src/lipidomics/bootstrap.ts b/src/lipidomics/bootstrap.ts
new file mode 100644
index 000000000..d50937678
--- /dev/null
+++ b/src/lipidomics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** lipidomics bootstrap module — tsb analytics library. */
+export interface LipidomicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeLipidomicsBootstrap(data: number[], opts: LipidomicsBootstrapOptions = {}): LipidomicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsBootstrap };
diff --git a/src/lipidomics/calculus.ts b/src/lipidomics/calculus.ts
new file mode 100644
index 000000000..523789303
--- /dev/null
+++ b/src/lipidomics/calculus.ts
@@ -0,0 +1,14 @@
+/** lipidomics calculus module — tsb analytics library. */
+export interface LipidomicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsCalculusResult { values: number[]; converged: boolean; }
+export function computeLipidomicsCalculus(data: number[], opts: LipidomicsCalculusOptions = {}): LipidomicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsCalculus };
diff --git a/src/lipidomics/calibration.ts b/src/lipidomics/calibration.ts
new file mode 100644
index 000000000..2d9c553fa
--- /dev/null
+++ b/src/lipidomics/calibration.ts
@@ -0,0 +1,14 @@
+/** lipidomics calibration module — tsb analytics library. */
+export interface LipidomicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsCalibration(data: number[], opts: LipidomicsCalibrationOptions = {}): LipidomicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsCalibration };
diff --git a/src/lipidomics/characterization.ts b/src/lipidomics/characterization.ts
new file mode 100644
index 000000000..d0cbae565
--- /dev/null
+++ b/src/lipidomics/characterization.ts
@@ -0,0 +1,14 @@
+/** lipidomics characterization module — tsb analytics library. */
+export interface LipidomicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsCharacterization(data: number[], opts: LipidomicsCharacterizationOptions = {}): LipidomicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsCharacterization };
diff --git a/src/lipidomics/classification.ts b/src/lipidomics/classification.ts
new file mode 100644
index 000000000..a131c3eb3
--- /dev/null
+++ b/src/lipidomics/classification.ts
@@ -0,0 +1,14 @@
+/** lipidomics classification module — tsb analytics library. */
+export interface LipidomicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsClassificationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsClassification(data: number[], opts: LipidomicsClassificationOptions = {}): LipidomicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsClassification };
diff --git a/src/lipidomics/clustering.ts b/src/lipidomics/clustering.ts
new file mode 100644
index 000000000..ba705c2d4
--- /dev/null
+++ b/src/lipidomics/clustering.ts
@@ -0,0 +1,14 @@
+/** lipidomics clustering module — tsb analytics library. */
+export interface LipidomicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsClusteringResult { values: number[]; converged: boolean; }
+export function computeLipidomicsClustering(data: number[], opts: LipidomicsClusteringOptions = {}): LipidomicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsClustering };
diff --git a/src/lipidomics/compression.ts b/src/lipidomics/compression.ts
new file mode 100644
index 000000000..860273b09
--- /dev/null
+++ b/src/lipidomics/compression.ts
@@ -0,0 +1,14 @@
+/** lipidomics compression module — tsb analytics library. */
+export interface LipidomicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsCompressionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsCompression(data: number[], opts: LipidomicsCompressionOptions = {}): LipidomicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsCompression };
diff --git a/src/lipidomics/continuous.ts b/src/lipidomics/continuous.ts
new file mode 100644
index 000000000..23883ce47
--- /dev/null
+++ b/src/lipidomics/continuous.ts
@@ -0,0 +1,14 @@
+/** lipidomics continuous module — tsb analytics library. */
+export interface LipidomicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsContinuousResult { values: number[]; converged: boolean; }
+export function computeLipidomicsContinuous(data: number[], opts: LipidomicsContinuousOptions = {}): LipidomicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsContinuous };
diff --git a/src/lipidomics/control.ts b/src/lipidomics/control.ts
new file mode 100644
index 000000000..f44311d0f
--- /dev/null
+++ b/src/lipidomics/control.ts
@@ -0,0 +1,14 @@
+/** lipidomics control module — tsb analytics library. */
+export interface LipidomicsControlOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsControlResult { values: number[]; converged: boolean; }
+export function computeLipidomicsControl(data: number[], opts: LipidomicsControlOptions = {}): LipidomicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsControl };
diff --git a/src/lipidomics/convergence.ts b/src/lipidomics/convergence.ts
new file mode 100644
index 000000000..c3f4b1b2d
--- /dev/null
+++ b/src/lipidomics/convergence.ts
@@ -0,0 +1,14 @@
+/** lipidomics convergence module — tsb analytics library. */
+export interface LipidomicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeLipidomicsConvergence(data: number[], opts: LipidomicsConvergenceOptions = {}): LipidomicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsConvergence };
diff --git a/src/lipidomics/convex.ts b/src/lipidomics/convex.ts
new file mode 100644
index 000000000..d013f79a7
--- /dev/null
+++ b/src/lipidomics/convex.ts
@@ -0,0 +1,14 @@
+/** lipidomics convex module — tsb analytics library. */
+export interface LipidomicsConvexOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsConvexResult { values: number[]; converged: boolean; }
+export function computeLipidomicsConvex(data: number[], opts: LipidomicsConvexOptions = {}): LipidomicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsConvex };
diff --git a/src/lipidomics/correlation.ts b/src/lipidomics/correlation.ts
new file mode 100644
index 000000000..5ebe99745
--- /dev/null
+++ b/src/lipidomics/correlation.ts
@@ -0,0 +1,14 @@
+/** lipidomics correlation module — tsb analytics library. */
+export interface LipidomicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsCorrelation(data: number[], opts: LipidomicsCorrelationOptions = {}): LipidomicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsCorrelation };
diff --git a/src/lipidomics/covariance.ts b/src/lipidomics/covariance.ts
new file mode 100644
index 000000000..962ad2783
--- /dev/null
+++ b/src/lipidomics/covariance.ts
@@ -0,0 +1,14 @@
+/** lipidomics covariance module — tsb analytics library. */
+export interface LipidomicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeLipidomicsCovariance(data: number[], opts: LipidomicsCovarianceOptions = {}): LipidomicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsCovariance };
diff --git a/src/lipidomics/cross_validation.ts b/src/lipidomics/cross_validation.ts
new file mode 100644
index 000000000..66d642a04
--- /dev/null
+++ b/src/lipidomics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** lipidomics cross_validation module — tsb analytics library. */
+export interface LipidomicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsCrossValidation(data: number[], opts: LipidomicsCrossValidationOptions = {}): LipidomicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsCrossValidation };
diff --git a/src/lipidomics/decoding.ts b/src/lipidomics/decoding.ts
new file mode 100644
index 000000000..5274f98b1
--- /dev/null
+++ b/src/lipidomics/decoding.ts
@@ -0,0 +1,14 @@
+/** lipidomics decoding module — tsb analytics library. */
+export interface LipidomicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDecodingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDecoding(data: number[], opts: LipidomicsDecodingOptions = {}): LipidomicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDecoding };
diff --git a/src/lipidomics/decomposition.ts b/src/lipidomics/decomposition.ts
new file mode 100644
index 000000000..7c775e451
--- /dev/null
+++ b/src/lipidomics/decomposition.ts
@@ -0,0 +1,14 @@
+/** lipidomics decomposition module — tsb analytics library. */
+export interface LipidomicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDecomposition(data: number[], opts: LipidomicsDecompositionOptions = {}): LipidomicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDecomposition };
diff --git a/src/lipidomics/detection.ts b/src/lipidomics/detection.ts
new file mode 100644
index 000000000..241013269
--- /dev/null
+++ b/src/lipidomics/detection.ts
@@ -0,0 +1,14 @@
+/** lipidomics detection module — tsb analytics library. */
+export interface LipidomicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDetectionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDetection(data: number[], opts: LipidomicsDetectionOptions = {}): LipidomicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDetection };
diff --git a/src/lipidomics/deterministic.ts b/src/lipidomics/deterministic.ts
new file mode 100644
index 000000000..ffaf68d23
--- /dev/null
+++ b/src/lipidomics/deterministic.ts
@@ -0,0 +1,14 @@
+/** lipidomics deterministic module — tsb analytics library. */
+export interface LipidomicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDeterministic(data: number[], opts: LipidomicsDeterministicOptions = {}): LipidomicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDeterministic };
diff --git a/src/lipidomics/diagnostics.ts b/src/lipidomics/diagnostics.ts
new file mode 100644
index 000000000..628fd1118
--- /dev/null
+++ b/src/lipidomics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** lipidomics diagnostics module — tsb analytics library. */
+export interface LipidomicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDiagnostics(data: number[], opts: LipidomicsDiagnosticsOptions = {}): LipidomicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDiagnostics };
diff --git a/src/lipidomics/differential.ts b/src/lipidomics/differential.ts
new file mode 100644
index 000000000..c0aa7176c
--- /dev/null
+++ b/src/lipidomics/differential.ts
@@ -0,0 +1,14 @@
+/** lipidomics differential module — tsb analytics library. */
+export interface LipidomicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDifferential(data: number[], opts: LipidomicsDifferentialOptions = {}): LipidomicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDifferential };
diff --git a/src/lipidomics/discrete.ts b/src/lipidomics/discrete.ts
new file mode 100644
index 000000000..b5f86c7dd
--- /dev/null
+++ b/src/lipidomics/discrete.ts
@@ -0,0 +1,14 @@
+/** lipidomics discrete module — tsb analytics library. */
+export interface LipidomicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDiscrete(data: number[], opts: LipidomicsDiscreteOptions = {}): LipidomicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDiscrete };
diff --git a/src/lipidomics/distribution.ts b/src/lipidomics/distribution.ts
new file mode 100644
index 000000000..189b3e17d
--- /dev/null
+++ b/src/lipidomics/distribution.ts
@@ -0,0 +1,14 @@
+/** lipidomics distribution module — tsb analytics library. */
+export interface LipidomicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDistributionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDistribution(data: number[], opts: LipidomicsDistributionOptions = {}): LipidomicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDistribution };
diff --git a/src/lipidomics/dynamic.ts b/src/lipidomics/dynamic.ts
new file mode 100644
index 000000000..f5898caf9
--- /dev/null
+++ b/src/lipidomics/dynamic.ts
@@ -0,0 +1,14 @@
+/** lipidomics dynamic module — tsb analytics library. */
+export interface LipidomicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsDynamicResult { values: number[]; converged: boolean; }
+export function computeLipidomicsDynamic(data: number[], opts: LipidomicsDynamicOptions = {}): LipidomicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsDynamic };
diff --git a/src/lipidomics/embedding.ts b/src/lipidomics/embedding.ts
new file mode 100644
index 000000000..395c6d005
--- /dev/null
+++ b/src/lipidomics/embedding.ts
@@ -0,0 +1,14 @@
+/** lipidomics embedding module — tsb analytics library. */
+export interface LipidomicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsEmbedding(data: number[], opts: LipidomicsEmbeddingOptions = {}): LipidomicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsEmbedding };
diff --git a/src/lipidomics/encoding.ts b/src/lipidomics/encoding.ts
new file mode 100644
index 000000000..de9133148
--- /dev/null
+++ b/src/lipidomics/encoding.ts
@@ -0,0 +1,14 @@
+/** lipidomics encoding module — tsb analytics library. */
+export interface LipidomicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsEncodingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsEncoding(data: number[], opts: LipidomicsEncodingOptions = {}): LipidomicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsEncoding };
diff --git a/src/lipidomics/ensemble.ts b/src/lipidomics/ensemble.ts
new file mode 100644
index 000000000..c135a7e7e
--- /dev/null
+++ b/src/lipidomics/ensemble.ts
@@ -0,0 +1,14 @@
+/** lipidomics ensemble module — tsb analytics library. */
+export interface LipidomicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeLipidomicsEnsemble(data: number[], opts: LipidomicsEnsembleOptions = {}): LipidomicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsEnsemble };
diff --git a/src/lipidomics/estimation.ts b/src/lipidomics/estimation.ts
new file mode 100644
index 000000000..b059ecf2f
--- /dev/null
+++ b/src/lipidomics/estimation.ts
@@ -0,0 +1,14 @@
+/** lipidomics estimation module — tsb analytics library. */
+export interface LipidomicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsEstimationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsEstimation(data: number[], opts: LipidomicsEstimationOptions = {}): LipidomicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsEstimation };
diff --git a/src/lipidomics/evaluation.ts b/src/lipidomics/evaluation.ts
new file mode 100644
index 000000000..9c134a470
--- /dev/null
+++ b/src/lipidomics/evaluation.ts
@@ -0,0 +1,14 @@
+/** lipidomics evaluation module — tsb analytics library. */
+export interface LipidomicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsEvaluation(data: number[], opts: LipidomicsEvaluationOptions = {}): LipidomicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsEvaluation };
diff --git a/src/lipidomics/extrapolation.ts b/src/lipidomics/extrapolation.ts
new file mode 100644
index 000000000..8567d6db3
--- /dev/null
+++ b/src/lipidomics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** lipidomics extrapolation module — tsb analytics library. */
+export interface LipidomicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsExtrapolation(data: number[], opts: LipidomicsExtrapolationOptions = {}): LipidomicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsExtrapolation };
diff --git a/src/lipidomics/features.ts b/src/lipidomics/features.ts
new file mode 100644
index 000000000..6125b574f
--- /dev/null
+++ b/src/lipidomics/features.ts
@@ -0,0 +1,14 @@
+/** lipidomics features module — tsb analytics library. */
+export interface LipidomicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeLipidomicsFeatures(data: number[], opts: LipidomicsFeaturesOptions = {}): LipidomicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsFeatures };
diff --git a/src/lipidomics/feedback.ts b/src/lipidomics/feedback.ts
new file mode 100644
index 000000000..97e328413
--- /dev/null
+++ b/src/lipidomics/feedback.ts
@@ -0,0 +1,14 @@
+/** lipidomics feedback module — tsb analytics library. */
+export interface LipidomicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeLipidomicsFeedback(data: number[], opts: LipidomicsFeedbackOptions = {}): LipidomicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsFeedback };
diff --git a/src/lipidomics/filtering.ts b/src/lipidomics/filtering.ts
new file mode 100644
index 000000000..8924901d8
--- /dev/null
+++ b/src/lipidomics/filtering.ts
@@ -0,0 +1,14 @@
+/** lipidomics filtering module — tsb analytics library. */
+export interface LipidomicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsFilteringResult { values: number[]; converged: boolean; }
+export function computeLipidomicsFiltering(data: number[], opts: LipidomicsFilteringOptions = {}): LipidomicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsFiltering };
diff --git a/src/lipidomics/fourier.ts b/src/lipidomics/fourier.ts
new file mode 100644
index 000000000..973420661
--- /dev/null
+++ b/src/lipidomics/fourier.ts
@@ -0,0 +1,14 @@
+/** lipidomics fourier module — tsb analytics library. */
+export interface LipidomicsFourierOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsFourierResult { values: number[]; converged: boolean; }
+export function computeLipidomicsFourier(data: number[], opts: LipidomicsFourierOptions = {}): LipidomicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsFourier };
diff --git a/src/lipidomics/fusion.ts b/src/lipidomics/fusion.ts
new file mode 100644
index 000000000..c54197c49
--- /dev/null
+++ b/src/lipidomics/fusion.ts
@@ -0,0 +1,14 @@
+/** lipidomics fusion module — tsb analytics library. */
+export interface LipidomicsFusionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsFusionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsFusion(data: number[], opts: LipidomicsFusionOptions = {}): LipidomicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsFusion };
diff --git a/src/lipidomics/generation.ts b/src/lipidomics/generation.ts
new file mode 100644
index 000000000..d5e9dc59c
--- /dev/null
+++ b/src/lipidomics/generation.ts
@@ -0,0 +1,14 @@
+/** lipidomics generation module — tsb analytics library. */
+export interface LipidomicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsGenerationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsGeneration(data: number[], opts: LipidomicsGenerationOptions = {}): LipidomicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsGeneration };
diff --git a/src/lipidomics/geometry.ts b/src/lipidomics/geometry.ts
new file mode 100644
index 000000000..3cefa6375
--- /dev/null
+++ b/src/lipidomics/geometry.ts
@@ -0,0 +1,14 @@
+/** lipidomics geometry module — tsb analytics library. */
+export interface LipidomicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsGeometryResult { values: number[]; converged: boolean; }
+export function computeLipidomicsGeometry(data: number[], opts: LipidomicsGeometryOptions = {}): LipidomicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsGeometry };
diff --git a/src/lipidomics/gradient.ts b/src/lipidomics/gradient.ts
new file mode 100644
index 000000000..312218f5c
--- /dev/null
+++ b/src/lipidomics/gradient.ts
@@ -0,0 +1,14 @@
+/** lipidomics gradient module — tsb analytics library. */
+export interface LipidomicsGradientOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsGradientResult { values: number[]; converged: boolean; }
+export function computeLipidomicsGradient(data: number[], opts: LipidomicsGradientOptions = {}): LipidomicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsGradient };
diff --git a/src/lipidomics/hessian.ts b/src/lipidomics/hessian.ts
new file mode 100644
index 000000000..88d9a92ec
--- /dev/null
+++ b/src/lipidomics/hessian.ts
@@ -0,0 +1,14 @@
+/** lipidomics hessian module — tsb analytics library. */
+export interface LipidomicsHessianOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsHessianResult { values: number[]; converged: boolean; }
+export function computeLipidomicsHessian(data: number[], opts: LipidomicsHessianOptions = {}): LipidomicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsHessian };
diff --git a/src/lipidomics/hypothesis.ts b/src/lipidomics/hypothesis.ts
new file mode 100644
index 000000000..93daae287
--- /dev/null
+++ b/src/lipidomics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** lipidomics hypothesis module — tsb analytics library. */
+export interface LipidomicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeLipidomicsHypothesis(data: number[], opts: LipidomicsHypothesisOptions = {}): LipidomicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsHypothesis };
diff --git a/src/lipidomics/inference.ts b/src/lipidomics/inference.ts
new file mode 100644
index 000000000..47dd3f2ba
--- /dev/null
+++ b/src/lipidomics/inference.ts
@@ -0,0 +1,14 @@
+/** lipidomics inference module — tsb analytics library. */
+export interface LipidomicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsInferenceResult { values: number[]; converged: boolean; }
+export function computeLipidomicsInference(data: number[], opts: LipidomicsInferenceOptions = {}): LipidomicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsInference };
diff --git a/src/lipidomics/inference2.ts b/src/lipidomics/inference2.ts
new file mode 100644
index 000000000..25e94cffb
--- /dev/null
+++ b/src/lipidomics/inference2.ts
@@ -0,0 +1,14 @@
+/** lipidomics inference2 module — tsb analytics library. */
+export interface LipidomicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsInferenceResult { values: number[]; converged: boolean; }
+export function computeLipidomicsInference(data: number[], opts: LipidomicsInferenceOptions = {}): LipidomicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsInference };
diff --git a/src/lipidomics/integral.ts b/src/lipidomics/integral.ts
new file mode 100644
index 000000000..2e418210f
--- /dev/null
+++ b/src/lipidomics/integral.ts
@@ -0,0 +1,14 @@
+/** lipidomics integral module — tsb analytics library. */
+export interface LipidomicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsIntegralResult { values: number[]; converged: boolean; }
+export function computeLipidomicsIntegral(data: number[], opts: LipidomicsIntegralOptions = {}): LipidomicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsIntegral };
diff --git a/src/lipidomics/integration.ts b/src/lipidomics/integration.ts
new file mode 100644
index 000000000..b3f19b59a
--- /dev/null
+++ b/src/lipidomics/integration.ts
@@ -0,0 +1,14 @@
+/** lipidomics integration module — tsb analytics library. */
+export interface LipidomicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsIntegration(data: number[], opts: LipidomicsIntegrationOptions = {}): LipidomicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsIntegration };
diff --git a/src/lipidomics/interpolation.ts b/src/lipidomics/interpolation.ts
new file mode 100644
index 000000000..352b1cf40
--- /dev/null
+++ b/src/lipidomics/interpolation.ts
@@ -0,0 +1,14 @@
+/** lipidomics interpolation module — tsb analytics library. */
+export interface LipidomicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsInterpolation(data: number[], opts: LipidomicsInterpolationOptions = {}): LipidomicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsInterpolation };
diff --git a/src/lipidomics/jacobian.ts b/src/lipidomics/jacobian.ts
new file mode 100644
index 000000000..1ffd583e8
--- /dev/null
+++ b/src/lipidomics/jacobian.ts
@@ -0,0 +1,14 @@
+/** lipidomics jacobian module — tsb analytics library. */
+export interface LipidomicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsJacobianResult { values: number[]; converged: boolean; }
+export function computeLipidomicsJacobian(data: number[], opts: LipidomicsJacobianOptions = {}): LipidomicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsJacobian };
diff --git a/src/lipidomics/kernel.ts b/src/lipidomics/kernel.ts
new file mode 100644
index 000000000..c3b9a1987
--- /dev/null
+++ b/src/lipidomics/kernel.ts
@@ -0,0 +1,14 @@
+/** lipidomics kernel module — tsb analytics library. */
+export interface LipidomicsKernelOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsKernelResult { values: number[]; converged: boolean; }
+export function computeLipidomicsKernel(data: number[], opts: LipidomicsKernelOptions = {}): LipidomicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsKernel };
diff --git a/src/lipidomics/laplacian.ts b/src/lipidomics/laplacian.ts
new file mode 100644
index 000000000..a67e3b285
--- /dev/null
+++ b/src/lipidomics/laplacian.ts
@@ -0,0 +1,14 @@
+/** lipidomics laplacian module — tsb analytics library. */
+export interface LipidomicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeLipidomicsLaplacian(data: number[], opts: LipidomicsLaplacianOptions = {}): LipidomicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsLaplacian };
diff --git a/src/lipidomics/learning.ts b/src/lipidomics/learning.ts
new file mode 100644
index 000000000..3688e17e4
--- /dev/null
+++ b/src/lipidomics/learning.ts
@@ -0,0 +1,14 @@
+/** lipidomics learning module — tsb analytics library. */
+export interface LipidomicsLearningOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsLearningResult { values: number[]; converged: boolean; }
+export function computeLipidomicsLearning(data: number[], opts: LipidomicsLearningOptions = {}): LipidomicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsLearning };
diff --git a/src/lipidomics/linear.ts b/src/lipidomics/linear.ts
new file mode 100644
index 000000000..1acbde317
--- /dev/null
+++ b/src/lipidomics/linear.ts
@@ -0,0 +1,14 @@
+/** lipidomics linear module — tsb analytics library. */
+export interface LipidomicsLinearOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsLinearResult { values: number[]; converged: boolean; }
+export function computeLipidomicsLinear(data: number[], opts: LipidomicsLinearOptions = {}): LipidomicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsLinear };
diff --git a/src/lipidomics/manifold.ts b/src/lipidomics/manifold.ts
new file mode 100644
index 000000000..f0e7486bc
--- /dev/null
+++ b/src/lipidomics/manifold.ts
@@ -0,0 +1,14 @@
+/** lipidomics manifold module — tsb analytics library. */
+export interface LipidomicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsManifoldResult { values: number[]; converged: boolean; }
+export function computeLipidomicsManifold(data: number[], opts: LipidomicsManifoldOptions = {}): LipidomicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsManifold };
diff --git a/src/lipidomics/matching.ts b/src/lipidomics/matching.ts
new file mode 100644
index 000000000..b7d5ac621
--- /dev/null
+++ b/src/lipidomics/matching.ts
@@ -0,0 +1,14 @@
+/** lipidomics matching module — tsb analytics library. */
+export interface LipidomicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsMatchingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsMatching(data: number[], opts: LipidomicsMatchingOptions = {}): LipidomicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsMatching };
diff --git a/src/lipidomics/measurement.ts b/src/lipidomics/measurement.ts
new file mode 100644
index 000000000..096e2f00c
--- /dev/null
+++ b/src/lipidomics/measurement.ts
@@ -0,0 +1,14 @@
+/** lipidomics measurement module — tsb analytics library. */
+export interface LipidomicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeLipidomicsMeasurement(data: number[], opts: LipidomicsMeasurementOptions = {}): LipidomicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsMeasurement };
diff --git a/src/lipidomics/metrics.ts b/src/lipidomics/metrics.ts
new file mode 100644
index 000000000..a87a13891
--- /dev/null
+++ b/src/lipidomics/metrics.ts
@@ -0,0 +1,14 @@
+/** lipidomics metrics module — tsb analytics library. */
+export interface LipidomicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsMetricsResult { values: number[]; converged: boolean; }
+export function computeLipidomicsMetrics(data: number[], opts: LipidomicsMetricsOptions = {}): LipidomicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsMetrics };
diff --git a/src/lipidomics/modeling.ts b/src/lipidomics/modeling.ts
new file mode 100644
index 000000000..d999c0115
--- /dev/null
+++ b/src/lipidomics/modeling.ts
@@ -0,0 +1,14 @@
+/** lipidomics modeling module — tsb analytics library. */
+export interface LipidomicsModelingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsModelingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsModeling(data: number[], opts: LipidomicsModelingOptions = {}): LipidomicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsModeling };
diff --git a/src/lipidomics/monitoring.ts b/src/lipidomics/monitoring.ts
new file mode 100644
index 000000000..56a5b459e
--- /dev/null
+++ b/src/lipidomics/monitoring.ts
@@ -0,0 +1,14 @@
+/** lipidomics monitoring module — tsb analytics library. */
+export interface LipidomicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeLipidomicsMonitoring(data: number[], opts: LipidomicsMonitoringOptions = {}): LipidomicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsMonitoring };
diff --git a/src/lipidomics/nonlinear.ts b/src/lipidomics/nonlinear.ts
new file mode 100644
index 000000000..bf0c48337
--- /dev/null
+++ b/src/lipidomics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** lipidomics nonlinear module — tsb analytics library. */
+export interface LipidomicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeLipidomicsNonlinear(data: number[], opts: LipidomicsNonlinearOptions = {}): LipidomicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsNonlinear };
diff --git a/src/lipidomics/normalization.ts b/src/lipidomics/normalization.ts
new file mode 100644
index 000000000..2c32ff797
--- /dev/null
+++ b/src/lipidomics/normalization.ts
@@ -0,0 +1,14 @@
+/** lipidomics normalization module — tsb analytics library. */
+export interface LipidomicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsNormalization(data: number[], opts: LipidomicsNormalizationOptions = {}): LipidomicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsNormalization };
diff --git a/src/lipidomics/optimization.ts b/src/lipidomics/optimization.ts
new file mode 100644
index 000000000..39341abe2
--- /dev/null
+++ b/src/lipidomics/optimization.ts
@@ -0,0 +1,14 @@
+/** lipidomics optimization module — tsb analytics library. */
+export interface LipidomicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsOptimization(data: number[], opts: LipidomicsOptimizationOptions = {}): LipidomicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsOptimization };
diff --git a/src/lipidomics/patterns.ts b/src/lipidomics/patterns.ts
new file mode 100644
index 000000000..de68e3403
--- /dev/null
+++ b/src/lipidomics/patterns.ts
@@ -0,0 +1,14 @@
+/** lipidomics patterns module — tsb analytics library. */
+export interface LipidomicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsPatternsResult { values: number[]; converged: boolean; }
+export function computeLipidomicsPatterns(data: number[], opts: LipidomicsPatternsOptions = {}): LipidomicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsPatterns };
diff --git a/src/lipidomics/permutation.ts b/src/lipidomics/permutation.ts
new file mode 100644
index 000000000..3d317b6b2
--- /dev/null
+++ b/src/lipidomics/permutation.ts
@@ -0,0 +1,14 @@
+/** lipidomics permutation module — tsb analytics library. */
+export interface LipidomicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsPermutationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsPermutation(data: number[], opts: LipidomicsPermutationOptions = {}): LipidomicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsPermutation };
diff --git a/src/lipidomics/prediction.ts b/src/lipidomics/prediction.ts
new file mode 100644
index 000000000..67fa67062
--- /dev/null
+++ b/src/lipidomics/prediction.ts
@@ -0,0 +1,14 @@
+/** lipidomics prediction module — tsb analytics library. */
+export interface LipidomicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsPredictionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsPrediction(data: number[], opts: LipidomicsPredictionOptions = {}): LipidomicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsPrediction };
diff --git a/src/lipidomics/processing.ts b/src/lipidomics/processing.ts
new file mode 100644
index 000000000..4e66cc185
--- /dev/null
+++ b/src/lipidomics/processing.ts
@@ -0,0 +1,14 @@
+/** lipidomics processing module — tsb analytics library. */
+export interface LipidomicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsProcessingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsProcessing(data: number[], opts: LipidomicsProcessingOptions = {}): LipidomicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsProcessing };
diff --git a/src/lipidomics/profiling.ts b/src/lipidomics/profiling.ts
new file mode 100644
index 000000000..578654e95
--- /dev/null
+++ b/src/lipidomics/profiling.ts
@@ -0,0 +1,14 @@
+/** lipidomics profiling module — tsb analytics library. */
+export interface LipidomicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsProfilingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsProfiling(data: number[], opts: LipidomicsProfilingOptions = {}): LipidomicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsProfiling };
diff --git a/src/lipidomics/projection.ts b/src/lipidomics/projection.ts
new file mode 100644
index 000000000..1b24c8593
--- /dev/null
+++ b/src/lipidomics/projection.ts
@@ -0,0 +1,14 @@
+/** lipidomics projection module — tsb analytics library. */
+export interface LipidomicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsProjectionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsProjection(data: number[], opts: LipidomicsProjectionOptions = {}): LipidomicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsProjection };
diff --git a/src/lipidomics/ranking.ts b/src/lipidomics/ranking.ts
new file mode 100644
index 000000000..da9616a2a
--- /dev/null
+++ b/src/lipidomics/ranking.ts
@@ -0,0 +1,14 @@
+/** lipidomics ranking module — tsb analytics library. */
+export interface LipidomicsRankingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsRankingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsRanking(data: number[], opts: LipidomicsRankingOptions = {}): LipidomicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsRanking };
diff --git a/src/lipidomics/reconstruction.ts b/src/lipidomics/reconstruction.ts
new file mode 100644
index 000000000..ad6bf9964
--- /dev/null
+++ b/src/lipidomics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** lipidomics reconstruction module — tsb analytics library. */
+export interface LipidomicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsReconstruction(data: number[], opts: LipidomicsReconstructionOptions = {}): LipidomicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsReconstruction };
diff --git a/src/lipidomics/registration.ts b/src/lipidomics/registration.ts
new file mode 100644
index 000000000..86dfdadfd
--- /dev/null
+++ b/src/lipidomics/registration.ts
@@ -0,0 +1,14 @@
+/** lipidomics registration module — tsb analytics library. */
+export interface LipidomicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsRegistration(data: number[], opts: LipidomicsRegistrationOptions = {}): LipidomicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsRegistration };
diff --git a/src/lipidomics/regression.ts b/src/lipidomics/regression.ts
new file mode 100644
index 000000000..a178d1b1a
--- /dev/null
+++ b/src/lipidomics/regression.ts
@@ -0,0 +1,14 @@
+/** lipidomics regression module — tsb analytics library. */
+export interface LipidomicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsRegressionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsRegression(data: number[], opts: LipidomicsRegressionOptions = {}): LipidomicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsRegression };
diff --git a/src/lipidomics/regularization.ts b/src/lipidomics/regularization.ts
new file mode 100644
index 000000000..1b3a63911
--- /dev/null
+++ b/src/lipidomics/regularization.ts
@@ -0,0 +1,14 @@
+/** lipidomics regularization module — tsb analytics library. */
+export interface LipidomicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsRegularization(data: number[], opts: LipidomicsRegularizationOptions = {}): LipidomicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsRegularization };
diff --git a/src/lipidomics/robustness.ts b/src/lipidomics/robustness.ts
new file mode 100644
index 000000000..96c894a1b
--- /dev/null
+++ b/src/lipidomics/robustness.ts
@@ -0,0 +1,14 @@
+/** lipidomics robustness module — tsb analytics library. */
+export interface LipidomicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeLipidomicsRobustness(data: number[], opts: LipidomicsRobustnessOptions = {}): LipidomicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsRobustness };
diff --git a/src/lipidomics/sampling.ts b/src/lipidomics/sampling.ts
new file mode 100644
index 000000000..c0f05648b
--- /dev/null
+++ b/src/lipidomics/sampling.ts
@@ -0,0 +1,14 @@
+/** lipidomics sampling module — tsb analytics library. */
+export interface LipidomicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsSamplingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsSampling(data: number[], opts: LipidomicsSamplingOptions = {}): LipidomicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsSampling };
diff --git a/src/lipidomics/sampling2.ts b/src/lipidomics/sampling2.ts
new file mode 100644
index 000000000..04909dd5f
--- /dev/null
+++ b/src/lipidomics/sampling2.ts
@@ -0,0 +1,14 @@
+/** lipidomics sampling2 module — tsb analytics library. */
+export interface LipidomicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsSamplingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsSampling(data: number[], opts: LipidomicsSamplingOptions = {}): LipidomicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsSampling };
diff --git a/src/lipidomics/scaling.ts b/src/lipidomics/scaling.ts
new file mode 100644
index 000000000..270acfad1
--- /dev/null
+++ b/src/lipidomics/scaling.ts
@@ -0,0 +1,14 @@
+/** lipidomics scaling module — tsb analytics library. */
+export interface LipidomicsScalingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsScalingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsScaling(data: number[], opts: LipidomicsScalingOptions = {}): LipidomicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsScaling };
diff --git a/src/lipidomics/scoring.ts b/src/lipidomics/scoring.ts
new file mode 100644
index 000000000..0a9ec4374
--- /dev/null
+++ b/src/lipidomics/scoring.ts
@@ -0,0 +1,14 @@
+/** lipidomics scoring module — tsb analytics library. */
+export interface LipidomicsScoringOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsScoringResult { values: number[]; converged: boolean; }
+export function computeLipidomicsScoring(data: number[], opts: LipidomicsScoringOptions = {}): LipidomicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsScoring };
diff --git a/src/lipidomics/segmentation.ts b/src/lipidomics/segmentation.ts
new file mode 100644
index 000000000..28585cfe8
--- /dev/null
+++ b/src/lipidomics/segmentation.ts
@@ -0,0 +1,14 @@
+/** lipidomics segmentation module — tsb analytics library. */
+export interface LipidomicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsSegmentation(data: number[], opts: LipidomicsSegmentationOptions = {}): LipidomicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsSegmentation };
diff --git a/src/lipidomics/selection.ts b/src/lipidomics/selection.ts
new file mode 100644
index 000000000..269ba7881
--- /dev/null
+++ b/src/lipidomics/selection.ts
@@ -0,0 +1,14 @@
+/** lipidomics selection module — tsb analytics library. */
+export interface LipidomicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsSelectionResult { values: number[]; converged: boolean; }
+export function computeLipidomicsSelection(data: number[], opts: LipidomicsSelectionOptions = {}): LipidomicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsSelection };
diff --git a/src/lipidomics/sensitivity.ts b/src/lipidomics/sensitivity.ts
new file mode 100644
index 000000000..ef99d86c2
--- /dev/null
+++ b/src/lipidomics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** lipidomics sensitivity module — tsb analytics library. */
+export interface LipidomicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeLipidomicsSensitivity(data: number[], opts: LipidomicsSensitivityOptions = {}): LipidomicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsSensitivity };
diff --git a/src/lipidomics/simulation.ts b/src/lipidomics/simulation.ts
new file mode 100644
index 000000000..364197b5b
--- /dev/null
+++ b/src/lipidomics/simulation.ts
@@ -0,0 +1,14 @@
+/** lipidomics simulation module — tsb analytics library. */
+export interface LipidomicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsSimulationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsSimulation(data: number[], opts: LipidomicsSimulationOptions = {}): LipidomicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsSimulation };
diff --git a/src/lipidomics/smoothing.ts b/src/lipidomics/smoothing.ts
new file mode 100644
index 000000000..87bb482fd
--- /dev/null
+++ b/src/lipidomics/smoothing.ts
@@ -0,0 +1,14 @@
+/** lipidomics smoothing module — tsb analytics library. */
+export interface LipidomicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsSmoothing(data: number[], opts: LipidomicsSmoothingOptions = {}): LipidomicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsSmoothing };
diff --git a/src/lipidomics/stability.ts b/src/lipidomics/stability.ts
new file mode 100644
index 000000000..fa0b2844e
--- /dev/null
+++ b/src/lipidomics/stability.ts
@@ -0,0 +1,14 @@
+/** lipidomics stability module — tsb analytics library. */
+export interface LipidomicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsStabilityResult { values: number[]; converged: boolean; }
+export function computeLipidomicsStability(data: number[], opts: LipidomicsStabilityOptions = {}): LipidomicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsStability };
diff --git a/src/lipidomics/stacking.ts b/src/lipidomics/stacking.ts
new file mode 100644
index 000000000..4cf81baaf
--- /dev/null
+++ b/src/lipidomics/stacking.ts
@@ -0,0 +1,14 @@
+/** lipidomics stacking module — tsb analytics library. */
+export interface LipidomicsStackingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsStackingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsStacking(data: number[], opts: LipidomicsStackingOptions = {}): LipidomicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsStacking };
diff --git a/src/lipidomics/standardization.ts b/src/lipidomics/standardization.ts
new file mode 100644
index 000000000..1746c25ab
--- /dev/null
+++ b/src/lipidomics/standardization.ts
@@ -0,0 +1,14 @@
+/** lipidomics standardization module — tsb analytics library. */
+export interface LipidomicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsStandardization(data: number[], opts: LipidomicsStandardizationOptions = {}): LipidomicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsStandardization };
diff --git a/src/lipidomics/static.ts b/src/lipidomics/static.ts
new file mode 100644
index 000000000..9bc9363f7
--- /dev/null
+++ b/src/lipidomics/static.ts
@@ -0,0 +1,14 @@
+/** lipidomics static module — tsb analytics library. */
+export interface LipidomicsStaticOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsStaticResult { values: number[]; converged: boolean; }
+export function computeLipidomicsStatic(data: number[], opts: LipidomicsStaticOptions = {}): LipidomicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsStatic };
diff --git a/src/lipidomics/stochastic.ts b/src/lipidomics/stochastic.ts
new file mode 100644
index 000000000..a2918b811
--- /dev/null
+++ b/src/lipidomics/stochastic.ts
@@ -0,0 +1,14 @@
+/** lipidomics stochastic module — tsb analytics library. */
+export interface LipidomicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsStochasticResult { values: number[]; converged: boolean; }
+export function computeLipidomicsStochastic(data: number[], opts: LipidomicsStochasticOptions = {}): LipidomicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsStochastic };
diff --git a/src/lipidomics/synthesis.ts b/src/lipidomics/synthesis.ts
new file mode 100644
index 000000000..471291a59
--- /dev/null
+++ b/src/lipidomics/synthesis.ts
@@ -0,0 +1,14 @@
+/** lipidomics synthesis module — tsb analytics library. */
+export interface LipidomicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeLipidomicsSynthesis(data: number[], opts: LipidomicsSynthesisOptions = {}): LipidomicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsSynthesis };
diff --git a/src/lipidomics/topology.ts b/src/lipidomics/topology.ts
new file mode 100644
index 000000000..69d74f1cf
--- /dev/null
+++ b/src/lipidomics/topology.ts
@@ -0,0 +1,14 @@
+/** lipidomics topology module — tsb analytics library. */
+export interface LipidomicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsTopologyResult { values: number[]; converged: boolean; }
+export function computeLipidomicsTopology(data: number[], opts: LipidomicsTopologyOptions = {}): LipidomicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsTopology };
diff --git a/src/lipidomics/tracking.ts b/src/lipidomics/tracking.ts
new file mode 100644
index 000000000..2058228a0
--- /dev/null
+++ b/src/lipidomics/tracking.ts
@@ -0,0 +1,14 @@
+/** lipidomics tracking module — tsb analytics library. */
+export interface LipidomicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsTrackingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsTracking(data: number[], opts: LipidomicsTrackingOptions = {}): LipidomicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsTracking };
diff --git a/src/lipidomics/transform.ts b/src/lipidomics/transform.ts
new file mode 100644
index 000000000..cc7125e66
--- /dev/null
+++ b/src/lipidomics/transform.ts
@@ -0,0 +1,14 @@
+/** lipidomics transform module — tsb analytics library. */
+export interface LipidomicsTransformOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsTransformResult { values: number[]; converged: boolean; }
+export function computeLipidomicsTransform(data: number[], opts: LipidomicsTransformOptions = {}): LipidomicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsTransform };
diff --git a/src/lipidomics/uncertainty.ts b/src/lipidomics/uncertainty.ts
new file mode 100644
index 000000000..8f502d66f
--- /dev/null
+++ b/src/lipidomics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** lipidomics uncertainty module — tsb analytics library. */
+export interface LipidomicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeLipidomicsUncertainty(data: number[], opts: LipidomicsUncertaintyOptions = {}): LipidomicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsUncertainty };
diff --git a/src/lipidomics/validation.ts b/src/lipidomics/validation.ts
new file mode 100644
index 000000000..abf8e113f
--- /dev/null
+++ b/src/lipidomics/validation.ts
@@ -0,0 +1,14 @@
+/** lipidomics validation module — tsb analytics library. */
+export interface LipidomicsValidationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsValidationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsValidation(data: number[], opts: LipidomicsValidationOptions = {}): LipidomicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsValidation };
diff --git a/src/lipidomics/verification.ts b/src/lipidomics/verification.ts
new file mode 100644
index 000000000..0184ea746
--- /dev/null
+++ b/src/lipidomics/verification.ts
@@ -0,0 +1,14 @@
+/** lipidomics verification module — tsb analytics library. */
+export interface LipidomicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsVerificationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsVerification(data: number[], opts: LipidomicsVerificationOptions = {}): LipidomicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsVerification };
diff --git a/src/lipidomics/visualization.ts b/src/lipidomics/visualization.ts
new file mode 100644
index 000000000..4811f476a
--- /dev/null
+++ b/src/lipidomics/visualization.ts
@@ -0,0 +1,14 @@
+/** lipidomics visualization module — tsb analytics library. */
+export interface LipidomicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeLipidomicsVisualization(data: number[], opts: LipidomicsVisualizationOptions = {}): LipidomicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsVisualization };
diff --git a/src/lipidomics/voting.ts b/src/lipidomics/voting.ts
new file mode 100644
index 000000000..4cb4fb44c
--- /dev/null
+++ b/src/lipidomics/voting.ts
@@ -0,0 +1,14 @@
+/** lipidomics voting module — tsb analytics library. */
+export interface LipidomicsVotingOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsVotingResult { values: number[]; converged: boolean; }
+export function computeLipidomicsVoting(data: number[], opts: LipidomicsVotingOptions = {}): LipidomicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsVoting };
diff --git a/src/lipidomics/wavelet.ts b/src/lipidomics/wavelet.ts
new file mode 100644
index 000000000..8dcfa4c59
--- /dev/null
+++ b/src/lipidomics/wavelet.ts
@@ -0,0 +1,14 @@
+/** lipidomics wavelet module — tsb analytics library. */
+export interface LipidomicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface LipidomicsWaveletResult { values: number[]; converged: boolean; }
+export function computeLipidomicsWavelet(data: number[], opts: LipidomicsWaveletOptions = {}): LipidomicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLipidomicsWavelet };
diff --git a/src/logistics/3pl.ts b/src/logistics/3pl.ts
new file mode 100644
index 000000000..8075b84f2
--- /dev/null
+++ b/src/logistics/3pl.ts
@@ -0,0 +1,22 @@
+/** 3Pl module — tsb analytics library. */
+
+/** Options for 3Pl. */
+export interface 3plOptions { tol?: number; maxIter?: number; }
+
+/** Result from 3Pl. */
+export interface 3plResult { values: number[]; converged: boolean; }
+
+/** Compute 3Pl. */
+export function compute3pl(data: number[], opts: 3plOptions = {}): 3plResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: compute3pl };
diff --git a/src/logistics/4pl.ts b/src/logistics/4pl.ts
new file mode 100644
index 000000000..561e465f9
--- /dev/null
+++ b/src/logistics/4pl.ts
@@ -0,0 +1,22 @@
+/** 4Pl module — tsb analytics library. */
+
+/** Options for 4Pl. */
+export interface 4plOptions { tol?: number; maxIter?: number; }
+
+/** Result from 4Pl. */
+export interface 4plResult { values: number[]; converged: boolean; }
+
+/** Compute 4Pl. */
+export function compute4pl(data: number[], opts: 4plOptions = {}): 4plResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: compute4pl };
diff --git a/src/logistics/advanced.ts b/src/logistics/advanced.ts
new file mode 100644
index 000000000..12c1727b7
--- /dev/null
+++ b/src/logistics/advanced.ts
@@ -0,0 +1,15 @@
+/** Logistics Advanced module — tsb analytics library. */
+export interface Logistics advancedOptions { tol?: number; maxIter?: number; }
+export interface Logistics advancedResult { values: number[]; converged: boolean; }
+export function computeLogistics advanced(data: number[], opts: Logistics advancedOptions = {}): Logistics advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics advanced };
diff --git a/src/logistics/air.ts b/src/logistics/air.ts
new file mode 100644
index 000000000..e2363b19b
--- /dev/null
+++ b/src/logistics/air.ts
@@ -0,0 +1,22 @@
+/** Air module — tsb analytics library. */
+
+/** Options for Air. */
+export interface AirOptions { tol?: number; maxIter?: number; }
+
+/** Result from Air. */
+export interface AirResult { values: number[]; converged: boolean; }
+
+/** Compute Air. */
+export function computeAir(data: number[], opts: AirOptions = {}): AirResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAir };
diff --git a/src/logistics/base2.ts b/src/logistics/base2.ts
new file mode 100644
index 000000000..7bf1a433b
--- /dev/null
+++ b/src/logistics/base2.ts
@@ -0,0 +1,15 @@
+/** Logistics Base2 module — tsb analytics library. */
+export interface Logistics base2Options { tol?: number; maxIter?: number; }
+export interface Logistics base2Result { values: number[]; converged: boolean; }
+export function computeLogistics base2(data: number[], opts: Logistics base2Options = {}): Logistics base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics base2 };
diff --git a/src/logistics/batch.ts b/src/logistics/batch.ts
new file mode 100644
index 000000000..c87df115d
--- /dev/null
+++ b/src/logistics/batch.ts
@@ -0,0 +1,15 @@
+/** Logistics Batch module — tsb analytics library. */
+export interface Logistics batchOptions { tol?: number; maxIter?: number; }
+export interface Logistics batchResult { values: number[]; converged: boolean; }
+export function computeLogistics batch(data: number[], opts: Logistics batchOptions = {}): Logistics batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics batch };
diff --git a/src/logistics/beta.ts b/src/logistics/beta.ts
new file mode 100644
index 000000000..a98bca084
--- /dev/null
+++ b/src/logistics/beta.ts
@@ -0,0 +1,15 @@
+/** Logistics Beta module — tsb analytics library. */
+export interface Logistics betaOptions { tol?: number; maxIter?: number; }
+export interface Logistics betaResult { values: number[]; converged: boolean; }
+export function computeLogistics beta(data: number[], opts: Logistics betaOptions = {}): Logistics betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics beta };
diff --git a/src/logistics/broker.ts b/src/logistics/broker.ts
new file mode 100644
index 000000000..4c562e9c6
--- /dev/null
+++ b/src/logistics/broker.ts
@@ -0,0 +1,22 @@
+/** Broker module — tsb analytics library. */
+
+/** Options for Broker. */
+export interface BrokerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Broker. */
+export interface BrokerResult { values: number[]; converged: boolean; }
+
+/** Compute Broker. */
+export function computeBroker(data: number[], opts: BrokerOptions = {}): BrokerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBroker };
diff --git a/src/logistics/carrier.ts b/src/logistics/carrier.ts
new file mode 100644
index 000000000..16d7eebba
--- /dev/null
+++ b/src/logistics/carrier.ts
@@ -0,0 +1,22 @@
+/** Carrier module — tsb analytics library. */
+
+/** Options for Carrier. */
+export interface CarrierOptions { tol?: number; maxIter?: number; }
+
+/** Result from Carrier. */
+export interface CarrierResult { values: number[]; converged: boolean; }
+
+/** Compute Carrier. */
+export function computeCarrier(data: number[], opts: CarrierOptions = {}): CarrierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCarrier };
diff --git a/src/logistics/consolidation.ts b/src/logistics/consolidation.ts
new file mode 100644
index 000000000..c5f7f6bdb
--- /dev/null
+++ b/src/logistics/consolidation.ts
@@ -0,0 +1,22 @@
+/** Consolidation module — tsb analytics library. */
+
+/** Options for Consolidation. */
+export interface ConsolidationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Consolidation. */
+export interface ConsolidationResult { values: number[]; converged: boolean; }
+
+/** Compute Consolidation. */
+export function computeConsolidation(data: number[], opts: ConsolidationOptions = {}): ConsolidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConsolidation };
diff --git a/src/logistics/cpu.ts b/src/logistics/cpu.ts
new file mode 100644
index 000000000..87cc707e4
--- /dev/null
+++ b/src/logistics/cpu.ts
@@ -0,0 +1,15 @@
+/** Logistics Cpu module — tsb analytics library. */
+export interface Logistics cpuOptions { tol?: number; maxIter?: number; }
+export interface Logistics cpuResult { values: number[]; converged: boolean; }
+export function computeLogistics cpu(data: number[], opts: Logistics cpuOptions = {}): Logistics cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics cpu };
diff --git a/src/logistics/cross_docking.ts b/src/logistics/cross_docking.ts
new file mode 100644
index 000000000..bfe7eaf40
--- /dev/null
+++ b/src/logistics/cross_docking.ts
@@ -0,0 +1,22 @@
+/** Cross Docking module — tsb analytics library. */
+
+/** Options for Cross Docking. */
+export interface CrossDockingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cross Docking. */
+export interface CrossDockingResult { values: number[]; converged: boolean; }
+
+/** Compute Cross Docking. */
+export function computeCrossDocking(data: number[], opts: CrossDockingOptions = {}): CrossDockingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCrossDocking };
diff --git a/src/logistics/customs.ts b/src/logistics/customs.ts
new file mode 100644
index 000000000..5194b2061
--- /dev/null
+++ b/src/logistics/customs.ts
@@ -0,0 +1,22 @@
+/** Customs module — tsb analytics library. */
+
+/** Options for Customs. */
+export interface CustomsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Customs. */
+export interface CustomsResult { values: number[]; converged: boolean; }
+
+/** Compute Customs. */
+export function computeCustoms(data: number[], opts: CustomsOptions = {}): CustomsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCustoms };
diff --git a/src/logistics/deconsolidation.ts b/src/logistics/deconsolidation.ts
new file mode 100644
index 000000000..b74535caa
--- /dev/null
+++ b/src/logistics/deconsolidation.ts
@@ -0,0 +1,22 @@
+/** Deconsolidation module — tsb analytics library. */
+
+/** Options for Deconsolidation. */
+export interface DeconsolidationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Deconsolidation. */
+export interface DeconsolidationResult { values: number[]; converged: boolean; }
+
+/** Compute Deconsolidation. */
+export function computeDeconsolidation(data: number[], opts: DeconsolidationOptions = {}): DeconsolidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDeconsolidation };
diff --git a/src/logistics/dense.ts b/src/logistics/dense.ts
new file mode 100644
index 000000000..48233d7aa
--- /dev/null
+++ b/src/logistics/dense.ts
@@ -0,0 +1,15 @@
+/** Logistics Dense module — tsb analytics library. */
+export interface Logistics denseOptions { tol?: number; maxIter?: number; }
+export interface Logistics denseResult { values: number[]; converged: boolean; }
+export function computeLogistics dense(data: number[], opts: Logistics denseOptions = {}): Logistics denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics dense };
diff --git a/src/logistics/distributed.ts b/src/logistics/distributed.ts
new file mode 100644
index 000000000..d97776126
--- /dev/null
+++ b/src/logistics/distributed.ts
@@ -0,0 +1,15 @@
+/** Logistics Distributed module — tsb analytics library. */
+export interface Logistics distributedOptions { tol?: number; maxIter?: number; }
+export interface Logistics distributedResult { values: number[]; converged: boolean; }
+export function computeLogistics distributed(data: number[], opts: Logistics distributedOptions = {}): Logistics distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics distributed };
diff --git a/src/logistics/documentation.ts b/src/logistics/documentation.ts
new file mode 100644
index 000000000..b8004bd57
--- /dev/null
+++ b/src/logistics/documentation.ts
@@ -0,0 +1,22 @@
+/** Documentation module — tsb analytics library. */
+
+/** Options for Documentation. */
+export interface DocumentationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Documentation. */
+export interface DocumentationResult { values: number[]; converged: boolean; }
+
+/** Compute Documentation. */
+export function computeDocumentation(data: number[], opts: DocumentationOptions = {}): DocumentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDocumentation };
diff --git a/src/logistics/event_management.ts b/src/logistics/event_management.ts
new file mode 100644
index 000000000..497bae603
--- /dev/null
+++ b/src/logistics/event_management.ts
@@ -0,0 +1,22 @@
+/** Event Management module — tsb analytics library. */
+
+/** Options for Event Management. */
+export interface EventManagementOptions { tol?: number; maxIter?: number; }
+
+/** Result from Event Management. */
+export interface EventManagementResult { values: number[]; converged: boolean; }
+
+/** Compute Event Management. */
+export function computeEventManagement(data: number[], opts: EventManagementOptions = {}): EventManagementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEventManagement };
diff --git a/src/logistics/exception.ts b/src/logistics/exception.ts
new file mode 100644
index 000000000..f7ff845b9
--- /dev/null
+++ b/src/logistics/exception.ts
@@ -0,0 +1,22 @@
+/** Exception module — tsb analytics library. */
+
+/** Options for Exception. */
+export interface ExceptionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Exception. */
+export interface ExceptionResult { values: number[]; converged: boolean; }
+
+/** Compute Exception. */
+export function computeException(data: number[], opts: ExceptionOptions = {}): ExceptionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeException };
diff --git a/src/logistics/experimental.ts b/src/logistics/experimental.ts
new file mode 100644
index 000000000..af794a801
--- /dev/null
+++ b/src/logistics/experimental.ts
@@ -0,0 +1,15 @@
+/** Logistics Experimental module — tsb analytics library. */
+export interface Logistics experimentalOptions { tol?: number; maxIter?: number; }
+export interface Logistics experimentalResult { values: number[]; converged: boolean; }
+export function computeLogistics experimental(data: number[], opts: Logistics experimentalOptions = {}): Logistics experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics experimental };
diff --git a/src/logistics/fast.ts b/src/logistics/fast.ts
new file mode 100644
index 000000000..2a5e3b3e7
--- /dev/null
+++ b/src/logistics/fast.ts
@@ -0,0 +1,15 @@
+/** Logistics Fast module — tsb analytics library. */
+export interface Logistics fastOptions { tol?: number; maxIter?: number; }
+export interface Logistics fastResult { values: number[]; converged: boolean; }
+export function computeLogistics fast(data: number[], opts: Logistics fastOptions = {}): Logistics fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics fast };
diff --git a/src/logistics/forwarder.ts b/src/logistics/forwarder.ts
new file mode 100644
index 000000000..054c515c2
--- /dev/null
+++ b/src/logistics/forwarder.ts
@@ -0,0 +1,22 @@
+/** Forwarder module — tsb analytics library. */
+
+/** Options for Forwarder. */
+export interface ForwarderOptions { tol?: number; maxIter?: number; }
+
+/** Result from Forwarder. */
+export interface ForwarderResult { values: number[]; converged: boolean; }
+
+/** Compute Forwarder. */
+export function computeForwarder(data: number[], opts: ForwarderOptions = {}): ForwarderResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeForwarder };
diff --git a/src/logistics/freight.ts b/src/logistics/freight.ts
new file mode 100644
index 000000000..218b78143
--- /dev/null
+++ b/src/logistics/freight.ts
@@ -0,0 +1,22 @@
+/** Freight module — tsb analytics library. */
+
+/** Options for Freight. */
+export interface FreightOptions { tol?: number; maxIter?: number; }
+
+/** Result from Freight. */
+export interface FreightResult { values: number[]; converged: boolean; }
+
+/** Compute Freight. */
+export function computeFreight(data: number[], opts: FreightOptions = {}): FreightResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFreight };
diff --git a/src/logistics/future.ts b/src/logistics/future.ts
new file mode 100644
index 000000000..2f08b7f39
--- /dev/null
+++ b/src/logistics/future.ts
@@ -0,0 +1,15 @@
+/** Logistics Future module — tsb analytics library. */
+export interface Logistics futureOptions { tol?: number; maxIter?: number; }
+export interface Logistics futureResult { values: number[]; converged: boolean; }
+export function computeLogistics future(data: number[], opts: Logistics futureOptions = {}): Logistics futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics future };
diff --git a/src/logistics/gpu.ts b/src/logistics/gpu.ts
new file mode 100644
index 000000000..bedb69f51
--- /dev/null
+++ b/src/logistics/gpu.ts
@@ -0,0 +1,15 @@
+/** Logistics Gpu module — tsb analytics library. */
+export interface Logistics gpuOptions { tol?: number; maxIter?: number; }
+export interface Logistics gpuResult { values: number[]; converged: boolean; }
+export function computeLogistics gpu(data: number[], opts: Logistics gpuOptions = {}): Logistics gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics gpu };
diff --git a/src/logistics/incoterms.ts b/src/logistics/incoterms.ts
new file mode 100644
index 000000000..07f4be4b7
--- /dev/null
+++ b/src/logistics/incoterms.ts
@@ -0,0 +1,22 @@
+/** Incoterms module — tsb analytics library. */
+
+/** Options for Incoterms. */
+export interface IncotermsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Incoterms. */
+export interface IncotermsResult { values: number[]; converged: boolean; }
+
+/** Compute Incoterms. */
+export function computeIncoterms(data: number[], opts: IncotermsOptions = {}): IncotermsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIncoterms };
diff --git a/src/logistics/intermodal.ts b/src/logistics/intermodal.ts
new file mode 100644
index 000000000..ad048fcd6
--- /dev/null
+++ b/src/logistics/intermodal.ts
@@ -0,0 +1,22 @@
+/** Intermodal module — tsb analytics library. */
+
+/** Options for Intermodal. */
+export interface IntermodalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Intermodal. */
+export interface IntermodalResult { values: number[]; converged: boolean; }
+
+/** Compute Intermodal. */
+export function computeIntermodal(data: number[], opts: IntermodalOptions = {}): IntermodalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIntermodal };
diff --git a/src/logistics/large.ts b/src/logistics/large.ts
new file mode 100644
index 000000000..cd0b19828
--- /dev/null
+++ b/src/logistics/large.ts
@@ -0,0 +1,15 @@
+/** Logistics Large module — tsb analytics library. */
+export interface Logistics largeOptions { tol?: number; maxIter?: number; }
+export interface Logistics largeResult { values: number[]; converged: boolean; }
+export function computeLogistics large(data: number[], opts: Logistics largeOptions = {}): Logistics largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics large };
diff --git a/src/logistics/last_mile_log.ts b/src/logistics/last_mile_log.ts
new file mode 100644
index 000000000..1f4098d09
--- /dev/null
+++ b/src/logistics/last_mile_log.ts
@@ -0,0 +1,22 @@
+/** Last Mile Log module — tsb analytics library. */
+
+/** Options for Last Mile Log. */
+export interface LastMileLogOptions { tol?: number; maxIter?: number; }
+
+/** Result from Last Mile Log. */
+export interface LastMileLogResult { values: number[]; converged: boolean; }
+
+/** Compute Last Mile Log. */
+export function computeLastMileLog(data: number[], opts: LastMileLogOptions = {}): LastMileLogResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLastMileLog };
diff --git a/src/logistics/legacy.ts b/src/logistics/legacy.ts
new file mode 100644
index 000000000..ac45c3ff6
--- /dev/null
+++ b/src/logistics/legacy.ts
@@ -0,0 +1,15 @@
+/** Logistics Legacy module — tsb analytics library. */
+export interface Logistics legacyOptions { tol?: number; maxIter?: number; }
+export interface Logistics legacyResult { values: number[]; converged: boolean; }
+export function computeLogistics legacy(data: number[], opts: Logistics legacyOptions = {}): Logistics legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics legacy };
diff --git a/src/logistics/lite.ts b/src/logistics/lite.ts
new file mode 100644
index 000000000..c1ea64fbe
--- /dev/null
+++ b/src/logistics/lite.ts
@@ -0,0 +1,15 @@
+/** Logistics Lite module — tsb analytics library. */
+export interface Logistics liteOptions { tol?: number; maxIter?: number; }
+export interface Logistics liteResult { values: number[]; converged: boolean; }
+export function computeLogistics lite(data: number[], opts: Logistics liteOptions = {}): Logistics liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics lite };
diff --git a/src/logistics/loading.ts b/src/logistics/loading.ts
new file mode 100644
index 000000000..e81801b1f
--- /dev/null
+++ b/src/logistics/loading.ts
@@ -0,0 +1,22 @@
+/** Loading module — tsb analytics library. */
+
+/** Options for Loading. */
+export interface LoadingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Loading. */
+export interface LoadingResult { values: number[]; converged: boolean; }
+
+/** Compute Loading. */
+export function computeLoading(data: number[], opts: LoadingOptions = {}): LoadingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLoading };
diff --git a/src/logistics/mini.ts b/src/logistics/mini.ts
new file mode 100644
index 000000000..2f9395d1c
--- /dev/null
+++ b/src/logistics/mini.ts
@@ -0,0 +1,15 @@
+/** Logistics Mini module — tsb analytics library. */
+export interface Logistics miniOptions { tol?: number; maxIter?: number; }
+export interface Logistics miniResult { values: number[]; converged: boolean; }
+export function computeLogistics mini(data: number[], opts: Logistics miniOptions = {}): Logistics miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics mini };
diff --git a/src/logistics/multimodal.ts b/src/logistics/multimodal.ts
new file mode 100644
index 000000000..1c9e62fe9
--- /dev/null
+++ b/src/logistics/multimodal.ts
@@ -0,0 +1,22 @@
+/** Multimodal module — tsb analytics library. */
+
+/** Options for Multimodal. */
+export interface MultimodalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Multimodal. */
+export interface MultimodalResult { values: number[]; converged: boolean; }
+
+/** Compute Multimodal. */
+export function computeMultimodal(data: number[], opts: MultimodalOptions = {}): MultimodalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMultimodal };
diff --git a/src/logistics/network_design.ts b/src/logistics/network_design.ts
new file mode 100644
index 000000000..5622a524b
--- /dev/null
+++ b/src/logistics/network_design.ts
@@ -0,0 +1,22 @@
+/** Network Design module — tsb analytics library. */
+
+/** Options for Network Design. */
+export interface NetworkDesignOptions { tol?: number; maxIter?: number; }
+
+/** Result from Network Design. */
+export interface NetworkDesignResult { values: number[]; converged: boolean; }
+
+/** Compute Network Design. */
+export function computeNetworkDesign(data: number[], opts: NetworkDesignOptions = {}): NetworkDesignResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNetworkDesign };
diff --git a/src/logistics/next.ts b/src/logistics/next.ts
new file mode 100644
index 000000000..2a0c90da2
--- /dev/null
+++ b/src/logistics/next.ts
@@ -0,0 +1,15 @@
+/** Logistics Next module — tsb analytics library. */
+export interface Logistics nextOptions { tol?: number; maxIter?: number; }
+export interface Logistics nextResult { values: number[]; converged: boolean; }
+export function computeLogistics next(data: number[], opts: Logistics nextOptions = {}): Logistics nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics next };
diff --git a/src/logistics/online.ts b/src/logistics/online.ts
new file mode 100644
index 000000000..f7bd8bf16
--- /dev/null
+++ b/src/logistics/online.ts
@@ -0,0 +1,15 @@
+/** Logistics Online module — tsb analytics library. */
+export interface Logistics onlineOptions { tol?: number; maxIter?: number; }
+export interface Logistics onlineResult { values: number[]; converged: boolean; }
+export function computeLogistics online(data: number[], opts: Logistics onlineOptions = {}): Logistics onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics online };
diff --git a/src/logistics/parallel.ts b/src/logistics/parallel.ts
new file mode 100644
index 000000000..d09a64c5b
--- /dev/null
+++ b/src/logistics/parallel.ts
@@ -0,0 +1,15 @@
+/** Logistics Parallel module — tsb analytics library. */
+export interface Logistics parallelOptions { tol?: number; maxIter?: number; }
+export interface Logistics parallelResult { values: number[]; converged: boolean; }
+export function computeLogistics parallel(data: number[], opts: Logistics parallelOptions = {}): Logistics parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics parallel };
diff --git a/src/logistics/plus.ts b/src/logistics/plus.ts
new file mode 100644
index 000000000..837ec1abf
--- /dev/null
+++ b/src/logistics/plus.ts
@@ -0,0 +1,15 @@
+/** Logistics Plus module — tsb analytics library. */
+export interface Logistics plusOptions { tol?: number; maxIter?: number; }
+export interface Logistics plusResult { values: number[]; converged: boolean; }
+export function computeLogistics plus(data: number[], opts: Logistics plusOptions = {}): Logistics plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics plus };
diff --git a/src/logistics/pro.ts b/src/logistics/pro.ts
new file mode 100644
index 000000000..bb23ecb0a
--- /dev/null
+++ b/src/logistics/pro.ts
@@ -0,0 +1,15 @@
+/** Logistics Pro module — tsb analytics library. */
+export interface Logistics proOptions { tol?: number; maxIter?: number; }
+export interface Logistics proResult { values: number[]; converged: boolean; }
+export function computeLogistics pro(data: number[], opts: Logistics proOptions = {}): Logistics proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics pro };
diff --git a/src/logistics/rail.ts b/src/logistics/rail.ts
new file mode 100644
index 000000000..5e71db6f6
--- /dev/null
+++ b/src/logistics/rail.ts
@@ -0,0 +1,22 @@
+/** Rail module — tsb analytics library. */
+
+/** Options for Rail. */
+export interface RailOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rail. */
+export interface RailResult { values: number[]; converged: boolean; }
+
+/** Compute Rail. */
+export function computeRail(data: number[], opts: RailOptions = {}): RailResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRail };
diff --git a/src/logistics/real_time.ts b/src/logistics/real_time.ts
new file mode 100644
index 000000000..a924530eb
--- /dev/null
+++ b/src/logistics/real_time.ts
@@ -0,0 +1,22 @@
+/** Real Time module — tsb analytics library. */
+
+/** Options for Real Time. */
+export interface RealTimeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Real Time. */
+export interface RealTimeResult { values: number[]; converged: boolean; }
+
+/** Compute Real Time. */
+export function computeRealTime(data: number[], opts: RealTimeOptions = {}): RealTimeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRealTime };
diff --git a/src/logistics/road.ts b/src/logistics/road.ts
new file mode 100644
index 000000000..6aeb3e467
--- /dev/null
+++ b/src/logistics/road.ts
@@ -0,0 +1,22 @@
+/** Road module — tsb analytics library. */
+
+/** Options for Road. */
+export interface RoadOptions { tol?: number; maxIter?: number; }
+
+/** Result from Road. */
+export interface RoadResult { values: number[]; converged: boolean; }
+
+/** Compute Road. */
+export function computeRoad(data: number[], opts: RoadOptions = {}): RoadResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRoad };
diff --git a/src/logistics/robust.ts b/src/logistics/robust.ts
new file mode 100644
index 000000000..3e7d8129c
--- /dev/null
+++ b/src/logistics/robust.ts
@@ -0,0 +1,15 @@
+/** Logistics Robust module — tsb analytics library. */
+export interface Logistics robustOptions { tol?: number; maxIter?: number; }
+export interface Logistics robustResult { values: number[]; converged: boolean; }
+export function computeLogistics robust(data: number[], opts: Logistics robustOptions = {}): Logistics robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics robust };
diff --git a/src/logistics/route_optimization.ts b/src/logistics/route_optimization.ts
new file mode 100644
index 000000000..502c9858b
--- /dev/null
+++ b/src/logistics/route_optimization.ts
@@ -0,0 +1,22 @@
+/** Route Optimization module — tsb analytics library. */
+
+/** Options for Route Optimization. */
+export interface RouteOptimizationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Route Optimization. */
+export interface RouteOptimizationResult { values: number[]; converged: boolean; }
+
+/** Compute Route Optimization. */
+export function computeRouteOptimization(data: number[], opts: RouteOptimizationOptions = {}): RouteOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRouteOptimization };
diff --git a/src/logistics/sea.ts b/src/logistics/sea.ts
new file mode 100644
index 000000000..f1381e6cc
--- /dev/null
+++ b/src/logistics/sea.ts
@@ -0,0 +1,22 @@
+/** Sea module — tsb analytics library. */
+
+/** Options for Sea. */
+export interface SeaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sea. */
+export interface SeaResult { values: number[]; converged: boolean; }
+
+/** Compute Sea. */
+export function computeSea(data: number[], opts: SeaOptions = {}): SeaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSea };
diff --git a/src/logistics/shipping.ts b/src/logistics/shipping.ts
new file mode 100644
index 000000000..e0835eaef
--- /dev/null
+++ b/src/logistics/shipping.ts
@@ -0,0 +1,22 @@
+/** Shipping module — tsb analytics library. */
+
+/** Options for Shipping. */
+export interface ShippingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Shipping. */
+export interface ShippingResult { values: number[]; converged: boolean; }
+
+/** Compute Shipping. */
+export function computeShipping(data: number[], opts: ShippingOptions = {}): ShippingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeShipping };
diff --git a/src/logistics/small.ts b/src/logistics/small.ts
new file mode 100644
index 000000000..aba275e1d
--- /dev/null
+++ b/src/logistics/small.ts
@@ -0,0 +1,15 @@
+/** Logistics Small module — tsb analytics library. */
+export interface Logistics smallOptions { tol?: number; maxIter?: number; }
+export interface Logistics smallResult { values: number[]; converged: boolean; }
+export function computeLogistics small(data: number[], opts: Logistics smallOptions = {}): Logistics smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics small };
diff --git a/src/logistics/sparse.ts b/src/logistics/sparse.ts
new file mode 100644
index 000000000..a76634f51
--- /dev/null
+++ b/src/logistics/sparse.ts
@@ -0,0 +1,15 @@
+/** Logistics Sparse module — tsb analytics library. */
+export interface Logistics sparseOptions { tol?: number; maxIter?: number; }
+export interface Logistics sparseResult { values: number[]; converged: boolean; }
+export function computeLogistics sparse(data: number[], opts: Logistics sparseOptions = {}): Logistics sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics sparse };
diff --git a/src/logistics/stable.ts b/src/logistics/stable.ts
new file mode 100644
index 000000000..df46ed0bc
--- /dev/null
+++ b/src/logistics/stable.ts
@@ -0,0 +1,15 @@
+/** Logistics Stable module — tsb analytics library. */
+export interface Logistics stableOptions { tol?: number; maxIter?: number; }
+export interface Logistics stableResult { values: number[]; converged: boolean; }
+export function computeLogistics stable(data: number[], opts: Logistics stableOptions = {}): Logistics stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics stable };
diff --git a/src/logistics/streaming.ts b/src/logistics/streaming.ts
new file mode 100644
index 000000000..212878cf9
--- /dev/null
+++ b/src/logistics/streaming.ts
@@ -0,0 +1,15 @@
+/** Logistics Streaming module — tsb analytics library. */
+export interface Logistics streamingOptions { tol?: number; maxIter?: number; }
+export interface Logistics streamingResult { values: number[]; converged: boolean; }
+export function computeLogistics streaming(data: number[], opts: Logistics streamingOptions = {}): Logistics streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics streaming };
diff --git a/src/logistics/tracking.ts b/src/logistics/tracking.ts
new file mode 100644
index 000000000..2e7304b5f
--- /dev/null
+++ b/src/logistics/tracking.ts
@@ -0,0 +1,22 @@
+/** Tracking module — tsb analytics library. */
+
+/** Options for Tracking. */
+export interface TrackingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tracking. */
+export interface TrackingResult { values: number[]; converged: boolean; }
+
+/** Compute Tracking. */
+export function computeTracking(data: number[], opts: TrackingOptions = {}): TrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTracking };
diff --git a/src/logistics/trade.ts b/src/logistics/trade.ts
new file mode 100644
index 000000000..bd2d44a85
--- /dev/null
+++ b/src/logistics/trade.ts
@@ -0,0 +1,22 @@
+/** Trade module — tsb analytics library. */
+
+/** Options for Trade. */
+export interface TradeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Trade. */
+export interface TradeResult { values: number[]; converged: boolean; }
+
+/** Compute Trade. */
+export function computeTrade(data: number[], opts: TradeOptions = {}): TradeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTrade };
diff --git a/src/logistics/transportation.ts b/src/logistics/transportation.ts
new file mode 100644
index 000000000..8fe6162fb
--- /dev/null
+++ b/src/logistics/transportation.ts
@@ -0,0 +1,22 @@
+/** Transportation module — tsb analytics library. */
+
+/** Options for Transportation. */
+export interface TransportationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Transportation. */
+export interface TransportationResult { values: number[]; converged: boolean; }
+
+/** Compute Transportation. */
+export function computeTransportation(data: number[], opts: TransportationOptions = {}): TransportationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTransportation };
diff --git a/src/logistics/urban.ts b/src/logistics/urban.ts
new file mode 100644
index 000000000..48d9afb07
--- /dev/null
+++ b/src/logistics/urban.ts
@@ -0,0 +1,22 @@
+/** Urban module — tsb analytics library. */
+
+/** Options for Urban. */
+export interface UrbanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Urban. */
+export interface UrbanResult { values: number[]; converged: boolean; }
+
+/** Compute Urban. */
+export function computeUrban(data: number[], opts: UrbanOptions = {}): UrbanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeUrban };
diff --git a/src/logistics/v2.ts b/src/logistics/v2.ts
new file mode 100644
index 000000000..96b8c1e2b
--- /dev/null
+++ b/src/logistics/v2.ts
@@ -0,0 +1,15 @@
+/** Logistics V2 module — tsb analytics library. */
+export interface Logistics v2Options { tol?: number; maxIter?: number; }
+export interface Logistics v2Result { values: number[]; converged: boolean; }
+export function computeLogistics v2(data: number[], opts: Logistics v2Options = {}): Logistics v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics v2 };
diff --git a/src/logistics/v3.ts b/src/logistics/v3.ts
new file mode 100644
index 000000000..760609cb2
--- /dev/null
+++ b/src/logistics/v3.ts
@@ -0,0 +1,15 @@
+/** Logistics V3 module — tsb analytics library. */
+export interface Logistics v3Options { tol?: number; maxIter?: number; }
+export interface Logistics v3Result { values: number[]; converged: boolean; }
+export function computeLogistics v3(data: number[], opts: Logistics v3Options = {}): Logistics v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics v3 };
diff --git a/src/logistics/wasm.ts b/src/logistics/wasm.ts
new file mode 100644
index 000000000..4df101dba
--- /dev/null
+++ b/src/logistics/wasm.ts
@@ -0,0 +1,15 @@
+/** Logistics Wasm module — tsb analytics library. */
+export interface Logistics wasmOptions { tol?: number; maxIter?: number; }
+export interface Logistics wasmResult { values: number[]; converged: boolean; }
+export function computeLogistics wasm(data: number[], opts: Logistics wasmOptions = {}): Logistics wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics wasm };
diff --git a/src/logistics/xlarge.ts b/src/logistics/xlarge.ts
new file mode 100644
index 000000000..5eb5e1bf1
--- /dev/null
+++ b/src/logistics/xlarge.ts
@@ -0,0 +1,15 @@
+/** Logistics Xlarge module — tsb analytics library. */
+export interface Logistics xlargeOptions { tol?: number; maxIter?: number; }
+export interface Logistics xlargeResult { values: number[]; converged: boolean; }
+export function computeLogistics xlarge(data: number[], opts: Logistics xlargeOptions = {}): Logistics xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLogistics xlarge };
diff --git a/src/lunar_sci/adaptation.ts b/src/lunar_sci/adaptation.ts
new file mode 100644
index 000000000..8076fee21
--- /dev/null
+++ b/src/lunar_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci adaptation module — tsb analytics library. */
+export interface LunarSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeLunarSciAdaptation(data: number[], opts: LunarSciAdaptationOptions = {}): LunarSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciAdaptation };
diff --git a/src/lunar_sci/aggregation.ts b/src/lunar_sci/aggregation.ts
new file mode 100644
index 000000000..07c301c0a
--- /dev/null
+++ b/src/lunar_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci aggregation module — tsb analytics library. */
+export interface LunarSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciAggregationResult { values: number[]; converged: boolean; }
+export function computeLunarSciAggregation(data: number[], opts: LunarSciAggregationOptions = {}): LunarSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciAggregation };
diff --git a/src/lunar_sci/algebra.ts b/src/lunar_sci/algebra.ts
new file mode 100644
index 000000000..b887a89ec
--- /dev/null
+++ b/src/lunar_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** lunar_sci algebra module — tsb analytics library. */
+export interface LunarSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface LunarSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeLunarSciAlgebra(data: number[], opts: LunarSciAlgebraOptions = {}): LunarSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciAlgebra };
diff --git a/src/lunar_sci/alignment.ts b/src/lunar_sci/alignment.ts
new file mode 100644
index 000000000..a5a689dc6
--- /dev/null
+++ b/src/lunar_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** lunar_sci alignment module — tsb analytics library. */
+export interface LunarSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface LunarSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeLunarSciAlignment(data: number[], opts: LunarSciAlignmentOptions = {}): LunarSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciAlignment };
diff --git a/src/lunar_sci/analysis.ts b/src/lunar_sci/analysis.ts
new file mode 100644
index 000000000..4285dd8b9
--- /dev/null
+++ b/src/lunar_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** lunar_sci analysis module — tsb analytics library. */
+export interface LunarSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface LunarSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeLunarSciAnalysis(data: number[], opts: LunarSciAnalysisOptions = {}): LunarSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciAnalysis };
diff --git a/src/lunar_sci/augmentation.ts b/src/lunar_sci/augmentation.ts
new file mode 100644
index 000000000..9f6a508fc
--- /dev/null
+++ b/src/lunar_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci augmentation module — tsb analytics library. */
+export interface LunarSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeLunarSciAugmentation(data: number[], opts: LunarSciAugmentationOptions = {}): LunarSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciAugmentation };
diff --git a/src/lunar_sci/bagging.ts b/src/lunar_sci/bagging.ts
new file mode 100644
index 000000000..7e547ec18
--- /dev/null
+++ b/src/lunar_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** lunar_sci bagging module — tsb analytics library. */
+export interface LunarSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciBaggingResult { values: number[]; converged: boolean; }
+export function computeLunarSciBagging(data: number[], opts: LunarSciBaggingOptions = {}): LunarSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciBagging };
diff --git a/src/lunar_sci/basis.ts b/src/lunar_sci/basis.ts
new file mode 100644
index 000000000..71d3f7623
--- /dev/null
+++ b/src/lunar_sci/basis.ts
@@ -0,0 +1,14 @@
+/** lunar_sci basis module — tsb analytics library. */
+export interface LunarSciBasisOptions { tol?: number; maxIter?: number; }
+export interface LunarSciBasisResult { values: number[]; converged: boolean; }
+export function computeLunarSciBasis(data: number[], opts: LunarSciBasisOptions = {}): LunarSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciBasis };
diff --git a/src/lunar_sci/benchmarking.ts b/src/lunar_sci/benchmarking.ts
new file mode 100644
index 000000000..6d187de54
--- /dev/null
+++ b/src/lunar_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** lunar_sci benchmarking module — tsb analytics library. */
+export interface LunarSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeLunarSciBenchmarking(data: number[], opts: LunarSciBenchmarkingOptions = {}): LunarSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciBenchmarking };
diff --git a/src/lunar_sci/blending.ts b/src/lunar_sci/blending.ts
new file mode 100644
index 000000000..fb4df1971
--- /dev/null
+++ b/src/lunar_sci/blending.ts
@@ -0,0 +1,14 @@
+/** lunar_sci blending module — tsb analytics library. */
+export interface LunarSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciBlendingResult { values: number[]; converged: boolean; }
+export function computeLunarSciBlending(data: number[], opts: LunarSciBlendingOptions = {}): LunarSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciBlending };
diff --git a/src/lunar_sci/boosting.ts b/src/lunar_sci/boosting.ts
new file mode 100644
index 000000000..cebc34288
--- /dev/null
+++ b/src/lunar_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** lunar_sci boosting module — tsb analytics library. */
+export interface LunarSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciBoostingResult { values: number[]; converged: boolean; }
+export function computeLunarSciBoosting(data: number[], opts: LunarSciBoostingOptions = {}): LunarSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciBoosting };
diff --git a/src/lunar_sci/bootstrap.ts b/src/lunar_sci/bootstrap.ts
new file mode 100644
index 000000000..67da42492
--- /dev/null
+++ b/src/lunar_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** lunar_sci bootstrap module — tsb analytics library. */
+export interface LunarSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface LunarSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeLunarSciBootstrap(data: number[], opts: LunarSciBootstrapOptions = {}): LunarSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciBootstrap };
diff --git a/src/lunar_sci/calculus.ts b/src/lunar_sci/calculus.ts
new file mode 100644
index 000000000..8df428561
--- /dev/null
+++ b/src/lunar_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** lunar_sci calculus module — tsb analytics library. */
+export interface LunarSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface LunarSciCalculusResult { values: number[]; converged: boolean; }
+export function computeLunarSciCalculus(data: number[], opts: LunarSciCalculusOptions = {}): LunarSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciCalculus };
diff --git a/src/lunar_sci/calibration.ts b/src/lunar_sci/calibration.ts
new file mode 100644
index 000000000..96aace91c
--- /dev/null
+++ b/src/lunar_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** lunar_sci calibration module — tsb analytics library. */
+export interface LunarSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeLunarSciCalibration(data: number[], opts: LunarSciCalibrationOptions = {}): LunarSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciCalibration };
diff --git a/src/lunar_sci/characterization.ts b/src/lunar_sci/characterization.ts
new file mode 100644
index 000000000..5f0280c9a
--- /dev/null
+++ b/src/lunar_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** lunar_sci characterization module — tsb analytics library. */
+export interface LunarSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeLunarSciCharacterization(data: number[], opts: LunarSciCharacterizationOptions = {}): LunarSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciCharacterization };
diff --git a/src/lunar_sci/classification.ts b/src/lunar_sci/classification.ts
new file mode 100644
index 000000000..86b9a7dc3
--- /dev/null
+++ b/src/lunar_sci/classification.ts
@@ -0,0 +1,14 @@
+/** lunar_sci classification module — tsb analytics library. */
+export interface LunarSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciClassificationResult { values: number[]; converged: boolean; }
+export function computeLunarSciClassification(data: number[], opts: LunarSciClassificationOptions = {}): LunarSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciClassification };
diff --git a/src/lunar_sci/clustering.ts b/src/lunar_sci/clustering.ts
new file mode 100644
index 000000000..98bca7209
--- /dev/null
+++ b/src/lunar_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** lunar_sci clustering module — tsb analytics library. */
+export interface LunarSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface LunarSciClusteringResult { values: number[]; converged: boolean; }
+export function computeLunarSciClustering(data: number[], opts: LunarSciClusteringOptions = {}): LunarSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciClustering };
diff --git a/src/lunar_sci/compression.ts b/src/lunar_sci/compression.ts
new file mode 100644
index 000000000..8db0d5efb
--- /dev/null
+++ b/src/lunar_sci/compression.ts
@@ -0,0 +1,14 @@
+/** lunar_sci compression module — tsb analytics library. */
+export interface LunarSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciCompressionResult { values: number[]; converged: boolean; }
+export function computeLunarSciCompression(data: number[], opts: LunarSciCompressionOptions = {}): LunarSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciCompression };
diff --git a/src/lunar_sci/continuous.ts b/src/lunar_sci/continuous.ts
new file mode 100644
index 000000000..df6a835ef
--- /dev/null
+++ b/src/lunar_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** lunar_sci continuous module — tsb analytics library. */
+export interface LunarSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface LunarSciContinuousResult { values: number[]; converged: boolean; }
+export function computeLunarSciContinuous(data: number[], opts: LunarSciContinuousOptions = {}): LunarSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciContinuous };
diff --git a/src/lunar_sci/control.ts b/src/lunar_sci/control.ts
new file mode 100644
index 000000000..a06ccb0e8
--- /dev/null
+++ b/src/lunar_sci/control.ts
@@ -0,0 +1,14 @@
+/** lunar_sci control module — tsb analytics library. */
+export interface LunarSciControlOptions { tol?: number; maxIter?: number; }
+export interface LunarSciControlResult { values: number[]; converged: boolean; }
+export function computeLunarSciControl(data: number[], opts: LunarSciControlOptions = {}): LunarSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciControl };
diff --git a/src/lunar_sci/convergence.ts b/src/lunar_sci/convergence.ts
new file mode 100644
index 000000000..3b25d14e1
--- /dev/null
+++ b/src/lunar_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** lunar_sci convergence module — tsb analytics library. */
+export interface LunarSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface LunarSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeLunarSciConvergence(data: number[], opts: LunarSciConvergenceOptions = {}): LunarSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciConvergence };
diff --git a/src/lunar_sci/convex.ts b/src/lunar_sci/convex.ts
new file mode 100644
index 000000000..567e79ec0
--- /dev/null
+++ b/src/lunar_sci/convex.ts
@@ -0,0 +1,14 @@
+/** lunar_sci convex module — tsb analytics library. */
+export interface LunarSciConvexOptions { tol?: number; maxIter?: number; }
+export interface LunarSciConvexResult { values: number[]; converged: boolean; }
+export function computeLunarSciConvex(data: number[], opts: LunarSciConvexOptions = {}): LunarSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciConvex };
diff --git a/src/lunar_sci/correlation.ts b/src/lunar_sci/correlation.ts
new file mode 100644
index 000000000..f6c4e5602
--- /dev/null
+++ b/src/lunar_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci correlation module — tsb analytics library. */
+export interface LunarSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeLunarSciCorrelation(data: number[], opts: LunarSciCorrelationOptions = {}): LunarSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciCorrelation };
diff --git a/src/lunar_sci/covariance.ts b/src/lunar_sci/covariance.ts
new file mode 100644
index 000000000..16f9d540d
--- /dev/null
+++ b/src/lunar_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** lunar_sci covariance module — tsb analytics library. */
+export interface LunarSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface LunarSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeLunarSciCovariance(data: number[], opts: LunarSciCovarianceOptions = {}): LunarSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciCovariance };
diff --git a/src/lunar_sci/cross_validation.ts b/src/lunar_sci/cross_validation.ts
new file mode 100644
index 000000000..036c0ca10
--- /dev/null
+++ b/src/lunar_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci cross_validation module — tsb analytics library. */
+export interface LunarSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeLunarSciCrossValidation(data: number[], opts: LunarSciCrossValidationOptions = {}): LunarSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciCrossValidation };
diff --git a/src/lunar_sci/decoding.ts b/src/lunar_sci/decoding.ts
new file mode 100644
index 000000000..27c3af428
--- /dev/null
+++ b/src/lunar_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** lunar_sci decoding module — tsb analytics library. */
+export interface LunarSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDecodingResult { values: number[]; converged: boolean; }
+export function computeLunarSciDecoding(data: number[], opts: LunarSciDecodingOptions = {}): LunarSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDecoding };
diff --git a/src/lunar_sci/decomposition.ts b/src/lunar_sci/decomposition.ts
new file mode 100644
index 000000000..0b4fcfbf8
--- /dev/null
+++ b/src/lunar_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** lunar_sci decomposition module — tsb analytics library. */
+export interface LunarSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeLunarSciDecomposition(data: number[], opts: LunarSciDecompositionOptions = {}): LunarSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDecomposition };
diff --git a/src/lunar_sci/detection.ts b/src/lunar_sci/detection.ts
new file mode 100644
index 000000000..4ee2c864b
--- /dev/null
+++ b/src/lunar_sci/detection.ts
@@ -0,0 +1,14 @@
+/** lunar_sci detection module — tsb analytics library. */
+export interface LunarSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDetectionResult { values: number[]; converged: boolean; }
+export function computeLunarSciDetection(data: number[], opts: LunarSciDetectionOptions = {}): LunarSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDetection };
diff --git a/src/lunar_sci/deterministic.ts b/src/lunar_sci/deterministic.ts
new file mode 100644
index 000000000..c1286bc34
--- /dev/null
+++ b/src/lunar_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** lunar_sci deterministic module — tsb analytics library. */
+export interface LunarSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeLunarSciDeterministic(data: number[], opts: LunarSciDeterministicOptions = {}): LunarSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDeterministic };
diff --git a/src/lunar_sci/diagnostics.ts b/src/lunar_sci/diagnostics.ts
new file mode 100644
index 000000000..d8cf94364
--- /dev/null
+++ b/src/lunar_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** lunar_sci diagnostics module — tsb analytics library. */
+export interface LunarSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeLunarSciDiagnostics(data: number[], opts: LunarSciDiagnosticsOptions = {}): LunarSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDiagnostics };
diff --git a/src/lunar_sci/differential.ts b/src/lunar_sci/differential.ts
new file mode 100644
index 000000000..9fdb7950a
--- /dev/null
+++ b/src/lunar_sci/differential.ts
@@ -0,0 +1,14 @@
+/** lunar_sci differential module — tsb analytics library. */
+export interface LunarSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeLunarSciDifferential(data: number[], opts: LunarSciDifferentialOptions = {}): LunarSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDifferential };
diff --git a/src/lunar_sci/discrete.ts b/src/lunar_sci/discrete.ts
new file mode 100644
index 000000000..10d54d323
--- /dev/null
+++ b/src/lunar_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** lunar_sci discrete module — tsb analytics library. */
+export interface LunarSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeLunarSciDiscrete(data: number[], opts: LunarSciDiscreteOptions = {}): LunarSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDiscrete };
diff --git a/src/lunar_sci/distribution.ts b/src/lunar_sci/distribution.ts
new file mode 100644
index 000000000..1cbe99f6a
--- /dev/null
+++ b/src/lunar_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** lunar_sci distribution module — tsb analytics library. */
+export interface LunarSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDistributionResult { values: number[]; converged: boolean; }
+export function computeLunarSciDistribution(data: number[], opts: LunarSciDistributionOptions = {}): LunarSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDistribution };
diff --git a/src/lunar_sci/dynamic.ts b/src/lunar_sci/dynamic.ts
new file mode 100644
index 000000000..a10fd550e
--- /dev/null
+++ b/src/lunar_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** lunar_sci dynamic module — tsb analytics library. */
+export interface LunarSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface LunarSciDynamicResult { values: number[]; converged: boolean; }
+export function computeLunarSciDynamic(data: number[], opts: LunarSciDynamicOptions = {}): LunarSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciDynamic };
diff --git a/src/lunar_sci/embedding.ts b/src/lunar_sci/embedding.ts
new file mode 100644
index 000000000..d2b3194aa
--- /dev/null
+++ b/src/lunar_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** lunar_sci embedding module — tsb analytics library. */
+export interface LunarSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeLunarSciEmbedding(data: number[], opts: LunarSciEmbeddingOptions = {}): LunarSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciEmbedding };
diff --git a/src/lunar_sci/encoding.ts b/src/lunar_sci/encoding.ts
new file mode 100644
index 000000000..8cfbdb05a
--- /dev/null
+++ b/src/lunar_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** lunar_sci encoding module — tsb analytics library. */
+export interface LunarSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciEncodingResult { values: number[]; converged: boolean; }
+export function computeLunarSciEncoding(data: number[], opts: LunarSciEncodingOptions = {}): LunarSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciEncoding };
diff --git a/src/lunar_sci/ensemble.ts b/src/lunar_sci/ensemble.ts
new file mode 100644
index 000000000..d0b002c95
--- /dev/null
+++ b/src/lunar_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** lunar_sci ensemble module — tsb analytics library. */
+export interface LunarSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface LunarSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeLunarSciEnsemble(data: number[], opts: LunarSciEnsembleOptions = {}): LunarSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciEnsemble };
diff --git a/src/lunar_sci/estimation.ts b/src/lunar_sci/estimation.ts
new file mode 100644
index 000000000..dce2e890a
--- /dev/null
+++ b/src/lunar_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci estimation module — tsb analytics library. */
+export interface LunarSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciEstimationResult { values: number[]; converged: boolean; }
+export function computeLunarSciEstimation(data: number[], opts: LunarSciEstimationOptions = {}): LunarSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciEstimation };
diff --git a/src/lunar_sci/evaluation.ts b/src/lunar_sci/evaluation.ts
new file mode 100644
index 000000000..a3aa91654
--- /dev/null
+++ b/src/lunar_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci evaluation module — tsb analytics library. */
+export interface LunarSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeLunarSciEvaluation(data: number[], opts: LunarSciEvaluationOptions = {}): LunarSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciEvaluation };
diff --git a/src/lunar_sci/extrapolation.ts b/src/lunar_sci/extrapolation.ts
new file mode 100644
index 000000000..21f1dbb70
--- /dev/null
+++ b/src/lunar_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci extrapolation module — tsb analytics library. */
+export interface LunarSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeLunarSciExtrapolation(data: number[], opts: LunarSciExtrapolationOptions = {}): LunarSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciExtrapolation };
diff --git a/src/lunar_sci/features.ts b/src/lunar_sci/features.ts
new file mode 100644
index 000000000..752c64a4c
--- /dev/null
+++ b/src/lunar_sci/features.ts
@@ -0,0 +1,14 @@
+/** lunar_sci features module — tsb analytics library. */
+export interface LunarSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface LunarSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeLunarSciFeatures(data: number[], opts: LunarSciFeaturesOptions = {}): LunarSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciFeatures };
diff --git a/src/lunar_sci/feedback.ts b/src/lunar_sci/feedback.ts
new file mode 100644
index 000000000..7dc67dbd5
--- /dev/null
+++ b/src/lunar_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** lunar_sci feedback module — tsb analytics library. */
+export interface LunarSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface LunarSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeLunarSciFeedback(data: number[], opts: LunarSciFeedbackOptions = {}): LunarSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciFeedback };
diff --git a/src/lunar_sci/filtering.ts b/src/lunar_sci/filtering.ts
new file mode 100644
index 000000000..b512ce3a2
--- /dev/null
+++ b/src/lunar_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** lunar_sci filtering module — tsb analytics library. */
+export interface LunarSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface LunarSciFilteringResult { values: number[]; converged: boolean; }
+export function computeLunarSciFiltering(data: number[], opts: LunarSciFilteringOptions = {}): LunarSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciFiltering };
diff --git a/src/lunar_sci/fourier.ts b/src/lunar_sci/fourier.ts
new file mode 100644
index 000000000..6b9245b4e
--- /dev/null
+++ b/src/lunar_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** lunar_sci fourier module — tsb analytics library. */
+export interface LunarSciFourierOptions { tol?: number; maxIter?: number; }
+export interface LunarSciFourierResult { values: number[]; converged: boolean; }
+export function computeLunarSciFourier(data: number[], opts: LunarSciFourierOptions = {}): LunarSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciFourier };
diff --git a/src/lunar_sci/fusion.ts b/src/lunar_sci/fusion.ts
new file mode 100644
index 000000000..89ddf75be
--- /dev/null
+++ b/src/lunar_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** lunar_sci fusion module — tsb analytics library. */
+export interface LunarSciFusionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciFusionResult { values: number[]; converged: boolean; }
+export function computeLunarSciFusion(data: number[], opts: LunarSciFusionOptions = {}): LunarSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciFusion };
diff --git a/src/lunar_sci/generation.ts b/src/lunar_sci/generation.ts
new file mode 100644
index 000000000..90ad5a9cb
--- /dev/null
+++ b/src/lunar_sci/generation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci generation module — tsb analytics library. */
+export interface LunarSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciGenerationResult { values: number[]; converged: boolean; }
+export function computeLunarSciGeneration(data: number[], opts: LunarSciGenerationOptions = {}): LunarSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciGeneration };
diff --git a/src/lunar_sci/geometry.ts b/src/lunar_sci/geometry.ts
new file mode 100644
index 000000000..5f6e9a2a0
--- /dev/null
+++ b/src/lunar_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** lunar_sci geometry module — tsb analytics library. */
+export interface LunarSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface LunarSciGeometryResult { values: number[]; converged: boolean; }
+export function computeLunarSciGeometry(data: number[], opts: LunarSciGeometryOptions = {}): LunarSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciGeometry };
diff --git a/src/lunar_sci/gradient.ts b/src/lunar_sci/gradient.ts
new file mode 100644
index 000000000..2e490207c
--- /dev/null
+++ b/src/lunar_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** lunar_sci gradient module — tsb analytics library. */
+export interface LunarSciGradientOptions { tol?: number; maxIter?: number; }
+export interface LunarSciGradientResult { values: number[]; converged: boolean; }
+export function computeLunarSciGradient(data: number[], opts: LunarSciGradientOptions = {}): LunarSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciGradient };
diff --git a/src/lunar_sci/hessian.ts b/src/lunar_sci/hessian.ts
new file mode 100644
index 000000000..b0c9b0e72
--- /dev/null
+++ b/src/lunar_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** lunar_sci hessian module — tsb analytics library. */
+export interface LunarSciHessianOptions { tol?: number; maxIter?: number; }
+export interface LunarSciHessianResult { values: number[]; converged: boolean; }
+export function computeLunarSciHessian(data: number[], opts: LunarSciHessianOptions = {}): LunarSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciHessian };
diff --git a/src/lunar_sci/hypothesis.ts b/src/lunar_sci/hypothesis.ts
new file mode 100644
index 000000000..e81dd19b9
--- /dev/null
+++ b/src/lunar_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** lunar_sci hypothesis module — tsb analytics library. */
+export interface LunarSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface LunarSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeLunarSciHypothesis(data: number[], opts: LunarSciHypothesisOptions = {}): LunarSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciHypothesis };
diff --git a/src/lunar_sci/inference.ts b/src/lunar_sci/inference.ts
new file mode 100644
index 000000000..badb5053e
--- /dev/null
+++ b/src/lunar_sci/inference.ts
@@ -0,0 +1,14 @@
+/** lunar_sci inference module — tsb analytics library. */
+export interface LunarSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface LunarSciInferenceResult { values: number[]; converged: boolean; }
+export function computeLunarSciInference(data: number[], opts: LunarSciInferenceOptions = {}): LunarSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciInference };
diff --git a/src/lunar_sci/inference2.ts b/src/lunar_sci/inference2.ts
new file mode 100644
index 000000000..bb8d0c942
--- /dev/null
+++ b/src/lunar_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** lunar_sci inference2 module — tsb analytics library. */
+export interface LunarSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface LunarSciInferenceResult { values: number[]; converged: boolean; }
+export function computeLunarSciInference(data: number[], opts: LunarSciInferenceOptions = {}): LunarSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciInference };
diff --git a/src/lunar_sci/integral.ts b/src/lunar_sci/integral.ts
new file mode 100644
index 000000000..721d1bc27
--- /dev/null
+++ b/src/lunar_sci/integral.ts
@@ -0,0 +1,14 @@
+/** lunar_sci integral module — tsb analytics library. */
+export interface LunarSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface LunarSciIntegralResult { values: number[]; converged: boolean; }
+export function computeLunarSciIntegral(data: number[], opts: LunarSciIntegralOptions = {}): LunarSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciIntegral };
diff --git a/src/lunar_sci/integration.ts b/src/lunar_sci/integration.ts
new file mode 100644
index 000000000..3aaed2c3f
--- /dev/null
+++ b/src/lunar_sci/integration.ts
@@ -0,0 +1,14 @@
+/** lunar_sci integration module — tsb analytics library. */
+export interface LunarSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeLunarSciIntegration(data: number[], opts: LunarSciIntegrationOptions = {}): LunarSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciIntegration };
diff --git a/src/lunar_sci/interpolation.ts b/src/lunar_sci/interpolation.ts
new file mode 100644
index 000000000..e5163feef
--- /dev/null
+++ b/src/lunar_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci interpolation module — tsb analytics library. */
+export interface LunarSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeLunarSciInterpolation(data: number[], opts: LunarSciInterpolationOptions = {}): LunarSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciInterpolation };
diff --git a/src/lunar_sci/jacobian.ts b/src/lunar_sci/jacobian.ts
new file mode 100644
index 000000000..1719917c2
--- /dev/null
+++ b/src/lunar_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** lunar_sci jacobian module — tsb analytics library. */
+export interface LunarSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface LunarSciJacobianResult { values: number[]; converged: boolean; }
+export function computeLunarSciJacobian(data: number[], opts: LunarSciJacobianOptions = {}): LunarSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciJacobian };
diff --git a/src/lunar_sci/kernel.ts b/src/lunar_sci/kernel.ts
new file mode 100644
index 000000000..54a16b25c
--- /dev/null
+++ b/src/lunar_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** lunar_sci kernel module — tsb analytics library. */
+export interface LunarSciKernelOptions { tol?: number; maxIter?: number; }
+export interface LunarSciKernelResult { values: number[]; converged: boolean; }
+export function computeLunarSciKernel(data: number[], opts: LunarSciKernelOptions = {}): LunarSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciKernel };
diff --git a/src/lunar_sci/laplacian.ts b/src/lunar_sci/laplacian.ts
new file mode 100644
index 000000000..b7a451dcf
--- /dev/null
+++ b/src/lunar_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** lunar_sci laplacian module — tsb analytics library. */
+export interface LunarSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface LunarSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeLunarSciLaplacian(data: number[], opts: LunarSciLaplacianOptions = {}): LunarSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciLaplacian };
diff --git a/src/lunar_sci/learning.ts b/src/lunar_sci/learning.ts
new file mode 100644
index 000000000..f97f690dd
--- /dev/null
+++ b/src/lunar_sci/learning.ts
@@ -0,0 +1,14 @@
+/** lunar_sci learning module — tsb analytics library. */
+export interface LunarSciLearningOptions { tol?: number; maxIter?: number; }
+export interface LunarSciLearningResult { values: number[]; converged: boolean; }
+export function computeLunarSciLearning(data: number[], opts: LunarSciLearningOptions = {}): LunarSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciLearning };
diff --git a/src/lunar_sci/linear.ts b/src/lunar_sci/linear.ts
new file mode 100644
index 000000000..8e837b6dc
--- /dev/null
+++ b/src/lunar_sci/linear.ts
@@ -0,0 +1,14 @@
+/** lunar_sci linear module — tsb analytics library. */
+export interface LunarSciLinearOptions { tol?: number; maxIter?: number; }
+export interface LunarSciLinearResult { values: number[]; converged: boolean; }
+export function computeLunarSciLinear(data: number[], opts: LunarSciLinearOptions = {}): LunarSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciLinear };
diff --git a/src/lunar_sci/manifold.ts b/src/lunar_sci/manifold.ts
new file mode 100644
index 000000000..75f445934
--- /dev/null
+++ b/src/lunar_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** lunar_sci manifold module — tsb analytics library. */
+export interface LunarSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface LunarSciManifoldResult { values: number[]; converged: boolean; }
+export function computeLunarSciManifold(data: number[], opts: LunarSciManifoldOptions = {}): LunarSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciManifold };
diff --git a/src/lunar_sci/matching.ts b/src/lunar_sci/matching.ts
new file mode 100644
index 000000000..e3ff26b7f
--- /dev/null
+++ b/src/lunar_sci/matching.ts
@@ -0,0 +1,14 @@
+/** lunar_sci matching module — tsb analytics library. */
+export interface LunarSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciMatchingResult { values: number[]; converged: boolean; }
+export function computeLunarSciMatching(data: number[], opts: LunarSciMatchingOptions = {}): LunarSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciMatching };
diff --git a/src/lunar_sci/measurement.ts b/src/lunar_sci/measurement.ts
new file mode 100644
index 000000000..70ce7e86c
--- /dev/null
+++ b/src/lunar_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** lunar_sci measurement module — tsb analytics library. */
+export interface LunarSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface LunarSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeLunarSciMeasurement(data: number[], opts: LunarSciMeasurementOptions = {}): LunarSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciMeasurement };
diff --git a/src/lunar_sci/metrics.ts b/src/lunar_sci/metrics.ts
new file mode 100644
index 000000000..777596e2e
--- /dev/null
+++ b/src/lunar_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** lunar_sci metrics module — tsb analytics library. */
+export interface LunarSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface LunarSciMetricsResult { values: number[]; converged: boolean; }
+export function computeLunarSciMetrics(data: number[], opts: LunarSciMetricsOptions = {}): LunarSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciMetrics };
diff --git a/src/lunar_sci/modeling.ts b/src/lunar_sci/modeling.ts
new file mode 100644
index 000000000..8344eed98
--- /dev/null
+++ b/src/lunar_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** lunar_sci modeling module — tsb analytics library. */
+export interface LunarSciModelingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciModelingResult { values: number[]; converged: boolean; }
+export function computeLunarSciModeling(data: number[], opts: LunarSciModelingOptions = {}): LunarSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciModeling };
diff --git a/src/lunar_sci/monitoring.ts b/src/lunar_sci/monitoring.ts
new file mode 100644
index 000000000..d2b088910
--- /dev/null
+++ b/src/lunar_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** lunar_sci monitoring module — tsb analytics library. */
+export interface LunarSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface LunarSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeLunarSciMonitoring(data: number[], opts: LunarSciMonitoringOptions = {}): LunarSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciMonitoring };
diff --git a/src/lunar_sci/nonlinear.ts b/src/lunar_sci/nonlinear.ts
new file mode 100644
index 000000000..9dbe72f86
--- /dev/null
+++ b/src/lunar_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** lunar_sci nonlinear module — tsb analytics library. */
+export interface LunarSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface LunarSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeLunarSciNonlinear(data: number[], opts: LunarSciNonlinearOptions = {}): LunarSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciNonlinear };
diff --git a/src/lunar_sci/normalization.ts b/src/lunar_sci/normalization.ts
new file mode 100644
index 000000000..3c79fe151
--- /dev/null
+++ b/src/lunar_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** lunar_sci normalization module — tsb analytics library. */
+export interface LunarSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeLunarSciNormalization(data: number[], opts: LunarSciNormalizationOptions = {}): LunarSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciNormalization };
diff --git a/src/lunar_sci/optimization.ts b/src/lunar_sci/optimization.ts
new file mode 100644
index 000000000..d58337aca
--- /dev/null
+++ b/src/lunar_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** lunar_sci optimization module — tsb analytics library. */
+export interface LunarSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeLunarSciOptimization(data: number[], opts: LunarSciOptimizationOptions = {}): LunarSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciOptimization };
diff --git a/src/lunar_sci/patterns.ts b/src/lunar_sci/patterns.ts
new file mode 100644
index 000000000..b98cfb806
--- /dev/null
+++ b/src/lunar_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** lunar_sci patterns module — tsb analytics library. */
+export interface LunarSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface LunarSciPatternsResult { values: number[]; converged: boolean; }
+export function computeLunarSciPatterns(data: number[], opts: LunarSciPatternsOptions = {}): LunarSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciPatterns };
diff --git a/src/lunar_sci/permutation.ts b/src/lunar_sci/permutation.ts
new file mode 100644
index 000000000..8c0f9a9cb
--- /dev/null
+++ b/src/lunar_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci permutation module — tsb analytics library. */
+export interface LunarSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciPermutationResult { values: number[]; converged: boolean; }
+export function computeLunarSciPermutation(data: number[], opts: LunarSciPermutationOptions = {}): LunarSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciPermutation };
diff --git a/src/lunar_sci/prediction.ts b/src/lunar_sci/prediction.ts
new file mode 100644
index 000000000..d3b54fd55
--- /dev/null
+++ b/src/lunar_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** lunar_sci prediction module — tsb analytics library. */
+export interface LunarSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciPredictionResult { values: number[]; converged: boolean; }
+export function computeLunarSciPrediction(data: number[], opts: LunarSciPredictionOptions = {}): LunarSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciPrediction };
diff --git a/src/lunar_sci/processing.ts b/src/lunar_sci/processing.ts
new file mode 100644
index 000000000..58d581c7c
--- /dev/null
+++ b/src/lunar_sci/processing.ts
@@ -0,0 +1,14 @@
+/** lunar_sci processing module — tsb analytics library. */
+export interface LunarSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciProcessingResult { values: number[]; converged: boolean; }
+export function computeLunarSciProcessing(data: number[], opts: LunarSciProcessingOptions = {}): LunarSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciProcessing };
diff --git a/src/lunar_sci/profiling.ts b/src/lunar_sci/profiling.ts
new file mode 100644
index 000000000..588a2b04b
--- /dev/null
+++ b/src/lunar_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** lunar_sci profiling module — tsb analytics library. */
+export interface LunarSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciProfilingResult { values: number[]; converged: boolean; }
+export function computeLunarSciProfiling(data: number[], opts: LunarSciProfilingOptions = {}): LunarSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciProfiling };
diff --git a/src/lunar_sci/projection.ts b/src/lunar_sci/projection.ts
new file mode 100644
index 000000000..5fb2eb711
--- /dev/null
+++ b/src/lunar_sci/projection.ts
@@ -0,0 +1,14 @@
+/** lunar_sci projection module — tsb analytics library. */
+export interface LunarSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciProjectionResult { values: number[]; converged: boolean; }
+export function computeLunarSciProjection(data: number[], opts: LunarSciProjectionOptions = {}): LunarSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciProjection };
diff --git a/src/lunar_sci/ranking.ts b/src/lunar_sci/ranking.ts
new file mode 100644
index 000000000..cc0aed285
--- /dev/null
+++ b/src/lunar_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** lunar_sci ranking module — tsb analytics library. */
+export interface LunarSciRankingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciRankingResult { values: number[]; converged: boolean; }
+export function computeLunarSciRanking(data: number[], opts: LunarSciRankingOptions = {}): LunarSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciRanking };
diff --git a/src/lunar_sci/reconstruction.ts b/src/lunar_sci/reconstruction.ts
new file mode 100644
index 000000000..7fde47e98
--- /dev/null
+++ b/src/lunar_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** lunar_sci reconstruction module — tsb analytics library. */
+export interface LunarSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeLunarSciReconstruction(data: number[], opts: LunarSciReconstructionOptions = {}): LunarSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciReconstruction };
diff --git a/src/lunar_sci/registration.ts b/src/lunar_sci/registration.ts
new file mode 100644
index 000000000..f737d81e0
--- /dev/null
+++ b/src/lunar_sci/registration.ts
@@ -0,0 +1,14 @@
+/** lunar_sci registration module — tsb analytics library. */
+export interface LunarSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeLunarSciRegistration(data: number[], opts: LunarSciRegistrationOptions = {}): LunarSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciRegistration };
diff --git a/src/lunar_sci/regression.ts b/src/lunar_sci/regression.ts
new file mode 100644
index 000000000..674bbf01b
--- /dev/null
+++ b/src/lunar_sci/regression.ts
@@ -0,0 +1,14 @@
+/** lunar_sci regression module — tsb analytics library. */
+export interface LunarSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciRegressionResult { values: number[]; converged: boolean; }
+export function computeLunarSciRegression(data: number[], opts: LunarSciRegressionOptions = {}): LunarSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciRegression };
diff --git a/src/lunar_sci/regularization.ts b/src/lunar_sci/regularization.ts
new file mode 100644
index 000000000..4848f3cf8
--- /dev/null
+++ b/src/lunar_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** lunar_sci regularization module — tsb analytics library. */
+export interface LunarSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeLunarSciRegularization(data: number[], opts: LunarSciRegularizationOptions = {}): LunarSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciRegularization };
diff --git a/src/lunar_sci/robustness.ts b/src/lunar_sci/robustness.ts
new file mode 100644
index 000000000..0e916cbe9
--- /dev/null
+++ b/src/lunar_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** lunar_sci robustness module — tsb analytics library. */
+export interface LunarSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface LunarSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeLunarSciRobustness(data: number[], opts: LunarSciRobustnessOptions = {}): LunarSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciRobustness };
diff --git a/src/lunar_sci/sampling.ts b/src/lunar_sci/sampling.ts
new file mode 100644
index 000000000..114b12570
--- /dev/null
+++ b/src/lunar_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** lunar_sci sampling module — tsb analytics library. */
+export interface LunarSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciSamplingResult { values: number[]; converged: boolean; }
+export function computeLunarSciSampling(data: number[], opts: LunarSciSamplingOptions = {}): LunarSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciSampling };
diff --git a/src/lunar_sci/sampling2.ts b/src/lunar_sci/sampling2.ts
new file mode 100644
index 000000000..1d0b89928
--- /dev/null
+++ b/src/lunar_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** lunar_sci sampling2 module — tsb analytics library. */
+export interface LunarSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciSamplingResult { values: number[]; converged: boolean; }
+export function computeLunarSciSampling(data: number[], opts: LunarSciSamplingOptions = {}): LunarSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciSampling };
diff --git a/src/lunar_sci/scaling.ts b/src/lunar_sci/scaling.ts
new file mode 100644
index 000000000..720f36820
--- /dev/null
+++ b/src/lunar_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** lunar_sci scaling module — tsb analytics library. */
+export interface LunarSciScalingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciScalingResult { values: number[]; converged: boolean; }
+export function computeLunarSciScaling(data: number[], opts: LunarSciScalingOptions = {}): LunarSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciScaling };
diff --git a/src/lunar_sci/scoring.ts b/src/lunar_sci/scoring.ts
new file mode 100644
index 000000000..8d9f7f981
--- /dev/null
+++ b/src/lunar_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** lunar_sci scoring module — tsb analytics library. */
+export interface LunarSciScoringOptions { tol?: number; maxIter?: number; }
+export interface LunarSciScoringResult { values: number[]; converged: boolean; }
+export function computeLunarSciScoring(data: number[], opts: LunarSciScoringOptions = {}): LunarSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciScoring };
diff --git a/src/lunar_sci/segmentation.ts b/src/lunar_sci/segmentation.ts
new file mode 100644
index 000000000..76df04ae7
--- /dev/null
+++ b/src/lunar_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci segmentation module — tsb analytics library. */
+export interface LunarSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeLunarSciSegmentation(data: number[], opts: LunarSciSegmentationOptions = {}): LunarSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciSegmentation };
diff --git a/src/lunar_sci/selection.ts b/src/lunar_sci/selection.ts
new file mode 100644
index 000000000..43713bfb3
--- /dev/null
+++ b/src/lunar_sci/selection.ts
@@ -0,0 +1,14 @@
+/** lunar_sci selection module — tsb analytics library. */
+export interface LunarSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface LunarSciSelectionResult { values: number[]; converged: boolean; }
+export function computeLunarSciSelection(data: number[], opts: LunarSciSelectionOptions = {}): LunarSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciSelection };
diff --git a/src/lunar_sci/sensitivity.ts b/src/lunar_sci/sensitivity.ts
new file mode 100644
index 000000000..bc8ee0789
--- /dev/null
+++ b/src/lunar_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** lunar_sci sensitivity module — tsb analytics library. */
+export interface LunarSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface LunarSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeLunarSciSensitivity(data: number[], opts: LunarSciSensitivityOptions = {}): LunarSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciSensitivity };
diff --git a/src/lunar_sci/simulation.ts b/src/lunar_sci/simulation.ts
new file mode 100644
index 000000000..f6249037f
--- /dev/null
+++ b/src/lunar_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci simulation module — tsb analytics library. */
+export interface LunarSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciSimulationResult { values: number[]; converged: boolean; }
+export function computeLunarSciSimulation(data: number[], opts: LunarSciSimulationOptions = {}): LunarSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciSimulation };
diff --git a/src/lunar_sci/smoothing.ts b/src/lunar_sci/smoothing.ts
new file mode 100644
index 000000000..f33485a63
--- /dev/null
+++ b/src/lunar_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** lunar_sci smoothing module — tsb analytics library. */
+export interface LunarSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeLunarSciSmoothing(data: number[], opts: LunarSciSmoothingOptions = {}): LunarSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciSmoothing };
diff --git a/src/lunar_sci/stability.ts b/src/lunar_sci/stability.ts
new file mode 100644
index 000000000..f2a4f5b67
--- /dev/null
+++ b/src/lunar_sci/stability.ts
@@ -0,0 +1,14 @@
+/** lunar_sci stability module — tsb analytics library. */
+export interface LunarSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface LunarSciStabilityResult { values: number[]; converged: boolean; }
+export function computeLunarSciStability(data: number[], opts: LunarSciStabilityOptions = {}): LunarSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciStability };
diff --git a/src/lunar_sci/stacking.ts b/src/lunar_sci/stacking.ts
new file mode 100644
index 000000000..4d00196bd
--- /dev/null
+++ b/src/lunar_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** lunar_sci stacking module — tsb analytics library. */
+export interface LunarSciStackingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciStackingResult { values: number[]; converged: boolean; }
+export function computeLunarSciStacking(data: number[], opts: LunarSciStackingOptions = {}): LunarSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciStacking };
diff --git a/src/lunar_sci/standardization.ts b/src/lunar_sci/standardization.ts
new file mode 100644
index 000000000..96398006b
--- /dev/null
+++ b/src/lunar_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** lunar_sci standardization module — tsb analytics library. */
+export interface LunarSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeLunarSciStandardization(data: number[], opts: LunarSciStandardizationOptions = {}): LunarSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciStandardization };
diff --git a/src/lunar_sci/static.ts b/src/lunar_sci/static.ts
new file mode 100644
index 000000000..1575e3871
--- /dev/null
+++ b/src/lunar_sci/static.ts
@@ -0,0 +1,14 @@
+/** lunar_sci static module — tsb analytics library. */
+export interface LunarSciStaticOptions { tol?: number; maxIter?: number; }
+export interface LunarSciStaticResult { values: number[]; converged: boolean; }
+export function computeLunarSciStatic(data: number[], opts: LunarSciStaticOptions = {}): LunarSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciStatic };
diff --git a/src/lunar_sci/stochastic.ts b/src/lunar_sci/stochastic.ts
new file mode 100644
index 000000000..266a7da8f
--- /dev/null
+++ b/src/lunar_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** lunar_sci stochastic module — tsb analytics library. */
+export interface LunarSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface LunarSciStochasticResult { values: number[]; converged: boolean; }
+export function computeLunarSciStochastic(data: number[], opts: LunarSciStochasticOptions = {}): LunarSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciStochastic };
diff --git a/src/lunar_sci/synthesis.ts b/src/lunar_sci/synthesis.ts
new file mode 100644
index 000000000..6981511b0
--- /dev/null
+++ b/src/lunar_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** lunar_sci synthesis module — tsb analytics library. */
+export interface LunarSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface LunarSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeLunarSciSynthesis(data: number[], opts: LunarSciSynthesisOptions = {}): LunarSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciSynthesis };
diff --git a/src/lunar_sci/topology.ts b/src/lunar_sci/topology.ts
new file mode 100644
index 000000000..7449781d9
--- /dev/null
+++ b/src/lunar_sci/topology.ts
@@ -0,0 +1,14 @@
+/** lunar_sci topology module — tsb analytics library. */
+export interface LunarSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface LunarSciTopologyResult { values: number[]; converged: boolean; }
+export function computeLunarSciTopology(data: number[], opts: LunarSciTopologyOptions = {}): LunarSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciTopology };
diff --git a/src/lunar_sci/tracking.ts b/src/lunar_sci/tracking.ts
new file mode 100644
index 000000000..6897e1845
--- /dev/null
+++ b/src/lunar_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** lunar_sci tracking module — tsb analytics library. */
+export interface LunarSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciTrackingResult { values: number[]; converged: boolean; }
+export function computeLunarSciTracking(data: number[], opts: LunarSciTrackingOptions = {}): LunarSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciTracking };
diff --git a/src/lunar_sci/transform.ts b/src/lunar_sci/transform.ts
new file mode 100644
index 000000000..1a7efa150
--- /dev/null
+++ b/src/lunar_sci/transform.ts
@@ -0,0 +1,14 @@
+/** lunar_sci transform module — tsb analytics library. */
+export interface LunarSciTransformOptions { tol?: number; maxIter?: number; }
+export interface LunarSciTransformResult { values: number[]; converged: boolean; }
+export function computeLunarSciTransform(data: number[], opts: LunarSciTransformOptions = {}): LunarSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciTransform };
diff --git a/src/lunar_sci/uncertainty.ts b/src/lunar_sci/uncertainty.ts
new file mode 100644
index 000000000..64d686f0e
--- /dev/null
+++ b/src/lunar_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** lunar_sci uncertainty module — tsb analytics library. */
+export interface LunarSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface LunarSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeLunarSciUncertainty(data: number[], opts: LunarSciUncertaintyOptions = {}): LunarSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciUncertainty };
diff --git a/src/lunar_sci/validation.ts b/src/lunar_sci/validation.ts
new file mode 100644
index 000000000..573da243b
--- /dev/null
+++ b/src/lunar_sci/validation.ts
@@ -0,0 +1,14 @@
+/** lunar_sci validation module — tsb analytics library. */
+export interface LunarSciValidationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciValidationResult { values: number[]; converged: boolean; }
+export function computeLunarSciValidation(data: number[], opts: LunarSciValidationOptions = {}): LunarSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciValidation };
diff --git a/src/lunar_sci/verification.ts b/src/lunar_sci/verification.ts
new file mode 100644
index 000000000..fcf34325d
--- /dev/null
+++ b/src/lunar_sci/verification.ts
@@ -0,0 +1,14 @@
+/** lunar_sci verification module — tsb analytics library. */
+export interface LunarSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciVerificationResult { values: number[]; converged: boolean; }
+export function computeLunarSciVerification(data: number[], opts: LunarSciVerificationOptions = {}): LunarSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciVerification };
diff --git a/src/lunar_sci/visualization.ts b/src/lunar_sci/visualization.ts
new file mode 100644
index 000000000..f03ff8f36
--- /dev/null
+++ b/src/lunar_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** lunar_sci visualization module — tsb analytics library. */
+export interface LunarSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface LunarSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeLunarSciVisualization(data: number[], opts: LunarSciVisualizationOptions = {}): LunarSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciVisualization };
diff --git a/src/lunar_sci/voting.ts b/src/lunar_sci/voting.ts
new file mode 100644
index 000000000..2c16f2832
--- /dev/null
+++ b/src/lunar_sci/voting.ts
@@ -0,0 +1,14 @@
+/** lunar_sci voting module — tsb analytics library. */
+export interface LunarSciVotingOptions { tol?: number; maxIter?: number; }
+export interface LunarSciVotingResult { values: number[]; converged: boolean; }
+export function computeLunarSciVoting(data: number[], opts: LunarSciVotingOptions = {}): LunarSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciVoting };
diff --git a/src/lunar_sci/wavelet.ts b/src/lunar_sci/wavelet.ts
new file mode 100644
index 000000000..ef83c4ff9
--- /dev/null
+++ b/src/lunar_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** lunar_sci wavelet module — tsb analytics library. */
+export interface LunarSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface LunarSciWaveletResult { values: number[]; converged: boolean; }
+export function computeLunarSciWavelet(data: number[], opts: LunarSciWaveletOptions = {}): LunarSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeLunarSciWavelet };
diff --git a/src/marine_biology/adaptation.ts b/src/marine_biology/adaptation.ts
new file mode 100644
index 000000000..b0585ae64
--- /dev/null
+++ b/src/marine_biology/adaptation.ts
@@ -0,0 +1,14 @@
+/** marine_biology adaptation module — tsb analytics library. */
+export interface MarineBiologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyAdaptation(data: number[], opts: MarineBiologyAdaptationOptions = {}): MarineBiologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyAdaptation };
diff --git a/src/marine_biology/aggregation.ts b/src/marine_biology/aggregation.ts
new file mode 100644
index 000000000..f77435c4f
--- /dev/null
+++ b/src/marine_biology/aggregation.ts
@@ -0,0 +1,14 @@
+/** marine_biology aggregation module — tsb analytics library. */
+export interface MarineBiologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyAggregationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyAggregation(data: number[], opts: MarineBiologyAggregationOptions = {}): MarineBiologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyAggregation };
diff --git a/src/marine_biology/algebra.ts b/src/marine_biology/algebra.ts
new file mode 100644
index 000000000..0a4da5e38
--- /dev/null
+++ b/src/marine_biology/algebra.ts
@@ -0,0 +1,14 @@
+/** marine_biology algebra module — tsb analytics library. */
+export interface MarineBiologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyAlgebra(data: number[], opts: MarineBiologyAlgebraOptions = {}): MarineBiologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyAlgebra };
diff --git a/src/marine_biology/alignment.ts b/src/marine_biology/alignment.ts
new file mode 100644
index 000000000..02aea5d56
--- /dev/null
+++ b/src/marine_biology/alignment.ts
@@ -0,0 +1,14 @@
+/** marine_biology alignment module — tsb analytics library. */
+export interface MarineBiologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyAlignment(data: number[], opts: MarineBiologyAlignmentOptions = {}): MarineBiologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyAlignment };
diff --git a/src/marine_biology/analysis.ts b/src/marine_biology/analysis.ts
new file mode 100644
index 000000000..6a0411f48
--- /dev/null
+++ b/src/marine_biology/analysis.ts
@@ -0,0 +1,14 @@
+/** marine_biology analysis module — tsb analytics library. */
+export interface MarineBiologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyAnalysis(data: number[], opts: MarineBiologyAnalysisOptions = {}): MarineBiologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyAnalysis };
diff --git a/src/marine_biology/augmentation.ts b/src/marine_biology/augmentation.ts
new file mode 100644
index 000000000..4403eb25e
--- /dev/null
+++ b/src/marine_biology/augmentation.ts
@@ -0,0 +1,14 @@
+/** marine_biology augmentation module — tsb analytics library. */
+export interface MarineBiologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyAugmentation(data: number[], opts: MarineBiologyAugmentationOptions = {}): MarineBiologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyAugmentation };
diff --git a/src/marine_biology/bagging.ts b/src/marine_biology/bagging.ts
new file mode 100644
index 000000000..537ea3eb7
--- /dev/null
+++ b/src/marine_biology/bagging.ts
@@ -0,0 +1,14 @@
+/** marine_biology bagging module — tsb analytics library. */
+export interface MarineBiologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyBaggingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyBagging(data: number[], opts: MarineBiologyBaggingOptions = {}): MarineBiologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyBagging };
diff --git a/src/marine_biology/basis.ts b/src/marine_biology/basis.ts
new file mode 100644
index 000000000..74e27b633
--- /dev/null
+++ b/src/marine_biology/basis.ts
@@ -0,0 +1,14 @@
+/** marine_biology basis module — tsb analytics library. */
+export interface MarineBiologyBasisOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyBasisResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyBasis(data: number[], opts: MarineBiologyBasisOptions = {}): MarineBiologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyBasis };
diff --git a/src/marine_biology/benchmarking.ts b/src/marine_biology/benchmarking.ts
new file mode 100644
index 000000000..40ad1be54
--- /dev/null
+++ b/src/marine_biology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** marine_biology benchmarking module — tsb analytics library. */
+export interface MarineBiologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyBenchmarking(data: number[], opts: MarineBiologyBenchmarkingOptions = {}): MarineBiologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyBenchmarking };
diff --git a/src/marine_biology/blending.ts b/src/marine_biology/blending.ts
new file mode 100644
index 000000000..be58f3ac4
--- /dev/null
+++ b/src/marine_biology/blending.ts
@@ -0,0 +1,14 @@
+/** marine_biology blending module — tsb analytics library. */
+export interface MarineBiologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyBlendingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyBlending(data: number[], opts: MarineBiologyBlendingOptions = {}): MarineBiologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyBlending };
diff --git a/src/marine_biology/boosting.ts b/src/marine_biology/boosting.ts
new file mode 100644
index 000000000..965599303
--- /dev/null
+++ b/src/marine_biology/boosting.ts
@@ -0,0 +1,14 @@
+/** marine_biology boosting module — tsb analytics library. */
+export interface MarineBiologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyBoostingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyBoosting(data: number[], opts: MarineBiologyBoostingOptions = {}): MarineBiologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyBoosting };
diff --git a/src/marine_biology/bootstrap.ts b/src/marine_biology/bootstrap.ts
new file mode 100644
index 000000000..afe967008
--- /dev/null
+++ b/src/marine_biology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** marine_biology bootstrap module — tsb analytics library. */
+export interface MarineBiologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyBootstrap(data: number[], opts: MarineBiologyBootstrapOptions = {}): MarineBiologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyBootstrap };
diff --git a/src/marine_biology/calculus.ts b/src/marine_biology/calculus.ts
new file mode 100644
index 000000000..8624ba0a6
--- /dev/null
+++ b/src/marine_biology/calculus.ts
@@ -0,0 +1,14 @@
+/** marine_biology calculus module — tsb analytics library. */
+export interface MarineBiologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyCalculusResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyCalculus(data: number[], opts: MarineBiologyCalculusOptions = {}): MarineBiologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyCalculus };
diff --git a/src/marine_biology/calibration.ts b/src/marine_biology/calibration.ts
new file mode 100644
index 000000000..9f67b7b8c
--- /dev/null
+++ b/src/marine_biology/calibration.ts
@@ -0,0 +1,14 @@
+/** marine_biology calibration module — tsb analytics library. */
+export interface MarineBiologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyCalibration(data: number[], opts: MarineBiologyCalibrationOptions = {}): MarineBiologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyCalibration };
diff --git a/src/marine_biology/characterization.ts b/src/marine_biology/characterization.ts
new file mode 100644
index 000000000..82358cbd5
--- /dev/null
+++ b/src/marine_biology/characterization.ts
@@ -0,0 +1,14 @@
+/** marine_biology characterization module — tsb analytics library. */
+export interface MarineBiologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyCharacterization(data: number[], opts: MarineBiologyCharacterizationOptions = {}): MarineBiologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyCharacterization };
diff --git a/src/marine_biology/classification.ts b/src/marine_biology/classification.ts
new file mode 100644
index 000000000..58c333eed
--- /dev/null
+++ b/src/marine_biology/classification.ts
@@ -0,0 +1,14 @@
+/** marine_biology classification module — tsb analytics library. */
+export interface MarineBiologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyClassificationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyClassification(data: number[], opts: MarineBiologyClassificationOptions = {}): MarineBiologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyClassification };
diff --git a/src/marine_biology/clustering.ts b/src/marine_biology/clustering.ts
new file mode 100644
index 000000000..bbe71f5c2
--- /dev/null
+++ b/src/marine_biology/clustering.ts
@@ -0,0 +1,14 @@
+/** marine_biology clustering module — tsb analytics library. */
+export interface MarineBiologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyClusteringResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyClustering(data: number[], opts: MarineBiologyClusteringOptions = {}): MarineBiologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyClustering };
diff --git a/src/marine_biology/compression.ts b/src/marine_biology/compression.ts
new file mode 100644
index 000000000..be12cac9c
--- /dev/null
+++ b/src/marine_biology/compression.ts
@@ -0,0 +1,14 @@
+/** marine_biology compression module — tsb analytics library. */
+export interface MarineBiologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyCompressionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyCompression(data: number[], opts: MarineBiologyCompressionOptions = {}): MarineBiologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyCompression };
diff --git a/src/marine_biology/continuous.ts b/src/marine_biology/continuous.ts
new file mode 100644
index 000000000..90ff9232c
--- /dev/null
+++ b/src/marine_biology/continuous.ts
@@ -0,0 +1,14 @@
+/** marine_biology continuous module — tsb analytics library. */
+export interface MarineBiologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyContinuousResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyContinuous(data: number[], opts: MarineBiologyContinuousOptions = {}): MarineBiologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyContinuous };
diff --git a/src/marine_biology/control.ts b/src/marine_biology/control.ts
new file mode 100644
index 000000000..04dabffb8
--- /dev/null
+++ b/src/marine_biology/control.ts
@@ -0,0 +1,14 @@
+/** marine_biology control module — tsb analytics library. */
+export interface MarineBiologyControlOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyControlResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyControl(data: number[], opts: MarineBiologyControlOptions = {}): MarineBiologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyControl };
diff --git a/src/marine_biology/convergence.ts b/src/marine_biology/convergence.ts
new file mode 100644
index 000000000..ce789f875
--- /dev/null
+++ b/src/marine_biology/convergence.ts
@@ -0,0 +1,14 @@
+/** marine_biology convergence module — tsb analytics library. */
+export interface MarineBiologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyConvergence(data: number[], opts: MarineBiologyConvergenceOptions = {}): MarineBiologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyConvergence };
diff --git a/src/marine_biology/convex.ts b/src/marine_biology/convex.ts
new file mode 100644
index 000000000..1f8bd9639
--- /dev/null
+++ b/src/marine_biology/convex.ts
@@ -0,0 +1,14 @@
+/** marine_biology convex module — tsb analytics library. */
+export interface MarineBiologyConvexOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyConvexResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyConvex(data: number[], opts: MarineBiologyConvexOptions = {}): MarineBiologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyConvex };
diff --git a/src/marine_biology/correlation.ts b/src/marine_biology/correlation.ts
new file mode 100644
index 000000000..e74e4de0a
--- /dev/null
+++ b/src/marine_biology/correlation.ts
@@ -0,0 +1,14 @@
+/** marine_biology correlation module — tsb analytics library. */
+export interface MarineBiologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyCorrelation(data: number[], opts: MarineBiologyCorrelationOptions = {}): MarineBiologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyCorrelation };
diff --git a/src/marine_biology/covariance.ts b/src/marine_biology/covariance.ts
new file mode 100644
index 000000000..10145f079
--- /dev/null
+++ b/src/marine_biology/covariance.ts
@@ -0,0 +1,14 @@
+/** marine_biology covariance module — tsb analytics library. */
+export interface MarineBiologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyCovariance(data: number[], opts: MarineBiologyCovarianceOptions = {}): MarineBiologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyCovariance };
diff --git a/src/marine_biology/cross_validation.ts b/src/marine_biology/cross_validation.ts
new file mode 100644
index 000000000..7b752d3dc
--- /dev/null
+++ b/src/marine_biology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** marine_biology cross_validation module — tsb analytics library. */
+export interface MarineBiologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyCrossValidation(data: number[], opts: MarineBiologyCrossValidationOptions = {}): MarineBiologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyCrossValidation };
diff --git a/src/marine_biology/decoding.ts b/src/marine_biology/decoding.ts
new file mode 100644
index 000000000..c17c1a3a6
--- /dev/null
+++ b/src/marine_biology/decoding.ts
@@ -0,0 +1,14 @@
+/** marine_biology decoding module — tsb analytics library. */
+export interface MarineBiologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDecodingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDecoding(data: number[], opts: MarineBiologyDecodingOptions = {}): MarineBiologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDecoding };
diff --git a/src/marine_biology/decomposition.ts b/src/marine_biology/decomposition.ts
new file mode 100644
index 000000000..8e53280ff
--- /dev/null
+++ b/src/marine_biology/decomposition.ts
@@ -0,0 +1,14 @@
+/** marine_biology decomposition module — tsb analytics library. */
+export interface MarineBiologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDecomposition(data: number[], opts: MarineBiologyDecompositionOptions = {}): MarineBiologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDecomposition };
diff --git a/src/marine_biology/detection.ts b/src/marine_biology/detection.ts
new file mode 100644
index 000000000..743bf0be5
--- /dev/null
+++ b/src/marine_biology/detection.ts
@@ -0,0 +1,14 @@
+/** marine_biology detection module — tsb analytics library. */
+export interface MarineBiologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDetectionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDetection(data: number[], opts: MarineBiologyDetectionOptions = {}): MarineBiologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDetection };
diff --git a/src/marine_biology/deterministic.ts b/src/marine_biology/deterministic.ts
new file mode 100644
index 000000000..4a2f644ed
--- /dev/null
+++ b/src/marine_biology/deterministic.ts
@@ -0,0 +1,14 @@
+/** marine_biology deterministic module — tsb analytics library. */
+export interface MarineBiologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDeterministic(data: number[], opts: MarineBiologyDeterministicOptions = {}): MarineBiologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDeterministic };
diff --git a/src/marine_biology/diagnostics.ts b/src/marine_biology/diagnostics.ts
new file mode 100644
index 000000000..402475cfa
--- /dev/null
+++ b/src/marine_biology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** marine_biology diagnostics module — tsb analytics library. */
+export interface MarineBiologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDiagnostics(data: number[], opts: MarineBiologyDiagnosticsOptions = {}): MarineBiologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDiagnostics };
diff --git a/src/marine_biology/differential.ts b/src/marine_biology/differential.ts
new file mode 100644
index 000000000..81cdec759
--- /dev/null
+++ b/src/marine_biology/differential.ts
@@ -0,0 +1,14 @@
+/** marine_biology differential module — tsb analytics library. */
+export interface MarineBiologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDifferential(data: number[], opts: MarineBiologyDifferentialOptions = {}): MarineBiologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDifferential };
diff --git a/src/marine_biology/discrete.ts b/src/marine_biology/discrete.ts
new file mode 100644
index 000000000..0a13c7638
--- /dev/null
+++ b/src/marine_biology/discrete.ts
@@ -0,0 +1,14 @@
+/** marine_biology discrete module — tsb analytics library. */
+export interface MarineBiologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDiscrete(data: number[], opts: MarineBiologyDiscreteOptions = {}): MarineBiologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDiscrete };
diff --git a/src/marine_biology/distribution.ts b/src/marine_biology/distribution.ts
new file mode 100644
index 000000000..f9aee7c54
--- /dev/null
+++ b/src/marine_biology/distribution.ts
@@ -0,0 +1,14 @@
+/** marine_biology distribution module — tsb analytics library. */
+export interface MarineBiologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDistributionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDistribution(data: number[], opts: MarineBiologyDistributionOptions = {}): MarineBiologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDistribution };
diff --git a/src/marine_biology/dynamic.ts b/src/marine_biology/dynamic.ts
new file mode 100644
index 000000000..43033da83
--- /dev/null
+++ b/src/marine_biology/dynamic.ts
@@ -0,0 +1,14 @@
+/** marine_biology dynamic module — tsb analytics library. */
+export interface MarineBiologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyDynamicResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyDynamic(data: number[], opts: MarineBiologyDynamicOptions = {}): MarineBiologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyDynamic };
diff --git a/src/marine_biology/embedding.ts b/src/marine_biology/embedding.ts
new file mode 100644
index 000000000..bfed615d4
--- /dev/null
+++ b/src/marine_biology/embedding.ts
@@ -0,0 +1,14 @@
+/** marine_biology embedding module — tsb analytics library. */
+export interface MarineBiologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyEmbedding(data: number[], opts: MarineBiologyEmbeddingOptions = {}): MarineBiologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyEmbedding };
diff --git a/src/marine_biology/encoding.ts b/src/marine_biology/encoding.ts
new file mode 100644
index 000000000..dc92827d0
--- /dev/null
+++ b/src/marine_biology/encoding.ts
@@ -0,0 +1,14 @@
+/** marine_biology encoding module — tsb analytics library. */
+export interface MarineBiologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyEncodingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyEncoding(data: number[], opts: MarineBiologyEncodingOptions = {}): MarineBiologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyEncoding };
diff --git a/src/marine_biology/ensemble.ts b/src/marine_biology/ensemble.ts
new file mode 100644
index 000000000..d540746d6
--- /dev/null
+++ b/src/marine_biology/ensemble.ts
@@ -0,0 +1,14 @@
+/** marine_biology ensemble module — tsb analytics library. */
+export interface MarineBiologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyEnsemble(data: number[], opts: MarineBiologyEnsembleOptions = {}): MarineBiologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyEnsemble };
diff --git a/src/marine_biology/estimation.ts b/src/marine_biology/estimation.ts
new file mode 100644
index 000000000..bbb581adc
--- /dev/null
+++ b/src/marine_biology/estimation.ts
@@ -0,0 +1,14 @@
+/** marine_biology estimation module — tsb analytics library. */
+export interface MarineBiologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyEstimationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyEstimation(data: number[], opts: MarineBiologyEstimationOptions = {}): MarineBiologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyEstimation };
diff --git a/src/marine_biology/evaluation.ts b/src/marine_biology/evaluation.ts
new file mode 100644
index 000000000..66af6d8b1
--- /dev/null
+++ b/src/marine_biology/evaluation.ts
@@ -0,0 +1,14 @@
+/** marine_biology evaluation module — tsb analytics library. */
+export interface MarineBiologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyEvaluation(data: number[], opts: MarineBiologyEvaluationOptions = {}): MarineBiologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyEvaluation };
diff --git a/src/marine_biology/extrapolation.ts b/src/marine_biology/extrapolation.ts
new file mode 100644
index 000000000..c986134af
--- /dev/null
+++ b/src/marine_biology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** marine_biology extrapolation module — tsb analytics library. */
+export interface MarineBiologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyExtrapolation(data: number[], opts: MarineBiologyExtrapolationOptions = {}): MarineBiologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyExtrapolation };
diff --git a/src/marine_biology/features.ts b/src/marine_biology/features.ts
new file mode 100644
index 000000000..e936d29f2
--- /dev/null
+++ b/src/marine_biology/features.ts
@@ -0,0 +1,14 @@
+/** marine_biology features module — tsb analytics library. */
+export interface MarineBiologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyFeatures(data: number[], opts: MarineBiologyFeaturesOptions = {}): MarineBiologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyFeatures };
diff --git a/src/marine_biology/feedback.ts b/src/marine_biology/feedback.ts
new file mode 100644
index 000000000..2e0e9936f
--- /dev/null
+++ b/src/marine_biology/feedback.ts
@@ -0,0 +1,14 @@
+/** marine_biology feedback module — tsb analytics library. */
+export interface MarineBiologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyFeedback(data: number[], opts: MarineBiologyFeedbackOptions = {}): MarineBiologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyFeedback };
diff --git a/src/marine_biology/filtering.ts b/src/marine_biology/filtering.ts
new file mode 100644
index 000000000..b34194790
--- /dev/null
+++ b/src/marine_biology/filtering.ts
@@ -0,0 +1,14 @@
+/** marine_biology filtering module — tsb analytics library. */
+export interface MarineBiologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyFilteringResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyFiltering(data: number[], opts: MarineBiologyFilteringOptions = {}): MarineBiologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyFiltering };
diff --git a/src/marine_biology/fourier.ts b/src/marine_biology/fourier.ts
new file mode 100644
index 000000000..2d1a8af9a
--- /dev/null
+++ b/src/marine_biology/fourier.ts
@@ -0,0 +1,14 @@
+/** marine_biology fourier module — tsb analytics library. */
+export interface MarineBiologyFourierOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyFourierResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyFourier(data: number[], opts: MarineBiologyFourierOptions = {}): MarineBiologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyFourier };
diff --git a/src/marine_biology/fusion.ts b/src/marine_biology/fusion.ts
new file mode 100644
index 000000000..fb4ebc333
--- /dev/null
+++ b/src/marine_biology/fusion.ts
@@ -0,0 +1,14 @@
+/** marine_biology fusion module — tsb analytics library. */
+export interface MarineBiologyFusionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyFusionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyFusion(data: number[], opts: MarineBiologyFusionOptions = {}): MarineBiologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyFusion };
diff --git a/src/marine_biology/generation.ts b/src/marine_biology/generation.ts
new file mode 100644
index 000000000..2ba53fb03
--- /dev/null
+++ b/src/marine_biology/generation.ts
@@ -0,0 +1,14 @@
+/** marine_biology generation module — tsb analytics library. */
+export interface MarineBiologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyGenerationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyGeneration(data: number[], opts: MarineBiologyGenerationOptions = {}): MarineBiologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyGeneration };
diff --git a/src/marine_biology/geometry.ts b/src/marine_biology/geometry.ts
new file mode 100644
index 000000000..c45f539e2
--- /dev/null
+++ b/src/marine_biology/geometry.ts
@@ -0,0 +1,14 @@
+/** marine_biology geometry module — tsb analytics library. */
+export interface MarineBiologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyGeometryResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyGeometry(data: number[], opts: MarineBiologyGeometryOptions = {}): MarineBiologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyGeometry };
diff --git a/src/marine_biology/gradient.ts b/src/marine_biology/gradient.ts
new file mode 100644
index 000000000..f4e264c1d
--- /dev/null
+++ b/src/marine_biology/gradient.ts
@@ -0,0 +1,14 @@
+/** marine_biology gradient module — tsb analytics library. */
+export interface MarineBiologyGradientOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyGradientResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyGradient(data: number[], opts: MarineBiologyGradientOptions = {}): MarineBiologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyGradient };
diff --git a/src/marine_biology/hessian.ts b/src/marine_biology/hessian.ts
new file mode 100644
index 000000000..f8dfabbcf
--- /dev/null
+++ b/src/marine_biology/hessian.ts
@@ -0,0 +1,14 @@
+/** marine_biology hessian module — tsb analytics library. */
+export interface MarineBiologyHessianOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyHessianResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyHessian(data: number[], opts: MarineBiologyHessianOptions = {}): MarineBiologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyHessian };
diff --git a/src/marine_biology/hypothesis.ts b/src/marine_biology/hypothesis.ts
new file mode 100644
index 000000000..802deec17
--- /dev/null
+++ b/src/marine_biology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** marine_biology hypothesis module — tsb analytics library. */
+export interface MarineBiologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyHypothesis(data: number[], opts: MarineBiologyHypothesisOptions = {}): MarineBiologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyHypothesis };
diff --git a/src/marine_biology/inference.ts b/src/marine_biology/inference.ts
new file mode 100644
index 000000000..d61d4871a
--- /dev/null
+++ b/src/marine_biology/inference.ts
@@ -0,0 +1,14 @@
+/** marine_biology inference module — tsb analytics library. */
+export interface MarineBiologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyInferenceResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyInference(data: number[], opts: MarineBiologyInferenceOptions = {}): MarineBiologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyInference };
diff --git a/src/marine_biology/inference2.ts b/src/marine_biology/inference2.ts
new file mode 100644
index 000000000..742d0537b
--- /dev/null
+++ b/src/marine_biology/inference2.ts
@@ -0,0 +1,14 @@
+/** marine_biology inference2 module — tsb analytics library. */
+export interface MarineBiologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyInferenceResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyInference(data: number[], opts: MarineBiologyInferenceOptions = {}): MarineBiologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyInference };
diff --git a/src/marine_biology/integral.ts b/src/marine_biology/integral.ts
new file mode 100644
index 000000000..23bb0b999
--- /dev/null
+++ b/src/marine_biology/integral.ts
@@ -0,0 +1,14 @@
+/** marine_biology integral module — tsb analytics library. */
+export interface MarineBiologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyIntegralResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyIntegral(data: number[], opts: MarineBiologyIntegralOptions = {}): MarineBiologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyIntegral };
diff --git a/src/marine_biology/integration.ts b/src/marine_biology/integration.ts
new file mode 100644
index 000000000..c4a9a20bd
--- /dev/null
+++ b/src/marine_biology/integration.ts
@@ -0,0 +1,14 @@
+/** marine_biology integration module — tsb analytics library. */
+export interface MarineBiologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyIntegration(data: number[], opts: MarineBiologyIntegrationOptions = {}): MarineBiologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyIntegration };
diff --git a/src/marine_biology/interpolation.ts b/src/marine_biology/interpolation.ts
new file mode 100644
index 000000000..a88f94c6b
--- /dev/null
+++ b/src/marine_biology/interpolation.ts
@@ -0,0 +1,14 @@
+/** marine_biology interpolation module — tsb analytics library. */
+export interface MarineBiologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyInterpolation(data: number[], opts: MarineBiologyInterpolationOptions = {}): MarineBiologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyInterpolation };
diff --git a/src/marine_biology/jacobian.ts b/src/marine_biology/jacobian.ts
new file mode 100644
index 000000000..2b03b18f8
--- /dev/null
+++ b/src/marine_biology/jacobian.ts
@@ -0,0 +1,14 @@
+/** marine_biology jacobian module — tsb analytics library. */
+export interface MarineBiologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyJacobianResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyJacobian(data: number[], opts: MarineBiologyJacobianOptions = {}): MarineBiologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyJacobian };
diff --git a/src/marine_biology/kernel.ts b/src/marine_biology/kernel.ts
new file mode 100644
index 000000000..7d5001471
--- /dev/null
+++ b/src/marine_biology/kernel.ts
@@ -0,0 +1,14 @@
+/** marine_biology kernel module — tsb analytics library. */
+export interface MarineBiologyKernelOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyKernelResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyKernel(data: number[], opts: MarineBiologyKernelOptions = {}): MarineBiologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyKernel };
diff --git a/src/marine_biology/laplacian.ts b/src/marine_biology/laplacian.ts
new file mode 100644
index 000000000..012a087c3
--- /dev/null
+++ b/src/marine_biology/laplacian.ts
@@ -0,0 +1,14 @@
+/** marine_biology laplacian module — tsb analytics library. */
+export interface MarineBiologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyLaplacian(data: number[], opts: MarineBiologyLaplacianOptions = {}): MarineBiologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyLaplacian };
diff --git a/src/marine_biology/learning.ts b/src/marine_biology/learning.ts
new file mode 100644
index 000000000..37689c8a1
--- /dev/null
+++ b/src/marine_biology/learning.ts
@@ -0,0 +1,14 @@
+/** marine_biology learning module — tsb analytics library. */
+export interface MarineBiologyLearningOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyLearningResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyLearning(data: number[], opts: MarineBiologyLearningOptions = {}): MarineBiologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyLearning };
diff --git a/src/marine_biology/linear.ts b/src/marine_biology/linear.ts
new file mode 100644
index 000000000..ed37f9925
--- /dev/null
+++ b/src/marine_biology/linear.ts
@@ -0,0 +1,14 @@
+/** marine_biology linear module — tsb analytics library. */
+export interface MarineBiologyLinearOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyLinearResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyLinear(data: number[], opts: MarineBiologyLinearOptions = {}): MarineBiologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyLinear };
diff --git a/src/marine_biology/manifold.ts b/src/marine_biology/manifold.ts
new file mode 100644
index 000000000..1d55637df
--- /dev/null
+++ b/src/marine_biology/manifold.ts
@@ -0,0 +1,14 @@
+/** marine_biology manifold module — tsb analytics library. */
+export interface MarineBiologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyManifoldResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyManifold(data: number[], opts: MarineBiologyManifoldOptions = {}): MarineBiologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyManifold };
diff --git a/src/marine_biology/matching.ts b/src/marine_biology/matching.ts
new file mode 100644
index 000000000..a8af8cd59
--- /dev/null
+++ b/src/marine_biology/matching.ts
@@ -0,0 +1,14 @@
+/** marine_biology matching module — tsb analytics library. */
+export interface MarineBiologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyMatchingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyMatching(data: number[], opts: MarineBiologyMatchingOptions = {}): MarineBiologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyMatching };
diff --git a/src/marine_biology/measurement.ts b/src/marine_biology/measurement.ts
new file mode 100644
index 000000000..7eebed8ac
--- /dev/null
+++ b/src/marine_biology/measurement.ts
@@ -0,0 +1,14 @@
+/** marine_biology measurement module — tsb analytics library. */
+export interface MarineBiologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyMeasurement(data: number[], opts: MarineBiologyMeasurementOptions = {}): MarineBiologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyMeasurement };
diff --git a/src/marine_biology/metrics.ts b/src/marine_biology/metrics.ts
new file mode 100644
index 000000000..b8a24f1c8
--- /dev/null
+++ b/src/marine_biology/metrics.ts
@@ -0,0 +1,14 @@
+/** marine_biology metrics module — tsb analytics library. */
+export interface MarineBiologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyMetricsResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyMetrics(data: number[], opts: MarineBiologyMetricsOptions = {}): MarineBiologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyMetrics };
diff --git a/src/marine_biology/modeling.ts b/src/marine_biology/modeling.ts
new file mode 100644
index 000000000..a97fd3d03
--- /dev/null
+++ b/src/marine_biology/modeling.ts
@@ -0,0 +1,14 @@
+/** marine_biology modeling module — tsb analytics library. */
+export interface MarineBiologyModelingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyModelingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyModeling(data: number[], opts: MarineBiologyModelingOptions = {}): MarineBiologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyModeling };
diff --git a/src/marine_biology/monitoring.ts b/src/marine_biology/monitoring.ts
new file mode 100644
index 000000000..844ad21f2
--- /dev/null
+++ b/src/marine_biology/monitoring.ts
@@ -0,0 +1,14 @@
+/** marine_biology monitoring module — tsb analytics library. */
+export interface MarineBiologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyMonitoring(data: number[], opts: MarineBiologyMonitoringOptions = {}): MarineBiologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyMonitoring };
diff --git a/src/marine_biology/nonlinear.ts b/src/marine_biology/nonlinear.ts
new file mode 100644
index 000000000..bb88b7b77
--- /dev/null
+++ b/src/marine_biology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** marine_biology nonlinear module — tsb analytics library. */
+export interface MarineBiologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyNonlinear(data: number[], opts: MarineBiologyNonlinearOptions = {}): MarineBiologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyNonlinear };
diff --git a/src/marine_biology/normalization.ts b/src/marine_biology/normalization.ts
new file mode 100644
index 000000000..c986ff02b
--- /dev/null
+++ b/src/marine_biology/normalization.ts
@@ -0,0 +1,14 @@
+/** marine_biology normalization module — tsb analytics library. */
+export interface MarineBiologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyNormalization(data: number[], opts: MarineBiologyNormalizationOptions = {}): MarineBiologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyNormalization };
diff --git a/src/marine_biology/optimization.ts b/src/marine_biology/optimization.ts
new file mode 100644
index 000000000..6b7f3863a
--- /dev/null
+++ b/src/marine_biology/optimization.ts
@@ -0,0 +1,14 @@
+/** marine_biology optimization module — tsb analytics library. */
+export interface MarineBiologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyOptimization(data: number[], opts: MarineBiologyOptimizationOptions = {}): MarineBiologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyOptimization };
diff --git a/src/marine_biology/patterns.ts b/src/marine_biology/patterns.ts
new file mode 100644
index 000000000..c796e3ddb
--- /dev/null
+++ b/src/marine_biology/patterns.ts
@@ -0,0 +1,14 @@
+/** marine_biology patterns module — tsb analytics library. */
+export interface MarineBiologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyPatternsResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyPatterns(data: number[], opts: MarineBiologyPatternsOptions = {}): MarineBiologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyPatterns };
diff --git a/src/marine_biology/permutation.ts b/src/marine_biology/permutation.ts
new file mode 100644
index 000000000..5f0114f12
--- /dev/null
+++ b/src/marine_biology/permutation.ts
@@ -0,0 +1,14 @@
+/** marine_biology permutation module — tsb analytics library. */
+export interface MarineBiologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyPermutationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyPermutation(data: number[], opts: MarineBiologyPermutationOptions = {}): MarineBiologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyPermutation };
diff --git a/src/marine_biology/prediction.ts b/src/marine_biology/prediction.ts
new file mode 100644
index 000000000..a2d8eb5c8
--- /dev/null
+++ b/src/marine_biology/prediction.ts
@@ -0,0 +1,14 @@
+/** marine_biology prediction module — tsb analytics library. */
+export interface MarineBiologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyPredictionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyPrediction(data: number[], opts: MarineBiologyPredictionOptions = {}): MarineBiologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyPrediction };
diff --git a/src/marine_biology/processing.ts b/src/marine_biology/processing.ts
new file mode 100644
index 000000000..b0f68de18
--- /dev/null
+++ b/src/marine_biology/processing.ts
@@ -0,0 +1,14 @@
+/** marine_biology processing module — tsb analytics library. */
+export interface MarineBiologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyProcessingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyProcessing(data: number[], opts: MarineBiologyProcessingOptions = {}): MarineBiologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyProcessing };
diff --git a/src/marine_biology/profiling.ts b/src/marine_biology/profiling.ts
new file mode 100644
index 000000000..b046fb51e
--- /dev/null
+++ b/src/marine_biology/profiling.ts
@@ -0,0 +1,14 @@
+/** marine_biology profiling module — tsb analytics library. */
+export interface MarineBiologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyProfilingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyProfiling(data: number[], opts: MarineBiologyProfilingOptions = {}): MarineBiologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyProfiling };
diff --git a/src/marine_biology/projection.ts b/src/marine_biology/projection.ts
new file mode 100644
index 000000000..1f692415e
--- /dev/null
+++ b/src/marine_biology/projection.ts
@@ -0,0 +1,14 @@
+/** marine_biology projection module — tsb analytics library. */
+export interface MarineBiologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyProjectionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyProjection(data: number[], opts: MarineBiologyProjectionOptions = {}): MarineBiologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyProjection };
diff --git a/src/marine_biology/ranking.ts b/src/marine_biology/ranking.ts
new file mode 100644
index 000000000..a684a264e
--- /dev/null
+++ b/src/marine_biology/ranking.ts
@@ -0,0 +1,14 @@
+/** marine_biology ranking module — tsb analytics library. */
+export interface MarineBiologyRankingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyRankingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyRanking(data: number[], opts: MarineBiologyRankingOptions = {}): MarineBiologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyRanking };
diff --git a/src/marine_biology/reconstruction.ts b/src/marine_biology/reconstruction.ts
new file mode 100644
index 000000000..1a6218f3a
--- /dev/null
+++ b/src/marine_biology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** marine_biology reconstruction module — tsb analytics library. */
+export interface MarineBiologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyReconstruction(data: number[], opts: MarineBiologyReconstructionOptions = {}): MarineBiologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyReconstruction };
diff --git a/src/marine_biology/registration.ts b/src/marine_biology/registration.ts
new file mode 100644
index 000000000..ad30bab3b
--- /dev/null
+++ b/src/marine_biology/registration.ts
@@ -0,0 +1,14 @@
+/** marine_biology registration module — tsb analytics library. */
+export interface MarineBiologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyRegistration(data: number[], opts: MarineBiologyRegistrationOptions = {}): MarineBiologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyRegistration };
diff --git a/src/marine_biology/regression.ts b/src/marine_biology/regression.ts
new file mode 100644
index 000000000..6c3a2ebb8
--- /dev/null
+++ b/src/marine_biology/regression.ts
@@ -0,0 +1,14 @@
+/** marine_biology regression module — tsb analytics library. */
+export interface MarineBiologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyRegressionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyRegression(data: number[], opts: MarineBiologyRegressionOptions = {}): MarineBiologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyRegression };
diff --git a/src/marine_biology/regularization.ts b/src/marine_biology/regularization.ts
new file mode 100644
index 000000000..52b681286
--- /dev/null
+++ b/src/marine_biology/regularization.ts
@@ -0,0 +1,14 @@
+/** marine_biology regularization module — tsb analytics library. */
+export interface MarineBiologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyRegularization(data: number[], opts: MarineBiologyRegularizationOptions = {}): MarineBiologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyRegularization };
diff --git a/src/marine_biology/robustness.ts b/src/marine_biology/robustness.ts
new file mode 100644
index 000000000..b0110cb8e
--- /dev/null
+++ b/src/marine_biology/robustness.ts
@@ -0,0 +1,14 @@
+/** marine_biology robustness module — tsb analytics library. */
+export interface MarineBiologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyRobustness(data: number[], opts: MarineBiologyRobustnessOptions = {}): MarineBiologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyRobustness };
diff --git a/src/marine_biology/sampling.ts b/src/marine_biology/sampling.ts
new file mode 100644
index 000000000..e778eb4dd
--- /dev/null
+++ b/src/marine_biology/sampling.ts
@@ -0,0 +1,14 @@
+/** marine_biology sampling module — tsb analytics library. */
+export interface MarineBiologySamplingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologySamplingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologySampling(data: number[], opts: MarineBiologySamplingOptions = {}): MarineBiologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologySampling };
diff --git a/src/marine_biology/sampling2.ts b/src/marine_biology/sampling2.ts
new file mode 100644
index 000000000..84e302798
--- /dev/null
+++ b/src/marine_biology/sampling2.ts
@@ -0,0 +1,14 @@
+/** marine_biology sampling2 module — tsb analytics library. */
+export interface MarineBiologySamplingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologySamplingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologySampling(data: number[], opts: MarineBiologySamplingOptions = {}): MarineBiologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologySampling };
diff --git a/src/marine_biology/scaling.ts b/src/marine_biology/scaling.ts
new file mode 100644
index 000000000..69137747e
--- /dev/null
+++ b/src/marine_biology/scaling.ts
@@ -0,0 +1,14 @@
+/** marine_biology scaling module — tsb analytics library. */
+export interface MarineBiologyScalingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyScalingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyScaling(data: number[], opts: MarineBiologyScalingOptions = {}): MarineBiologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyScaling };
diff --git a/src/marine_biology/scoring.ts b/src/marine_biology/scoring.ts
new file mode 100644
index 000000000..9885dfe86
--- /dev/null
+++ b/src/marine_biology/scoring.ts
@@ -0,0 +1,14 @@
+/** marine_biology scoring module — tsb analytics library. */
+export interface MarineBiologyScoringOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyScoringResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyScoring(data: number[], opts: MarineBiologyScoringOptions = {}): MarineBiologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyScoring };
diff --git a/src/marine_biology/segmentation.ts b/src/marine_biology/segmentation.ts
new file mode 100644
index 000000000..27de1738b
--- /dev/null
+++ b/src/marine_biology/segmentation.ts
@@ -0,0 +1,14 @@
+/** marine_biology segmentation module — tsb analytics library. */
+export interface MarineBiologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologySegmentationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologySegmentation(data: number[], opts: MarineBiologySegmentationOptions = {}): MarineBiologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologySegmentation };
diff --git a/src/marine_biology/selection.ts b/src/marine_biology/selection.ts
new file mode 100644
index 000000000..517735075
--- /dev/null
+++ b/src/marine_biology/selection.ts
@@ -0,0 +1,14 @@
+/** marine_biology selection module — tsb analytics library. */
+export interface MarineBiologySelectionOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologySelectionResult { values: number[]; converged: boolean; }
+export function computeMarineBiologySelection(data: number[], opts: MarineBiologySelectionOptions = {}): MarineBiologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologySelection };
diff --git a/src/marine_biology/sensitivity.ts b/src/marine_biology/sensitivity.ts
new file mode 100644
index 000000000..4cc87b93b
--- /dev/null
+++ b/src/marine_biology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** marine_biology sensitivity module — tsb analytics library. */
+export interface MarineBiologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologySensitivityResult { values: number[]; converged: boolean; }
+export function computeMarineBiologySensitivity(data: number[], opts: MarineBiologySensitivityOptions = {}): MarineBiologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologySensitivity };
diff --git a/src/marine_biology/simulation.ts b/src/marine_biology/simulation.ts
new file mode 100644
index 000000000..447f7ced5
--- /dev/null
+++ b/src/marine_biology/simulation.ts
@@ -0,0 +1,14 @@
+/** marine_biology simulation module — tsb analytics library. */
+export interface MarineBiologySimulationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologySimulationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologySimulation(data: number[], opts: MarineBiologySimulationOptions = {}): MarineBiologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologySimulation };
diff --git a/src/marine_biology/smoothing.ts b/src/marine_biology/smoothing.ts
new file mode 100644
index 000000000..487252792
--- /dev/null
+++ b/src/marine_biology/smoothing.ts
@@ -0,0 +1,14 @@
+/** marine_biology smoothing module — tsb analytics library. */
+export interface MarineBiologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologySmoothingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologySmoothing(data: number[], opts: MarineBiologySmoothingOptions = {}): MarineBiologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologySmoothing };
diff --git a/src/marine_biology/stability.ts b/src/marine_biology/stability.ts
new file mode 100644
index 000000000..cd6283913
--- /dev/null
+++ b/src/marine_biology/stability.ts
@@ -0,0 +1,14 @@
+/** marine_biology stability module — tsb analytics library. */
+export interface MarineBiologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyStabilityResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyStability(data: number[], opts: MarineBiologyStabilityOptions = {}): MarineBiologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyStability };
diff --git a/src/marine_biology/stacking.ts b/src/marine_biology/stacking.ts
new file mode 100644
index 000000000..62d021ac2
--- /dev/null
+++ b/src/marine_biology/stacking.ts
@@ -0,0 +1,14 @@
+/** marine_biology stacking module — tsb analytics library. */
+export interface MarineBiologyStackingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyStackingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyStacking(data: number[], opts: MarineBiologyStackingOptions = {}): MarineBiologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyStacking };
diff --git a/src/marine_biology/standardization.ts b/src/marine_biology/standardization.ts
new file mode 100644
index 000000000..ea5d6e15c
--- /dev/null
+++ b/src/marine_biology/standardization.ts
@@ -0,0 +1,14 @@
+/** marine_biology standardization module — tsb analytics library. */
+export interface MarineBiologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyStandardization(data: number[], opts: MarineBiologyStandardizationOptions = {}): MarineBiologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyStandardization };
diff --git a/src/marine_biology/static.ts b/src/marine_biology/static.ts
new file mode 100644
index 000000000..1f0585c2b
--- /dev/null
+++ b/src/marine_biology/static.ts
@@ -0,0 +1,14 @@
+/** marine_biology static module — tsb analytics library. */
+export interface MarineBiologyStaticOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyStaticResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyStatic(data: number[], opts: MarineBiologyStaticOptions = {}): MarineBiologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyStatic };
diff --git a/src/marine_biology/stochastic.ts b/src/marine_biology/stochastic.ts
new file mode 100644
index 000000000..54e541774
--- /dev/null
+++ b/src/marine_biology/stochastic.ts
@@ -0,0 +1,14 @@
+/** marine_biology stochastic module — tsb analytics library. */
+export interface MarineBiologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyStochasticResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyStochastic(data: number[], opts: MarineBiologyStochasticOptions = {}): MarineBiologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyStochastic };
diff --git a/src/marine_biology/synthesis.ts b/src/marine_biology/synthesis.ts
new file mode 100644
index 000000000..5996aafda
--- /dev/null
+++ b/src/marine_biology/synthesis.ts
@@ -0,0 +1,14 @@
+/** marine_biology synthesis module — tsb analytics library. */
+export interface MarineBiologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologySynthesisResult { values: number[]; converged: boolean; }
+export function computeMarineBiologySynthesis(data: number[], opts: MarineBiologySynthesisOptions = {}): MarineBiologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologySynthesis };
diff --git a/src/marine_biology/topology.ts b/src/marine_biology/topology.ts
new file mode 100644
index 000000000..755fa84a1
--- /dev/null
+++ b/src/marine_biology/topology.ts
@@ -0,0 +1,14 @@
+/** marine_biology topology module — tsb analytics library. */
+export interface MarineBiologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyTopologyResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyTopology(data: number[], opts: MarineBiologyTopologyOptions = {}): MarineBiologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyTopology };
diff --git a/src/marine_biology/tracking.ts b/src/marine_biology/tracking.ts
new file mode 100644
index 000000000..9122ccb3e
--- /dev/null
+++ b/src/marine_biology/tracking.ts
@@ -0,0 +1,14 @@
+/** marine_biology tracking module — tsb analytics library. */
+export interface MarineBiologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyTrackingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyTracking(data: number[], opts: MarineBiologyTrackingOptions = {}): MarineBiologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyTracking };
diff --git a/src/marine_biology/transform.ts b/src/marine_biology/transform.ts
new file mode 100644
index 000000000..c12251efc
--- /dev/null
+++ b/src/marine_biology/transform.ts
@@ -0,0 +1,14 @@
+/** marine_biology transform module — tsb analytics library. */
+export interface MarineBiologyTransformOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyTransformResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyTransform(data: number[], opts: MarineBiologyTransformOptions = {}): MarineBiologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyTransform };
diff --git a/src/marine_biology/uncertainty.ts b/src/marine_biology/uncertainty.ts
new file mode 100644
index 000000000..357bf049e
--- /dev/null
+++ b/src/marine_biology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** marine_biology uncertainty module — tsb analytics library. */
+export interface MarineBiologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyUncertainty(data: number[], opts: MarineBiologyUncertaintyOptions = {}): MarineBiologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyUncertainty };
diff --git a/src/marine_biology/validation.ts b/src/marine_biology/validation.ts
new file mode 100644
index 000000000..a764b1b43
--- /dev/null
+++ b/src/marine_biology/validation.ts
@@ -0,0 +1,14 @@
+/** marine_biology validation module — tsb analytics library. */
+export interface MarineBiologyValidationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyValidationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyValidation(data: number[], opts: MarineBiologyValidationOptions = {}): MarineBiologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyValidation };
diff --git a/src/marine_biology/verification.ts b/src/marine_biology/verification.ts
new file mode 100644
index 000000000..4a6fd5d94
--- /dev/null
+++ b/src/marine_biology/verification.ts
@@ -0,0 +1,14 @@
+/** marine_biology verification module — tsb analytics library. */
+export interface MarineBiologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyVerificationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyVerification(data: number[], opts: MarineBiologyVerificationOptions = {}): MarineBiologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyVerification };
diff --git a/src/marine_biology/visualization.ts b/src/marine_biology/visualization.ts
new file mode 100644
index 000000000..c698ad9df
--- /dev/null
+++ b/src/marine_biology/visualization.ts
@@ -0,0 +1,14 @@
+/** marine_biology visualization module — tsb analytics library. */
+export interface MarineBiologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyVisualization(data: number[], opts: MarineBiologyVisualizationOptions = {}): MarineBiologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyVisualization };
diff --git a/src/marine_biology/voting.ts b/src/marine_biology/voting.ts
new file mode 100644
index 000000000..e36212c46
--- /dev/null
+++ b/src/marine_biology/voting.ts
@@ -0,0 +1,14 @@
+/** marine_biology voting module — tsb analytics library. */
+export interface MarineBiologyVotingOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyVotingResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyVoting(data: number[], opts: MarineBiologyVotingOptions = {}): MarineBiologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyVoting };
diff --git a/src/marine_biology/wavelet.ts b/src/marine_biology/wavelet.ts
new file mode 100644
index 000000000..78b38df3a
--- /dev/null
+++ b/src/marine_biology/wavelet.ts
@@ -0,0 +1,14 @@
+/** marine_biology wavelet module — tsb analytics library. */
+export interface MarineBiologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface MarineBiologyWaveletResult { values: number[]; converged: boolean; }
+export function computeMarineBiologyWavelet(data: number[], opts: MarineBiologyWaveletOptions = {}): MarineBiologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMarineBiologyWavelet };
diff --git a/src/metabolomics_sci/adaptation.ts b/src/metabolomics_sci/adaptation.ts
new file mode 100644
index 000000000..eef9a0ad1
--- /dev/null
+++ b/src/metabolomics_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci adaptation module — tsb analytics library. */
+export interface MetabolomicsSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciAdaptation(data: number[], opts: MetabolomicsSciAdaptationOptions = {}): MetabolomicsSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciAdaptation };
diff --git a/src/metabolomics_sci/aggregation.ts b/src/metabolomics_sci/aggregation.ts
new file mode 100644
index 000000000..82856bab4
--- /dev/null
+++ b/src/metabolomics_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci aggregation module — tsb analytics library. */
+export interface MetabolomicsSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciAggregationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciAggregation(data: number[], opts: MetabolomicsSciAggregationOptions = {}): MetabolomicsSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciAggregation };
diff --git a/src/metabolomics_sci/algebra.ts b/src/metabolomics_sci/algebra.ts
new file mode 100644
index 000000000..02fe49876
--- /dev/null
+++ b/src/metabolomics_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci algebra module — tsb analytics library. */
+export interface MetabolomicsSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciAlgebra(data: number[], opts: MetabolomicsSciAlgebraOptions = {}): MetabolomicsSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciAlgebra };
diff --git a/src/metabolomics_sci/alignment.ts b/src/metabolomics_sci/alignment.ts
new file mode 100644
index 000000000..372eba31a
--- /dev/null
+++ b/src/metabolomics_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci alignment module — tsb analytics library. */
+export interface MetabolomicsSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciAlignment(data: number[], opts: MetabolomicsSciAlignmentOptions = {}): MetabolomicsSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciAlignment };
diff --git a/src/metabolomics_sci/analysis.ts b/src/metabolomics_sci/analysis.ts
new file mode 100644
index 000000000..b9fe3a038
--- /dev/null
+++ b/src/metabolomics_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci analysis module — tsb analytics library. */
+export interface MetabolomicsSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciAnalysis(data: number[], opts: MetabolomicsSciAnalysisOptions = {}): MetabolomicsSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciAnalysis };
diff --git a/src/metabolomics_sci/augmentation.ts b/src/metabolomics_sci/augmentation.ts
new file mode 100644
index 000000000..9decb187b
--- /dev/null
+++ b/src/metabolomics_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci augmentation module — tsb analytics library. */
+export interface MetabolomicsSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciAugmentation(data: number[], opts: MetabolomicsSciAugmentationOptions = {}): MetabolomicsSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciAugmentation };
diff --git a/src/metabolomics_sci/bagging.ts b/src/metabolomics_sci/bagging.ts
new file mode 100644
index 000000000..ed68414c7
--- /dev/null
+++ b/src/metabolomics_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci bagging module — tsb analytics library. */
+export interface MetabolomicsSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciBaggingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciBagging(data: number[], opts: MetabolomicsSciBaggingOptions = {}): MetabolomicsSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciBagging };
diff --git a/src/metabolomics_sci/basis.ts b/src/metabolomics_sci/basis.ts
new file mode 100644
index 000000000..10711a146
--- /dev/null
+++ b/src/metabolomics_sci/basis.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci basis module — tsb analytics library. */
+export interface MetabolomicsSciBasisOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciBasisResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciBasis(data: number[], opts: MetabolomicsSciBasisOptions = {}): MetabolomicsSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciBasis };
diff --git a/src/metabolomics_sci/benchmarking.ts b/src/metabolomics_sci/benchmarking.ts
new file mode 100644
index 000000000..3cbab1169
--- /dev/null
+++ b/src/metabolomics_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci benchmarking module — tsb analytics library. */
+export interface MetabolomicsSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciBenchmarking(data: number[], opts: MetabolomicsSciBenchmarkingOptions = {}): MetabolomicsSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciBenchmarking };
diff --git a/src/metabolomics_sci/blending.ts b/src/metabolomics_sci/blending.ts
new file mode 100644
index 000000000..7dc5483e2
--- /dev/null
+++ b/src/metabolomics_sci/blending.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci blending module — tsb analytics library. */
+export interface MetabolomicsSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciBlendingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciBlending(data: number[], opts: MetabolomicsSciBlendingOptions = {}): MetabolomicsSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciBlending };
diff --git a/src/metabolomics_sci/boosting.ts b/src/metabolomics_sci/boosting.ts
new file mode 100644
index 000000000..0056b06db
--- /dev/null
+++ b/src/metabolomics_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci boosting module — tsb analytics library. */
+export interface MetabolomicsSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciBoostingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciBoosting(data: number[], opts: MetabolomicsSciBoostingOptions = {}): MetabolomicsSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciBoosting };
diff --git a/src/metabolomics_sci/bootstrap.ts b/src/metabolomics_sci/bootstrap.ts
new file mode 100644
index 000000000..8efb67e3d
--- /dev/null
+++ b/src/metabolomics_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci bootstrap module — tsb analytics library. */
+export interface MetabolomicsSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciBootstrap(data: number[], opts: MetabolomicsSciBootstrapOptions = {}): MetabolomicsSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciBootstrap };
diff --git a/src/metabolomics_sci/calculus.ts b/src/metabolomics_sci/calculus.ts
new file mode 100644
index 000000000..8e7d27d57
--- /dev/null
+++ b/src/metabolomics_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci calculus module — tsb analytics library. */
+export interface MetabolomicsSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciCalculusResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciCalculus(data: number[], opts: MetabolomicsSciCalculusOptions = {}): MetabolomicsSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciCalculus };
diff --git a/src/metabolomics_sci/calibration.ts b/src/metabolomics_sci/calibration.ts
new file mode 100644
index 000000000..b6cae3098
--- /dev/null
+++ b/src/metabolomics_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci calibration module — tsb analytics library. */
+export interface MetabolomicsSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciCalibration(data: number[], opts: MetabolomicsSciCalibrationOptions = {}): MetabolomicsSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciCalibration };
diff --git a/src/metabolomics_sci/characterization.ts b/src/metabolomics_sci/characterization.ts
new file mode 100644
index 000000000..501962f31
--- /dev/null
+++ b/src/metabolomics_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci characterization module — tsb analytics library. */
+export interface MetabolomicsSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciCharacterization(data: number[], opts: MetabolomicsSciCharacterizationOptions = {}): MetabolomicsSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciCharacterization };
diff --git a/src/metabolomics_sci/classification.ts b/src/metabolomics_sci/classification.ts
new file mode 100644
index 000000000..e9cf3f151
--- /dev/null
+++ b/src/metabolomics_sci/classification.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci classification module — tsb analytics library. */
+export interface MetabolomicsSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciClassificationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciClassification(data: number[], opts: MetabolomicsSciClassificationOptions = {}): MetabolomicsSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciClassification };
diff --git a/src/metabolomics_sci/clustering.ts b/src/metabolomics_sci/clustering.ts
new file mode 100644
index 000000000..0fdd086e3
--- /dev/null
+++ b/src/metabolomics_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci clustering module — tsb analytics library. */
+export interface MetabolomicsSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciClusteringResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciClustering(data: number[], opts: MetabolomicsSciClusteringOptions = {}): MetabolomicsSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciClustering };
diff --git a/src/metabolomics_sci/compression.ts b/src/metabolomics_sci/compression.ts
new file mode 100644
index 000000000..fce48636a
--- /dev/null
+++ b/src/metabolomics_sci/compression.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci compression module — tsb analytics library. */
+export interface MetabolomicsSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciCompressionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciCompression(data: number[], opts: MetabolomicsSciCompressionOptions = {}): MetabolomicsSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciCompression };
diff --git a/src/metabolomics_sci/continuous.ts b/src/metabolomics_sci/continuous.ts
new file mode 100644
index 000000000..2be47d581
--- /dev/null
+++ b/src/metabolomics_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci continuous module — tsb analytics library. */
+export interface MetabolomicsSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciContinuousResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciContinuous(data: number[], opts: MetabolomicsSciContinuousOptions = {}): MetabolomicsSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciContinuous };
diff --git a/src/metabolomics_sci/control.ts b/src/metabolomics_sci/control.ts
new file mode 100644
index 000000000..1b2d969f3
--- /dev/null
+++ b/src/metabolomics_sci/control.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci control module — tsb analytics library. */
+export interface MetabolomicsSciControlOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciControlResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciControl(data: number[], opts: MetabolomicsSciControlOptions = {}): MetabolomicsSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciControl };
diff --git a/src/metabolomics_sci/convergence.ts b/src/metabolomics_sci/convergence.ts
new file mode 100644
index 000000000..f29066961
--- /dev/null
+++ b/src/metabolomics_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci convergence module — tsb analytics library. */
+export interface MetabolomicsSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciConvergence(data: number[], opts: MetabolomicsSciConvergenceOptions = {}): MetabolomicsSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciConvergence };
diff --git a/src/metabolomics_sci/convex.ts b/src/metabolomics_sci/convex.ts
new file mode 100644
index 000000000..e7a5052e8
--- /dev/null
+++ b/src/metabolomics_sci/convex.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci convex module — tsb analytics library. */
+export interface MetabolomicsSciConvexOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciConvexResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciConvex(data: number[], opts: MetabolomicsSciConvexOptions = {}): MetabolomicsSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciConvex };
diff --git a/src/metabolomics_sci/correlation.ts b/src/metabolomics_sci/correlation.ts
new file mode 100644
index 000000000..592d8377e
--- /dev/null
+++ b/src/metabolomics_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci correlation module — tsb analytics library. */
+export interface MetabolomicsSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciCorrelation(data: number[], opts: MetabolomicsSciCorrelationOptions = {}): MetabolomicsSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciCorrelation };
diff --git a/src/metabolomics_sci/covariance.ts b/src/metabolomics_sci/covariance.ts
new file mode 100644
index 000000000..307976626
--- /dev/null
+++ b/src/metabolomics_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci covariance module — tsb analytics library. */
+export interface MetabolomicsSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciCovariance(data: number[], opts: MetabolomicsSciCovarianceOptions = {}): MetabolomicsSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciCovariance };
diff --git a/src/metabolomics_sci/cross_validation.ts b/src/metabolomics_sci/cross_validation.ts
new file mode 100644
index 000000000..bf8359d53
--- /dev/null
+++ b/src/metabolomics_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci cross_validation module — tsb analytics library. */
+export interface MetabolomicsSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciCrossValidation(data: number[], opts: MetabolomicsSciCrossValidationOptions = {}): MetabolomicsSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciCrossValidation };
diff --git a/src/metabolomics_sci/decoding.ts b/src/metabolomics_sci/decoding.ts
new file mode 100644
index 000000000..182654ada
--- /dev/null
+++ b/src/metabolomics_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci decoding module — tsb analytics library. */
+export interface MetabolomicsSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDecodingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDecoding(data: number[], opts: MetabolomicsSciDecodingOptions = {}): MetabolomicsSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDecoding };
diff --git a/src/metabolomics_sci/decomposition.ts b/src/metabolomics_sci/decomposition.ts
new file mode 100644
index 000000000..dbb064084
--- /dev/null
+++ b/src/metabolomics_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci decomposition module — tsb analytics library. */
+export interface MetabolomicsSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDecomposition(data: number[], opts: MetabolomicsSciDecompositionOptions = {}): MetabolomicsSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDecomposition };
diff --git a/src/metabolomics_sci/detection.ts b/src/metabolomics_sci/detection.ts
new file mode 100644
index 000000000..95e55a0dc
--- /dev/null
+++ b/src/metabolomics_sci/detection.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci detection module — tsb analytics library. */
+export interface MetabolomicsSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDetectionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDetection(data: number[], opts: MetabolomicsSciDetectionOptions = {}): MetabolomicsSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDetection };
diff --git a/src/metabolomics_sci/deterministic.ts b/src/metabolomics_sci/deterministic.ts
new file mode 100644
index 000000000..f60cf5a89
--- /dev/null
+++ b/src/metabolomics_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci deterministic module — tsb analytics library. */
+export interface MetabolomicsSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDeterministic(data: number[], opts: MetabolomicsSciDeterministicOptions = {}): MetabolomicsSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDeterministic };
diff --git a/src/metabolomics_sci/diagnostics.ts b/src/metabolomics_sci/diagnostics.ts
new file mode 100644
index 000000000..108e6a393
--- /dev/null
+++ b/src/metabolomics_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci diagnostics module — tsb analytics library. */
+export interface MetabolomicsSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDiagnostics(data: number[], opts: MetabolomicsSciDiagnosticsOptions = {}): MetabolomicsSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDiagnostics };
diff --git a/src/metabolomics_sci/differential.ts b/src/metabolomics_sci/differential.ts
new file mode 100644
index 000000000..a4a8c5377
--- /dev/null
+++ b/src/metabolomics_sci/differential.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci differential module — tsb analytics library. */
+export interface MetabolomicsSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDifferential(data: number[], opts: MetabolomicsSciDifferentialOptions = {}): MetabolomicsSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDifferential };
diff --git a/src/metabolomics_sci/discrete.ts b/src/metabolomics_sci/discrete.ts
new file mode 100644
index 000000000..be8da6602
--- /dev/null
+++ b/src/metabolomics_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci discrete module — tsb analytics library. */
+export interface MetabolomicsSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDiscrete(data: number[], opts: MetabolomicsSciDiscreteOptions = {}): MetabolomicsSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDiscrete };
diff --git a/src/metabolomics_sci/distribution.ts b/src/metabolomics_sci/distribution.ts
new file mode 100644
index 000000000..224f26a83
--- /dev/null
+++ b/src/metabolomics_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci distribution module — tsb analytics library. */
+export interface MetabolomicsSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDistributionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDistribution(data: number[], opts: MetabolomicsSciDistributionOptions = {}): MetabolomicsSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDistribution };
diff --git a/src/metabolomics_sci/dynamic.ts b/src/metabolomics_sci/dynamic.ts
new file mode 100644
index 000000000..5166cc3a1
--- /dev/null
+++ b/src/metabolomics_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci dynamic module — tsb analytics library. */
+export interface MetabolomicsSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciDynamicResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciDynamic(data: number[], opts: MetabolomicsSciDynamicOptions = {}): MetabolomicsSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciDynamic };
diff --git a/src/metabolomics_sci/embedding.ts b/src/metabolomics_sci/embedding.ts
new file mode 100644
index 000000000..dad53ed92
--- /dev/null
+++ b/src/metabolomics_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci embedding module — tsb analytics library. */
+export interface MetabolomicsSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciEmbedding(data: number[], opts: MetabolomicsSciEmbeddingOptions = {}): MetabolomicsSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciEmbedding };
diff --git a/src/metabolomics_sci/encoding.ts b/src/metabolomics_sci/encoding.ts
new file mode 100644
index 000000000..88f155be2
--- /dev/null
+++ b/src/metabolomics_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci encoding module — tsb analytics library. */
+export interface MetabolomicsSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciEncodingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciEncoding(data: number[], opts: MetabolomicsSciEncodingOptions = {}): MetabolomicsSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciEncoding };
diff --git a/src/metabolomics_sci/ensemble.ts b/src/metabolomics_sci/ensemble.ts
new file mode 100644
index 000000000..344059faf
--- /dev/null
+++ b/src/metabolomics_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci ensemble module — tsb analytics library. */
+export interface MetabolomicsSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciEnsemble(data: number[], opts: MetabolomicsSciEnsembleOptions = {}): MetabolomicsSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciEnsemble };
diff --git a/src/metabolomics_sci/estimation.ts b/src/metabolomics_sci/estimation.ts
new file mode 100644
index 000000000..46aa0de4b
--- /dev/null
+++ b/src/metabolomics_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci estimation module — tsb analytics library. */
+export interface MetabolomicsSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciEstimationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciEstimation(data: number[], opts: MetabolomicsSciEstimationOptions = {}): MetabolomicsSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciEstimation };
diff --git a/src/metabolomics_sci/evaluation.ts b/src/metabolomics_sci/evaluation.ts
new file mode 100644
index 000000000..56f07d633
--- /dev/null
+++ b/src/metabolomics_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci evaluation module — tsb analytics library. */
+export interface MetabolomicsSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciEvaluation(data: number[], opts: MetabolomicsSciEvaluationOptions = {}): MetabolomicsSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciEvaluation };
diff --git a/src/metabolomics_sci/extrapolation.ts b/src/metabolomics_sci/extrapolation.ts
new file mode 100644
index 000000000..d7515ebbb
--- /dev/null
+++ b/src/metabolomics_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci extrapolation module — tsb analytics library. */
+export interface MetabolomicsSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciExtrapolation(data: number[], opts: MetabolomicsSciExtrapolationOptions = {}): MetabolomicsSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciExtrapolation };
diff --git a/src/metabolomics_sci/features.ts b/src/metabolomics_sci/features.ts
new file mode 100644
index 000000000..38c826044
--- /dev/null
+++ b/src/metabolomics_sci/features.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci features module — tsb analytics library. */
+export interface MetabolomicsSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciFeatures(data: number[], opts: MetabolomicsSciFeaturesOptions = {}): MetabolomicsSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciFeatures };
diff --git a/src/metabolomics_sci/feedback.ts b/src/metabolomics_sci/feedback.ts
new file mode 100644
index 000000000..ca20a19d3
--- /dev/null
+++ b/src/metabolomics_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci feedback module — tsb analytics library. */
+export interface MetabolomicsSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciFeedback(data: number[], opts: MetabolomicsSciFeedbackOptions = {}): MetabolomicsSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciFeedback };
diff --git a/src/metabolomics_sci/filtering.ts b/src/metabolomics_sci/filtering.ts
new file mode 100644
index 000000000..4dc2d05b8
--- /dev/null
+++ b/src/metabolomics_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci filtering module — tsb analytics library. */
+export interface MetabolomicsSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciFilteringResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciFiltering(data: number[], opts: MetabolomicsSciFilteringOptions = {}): MetabolomicsSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciFiltering };
diff --git a/src/metabolomics_sci/fourier.ts b/src/metabolomics_sci/fourier.ts
new file mode 100644
index 000000000..f0d4a3053
--- /dev/null
+++ b/src/metabolomics_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci fourier module — tsb analytics library. */
+export interface MetabolomicsSciFourierOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciFourierResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciFourier(data: number[], opts: MetabolomicsSciFourierOptions = {}): MetabolomicsSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciFourier };
diff --git a/src/metabolomics_sci/fusion.ts b/src/metabolomics_sci/fusion.ts
new file mode 100644
index 000000000..bd40b4a98
--- /dev/null
+++ b/src/metabolomics_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci fusion module — tsb analytics library. */
+export interface MetabolomicsSciFusionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciFusionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciFusion(data: number[], opts: MetabolomicsSciFusionOptions = {}): MetabolomicsSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciFusion };
diff --git a/src/metabolomics_sci/generation.ts b/src/metabolomics_sci/generation.ts
new file mode 100644
index 000000000..595c42fe4
--- /dev/null
+++ b/src/metabolomics_sci/generation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci generation module — tsb analytics library. */
+export interface MetabolomicsSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciGenerationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciGeneration(data: number[], opts: MetabolomicsSciGenerationOptions = {}): MetabolomicsSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciGeneration };
diff --git a/src/metabolomics_sci/geometry.ts b/src/metabolomics_sci/geometry.ts
new file mode 100644
index 000000000..d05639138
--- /dev/null
+++ b/src/metabolomics_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci geometry module — tsb analytics library. */
+export interface MetabolomicsSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciGeometryResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciGeometry(data: number[], opts: MetabolomicsSciGeometryOptions = {}): MetabolomicsSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciGeometry };
diff --git a/src/metabolomics_sci/gradient.ts b/src/metabolomics_sci/gradient.ts
new file mode 100644
index 000000000..cde80aa61
--- /dev/null
+++ b/src/metabolomics_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci gradient module — tsb analytics library. */
+export interface MetabolomicsSciGradientOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciGradientResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciGradient(data: number[], opts: MetabolomicsSciGradientOptions = {}): MetabolomicsSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciGradient };
diff --git a/src/metabolomics_sci/hessian.ts b/src/metabolomics_sci/hessian.ts
new file mode 100644
index 000000000..8ad8667af
--- /dev/null
+++ b/src/metabolomics_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci hessian module — tsb analytics library. */
+export interface MetabolomicsSciHessianOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciHessianResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciHessian(data: number[], opts: MetabolomicsSciHessianOptions = {}): MetabolomicsSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciHessian };
diff --git a/src/metabolomics_sci/hypothesis.ts b/src/metabolomics_sci/hypothesis.ts
new file mode 100644
index 000000000..82bfc2e26
--- /dev/null
+++ b/src/metabolomics_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci hypothesis module — tsb analytics library. */
+export interface MetabolomicsSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciHypothesis(data: number[], opts: MetabolomicsSciHypothesisOptions = {}): MetabolomicsSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciHypothesis };
diff --git a/src/metabolomics_sci/inference.ts b/src/metabolomics_sci/inference.ts
new file mode 100644
index 000000000..01ba34b73
--- /dev/null
+++ b/src/metabolomics_sci/inference.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci inference module — tsb analytics library. */
+export interface MetabolomicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciInference(data: number[], opts: MetabolomicsSciInferenceOptions = {}): MetabolomicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciInference };
diff --git a/src/metabolomics_sci/inference2.ts b/src/metabolomics_sci/inference2.ts
new file mode 100644
index 000000000..26e41a93f
--- /dev/null
+++ b/src/metabolomics_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci inference2 module — tsb analytics library. */
+export interface MetabolomicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciInference(data: number[], opts: MetabolomicsSciInferenceOptions = {}): MetabolomicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciInference };
diff --git a/src/metabolomics_sci/integral.ts b/src/metabolomics_sci/integral.ts
new file mode 100644
index 000000000..dd7390d4b
--- /dev/null
+++ b/src/metabolomics_sci/integral.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci integral module — tsb analytics library. */
+export interface MetabolomicsSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciIntegralResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciIntegral(data: number[], opts: MetabolomicsSciIntegralOptions = {}): MetabolomicsSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciIntegral };
diff --git a/src/metabolomics_sci/integration.ts b/src/metabolomics_sci/integration.ts
new file mode 100644
index 000000000..b583e7db5
--- /dev/null
+++ b/src/metabolomics_sci/integration.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci integration module — tsb analytics library. */
+export interface MetabolomicsSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciIntegration(data: number[], opts: MetabolomicsSciIntegrationOptions = {}): MetabolomicsSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciIntegration };
diff --git a/src/metabolomics_sci/interpolation.ts b/src/metabolomics_sci/interpolation.ts
new file mode 100644
index 000000000..a0d10c11d
--- /dev/null
+++ b/src/metabolomics_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci interpolation module — tsb analytics library. */
+export interface MetabolomicsSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciInterpolation(data: number[], opts: MetabolomicsSciInterpolationOptions = {}): MetabolomicsSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciInterpolation };
diff --git a/src/metabolomics_sci/jacobian.ts b/src/metabolomics_sci/jacobian.ts
new file mode 100644
index 000000000..3cac7a0f3
--- /dev/null
+++ b/src/metabolomics_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci jacobian module — tsb analytics library. */
+export interface MetabolomicsSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciJacobianResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciJacobian(data: number[], opts: MetabolomicsSciJacobianOptions = {}): MetabolomicsSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciJacobian };
diff --git a/src/metabolomics_sci/kernel.ts b/src/metabolomics_sci/kernel.ts
new file mode 100644
index 000000000..d599471f5
--- /dev/null
+++ b/src/metabolomics_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci kernel module — tsb analytics library. */
+export interface MetabolomicsSciKernelOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciKernelResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciKernel(data: number[], opts: MetabolomicsSciKernelOptions = {}): MetabolomicsSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciKernel };
diff --git a/src/metabolomics_sci/laplacian.ts b/src/metabolomics_sci/laplacian.ts
new file mode 100644
index 000000000..b305e8096
--- /dev/null
+++ b/src/metabolomics_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci laplacian module — tsb analytics library. */
+export interface MetabolomicsSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciLaplacian(data: number[], opts: MetabolomicsSciLaplacianOptions = {}): MetabolomicsSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciLaplacian };
diff --git a/src/metabolomics_sci/learning.ts b/src/metabolomics_sci/learning.ts
new file mode 100644
index 000000000..846107d3f
--- /dev/null
+++ b/src/metabolomics_sci/learning.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci learning module — tsb analytics library. */
+export interface MetabolomicsSciLearningOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciLearningResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciLearning(data: number[], opts: MetabolomicsSciLearningOptions = {}): MetabolomicsSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciLearning };
diff --git a/src/metabolomics_sci/linear.ts b/src/metabolomics_sci/linear.ts
new file mode 100644
index 000000000..8d6ffd57b
--- /dev/null
+++ b/src/metabolomics_sci/linear.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci linear module — tsb analytics library. */
+export interface MetabolomicsSciLinearOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciLinearResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciLinear(data: number[], opts: MetabolomicsSciLinearOptions = {}): MetabolomicsSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciLinear };
diff --git a/src/metabolomics_sci/manifold.ts b/src/metabolomics_sci/manifold.ts
new file mode 100644
index 000000000..f02f58f20
--- /dev/null
+++ b/src/metabolomics_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci manifold module — tsb analytics library. */
+export interface MetabolomicsSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciManifoldResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciManifold(data: number[], opts: MetabolomicsSciManifoldOptions = {}): MetabolomicsSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciManifold };
diff --git a/src/metabolomics_sci/matching.ts b/src/metabolomics_sci/matching.ts
new file mode 100644
index 000000000..3da8af6a0
--- /dev/null
+++ b/src/metabolomics_sci/matching.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci matching module — tsb analytics library. */
+export interface MetabolomicsSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciMatchingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciMatching(data: number[], opts: MetabolomicsSciMatchingOptions = {}): MetabolomicsSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciMatching };
diff --git a/src/metabolomics_sci/measurement.ts b/src/metabolomics_sci/measurement.ts
new file mode 100644
index 000000000..d1938e447
--- /dev/null
+++ b/src/metabolomics_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci measurement module — tsb analytics library. */
+export interface MetabolomicsSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciMeasurement(data: number[], opts: MetabolomicsSciMeasurementOptions = {}): MetabolomicsSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciMeasurement };
diff --git a/src/metabolomics_sci/metrics.ts b/src/metabolomics_sci/metrics.ts
new file mode 100644
index 000000000..77a5574eb
--- /dev/null
+++ b/src/metabolomics_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci metrics module — tsb analytics library. */
+export interface MetabolomicsSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciMetricsResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciMetrics(data: number[], opts: MetabolomicsSciMetricsOptions = {}): MetabolomicsSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciMetrics };
diff --git a/src/metabolomics_sci/modeling.ts b/src/metabolomics_sci/modeling.ts
new file mode 100644
index 000000000..91739da80
--- /dev/null
+++ b/src/metabolomics_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci modeling module — tsb analytics library. */
+export interface MetabolomicsSciModelingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciModelingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciModeling(data: number[], opts: MetabolomicsSciModelingOptions = {}): MetabolomicsSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciModeling };
diff --git a/src/metabolomics_sci/monitoring.ts b/src/metabolomics_sci/monitoring.ts
new file mode 100644
index 000000000..a7b680e99
--- /dev/null
+++ b/src/metabolomics_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci monitoring module — tsb analytics library. */
+export interface MetabolomicsSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciMonitoring(data: number[], opts: MetabolomicsSciMonitoringOptions = {}): MetabolomicsSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciMonitoring };
diff --git a/src/metabolomics_sci/nonlinear.ts b/src/metabolomics_sci/nonlinear.ts
new file mode 100644
index 000000000..4b8567fbe
--- /dev/null
+++ b/src/metabolomics_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci nonlinear module — tsb analytics library. */
+export interface MetabolomicsSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciNonlinear(data: number[], opts: MetabolomicsSciNonlinearOptions = {}): MetabolomicsSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciNonlinear };
diff --git a/src/metabolomics_sci/normalization.ts b/src/metabolomics_sci/normalization.ts
new file mode 100644
index 000000000..d9b4f6eab
--- /dev/null
+++ b/src/metabolomics_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci normalization module — tsb analytics library. */
+export interface MetabolomicsSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciNormalization(data: number[], opts: MetabolomicsSciNormalizationOptions = {}): MetabolomicsSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciNormalization };
diff --git a/src/metabolomics_sci/optimization.ts b/src/metabolomics_sci/optimization.ts
new file mode 100644
index 000000000..84bf3bcf3
--- /dev/null
+++ b/src/metabolomics_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci optimization module — tsb analytics library. */
+export interface MetabolomicsSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciOptimization(data: number[], opts: MetabolomicsSciOptimizationOptions = {}): MetabolomicsSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciOptimization };
diff --git a/src/metabolomics_sci/patterns.ts b/src/metabolomics_sci/patterns.ts
new file mode 100644
index 000000000..848cfd70f
--- /dev/null
+++ b/src/metabolomics_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci patterns module — tsb analytics library. */
+export interface MetabolomicsSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciPatternsResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciPatterns(data: number[], opts: MetabolomicsSciPatternsOptions = {}): MetabolomicsSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciPatterns };
diff --git a/src/metabolomics_sci/permutation.ts b/src/metabolomics_sci/permutation.ts
new file mode 100644
index 000000000..4f80ee9a9
--- /dev/null
+++ b/src/metabolomics_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci permutation module — tsb analytics library. */
+export interface MetabolomicsSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciPermutationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciPermutation(data: number[], opts: MetabolomicsSciPermutationOptions = {}): MetabolomicsSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciPermutation };
diff --git a/src/metabolomics_sci/prediction.ts b/src/metabolomics_sci/prediction.ts
new file mode 100644
index 000000000..795590768
--- /dev/null
+++ b/src/metabolomics_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci prediction module — tsb analytics library. */
+export interface MetabolomicsSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciPredictionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciPrediction(data: number[], opts: MetabolomicsSciPredictionOptions = {}): MetabolomicsSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciPrediction };
diff --git a/src/metabolomics_sci/processing.ts b/src/metabolomics_sci/processing.ts
new file mode 100644
index 000000000..a45ca87b6
--- /dev/null
+++ b/src/metabolomics_sci/processing.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci processing module — tsb analytics library. */
+export interface MetabolomicsSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciProcessingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciProcessing(data: number[], opts: MetabolomicsSciProcessingOptions = {}): MetabolomicsSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciProcessing };
diff --git a/src/metabolomics_sci/profiling.ts b/src/metabolomics_sci/profiling.ts
new file mode 100644
index 000000000..b533966f1
--- /dev/null
+++ b/src/metabolomics_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci profiling module — tsb analytics library. */
+export interface MetabolomicsSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciProfilingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciProfiling(data: number[], opts: MetabolomicsSciProfilingOptions = {}): MetabolomicsSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciProfiling };
diff --git a/src/metabolomics_sci/projection.ts b/src/metabolomics_sci/projection.ts
new file mode 100644
index 000000000..87743421e
--- /dev/null
+++ b/src/metabolomics_sci/projection.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci projection module — tsb analytics library. */
+export interface MetabolomicsSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciProjectionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciProjection(data: number[], opts: MetabolomicsSciProjectionOptions = {}): MetabolomicsSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciProjection };
diff --git a/src/metabolomics_sci/ranking.ts b/src/metabolomics_sci/ranking.ts
new file mode 100644
index 000000000..44984020b
--- /dev/null
+++ b/src/metabolomics_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci ranking module — tsb analytics library. */
+export interface MetabolomicsSciRankingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciRankingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciRanking(data: number[], opts: MetabolomicsSciRankingOptions = {}): MetabolomicsSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciRanking };
diff --git a/src/metabolomics_sci/reconstruction.ts b/src/metabolomics_sci/reconstruction.ts
new file mode 100644
index 000000000..dd6838a2a
--- /dev/null
+++ b/src/metabolomics_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci reconstruction module — tsb analytics library. */
+export interface MetabolomicsSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciReconstruction(data: number[], opts: MetabolomicsSciReconstructionOptions = {}): MetabolomicsSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciReconstruction };
diff --git a/src/metabolomics_sci/registration.ts b/src/metabolomics_sci/registration.ts
new file mode 100644
index 000000000..5a68a76cc
--- /dev/null
+++ b/src/metabolomics_sci/registration.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci registration module — tsb analytics library. */
+export interface MetabolomicsSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciRegistration(data: number[], opts: MetabolomicsSciRegistrationOptions = {}): MetabolomicsSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciRegistration };
diff --git a/src/metabolomics_sci/regression.ts b/src/metabolomics_sci/regression.ts
new file mode 100644
index 000000000..334b6282f
--- /dev/null
+++ b/src/metabolomics_sci/regression.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci regression module — tsb analytics library. */
+export interface MetabolomicsSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciRegressionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciRegression(data: number[], opts: MetabolomicsSciRegressionOptions = {}): MetabolomicsSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciRegression };
diff --git a/src/metabolomics_sci/regularization.ts b/src/metabolomics_sci/regularization.ts
new file mode 100644
index 000000000..45a8bb392
--- /dev/null
+++ b/src/metabolomics_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci regularization module — tsb analytics library. */
+export interface MetabolomicsSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciRegularization(data: number[], opts: MetabolomicsSciRegularizationOptions = {}): MetabolomicsSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciRegularization };
diff --git a/src/metabolomics_sci/robustness.ts b/src/metabolomics_sci/robustness.ts
new file mode 100644
index 000000000..fc241d475
--- /dev/null
+++ b/src/metabolomics_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci robustness module — tsb analytics library. */
+export interface MetabolomicsSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciRobustness(data: number[], opts: MetabolomicsSciRobustnessOptions = {}): MetabolomicsSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciRobustness };
diff --git a/src/metabolomics_sci/sampling.ts b/src/metabolomics_sci/sampling.ts
new file mode 100644
index 000000000..6b5147941
--- /dev/null
+++ b/src/metabolomics_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci sampling module — tsb analytics library. */
+export interface MetabolomicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciSampling(data: number[], opts: MetabolomicsSciSamplingOptions = {}): MetabolomicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciSampling };
diff --git a/src/metabolomics_sci/sampling2.ts b/src/metabolomics_sci/sampling2.ts
new file mode 100644
index 000000000..af6a0fdae
--- /dev/null
+++ b/src/metabolomics_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci sampling2 module — tsb analytics library. */
+export interface MetabolomicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciSampling(data: number[], opts: MetabolomicsSciSamplingOptions = {}): MetabolomicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciSampling };
diff --git a/src/metabolomics_sci/scaling.ts b/src/metabolomics_sci/scaling.ts
new file mode 100644
index 000000000..d8deb4ce0
--- /dev/null
+++ b/src/metabolomics_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci scaling module — tsb analytics library. */
+export interface MetabolomicsSciScalingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciScalingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciScaling(data: number[], opts: MetabolomicsSciScalingOptions = {}): MetabolomicsSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciScaling };
diff --git a/src/metabolomics_sci/scoring.ts b/src/metabolomics_sci/scoring.ts
new file mode 100644
index 000000000..a8cffb5a1
--- /dev/null
+++ b/src/metabolomics_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci scoring module — tsb analytics library. */
+export interface MetabolomicsSciScoringOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciScoringResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciScoring(data: number[], opts: MetabolomicsSciScoringOptions = {}): MetabolomicsSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciScoring };
diff --git a/src/metabolomics_sci/segmentation.ts b/src/metabolomics_sci/segmentation.ts
new file mode 100644
index 000000000..18e77ae3e
--- /dev/null
+++ b/src/metabolomics_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci segmentation module — tsb analytics library. */
+export interface MetabolomicsSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciSegmentation(data: number[], opts: MetabolomicsSciSegmentationOptions = {}): MetabolomicsSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciSegmentation };
diff --git a/src/metabolomics_sci/selection.ts b/src/metabolomics_sci/selection.ts
new file mode 100644
index 000000000..b3f946ec0
--- /dev/null
+++ b/src/metabolomics_sci/selection.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci selection module — tsb analytics library. */
+export interface MetabolomicsSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciSelectionResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciSelection(data: number[], opts: MetabolomicsSciSelectionOptions = {}): MetabolomicsSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciSelection };
diff --git a/src/metabolomics_sci/sensitivity.ts b/src/metabolomics_sci/sensitivity.ts
new file mode 100644
index 000000000..0ea0ce302
--- /dev/null
+++ b/src/metabolomics_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci sensitivity module — tsb analytics library. */
+export interface MetabolomicsSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciSensitivity(data: number[], opts: MetabolomicsSciSensitivityOptions = {}): MetabolomicsSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciSensitivity };
diff --git a/src/metabolomics_sci/simulation.ts b/src/metabolomics_sci/simulation.ts
new file mode 100644
index 000000000..b98bbe4cc
--- /dev/null
+++ b/src/metabolomics_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci simulation module — tsb analytics library. */
+export interface MetabolomicsSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciSimulationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciSimulation(data: number[], opts: MetabolomicsSciSimulationOptions = {}): MetabolomicsSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciSimulation };
diff --git a/src/metabolomics_sci/smoothing.ts b/src/metabolomics_sci/smoothing.ts
new file mode 100644
index 000000000..0ddfa1b3d
--- /dev/null
+++ b/src/metabolomics_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci smoothing module — tsb analytics library. */
+export interface MetabolomicsSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciSmoothing(data: number[], opts: MetabolomicsSciSmoothingOptions = {}): MetabolomicsSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciSmoothing };
diff --git a/src/metabolomics_sci/stability.ts b/src/metabolomics_sci/stability.ts
new file mode 100644
index 000000000..b84fdafae
--- /dev/null
+++ b/src/metabolomics_sci/stability.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci stability module — tsb analytics library. */
+export interface MetabolomicsSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciStabilityResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciStability(data: number[], opts: MetabolomicsSciStabilityOptions = {}): MetabolomicsSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciStability };
diff --git a/src/metabolomics_sci/stacking.ts b/src/metabolomics_sci/stacking.ts
new file mode 100644
index 000000000..30983e4c7
--- /dev/null
+++ b/src/metabolomics_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci stacking module — tsb analytics library. */
+export interface MetabolomicsSciStackingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciStackingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciStacking(data: number[], opts: MetabolomicsSciStackingOptions = {}): MetabolomicsSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciStacking };
diff --git a/src/metabolomics_sci/standardization.ts b/src/metabolomics_sci/standardization.ts
new file mode 100644
index 000000000..8e7c7f1ed
--- /dev/null
+++ b/src/metabolomics_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci standardization module — tsb analytics library. */
+export interface MetabolomicsSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciStandardization(data: number[], opts: MetabolomicsSciStandardizationOptions = {}): MetabolomicsSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciStandardization };
diff --git a/src/metabolomics_sci/static.ts b/src/metabolomics_sci/static.ts
new file mode 100644
index 000000000..fc5cbedbe
--- /dev/null
+++ b/src/metabolomics_sci/static.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci static module — tsb analytics library. */
+export interface MetabolomicsSciStaticOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciStaticResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciStatic(data: number[], opts: MetabolomicsSciStaticOptions = {}): MetabolomicsSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciStatic };
diff --git a/src/metabolomics_sci/stochastic.ts b/src/metabolomics_sci/stochastic.ts
new file mode 100644
index 000000000..861d7a48a
--- /dev/null
+++ b/src/metabolomics_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci stochastic module — tsb analytics library. */
+export interface MetabolomicsSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciStochasticResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciStochastic(data: number[], opts: MetabolomicsSciStochasticOptions = {}): MetabolomicsSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciStochastic };
diff --git a/src/metabolomics_sci/synthesis.ts b/src/metabolomics_sci/synthesis.ts
new file mode 100644
index 000000000..650cd7c86
--- /dev/null
+++ b/src/metabolomics_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci synthesis module — tsb analytics library. */
+export interface MetabolomicsSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciSynthesis(data: number[], opts: MetabolomicsSciSynthesisOptions = {}): MetabolomicsSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciSynthesis };
diff --git a/src/metabolomics_sci/topology.ts b/src/metabolomics_sci/topology.ts
new file mode 100644
index 000000000..d48ed166c
--- /dev/null
+++ b/src/metabolomics_sci/topology.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci topology module — tsb analytics library. */
+export interface MetabolomicsSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciTopologyResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciTopology(data: number[], opts: MetabolomicsSciTopologyOptions = {}): MetabolomicsSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciTopology };
diff --git a/src/metabolomics_sci/tracking.ts b/src/metabolomics_sci/tracking.ts
new file mode 100644
index 000000000..9517e28f8
--- /dev/null
+++ b/src/metabolomics_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci tracking module — tsb analytics library. */
+export interface MetabolomicsSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciTrackingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciTracking(data: number[], opts: MetabolomicsSciTrackingOptions = {}): MetabolomicsSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciTracking };
diff --git a/src/metabolomics_sci/transform.ts b/src/metabolomics_sci/transform.ts
new file mode 100644
index 000000000..1a784ea8b
--- /dev/null
+++ b/src/metabolomics_sci/transform.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci transform module — tsb analytics library. */
+export interface MetabolomicsSciTransformOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciTransformResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciTransform(data: number[], opts: MetabolomicsSciTransformOptions = {}): MetabolomicsSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciTransform };
diff --git a/src/metabolomics_sci/uncertainty.ts b/src/metabolomics_sci/uncertainty.ts
new file mode 100644
index 000000000..5b141914c
--- /dev/null
+++ b/src/metabolomics_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci uncertainty module — tsb analytics library. */
+export interface MetabolomicsSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciUncertainty(data: number[], opts: MetabolomicsSciUncertaintyOptions = {}): MetabolomicsSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciUncertainty };
diff --git a/src/metabolomics_sci/validation.ts b/src/metabolomics_sci/validation.ts
new file mode 100644
index 000000000..6ac142e89
--- /dev/null
+++ b/src/metabolomics_sci/validation.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci validation module — tsb analytics library. */
+export interface MetabolomicsSciValidationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciValidationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciValidation(data: number[], opts: MetabolomicsSciValidationOptions = {}): MetabolomicsSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciValidation };
diff --git a/src/metabolomics_sci/verification.ts b/src/metabolomics_sci/verification.ts
new file mode 100644
index 000000000..88b4d09b9
--- /dev/null
+++ b/src/metabolomics_sci/verification.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci verification module — tsb analytics library. */
+export interface MetabolomicsSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciVerificationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciVerification(data: number[], opts: MetabolomicsSciVerificationOptions = {}): MetabolomicsSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciVerification };
diff --git a/src/metabolomics_sci/visualization.ts b/src/metabolomics_sci/visualization.ts
new file mode 100644
index 000000000..b19070aae
--- /dev/null
+++ b/src/metabolomics_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci visualization module — tsb analytics library. */
+export interface MetabolomicsSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciVisualization(data: number[], opts: MetabolomicsSciVisualizationOptions = {}): MetabolomicsSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciVisualization };
diff --git a/src/metabolomics_sci/voting.ts b/src/metabolomics_sci/voting.ts
new file mode 100644
index 000000000..c214a3679
--- /dev/null
+++ b/src/metabolomics_sci/voting.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci voting module — tsb analytics library. */
+export interface MetabolomicsSciVotingOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciVotingResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciVoting(data: number[], opts: MetabolomicsSciVotingOptions = {}): MetabolomicsSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciVoting };
diff --git a/src/metabolomics_sci/wavelet.ts b/src/metabolomics_sci/wavelet.ts
new file mode 100644
index 000000000..a11c457cb
--- /dev/null
+++ b/src/metabolomics_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** metabolomics_sci wavelet module — tsb analytics library. */
+export interface MetabolomicsSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface MetabolomicsSciWaveletResult { values: number[]; converged: boolean; }
+export function computeMetabolomicsSciWavelet(data: number[], opts: MetabolomicsSciWaveletOptions = {}): MetabolomicsSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMetabolomicsSciWavelet };
diff --git a/src/meteorology/advanced.ts b/src/meteorology/advanced.ts
new file mode 100644
index 000000000..d7d0d712c
--- /dev/null
+++ b/src/meteorology/advanced.ts
@@ -0,0 +1,15 @@
+/** Meteorology Advanced module — tsb analytics library. */
+export interface Meteorology advancedOptions { tol?: number; maxIter?: number; }
+export interface Meteorology advancedResult { values: number[]; converged: boolean; }
+export function computeMeteorology advanced(data: number[], opts: Meteorology advancedOptions = {}): Meteorology advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology advanced };
diff --git a/src/meteorology/anticyclone.ts b/src/meteorology/anticyclone.ts
new file mode 100644
index 000000000..632389e49
--- /dev/null
+++ b/src/meteorology/anticyclone.ts
@@ -0,0 +1,22 @@
+/** Anticyclone module — tsb analytics library. */
+
+/** Options for Anticyclone. */
+export interface AnticycloneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Anticyclone. */
+export interface AnticycloneResult { values: number[]; converged: boolean; }
+
+/** Compute Anticyclone. */
+export function computeAnticyclone(data: number[], opts: AnticycloneOptions = {}): AnticycloneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAnticyclone };
diff --git a/src/meteorology/base2.ts b/src/meteorology/base2.ts
new file mode 100644
index 000000000..4e246c101
--- /dev/null
+++ b/src/meteorology/base2.ts
@@ -0,0 +1,15 @@
+/** Meteorology Base2 module — tsb analytics library. */
+export interface Meteorology base2Options { tol?: number; maxIter?: number; }
+export interface Meteorology base2Result { values: number[]; converged: boolean; }
+export function computeMeteorology base2(data: number[], opts: Meteorology base2Options = {}): Meteorology base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology base2 };
diff --git a/src/meteorology/batch.ts b/src/meteorology/batch.ts
new file mode 100644
index 000000000..c6379a2f8
--- /dev/null
+++ b/src/meteorology/batch.ts
@@ -0,0 +1,15 @@
+/** Meteorology Batch module — tsb analytics library. */
+export interface Meteorology batchOptions { tol?: number; maxIter?: number; }
+export interface Meteorology batchResult { values: number[]; converged: boolean; }
+export function computeMeteorology batch(data: number[], opts: Meteorology batchOptions = {}): Meteorology batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology batch };
diff --git a/src/meteorology/beta.ts b/src/meteorology/beta.ts
new file mode 100644
index 000000000..a033081f0
--- /dev/null
+++ b/src/meteorology/beta.ts
@@ -0,0 +1,15 @@
+/** Meteorology Beta module — tsb analytics library. */
+export interface Meteorology betaOptions { tol?: number; maxIter?: number; }
+export interface Meteorology betaResult { values: number[]; converged: boolean; }
+export function computeMeteorology beta(data: number[], opts: Meteorology betaOptions = {}): Meteorology betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology beta };
diff --git a/src/meteorology/boundary_layer.ts b/src/meteorology/boundary_layer.ts
new file mode 100644
index 000000000..112b270ae
--- /dev/null
+++ b/src/meteorology/boundary_layer.ts
@@ -0,0 +1,22 @@
+/** Boundary Layer module — tsb analytics library. */
+
+/** Options for Boundary Layer. */
+export interface BoundaryLayerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Boundary Layer. */
+export interface BoundaryLayerResult { values: number[]; converged: boolean; }
+
+/** Compute Boundary Layer. */
+export function computeBoundaryLayer(data: number[], opts: BoundaryLayerOptions = {}): BoundaryLayerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBoundaryLayer };
diff --git a/src/meteorology/cape.ts b/src/meteorology/cape.ts
new file mode 100644
index 000000000..529baeaa7
--- /dev/null
+++ b/src/meteorology/cape.ts
@@ -0,0 +1,22 @@
+/** Cape module — tsb analytics library. */
+
+/** Options for Cape. */
+export interface CapeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cape. */
+export interface CapeResult { values: number[]; converged: boolean; }
+
+/** Compute Cape. */
+export function computeCape(data: number[], opts: CapeOptions = {}): CapeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCape };
diff --git a/src/meteorology/cin.ts b/src/meteorology/cin.ts
new file mode 100644
index 000000000..0c7ad8190
--- /dev/null
+++ b/src/meteorology/cin.ts
@@ -0,0 +1,22 @@
+/** Cin module — tsb analytics library. */
+
+/** Options for Cin. */
+export interface CinOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cin. */
+export interface CinResult { values: number[]; converged: boolean; }
+
+/** Compute Cin. */
+export function computeCin(data: number[], opts: CinOptions = {}): CinResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCin };
diff --git a/src/meteorology/cloud.ts b/src/meteorology/cloud.ts
new file mode 100644
index 000000000..d49b7c095
--- /dev/null
+++ b/src/meteorology/cloud.ts
@@ -0,0 +1,22 @@
+/** Cloud module — tsb analytics library. */
+
+/** Options for Cloud. */
+export interface CloudOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cloud. */
+export interface CloudResult { values: number[]; converged: boolean; }
+
+/** Compute Cloud. */
+export function computeCloud(data: number[], opts: CloudOptions = {}): CloudResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCloud };
diff --git a/src/meteorology/convective.ts b/src/meteorology/convective.ts
new file mode 100644
index 000000000..036ceb24d
--- /dev/null
+++ b/src/meteorology/convective.ts
@@ -0,0 +1,22 @@
+/** Convective module — tsb analytics library. */
+
+/** Options for Convective. */
+export interface ConvectiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Convective. */
+export interface ConvectiveResult { values: number[]; converged: boolean; }
+
+/** Compute Convective. */
+export function computeConvective(data: number[], opts: ConvectiveOptions = {}): ConvectiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConvective };
diff --git a/src/meteorology/convergence.ts b/src/meteorology/convergence.ts
new file mode 100644
index 000000000..2eb179938
--- /dev/null
+++ b/src/meteorology/convergence.ts
@@ -0,0 +1,22 @@
+/** Convergence module — tsb analytics library. */
+
+/** Options for Convergence. */
+export interface ConvergenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Convergence. */
+export interface ConvergenceResult { values: number[]; converged: boolean; }
+
+/** Compute Convergence. */
+export function computeConvergence(data: number[], opts: ConvergenceOptions = {}): ConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConvergence };
diff --git a/src/meteorology/cpu.ts b/src/meteorology/cpu.ts
new file mode 100644
index 000000000..fc914b1aa
--- /dev/null
+++ b/src/meteorology/cpu.ts
@@ -0,0 +1,15 @@
+/** Meteorology Cpu module — tsb analytics library. */
+export interface Meteorology cpuOptions { tol?: number; maxIter?: number; }
+export interface Meteorology cpuResult { values: number[]; converged: boolean; }
+export function computeMeteorology cpu(data: number[], opts: Meteorology cpuOptions = {}): Meteorology cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology cpu };
diff --git a/src/meteorology/cyclone.ts b/src/meteorology/cyclone.ts
new file mode 100644
index 000000000..2ef517220
--- /dev/null
+++ b/src/meteorology/cyclone.ts
@@ -0,0 +1,22 @@
+/** Cyclone module — tsb analytics library. */
+
+/** Options for Cyclone. */
+export interface CycloneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cyclone. */
+export interface CycloneResult { values: number[]; converged: boolean; }
+
+/** Compute Cyclone. */
+export function computeCyclone(data: number[], opts: CycloneOptions = {}): CycloneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCyclone };
diff --git a/src/meteorology/dense.ts b/src/meteorology/dense.ts
new file mode 100644
index 000000000..ddc6cde41
--- /dev/null
+++ b/src/meteorology/dense.ts
@@ -0,0 +1,15 @@
+/** Meteorology Dense module — tsb analytics library. */
+export interface Meteorology denseOptions { tol?: number; maxIter?: number; }
+export interface Meteorology denseResult { values: number[]; converged: boolean; }
+export function computeMeteorology dense(data: number[], opts: Meteorology denseOptions = {}): Meteorology denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology dense };
diff --git a/src/meteorology/distributed.ts b/src/meteorology/distributed.ts
new file mode 100644
index 000000000..0915ffd22
--- /dev/null
+++ b/src/meteorology/distributed.ts
@@ -0,0 +1,15 @@
+/** Meteorology Distributed module — tsb analytics library. */
+export interface Meteorology distributedOptions { tol?: number; maxIter?: number; }
+export interface Meteorology distributedResult { values: number[]; converged: boolean; }
+export function computeMeteorology distributed(data: number[], opts: Meteorology distributedOptions = {}): Meteorology distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology distributed };
diff --git a/src/meteorology/divergence.ts b/src/meteorology/divergence.ts
new file mode 100644
index 000000000..6e5513318
--- /dev/null
+++ b/src/meteorology/divergence.ts
@@ -0,0 +1,22 @@
+/** Divergence module — tsb analytics library. */
+
+/** Options for Divergence. */
+export interface DivergenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Divergence. */
+export interface DivergenceResult { values: number[]; converged: boolean; }
+
+/** Compute Divergence. */
+export function computeDivergence(data: number[], opts: DivergenceOptions = {}): DivergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDivergence };
diff --git a/src/meteorology/experimental.ts b/src/meteorology/experimental.ts
new file mode 100644
index 000000000..3d606c50b
--- /dev/null
+++ b/src/meteorology/experimental.ts
@@ -0,0 +1,15 @@
+/** Meteorology Experimental module — tsb analytics library. */
+export interface Meteorology experimentalOptions { tol?: number; maxIter?: number; }
+export interface Meteorology experimentalResult { values: number[]; converged: boolean; }
+export function computeMeteorology experimental(data: number[], opts: Meteorology experimentalOptions = {}): Meteorology experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology experimental };
diff --git a/src/meteorology/fast.ts b/src/meteorology/fast.ts
new file mode 100644
index 000000000..f0521f699
--- /dev/null
+++ b/src/meteorology/fast.ts
@@ -0,0 +1,15 @@
+/** Meteorology Fast module — tsb analytics library. */
+export interface Meteorology fastOptions { tol?: number; maxIter?: number; }
+export interface Meteorology fastResult { values: number[]; converged: boolean; }
+export function computeMeteorology fast(data: number[], opts: Meteorology fastOptions = {}): Meteorology fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology fast };
diff --git a/src/meteorology/front.ts b/src/meteorology/front.ts
new file mode 100644
index 000000000..688039900
--- /dev/null
+++ b/src/meteorology/front.ts
@@ -0,0 +1,22 @@
+/** Front module — tsb analytics library. */
+
+/** Options for Front. */
+export interface FrontOptions { tol?: number; maxIter?: number; }
+
+/** Result from Front. */
+export interface FrontResult { values: number[]; converged: boolean; }
+
+/** Compute Front. */
+export function computeFront(data: number[], opts: FrontOptions = {}): FrontResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFront };
diff --git a/src/meteorology/future.ts b/src/meteorology/future.ts
new file mode 100644
index 000000000..c6ab11d5b
--- /dev/null
+++ b/src/meteorology/future.ts
@@ -0,0 +1,15 @@
+/** Meteorology Future module — tsb analytics library. */
+export interface Meteorology futureOptions { tol?: number; maxIter?: number; }
+export interface Meteorology futureResult { values: number[]; converged: boolean; }
+export function computeMeteorology future(data: number[], opts: Meteorology futureOptions = {}): Meteorology futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology future };
diff --git a/src/meteorology/gpu.ts b/src/meteorology/gpu.ts
new file mode 100644
index 000000000..b75caa87f
--- /dev/null
+++ b/src/meteorology/gpu.ts
@@ -0,0 +1,15 @@
+/** Meteorology Gpu module — tsb analytics library. */
+export interface Meteorology gpuOptions { tol?: number; maxIter?: number; }
+export interface Meteorology gpuResult { values: number[]; converged: boolean; }
+export function computeMeteorology gpu(data: number[], opts: Meteorology gpuOptions = {}): Meteorology gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology gpu };
diff --git a/src/meteorology/hodograph.ts b/src/meteorology/hodograph.ts
new file mode 100644
index 000000000..23d5a4d36
--- /dev/null
+++ b/src/meteorology/hodograph.ts
@@ -0,0 +1,22 @@
+/** Hodograph module — tsb analytics library. */
+
+/** Options for Hodograph. */
+export interface HodographOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hodograph. */
+export interface HodographResult { values: number[]; converged: boolean; }
+
+/** Compute Hodograph. */
+export function computeHodograph(data: number[], opts: HodographOptions = {}): HodographResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHodograph };
diff --git a/src/meteorology/humidity_met.ts b/src/meteorology/humidity_met.ts
new file mode 100644
index 000000000..0a41ae477
--- /dev/null
+++ b/src/meteorology/humidity_met.ts
@@ -0,0 +1,22 @@
+/** Humidity Met module — tsb analytics library. */
+
+/** Options for Humidity Met. */
+export interface HumidityMetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Humidity Met. */
+export interface HumidityMetResult { values: number[]; converged: boolean; }
+
+/** Compute Humidity Met. */
+export function computeHumidityMet(data: number[], opts: HumidityMetOptions = {}): HumidityMetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHumidityMet };
diff --git a/src/meteorology/instability.ts b/src/meteorology/instability.ts
new file mode 100644
index 000000000..8efee167f
--- /dev/null
+++ b/src/meteorology/instability.ts
@@ -0,0 +1,22 @@
+/** Instability module — tsb analytics library. */
+
+/** Options for Instability. */
+export interface InstabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Instability. */
+export interface InstabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Instability. */
+export function computeInstability(data: number[], opts: InstabilityOptions = {}): InstabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInstability };
diff --git a/src/meteorology/jet_stream.ts b/src/meteorology/jet_stream.ts
new file mode 100644
index 000000000..e1268f08a
--- /dev/null
+++ b/src/meteorology/jet_stream.ts
@@ -0,0 +1,22 @@
+/** Jet Stream module — tsb analytics library. */
+
+/** Options for Jet Stream. */
+export interface JetStreamOptions { tol?: number; maxIter?: number; }
+
+/** Result from Jet Stream. */
+export interface JetStreamResult { values: number[]; converged: boolean; }
+
+/** Compute Jet Stream. */
+export function computeJetStream(data: number[], opts: JetStreamOptions = {}): JetStreamResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeJetStream };
diff --git a/src/meteorology/large.ts b/src/meteorology/large.ts
new file mode 100644
index 000000000..4dc753d79
--- /dev/null
+++ b/src/meteorology/large.ts
@@ -0,0 +1,15 @@
+/** Meteorology Large module — tsb analytics library. */
+export interface Meteorology largeOptions { tol?: number; maxIter?: number; }
+export interface Meteorology largeResult { values: number[]; converged: boolean; }
+export function computeMeteorology large(data: number[], opts: Meteorology largeOptions = {}): Meteorology largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology large };
diff --git a/src/meteorology/legacy.ts b/src/meteorology/legacy.ts
new file mode 100644
index 000000000..2afad208a
--- /dev/null
+++ b/src/meteorology/legacy.ts
@@ -0,0 +1,15 @@
+/** Meteorology Legacy module — tsb analytics library. */
+export interface Meteorology legacyOptions { tol?: number; maxIter?: number; }
+export interface Meteorology legacyResult { values: number[]; converged: boolean; }
+export function computeMeteorology legacy(data: number[], opts: Meteorology legacyOptions = {}): Meteorology legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology legacy };
diff --git a/src/meteorology/lite.ts b/src/meteorology/lite.ts
new file mode 100644
index 000000000..178646e30
--- /dev/null
+++ b/src/meteorology/lite.ts
@@ -0,0 +1,15 @@
+/** Meteorology Lite module — tsb analytics library. */
+export interface Meteorology liteOptions { tol?: number; maxIter?: number; }
+export interface Meteorology liteResult { values: number[]; converged: boolean; }
+export function computeMeteorology lite(data: number[], opts: Meteorology liteOptions = {}): Meteorology liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology lite };
diff --git a/src/meteorology/mesoscale.ts b/src/meteorology/mesoscale.ts
new file mode 100644
index 000000000..6293d947b
--- /dev/null
+++ b/src/meteorology/mesoscale.ts
@@ -0,0 +1,22 @@
+/** Mesoscale module — tsb analytics library. */
+
+/** Options for Mesoscale. */
+export interface MesoscaleOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mesoscale. */
+export interface MesoscaleResult { values: number[]; converged: boolean; }
+
+/** Compute Mesoscale. */
+export function computeMesoscale(data: number[], opts: MesoscaleOptions = {}): MesoscaleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMesoscale };
diff --git a/src/meteorology/mini.ts b/src/meteorology/mini.ts
new file mode 100644
index 000000000..1524e92fc
--- /dev/null
+++ b/src/meteorology/mini.ts
@@ -0,0 +1,15 @@
+/** Meteorology Mini module — tsb analytics library. */
+export interface Meteorology miniOptions { tol?: number; maxIter?: number; }
+export interface Meteorology miniResult { values: number[]; converged: boolean; }
+export function computeMeteorology mini(data: number[], opts: Meteorology miniOptions = {}): Meteorology miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology mini };
diff --git a/src/meteorology/next.ts b/src/meteorology/next.ts
new file mode 100644
index 000000000..564494fd9
--- /dev/null
+++ b/src/meteorology/next.ts
@@ -0,0 +1,15 @@
+/** Meteorology Next module — tsb analytics library. */
+export interface Meteorology nextOptions { tol?: number; maxIter?: number; }
+export interface Meteorology nextResult { values: number[]; converged: boolean; }
+export function computeMeteorology next(data: number[], opts: Meteorology nextOptions = {}): Meteorology nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology next };
diff --git a/src/meteorology/nwp.ts b/src/meteorology/nwp.ts
new file mode 100644
index 000000000..0defcb1fc
--- /dev/null
+++ b/src/meteorology/nwp.ts
@@ -0,0 +1,22 @@
+/** Nwp module — tsb analytics library. */
+
+/** Options for Nwp. */
+export interface NwpOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nwp. */
+export interface NwpResult { values: number[]; converged: boolean; }
+
+/** Compute Nwp. */
+export function computeNwp(data: number[], opts: NwpOptions = {}): NwpResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNwp };
diff --git a/src/meteorology/omega.ts b/src/meteorology/omega.ts
new file mode 100644
index 000000000..fb37b1f58
--- /dev/null
+++ b/src/meteorology/omega.ts
@@ -0,0 +1,22 @@
+/** Omega module — tsb analytics library. */
+
+/** Options for Omega. */
+export interface OmegaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Omega. */
+export interface OmegaResult { values: number[]; converged: boolean; }
+
+/** Compute Omega. */
+export function computeOmega(data: number[], opts: OmegaOptions = {}): OmegaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOmega };
diff --git a/src/meteorology/online.ts b/src/meteorology/online.ts
new file mode 100644
index 000000000..eee2552f8
--- /dev/null
+++ b/src/meteorology/online.ts
@@ -0,0 +1,15 @@
+/** Meteorology Online module — tsb analytics library. */
+export interface Meteorology onlineOptions { tol?: number; maxIter?: number; }
+export interface Meteorology onlineResult { values: number[]; converged: boolean; }
+export function computeMeteorology online(data: number[], opts: Meteorology onlineOptions = {}): Meteorology onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology online };
diff --git a/src/meteorology/parallel.ts b/src/meteorology/parallel.ts
new file mode 100644
index 000000000..456c543a5
--- /dev/null
+++ b/src/meteorology/parallel.ts
@@ -0,0 +1,15 @@
+/** Meteorology Parallel module — tsb analytics library. */
+export interface Meteorology parallelOptions { tol?: number; maxIter?: number; }
+export interface Meteorology parallelResult { values: number[]; converged: boolean; }
+export function computeMeteorology parallel(data: number[], opts: Meteorology parallelOptions = {}): Meteorology parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology parallel };
diff --git a/src/meteorology/plus.ts b/src/meteorology/plus.ts
new file mode 100644
index 000000000..47ccd1071
--- /dev/null
+++ b/src/meteorology/plus.ts
@@ -0,0 +1,15 @@
+/** Meteorology Plus module — tsb analytics library. */
+export interface Meteorology plusOptions { tol?: number; maxIter?: number; }
+export interface Meteorology plusResult { values: number[]; converged: boolean; }
+export function computeMeteorology plus(data: number[], opts: Meteorology plusOptions = {}): Meteorology plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology plus };
diff --git a/src/meteorology/precipitation_met.ts b/src/meteorology/precipitation_met.ts
new file mode 100644
index 000000000..0e95d6145
--- /dev/null
+++ b/src/meteorology/precipitation_met.ts
@@ -0,0 +1,22 @@
+/** Precipitation Met module — tsb analytics library. */
+
+/** Options for Precipitation Met. */
+export interface PrecipitationMetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Precipitation Met. */
+export interface PrecipitationMetResult { values: number[]; converged: boolean; }
+
+/** Compute Precipitation Met. */
+export function computePrecipitationMet(data: number[], opts: PrecipitationMetOptions = {}): PrecipitationMetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrecipitationMet };
diff --git a/src/meteorology/pressure_met.ts b/src/meteorology/pressure_met.ts
new file mode 100644
index 000000000..c1a3ed708
--- /dev/null
+++ b/src/meteorology/pressure_met.ts
@@ -0,0 +1,22 @@
+/** Pressure Met module — tsb analytics library. */
+
+/** Options for Pressure Met. */
+export interface PressureMetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pressure Met. */
+export interface PressureMetResult { values: number[]; converged: boolean; }
+
+/** Compute Pressure Met. */
+export function computePressureMet(data: number[], opts: PressureMetOptions = {}): PressureMetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePressureMet };
diff --git a/src/meteorology/pro.ts b/src/meteorology/pro.ts
new file mode 100644
index 000000000..a15ff007b
--- /dev/null
+++ b/src/meteorology/pro.ts
@@ -0,0 +1,15 @@
+/** Meteorology Pro module — tsb analytics library. */
+export interface Meteorology proOptions { tol?: number; maxIter?: number; }
+export interface Meteorology proResult { values: number[]; converged: boolean; }
+export function computeMeteorology pro(data: number[], opts: Meteorology proOptions = {}): Meteorology proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology pro };
diff --git a/src/meteorology/radiation_met.ts b/src/meteorology/radiation_met.ts
new file mode 100644
index 000000000..604de9838
--- /dev/null
+++ b/src/meteorology/radiation_met.ts
@@ -0,0 +1,22 @@
+/** Radiation Met module — tsb analytics library. */
+
+/** Options for Radiation Met. */
+export interface RadiationMetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Radiation Met. */
+export interface RadiationMetResult { values: number[]; converged: boolean; }
+
+/** Compute Radiation Met. */
+export function computeRadiationMet(data: number[], opts: RadiationMetOptions = {}): RadiationMetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRadiationMet };
diff --git a/src/meteorology/reanalysis.ts b/src/meteorology/reanalysis.ts
new file mode 100644
index 000000000..e2eefb688
--- /dev/null
+++ b/src/meteorology/reanalysis.ts
@@ -0,0 +1,22 @@
+/** Reanalysis module — tsb analytics library. */
+
+/** Options for Reanalysis. */
+export interface ReanalysisOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reanalysis. */
+export interface ReanalysisResult { values: number[]; converged: boolean; }
+
+/** Compute Reanalysis. */
+export function computeReanalysis(data: number[], opts: ReanalysisOptions = {}): ReanalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReanalysis };
diff --git a/src/meteorology/robust.ts b/src/meteorology/robust.ts
new file mode 100644
index 000000000..7965df778
--- /dev/null
+++ b/src/meteorology/robust.ts
@@ -0,0 +1,15 @@
+/** Meteorology Robust module — tsb analytics library. */
+export interface Meteorology robustOptions { tol?: number; maxIter?: number; }
+export interface Meteorology robustResult { values: number[]; converged: boolean; }
+export function computeMeteorology robust(data: number[], opts: Meteorology robustOptions = {}): Meteorology robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology robust };
diff --git a/src/meteorology/shear.ts b/src/meteorology/shear.ts
new file mode 100644
index 000000000..e1f5deef7
--- /dev/null
+++ b/src/meteorology/shear.ts
@@ -0,0 +1,22 @@
+/** Shear module — tsb analytics library. */
+
+/** Options for Shear. */
+export interface ShearOptions { tol?: number; maxIter?: number; }
+
+/** Result from Shear. */
+export interface ShearResult { values: number[]; converged: boolean; }
+
+/** Compute Shear. */
+export function computeShear(data: number[], opts: ShearOptions = {}): ShearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeShear };
diff --git a/src/meteorology/small.ts b/src/meteorology/small.ts
new file mode 100644
index 000000000..f7b3e34da
--- /dev/null
+++ b/src/meteorology/small.ts
@@ -0,0 +1,15 @@
+/** Meteorology Small module — tsb analytics library. */
+export interface Meteorology smallOptions { tol?: number; maxIter?: number; }
+export interface Meteorology smallResult { values: number[]; converged: boolean; }
+export function computeMeteorology small(data: number[], opts: Meteorology smallOptions = {}): Meteorology smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology small };
diff --git a/src/meteorology/sounding.ts b/src/meteorology/sounding.ts
new file mode 100644
index 000000000..9f16bbd17
--- /dev/null
+++ b/src/meteorology/sounding.ts
@@ -0,0 +1,22 @@
+/** Sounding module — tsb analytics library. */
+
+/** Options for Sounding. */
+export interface SoundingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sounding. */
+export interface SoundingResult { values: number[]; converged: boolean; }
+
+/** Compute Sounding. */
+export function computeSounding(data: number[], opts: SoundingOptions = {}): SoundingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSounding };
diff --git a/src/meteorology/sparse.ts b/src/meteorology/sparse.ts
new file mode 100644
index 000000000..e9c56203f
--- /dev/null
+++ b/src/meteorology/sparse.ts
@@ -0,0 +1,15 @@
+/** Meteorology Sparse module — tsb analytics library. */
+export interface Meteorology sparseOptions { tol?: number; maxIter?: number; }
+export interface Meteorology sparseResult { values: number[]; converged: boolean; }
+export function computeMeteorology sparse(data: number[], opts: Meteorology sparseOptions = {}): Meteorology sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology sparse };
diff --git a/src/meteorology/stability.ts b/src/meteorology/stability.ts
new file mode 100644
index 000000000..f664dbc0f
--- /dev/null
+++ b/src/meteorology/stability.ts
@@ -0,0 +1,22 @@
+/** Stability module — tsb analytics library. */
+
+/** Options for Stability. */
+export interface StabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stability. */
+export interface StabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Stability. */
+export function computeStability(data: number[], opts: StabilityOptions = {}): StabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStability };
diff --git a/src/meteorology/stable.ts b/src/meteorology/stable.ts
new file mode 100644
index 000000000..11f536afd
--- /dev/null
+++ b/src/meteorology/stable.ts
@@ -0,0 +1,15 @@
+/** Meteorology Stable module — tsb analytics library. */
+export interface Meteorology stableOptions { tol?: number; maxIter?: number; }
+export interface Meteorology stableResult { values: number[]; converged: boolean; }
+export function computeMeteorology stable(data: number[], opts: Meteorology stableOptions = {}): Meteorology stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology stable };
diff --git a/src/meteorology/stratosphere.ts b/src/meteorology/stratosphere.ts
new file mode 100644
index 000000000..d205f908e
--- /dev/null
+++ b/src/meteorology/stratosphere.ts
@@ -0,0 +1,22 @@
+/** Stratosphere module — tsb analytics library. */
+
+/** Options for Stratosphere. */
+export interface StratosphereOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stratosphere. */
+export interface StratosphereResult { values: number[]; converged: boolean; }
+
+/** Compute Stratosphere. */
+export function computeStratosphere(data: number[], opts: StratosphereOptions = {}): StratosphereResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStratosphere };
diff --git a/src/meteorology/streaming.ts b/src/meteorology/streaming.ts
new file mode 100644
index 000000000..a6b5bfe0d
--- /dev/null
+++ b/src/meteorology/streaming.ts
@@ -0,0 +1,15 @@
+/** Meteorology Streaming module — tsb analytics library. */
+export interface Meteorology streamingOptions { tol?: number; maxIter?: number; }
+export interface Meteorology streamingResult { values: number[]; converged: boolean; }
+export function computeMeteorology streaming(data: number[], opts: Meteorology streamingOptions = {}): Meteorology streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology streaming };
diff --git a/src/meteorology/synoptic.ts b/src/meteorology/synoptic.ts
new file mode 100644
index 000000000..1df7a0687
--- /dev/null
+++ b/src/meteorology/synoptic.ts
@@ -0,0 +1,22 @@
+/** Synoptic module — tsb analytics library. */
+
+/** Options for Synoptic. */
+export interface SynopticOptions { tol?: number; maxIter?: number; }
+
+/** Result from Synoptic. */
+export interface SynopticResult { values: number[]; converged: boolean; }
+
+/** Compute Synoptic. */
+export function computeSynoptic(data: number[], opts: SynopticOptions = {}): SynopticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSynoptic };
diff --git a/src/meteorology/temperature_met.ts b/src/meteorology/temperature_met.ts
new file mode 100644
index 000000000..b7451f277
--- /dev/null
+++ b/src/meteorology/temperature_met.ts
@@ -0,0 +1,22 @@
+/** Temperature Met module — tsb analytics library. */
+
+/** Options for Temperature Met. */
+export interface TemperatureMetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Temperature Met. */
+export interface TemperatureMetResult { values: number[]; converged: boolean; }
+
+/** Compute Temperature Met. */
+export function computeTemperatureMet(data: number[], opts: TemperatureMetOptions = {}): TemperatureMetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTemperatureMet };
diff --git a/src/meteorology/troposphere.ts b/src/meteorology/troposphere.ts
new file mode 100644
index 000000000..010e660ca
--- /dev/null
+++ b/src/meteorology/troposphere.ts
@@ -0,0 +1,22 @@
+/** Troposphere module — tsb analytics library. */
+
+/** Options for Troposphere. */
+export interface TroposphereOptions { tol?: number; maxIter?: number; }
+
+/** Result from Troposphere. */
+export interface TroposphereResult { values: number[]; converged: boolean; }
+
+/** Compute Troposphere. */
+export function computeTroposphere(data: number[], opts: TroposphereOptions = {}): TroposphereResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTroposphere };
diff --git a/src/meteorology/v2.ts b/src/meteorology/v2.ts
new file mode 100644
index 000000000..0b850e596
--- /dev/null
+++ b/src/meteorology/v2.ts
@@ -0,0 +1,15 @@
+/** Meteorology V2 module — tsb analytics library. */
+export interface Meteorology v2Options { tol?: number; maxIter?: number; }
+export interface Meteorology v2Result { values: number[]; converged: boolean; }
+export function computeMeteorology v2(data: number[], opts: Meteorology v2Options = {}): Meteorology v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology v2 };
diff --git a/src/meteorology/v3.ts b/src/meteorology/v3.ts
new file mode 100644
index 000000000..7d00516cf
--- /dev/null
+++ b/src/meteorology/v3.ts
@@ -0,0 +1,15 @@
+/** Meteorology V3 module — tsb analytics library. */
+export interface Meteorology v3Options { tol?: number; maxIter?: number; }
+export interface Meteorology v3Result { values: number[]; converged: boolean; }
+export function computeMeteorology v3(data: number[], opts: Meteorology v3Options = {}): Meteorology v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology v3 };
diff --git a/src/meteorology/vorticity.ts b/src/meteorology/vorticity.ts
new file mode 100644
index 000000000..80f11cdeb
--- /dev/null
+++ b/src/meteorology/vorticity.ts
@@ -0,0 +1,22 @@
+/** Vorticity module — tsb analytics library. */
+
+/** Options for Vorticity. */
+export interface VorticityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vorticity. */
+export interface VorticityResult { values: number[]; converged: boolean; }
+
+/** Compute Vorticity. */
+export function computeVorticity(data: number[], opts: VorticityOptions = {}): VorticityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVorticity };
diff --git a/src/meteorology/wasm.ts b/src/meteorology/wasm.ts
new file mode 100644
index 000000000..85c1cb372
--- /dev/null
+++ b/src/meteorology/wasm.ts
@@ -0,0 +1,15 @@
+/** Meteorology Wasm module — tsb analytics library. */
+export interface Meteorology wasmOptions { tol?: number; maxIter?: number; }
+export interface Meteorology wasmResult { values: number[]; converged: boolean; }
+export function computeMeteorology wasm(data: number[], opts: Meteorology wasmOptions = {}): Meteorology wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology wasm };
diff --git a/src/meteorology/wind_met.ts b/src/meteorology/wind_met.ts
new file mode 100644
index 000000000..12f56cb18
--- /dev/null
+++ b/src/meteorology/wind_met.ts
@@ -0,0 +1,22 @@
+/** Wind Met module — tsb analytics library. */
+
+/** Options for Wind Met. */
+export interface WindMetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Wind Met. */
+export interface WindMetResult { values: number[]; converged: boolean; }
+
+/** Compute Wind Met. */
+export function computeWindMet(data: number[], opts: WindMetOptions = {}): WindMetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWindMet };
diff --git a/src/meteorology/xlarge.ts b/src/meteorology/xlarge.ts
new file mode 100644
index 000000000..ebb0a7828
--- /dev/null
+++ b/src/meteorology/xlarge.ts
@@ -0,0 +1,15 @@
+/** Meteorology Xlarge module — tsb analytics library. */
+export interface Meteorology xlargeOptions { tol?: number; maxIter?: number; }
+export interface Meteorology xlargeResult { values: number[]; converged: boolean; }
+export function computeMeteorology xlarge(data: number[], opts: Meteorology xlargeOptions = {}): Meteorology xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMeteorology xlarge };
diff --git a/src/mineralogy/adaptation.ts b/src/mineralogy/adaptation.ts
new file mode 100644
index 000000000..0151d9621
--- /dev/null
+++ b/src/mineralogy/adaptation.ts
@@ -0,0 +1,14 @@
+/** mineralogy adaptation module — tsb analytics library. */
+export interface MineralogyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyAdaptationResult { values: number[]; converged: boolean; }
+export function computeMineralogyAdaptation(data: number[], opts: MineralogyAdaptationOptions = {}): MineralogyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyAdaptation };
diff --git a/src/mineralogy/aggregation.ts b/src/mineralogy/aggregation.ts
new file mode 100644
index 000000000..057ec8fdb
--- /dev/null
+++ b/src/mineralogy/aggregation.ts
@@ -0,0 +1,14 @@
+/** mineralogy aggregation module — tsb analytics library. */
+export interface MineralogyAggregationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyAggregationResult { values: number[]; converged: boolean; }
+export function computeMineralogyAggregation(data: number[], opts: MineralogyAggregationOptions = {}): MineralogyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyAggregation };
diff --git a/src/mineralogy/algebra.ts b/src/mineralogy/algebra.ts
new file mode 100644
index 000000000..68cc5a65e
--- /dev/null
+++ b/src/mineralogy/algebra.ts
@@ -0,0 +1,14 @@
+/** mineralogy algebra module — tsb analytics library. */
+export interface MineralogyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface MineralogyAlgebraResult { values: number[]; converged: boolean; }
+export function computeMineralogyAlgebra(data: number[], opts: MineralogyAlgebraOptions = {}): MineralogyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyAlgebra };
diff --git a/src/mineralogy/alignment.ts b/src/mineralogy/alignment.ts
new file mode 100644
index 000000000..57995ce6e
--- /dev/null
+++ b/src/mineralogy/alignment.ts
@@ -0,0 +1,14 @@
+/** mineralogy alignment module — tsb analytics library. */
+export interface MineralogyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface MineralogyAlignmentResult { values: number[]; converged: boolean; }
+export function computeMineralogyAlignment(data: number[], opts: MineralogyAlignmentOptions = {}): MineralogyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyAlignment };
diff --git a/src/mineralogy/analysis.ts b/src/mineralogy/analysis.ts
new file mode 100644
index 000000000..2df69535a
--- /dev/null
+++ b/src/mineralogy/analysis.ts
@@ -0,0 +1,14 @@
+/** mineralogy analysis module — tsb analytics library. */
+export interface MineralogyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface MineralogyAnalysisResult { values: number[]; converged: boolean; }
+export function computeMineralogyAnalysis(data: number[], opts: MineralogyAnalysisOptions = {}): MineralogyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyAnalysis };
diff --git a/src/mineralogy/augmentation.ts b/src/mineralogy/augmentation.ts
new file mode 100644
index 000000000..041d4fe2f
--- /dev/null
+++ b/src/mineralogy/augmentation.ts
@@ -0,0 +1,14 @@
+/** mineralogy augmentation module — tsb analytics library. */
+export interface MineralogyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyAugmentationResult { values: number[]; converged: boolean; }
+export function computeMineralogyAugmentation(data: number[], opts: MineralogyAugmentationOptions = {}): MineralogyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyAugmentation };
diff --git a/src/mineralogy/bagging.ts b/src/mineralogy/bagging.ts
new file mode 100644
index 000000000..c6e0a272a
--- /dev/null
+++ b/src/mineralogy/bagging.ts
@@ -0,0 +1,14 @@
+/** mineralogy bagging module — tsb analytics library. */
+export interface MineralogyBaggingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyBaggingResult { values: number[]; converged: boolean; }
+export function computeMineralogyBagging(data: number[], opts: MineralogyBaggingOptions = {}): MineralogyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyBagging };
diff --git a/src/mineralogy/basis.ts b/src/mineralogy/basis.ts
new file mode 100644
index 000000000..67bd8b959
--- /dev/null
+++ b/src/mineralogy/basis.ts
@@ -0,0 +1,14 @@
+/** mineralogy basis module — tsb analytics library. */
+export interface MineralogyBasisOptions { tol?: number; maxIter?: number; }
+export interface MineralogyBasisResult { values: number[]; converged: boolean; }
+export function computeMineralogyBasis(data: number[], opts: MineralogyBasisOptions = {}): MineralogyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyBasis };
diff --git a/src/mineralogy/benchmarking.ts b/src/mineralogy/benchmarking.ts
new file mode 100644
index 000000000..8fb69822a
--- /dev/null
+++ b/src/mineralogy/benchmarking.ts
@@ -0,0 +1,14 @@
+/** mineralogy benchmarking module — tsb analytics library. */
+export interface MineralogyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeMineralogyBenchmarking(data: number[], opts: MineralogyBenchmarkingOptions = {}): MineralogyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyBenchmarking };
diff --git a/src/mineralogy/blending.ts b/src/mineralogy/blending.ts
new file mode 100644
index 000000000..ae220adec
--- /dev/null
+++ b/src/mineralogy/blending.ts
@@ -0,0 +1,14 @@
+/** mineralogy blending module — tsb analytics library. */
+export interface MineralogyBlendingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyBlendingResult { values: number[]; converged: boolean; }
+export function computeMineralogyBlending(data: number[], opts: MineralogyBlendingOptions = {}): MineralogyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyBlending };
diff --git a/src/mineralogy/boosting.ts b/src/mineralogy/boosting.ts
new file mode 100644
index 000000000..898adfe2c
--- /dev/null
+++ b/src/mineralogy/boosting.ts
@@ -0,0 +1,14 @@
+/** mineralogy boosting module — tsb analytics library. */
+export interface MineralogyBoostingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyBoostingResult { values: number[]; converged: boolean; }
+export function computeMineralogyBoosting(data: number[], opts: MineralogyBoostingOptions = {}): MineralogyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyBoosting };
diff --git a/src/mineralogy/bootstrap.ts b/src/mineralogy/bootstrap.ts
new file mode 100644
index 000000000..cead14308
--- /dev/null
+++ b/src/mineralogy/bootstrap.ts
@@ -0,0 +1,14 @@
+/** mineralogy bootstrap module — tsb analytics library. */
+export interface MineralogyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface MineralogyBootstrapResult { values: number[]; converged: boolean; }
+export function computeMineralogyBootstrap(data: number[], opts: MineralogyBootstrapOptions = {}): MineralogyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyBootstrap };
diff --git a/src/mineralogy/calculus.ts b/src/mineralogy/calculus.ts
new file mode 100644
index 000000000..7f3a81515
--- /dev/null
+++ b/src/mineralogy/calculus.ts
@@ -0,0 +1,14 @@
+/** mineralogy calculus module — tsb analytics library. */
+export interface MineralogyCalculusOptions { tol?: number; maxIter?: number; }
+export interface MineralogyCalculusResult { values: number[]; converged: boolean; }
+export function computeMineralogyCalculus(data: number[], opts: MineralogyCalculusOptions = {}): MineralogyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyCalculus };
diff --git a/src/mineralogy/calibration.ts b/src/mineralogy/calibration.ts
new file mode 100644
index 000000000..69834620a
--- /dev/null
+++ b/src/mineralogy/calibration.ts
@@ -0,0 +1,14 @@
+/** mineralogy calibration module — tsb analytics library. */
+export interface MineralogyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyCalibrationResult { values: number[]; converged: boolean; }
+export function computeMineralogyCalibration(data: number[], opts: MineralogyCalibrationOptions = {}): MineralogyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyCalibration };
diff --git a/src/mineralogy/characterization.ts b/src/mineralogy/characterization.ts
new file mode 100644
index 000000000..96b242233
--- /dev/null
+++ b/src/mineralogy/characterization.ts
@@ -0,0 +1,14 @@
+/** mineralogy characterization module — tsb analytics library. */
+export interface MineralogyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeMineralogyCharacterization(data: number[], opts: MineralogyCharacterizationOptions = {}): MineralogyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyCharacterization };
diff --git a/src/mineralogy/classification.ts b/src/mineralogy/classification.ts
new file mode 100644
index 000000000..1d917e36c
--- /dev/null
+++ b/src/mineralogy/classification.ts
@@ -0,0 +1,14 @@
+/** mineralogy classification module — tsb analytics library. */
+export interface MineralogyClassificationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyClassificationResult { values: number[]; converged: boolean; }
+export function computeMineralogyClassification(data: number[], opts: MineralogyClassificationOptions = {}): MineralogyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyClassification };
diff --git a/src/mineralogy/clustering.ts b/src/mineralogy/clustering.ts
new file mode 100644
index 000000000..d9b7de6db
--- /dev/null
+++ b/src/mineralogy/clustering.ts
@@ -0,0 +1,14 @@
+/** mineralogy clustering module — tsb analytics library. */
+export interface MineralogyClusteringOptions { tol?: number; maxIter?: number; }
+export interface MineralogyClusteringResult { values: number[]; converged: boolean; }
+export function computeMineralogyClustering(data: number[], opts: MineralogyClusteringOptions = {}): MineralogyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyClustering };
diff --git a/src/mineralogy/compression.ts b/src/mineralogy/compression.ts
new file mode 100644
index 000000000..22e4d2800
--- /dev/null
+++ b/src/mineralogy/compression.ts
@@ -0,0 +1,14 @@
+/** mineralogy compression module — tsb analytics library. */
+export interface MineralogyCompressionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyCompressionResult { values: number[]; converged: boolean; }
+export function computeMineralogyCompression(data: number[], opts: MineralogyCompressionOptions = {}): MineralogyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyCompression };
diff --git a/src/mineralogy/continuous.ts b/src/mineralogy/continuous.ts
new file mode 100644
index 000000000..e615285bf
--- /dev/null
+++ b/src/mineralogy/continuous.ts
@@ -0,0 +1,14 @@
+/** mineralogy continuous module — tsb analytics library. */
+export interface MineralogyContinuousOptions { tol?: number; maxIter?: number; }
+export interface MineralogyContinuousResult { values: number[]; converged: boolean; }
+export function computeMineralogyContinuous(data: number[], opts: MineralogyContinuousOptions = {}): MineralogyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyContinuous };
diff --git a/src/mineralogy/control.ts b/src/mineralogy/control.ts
new file mode 100644
index 000000000..d0a0488dc
--- /dev/null
+++ b/src/mineralogy/control.ts
@@ -0,0 +1,14 @@
+/** mineralogy control module — tsb analytics library. */
+export interface MineralogyControlOptions { tol?: number; maxIter?: number; }
+export interface MineralogyControlResult { values: number[]; converged: boolean; }
+export function computeMineralogyControl(data: number[], opts: MineralogyControlOptions = {}): MineralogyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyControl };
diff --git a/src/mineralogy/convergence.ts b/src/mineralogy/convergence.ts
new file mode 100644
index 000000000..ccae9d76c
--- /dev/null
+++ b/src/mineralogy/convergence.ts
@@ -0,0 +1,14 @@
+/** mineralogy convergence module — tsb analytics library. */
+export interface MineralogyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface MineralogyConvergenceResult { values: number[]; converged: boolean; }
+export function computeMineralogyConvergence(data: number[], opts: MineralogyConvergenceOptions = {}): MineralogyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyConvergence };
diff --git a/src/mineralogy/convex.ts b/src/mineralogy/convex.ts
new file mode 100644
index 000000000..18af8fb32
--- /dev/null
+++ b/src/mineralogy/convex.ts
@@ -0,0 +1,14 @@
+/** mineralogy convex module — tsb analytics library. */
+export interface MineralogyConvexOptions { tol?: number; maxIter?: number; }
+export interface MineralogyConvexResult { values: number[]; converged: boolean; }
+export function computeMineralogyConvex(data: number[], opts: MineralogyConvexOptions = {}): MineralogyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyConvex };
diff --git a/src/mineralogy/correlation.ts b/src/mineralogy/correlation.ts
new file mode 100644
index 000000000..36992eff6
--- /dev/null
+++ b/src/mineralogy/correlation.ts
@@ -0,0 +1,14 @@
+/** mineralogy correlation module — tsb analytics library. */
+export interface MineralogyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyCorrelationResult { values: number[]; converged: boolean; }
+export function computeMineralogyCorrelation(data: number[], opts: MineralogyCorrelationOptions = {}): MineralogyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyCorrelation };
diff --git a/src/mineralogy/covariance.ts b/src/mineralogy/covariance.ts
new file mode 100644
index 000000000..4128cdd0e
--- /dev/null
+++ b/src/mineralogy/covariance.ts
@@ -0,0 +1,14 @@
+/** mineralogy covariance module — tsb analytics library. */
+export interface MineralogyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface MineralogyCovarianceResult { values: number[]; converged: boolean; }
+export function computeMineralogyCovariance(data: number[], opts: MineralogyCovarianceOptions = {}): MineralogyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyCovariance };
diff --git a/src/mineralogy/cross_validation.ts b/src/mineralogy/cross_validation.ts
new file mode 100644
index 000000000..8764010da
--- /dev/null
+++ b/src/mineralogy/cross_validation.ts
@@ -0,0 +1,14 @@
+/** mineralogy cross_validation module — tsb analytics library. */
+export interface MineralogyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeMineralogyCrossValidation(data: number[], opts: MineralogyCrossValidationOptions = {}): MineralogyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyCrossValidation };
diff --git a/src/mineralogy/decoding.ts b/src/mineralogy/decoding.ts
new file mode 100644
index 000000000..84a1ba298
--- /dev/null
+++ b/src/mineralogy/decoding.ts
@@ -0,0 +1,14 @@
+/** mineralogy decoding module — tsb analytics library. */
+export interface MineralogyDecodingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDecodingResult { values: number[]; converged: boolean; }
+export function computeMineralogyDecoding(data: number[], opts: MineralogyDecodingOptions = {}): MineralogyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDecoding };
diff --git a/src/mineralogy/decomposition.ts b/src/mineralogy/decomposition.ts
new file mode 100644
index 000000000..32b2c5e4b
--- /dev/null
+++ b/src/mineralogy/decomposition.ts
@@ -0,0 +1,14 @@
+/** mineralogy decomposition module — tsb analytics library. */
+export interface MineralogyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDecompositionResult { values: number[]; converged: boolean; }
+export function computeMineralogyDecomposition(data: number[], opts: MineralogyDecompositionOptions = {}): MineralogyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDecomposition };
diff --git a/src/mineralogy/detection.ts b/src/mineralogy/detection.ts
new file mode 100644
index 000000000..f8cdf23ea
--- /dev/null
+++ b/src/mineralogy/detection.ts
@@ -0,0 +1,14 @@
+/** mineralogy detection module — tsb analytics library. */
+export interface MineralogyDetectionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDetectionResult { values: number[]; converged: boolean; }
+export function computeMineralogyDetection(data: number[], opts: MineralogyDetectionOptions = {}): MineralogyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDetection };
diff --git a/src/mineralogy/deterministic.ts b/src/mineralogy/deterministic.ts
new file mode 100644
index 000000000..c2c7e4172
--- /dev/null
+++ b/src/mineralogy/deterministic.ts
@@ -0,0 +1,14 @@
+/** mineralogy deterministic module — tsb analytics library. */
+export interface MineralogyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDeterministicResult { values: number[]; converged: boolean; }
+export function computeMineralogyDeterministic(data: number[], opts: MineralogyDeterministicOptions = {}): MineralogyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDeterministic };
diff --git a/src/mineralogy/diagnostics.ts b/src/mineralogy/diagnostics.ts
new file mode 100644
index 000000000..c020003f0
--- /dev/null
+++ b/src/mineralogy/diagnostics.ts
@@ -0,0 +1,14 @@
+/** mineralogy diagnostics module — tsb analytics library. */
+export interface MineralogyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeMineralogyDiagnostics(data: number[], opts: MineralogyDiagnosticsOptions = {}): MineralogyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDiagnostics };
diff --git a/src/mineralogy/differential.ts b/src/mineralogy/differential.ts
new file mode 100644
index 000000000..b80120efe
--- /dev/null
+++ b/src/mineralogy/differential.ts
@@ -0,0 +1,14 @@
+/** mineralogy differential module — tsb analytics library. */
+export interface MineralogyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDifferentialResult { values: number[]; converged: boolean; }
+export function computeMineralogyDifferential(data: number[], opts: MineralogyDifferentialOptions = {}): MineralogyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDifferential };
diff --git a/src/mineralogy/discrete.ts b/src/mineralogy/discrete.ts
new file mode 100644
index 000000000..5f08e1fd8
--- /dev/null
+++ b/src/mineralogy/discrete.ts
@@ -0,0 +1,14 @@
+/** mineralogy discrete module — tsb analytics library. */
+export interface MineralogyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDiscreteResult { values: number[]; converged: boolean; }
+export function computeMineralogyDiscrete(data: number[], opts: MineralogyDiscreteOptions = {}): MineralogyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDiscrete };
diff --git a/src/mineralogy/distribution.ts b/src/mineralogy/distribution.ts
new file mode 100644
index 000000000..e6af60729
--- /dev/null
+++ b/src/mineralogy/distribution.ts
@@ -0,0 +1,14 @@
+/** mineralogy distribution module — tsb analytics library. */
+export interface MineralogyDistributionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDistributionResult { values: number[]; converged: boolean; }
+export function computeMineralogyDistribution(data: number[], opts: MineralogyDistributionOptions = {}): MineralogyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDistribution };
diff --git a/src/mineralogy/dynamic.ts b/src/mineralogy/dynamic.ts
new file mode 100644
index 000000000..f82dd2fed
--- /dev/null
+++ b/src/mineralogy/dynamic.ts
@@ -0,0 +1,14 @@
+/** mineralogy dynamic module — tsb analytics library. */
+export interface MineralogyDynamicOptions { tol?: number; maxIter?: number; }
+export interface MineralogyDynamicResult { values: number[]; converged: boolean; }
+export function computeMineralogyDynamic(data: number[], opts: MineralogyDynamicOptions = {}): MineralogyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyDynamic };
diff --git a/src/mineralogy/embedding.ts b/src/mineralogy/embedding.ts
new file mode 100644
index 000000000..301efd83a
--- /dev/null
+++ b/src/mineralogy/embedding.ts
@@ -0,0 +1,14 @@
+/** mineralogy embedding module — tsb analytics library. */
+export interface MineralogyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeMineralogyEmbedding(data: number[], opts: MineralogyEmbeddingOptions = {}): MineralogyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyEmbedding };
diff --git a/src/mineralogy/encoding.ts b/src/mineralogy/encoding.ts
new file mode 100644
index 000000000..5b48ec9fd
--- /dev/null
+++ b/src/mineralogy/encoding.ts
@@ -0,0 +1,14 @@
+/** mineralogy encoding module — tsb analytics library. */
+export interface MineralogyEncodingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyEncodingResult { values: number[]; converged: boolean; }
+export function computeMineralogyEncoding(data: number[], opts: MineralogyEncodingOptions = {}): MineralogyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyEncoding };
diff --git a/src/mineralogy/ensemble.ts b/src/mineralogy/ensemble.ts
new file mode 100644
index 000000000..2f86663f3
--- /dev/null
+++ b/src/mineralogy/ensemble.ts
@@ -0,0 +1,14 @@
+/** mineralogy ensemble module — tsb analytics library. */
+export interface MineralogyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface MineralogyEnsembleResult { values: number[]; converged: boolean; }
+export function computeMineralogyEnsemble(data: number[], opts: MineralogyEnsembleOptions = {}): MineralogyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyEnsemble };
diff --git a/src/mineralogy/estimation.ts b/src/mineralogy/estimation.ts
new file mode 100644
index 000000000..bbaafe4a5
--- /dev/null
+++ b/src/mineralogy/estimation.ts
@@ -0,0 +1,14 @@
+/** mineralogy estimation module — tsb analytics library. */
+export interface MineralogyEstimationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyEstimationResult { values: number[]; converged: boolean; }
+export function computeMineralogyEstimation(data: number[], opts: MineralogyEstimationOptions = {}): MineralogyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyEstimation };
diff --git a/src/mineralogy/evaluation.ts b/src/mineralogy/evaluation.ts
new file mode 100644
index 000000000..a246a1666
--- /dev/null
+++ b/src/mineralogy/evaluation.ts
@@ -0,0 +1,14 @@
+/** mineralogy evaluation module — tsb analytics library. */
+export interface MineralogyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyEvaluationResult { values: number[]; converged: boolean; }
+export function computeMineralogyEvaluation(data: number[], opts: MineralogyEvaluationOptions = {}): MineralogyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyEvaluation };
diff --git a/src/mineralogy/extrapolation.ts b/src/mineralogy/extrapolation.ts
new file mode 100644
index 000000000..f7fefa3eb
--- /dev/null
+++ b/src/mineralogy/extrapolation.ts
@@ -0,0 +1,14 @@
+/** mineralogy extrapolation module — tsb analytics library. */
+export interface MineralogyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeMineralogyExtrapolation(data: number[], opts: MineralogyExtrapolationOptions = {}): MineralogyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyExtrapolation };
diff --git a/src/mineralogy/features.ts b/src/mineralogy/features.ts
new file mode 100644
index 000000000..8894c7a8b
--- /dev/null
+++ b/src/mineralogy/features.ts
@@ -0,0 +1,14 @@
+/** mineralogy features module — tsb analytics library. */
+export interface MineralogyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface MineralogyFeaturesResult { values: number[]; converged: boolean; }
+export function computeMineralogyFeatures(data: number[], opts: MineralogyFeaturesOptions = {}): MineralogyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyFeatures };
diff --git a/src/mineralogy/feedback.ts b/src/mineralogy/feedback.ts
new file mode 100644
index 000000000..6a8df35a2
--- /dev/null
+++ b/src/mineralogy/feedback.ts
@@ -0,0 +1,14 @@
+/** mineralogy feedback module — tsb analytics library. */
+export interface MineralogyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface MineralogyFeedbackResult { values: number[]; converged: boolean; }
+export function computeMineralogyFeedback(data: number[], opts: MineralogyFeedbackOptions = {}): MineralogyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyFeedback };
diff --git a/src/mineralogy/filtering.ts b/src/mineralogy/filtering.ts
new file mode 100644
index 000000000..bec9e94f2
--- /dev/null
+++ b/src/mineralogy/filtering.ts
@@ -0,0 +1,14 @@
+/** mineralogy filtering module — tsb analytics library. */
+export interface MineralogyFilteringOptions { tol?: number; maxIter?: number; }
+export interface MineralogyFilteringResult { values: number[]; converged: boolean; }
+export function computeMineralogyFiltering(data: number[], opts: MineralogyFilteringOptions = {}): MineralogyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyFiltering };
diff --git a/src/mineralogy/fourier.ts b/src/mineralogy/fourier.ts
new file mode 100644
index 000000000..a8a951f05
--- /dev/null
+++ b/src/mineralogy/fourier.ts
@@ -0,0 +1,14 @@
+/** mineralogy fourier module — tsb analytics library. */
+export interface MineralogyFourierOptions { tol?: number; maxIter?: number; }
+export interface MineralogyFourierResult { values: number[]; converged: boolean; }
+export function computeMineralogyFourier(data: number[], opts: MineralogyFourierOptions = {}): MineralogyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyFourier };
diff --git a/src/mineralogy/fusion.ts b/src/mineralogy/fusion.ts
new file mode 100644
index 000000000..c0fa18d9b
--- /dev/null
+++ b/src/mineralogy/fusion.ts
@@ -0,0 +1,14 @@
+/** mineralogy fusion module — tsb analytics library. */
+export interface MineralogyFusionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyFusionResult { values: number[]; converged: boolean; }
+export function computeMineralogyFusion(data: number[], opts: MineralogyFusionOptions = {}): MineralogyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyFusion };
diff --git a/src/mineralogy/generation.ts b/src/mineralogy/generation.ts
new file mode 100644
index 000000000..f9488ff09
--- /dev/null
+++ b/src/mineralogy/generation.ts
@@ -0,0 +1,14 @@
+/** mineralogy generation module — tsb analytics library. */
+export interface MineralogyGenerationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyGenerationResult { values: number[]; converged: boolean; }
+export function computeMineralogyGeneration(data: number[], opts: MineralogyGenerationOptions = {}): MineralogyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyGeneration };
diff --git a/src/mineralogy/geometry.ts b/src/mineralogy/geometry.ts
new file mode 100644
index 000000000..c0aecc18d
--- /dev/null
+++ b/src/mineralogy/geometry.ts
@@ -0,0 +1,14 @@
+/** mineralogy geometry module — tsb analytics library. */
+export interface MineralogyGeometryOptions { tol?: number; maxIter?: number; }
+export interface MineralogyGeometryResult { values: number[]; converged: boolean; }
+export function computeMineralogyGeometry(data: number[], opts: MineralogyGeometryOptions = {}): MineralogyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyGeometry };
diff --git a/src/mineralogy/gradient.ts b/src/mineralogy/gradient.ts
new file mode 100644
index 000000000..1cea11d4a
--- /dev/null
+++ b/src/mineralogy/gradient.ts
@@ -0,0 +1,14 @@
+/** mineralogy gradient module — tsb analytics library. */
+export interface MineralogyGradientOptions { tol?: number; maxIter?: number; }
+export interface MineralogyGradientResult { values: number[]; converged: boolean; }
+export function computeMineralogyGradient(data: number[], opts: MineralogyGradientOptions = {}): MineralogyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyGradient };
diff --git a/src/mineralogy/hessian.ts b/src/mineralogy/hessian.ts
new file mode 100644
index 000000000..e29281ff3
--- /dev/null
+++ b/src/mineralogy/hessian.ts
@@ -0,0 +1,14 @@
+/** mineralogy hessian module — tsb analytics library. */
+export interface MineralogyHessianOptions { tol?: number; maxIter?: number; }
+export interface MineralogyHessianResult { values: number[]; converged: boolean; }
+export function computeMineralogyHessian(data: number[], opts: MineralogyHessianOptions = {}): MineralogyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyHessian };
diff --git a/src/mineralogy/hypothesis.ts b/src/mineralogy/hypothesis.ts
new file mode 100644
index 000000000..66008028f
--- /dev/null
+++ b/src/mineralogy/hypothesis.ts
@@ -0,0 +1,14 @@
+/** mineralogy hypothesis module — tsb analytics library. */
+export interface MineralogyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface MineralogyHypothesisResult { values: number[]; converged: boolean; }
+export function computeMineralogyHypothesis(data: number[], opts: MineralogyHypothesisOptions = {}): MineralogyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyHypothesis };
diff --git a/src/mineralogy/inference.ts b/src/mineralogy/inference.ts
new file mode 100644
index 000000000..6fdc075b8
--- /dev/null
+++ b/src/mineralogy/inference.ts
@@ -0,0 +1,14 @@
+/** mineralogy inference module — tsb analytics library. */
+export interface MineralogyInferenceOptions { tol?: number; maxIter?: number; }
+export interface MineralogyInferenceResult { values: number[]; converged: boolean; }
+export function computeMineralogyInference(data: number[], opts: MineralogyInferenceOptions = {}): MineralogyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyInference };
diff --git a/src/mineralogy/inference2.ts b/src/mineralogy/inference2.ts
new file mode 100644
index 000000000..62ab19e4a
--- /dev/null
+++ b/src/mineralogy/inference2.ts
@@ -0,0 +1,14 @@
+/** mineralogy inference2 module — tsb analytics library. */
+export interface MineralogyInferenceOptions { tol?: number; maxIter?: number; }
+export interface MineralogyInferenceResult { values: number[]; converged: boolean; }
+export function computeMineralogyInference(data: number[], opts: MineralogyInferenceOptions = {}): MineralogyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyInference };
diff --git a/src/mineralogy/integral.ts b/src/mineralogy/integral.ts
new file mode 100644
index 000000000..f2ec53299
--- /dev/null
+++ b/src/mineralogy/integral.ts
@@ -0,0 +1,14 @@
+/** mineralogy integral module — tsb analytics library. */
+export interface MineralogyIntegralOptions { tol?: number; maxIter?: number; }
+export interface MineralogyIntegralResult { values: number[]; converged: boolean; }
+export function computeMineralogyIntegral(data: number[], opts: MineralogyIntegralOptions = {}): MineralogyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyIntegral };
diff --git a/src/mineralogy/integration.ts b/src/mineralogy/integration.ts
new file mode 100644
index 000000000..059b44513
--- /dev/null
+++ b/src/mineralogy/integration.ts
@@ -0,0 +1,14 @@
+/** mineralogy integration module — tsb analytics library. */
+export interface MineralogyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyIntegrationResult { values: number[]; converged: boolean; }
+export function computeMineralogyIntegration(data: number[], opts: MineralogyIntegrationOptions = {}): MineralogyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyIntegration };
diff --git a/src/mineralogy/interpolation.ts b/src/mineralogy/interpolation.ts
new file mode 100644
index 000000000..c8d7e0460
--- /dev/null
+++ b/src/mineralogy/interpolation.ts
@@ -0,0 +1,14 @@
+/** mineralogy interpolation module — tsb analytics library. */
+export interface MineralogyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyInterpolationResult { values: number[]; converged: boolean; }
+export function computeMineralogyInterpolation(data: number[], opts: MineralogyInterpolationOptions = {}): MineralogyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyInterpolation };
diff --git a/src/mineralogy/jacobian.ts b/src/mineralogy/jacobian.ts
new file mode 100644
index 000000000..8c7ca6c1a
--- /dev/null
+++ b/src/mineralogy/jacobian.ts
@@ -0,0 +1,14 @@
+/** mineralogy jacobian module — tsb analytics library. */
+export interface MineralogyJacobianOptions { tol?: number; maxIter?: number; }
+export interface MineralogyJacobianResult { values: number[]; converged: boolean; }
+export function computeMineralogyJacobian(data: number[], opts: MineralogyJacobianOptions = {}): MineralogyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyJacobian };
diff --git a/src/mineralogy/kernel.ts b/src/mineralogy/kernel.ts
new file mode 100644
index 000000000..6b031df47
--- /dev/null
+++ b/src/mineralogy/kernel.ts
@@ -0,0 +1,14 @@
+/** mineralogy kernel module — tsb analytics library. */
+export interface MineralogyKernelOptions { tol?: number; maxIter?: number; }
+export interface MineralogyKernelResult { values: number[]; converged: boolean; }
+export function computeMineralogyKernel(data: number[], opts: MineralogyKernelOptions = {}): MineralogyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyKernel };
diff --git a/src/mineralogy/laplacian.ts b/src/mineralogy/laplacian.ts
new file mode 100644
index 000000000..fb5a19155
--- /dev/null
+++ b/src/mineralogy/laplacian.ts
@@ -0,0 +1,14 @@
+/** mineralogy laplacian module — tsb analytics library. */
+export interface MineralogyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface MineralogyLaplacianResult { values: number[]; converged: boolean; }
+export function computeMineralogyLaplacian(data: number[], opts: MineralogyLaplacianOptions = {}): MineralogyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyLaplacian };
diff --git a/src/mineralogy/learning.ts b/src/mineralogy/learning.ts
new file mode 100644
index 000000000..98307a6cc
--- /dev/null
+++ b/src/mineralogy/learning.ts
@@ -0,0 +1,14 @@
+/** mineralogy learning module — tsb analytics library. */
+export interface MineralogyLearningOptions { tol?: number; maxIter?: number; }
+export interface MineralogyLearningResult { values: number[]; converged: boolean; }
+export function computeMineralogyLearning(data: number[], opts: MineralogyLearningOptions = {}): MineralogyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyLearning };
diff --git a/src/mineralogy/linear.ts b/src/mineralogy/linear.ts
new file mode 100644
index 000000000..818e2d56c
--- /dev/null
+++ b/src/mineralogy/linear.ts
@@ -0,0 +1,14 @@
+/** mineralogy linear module — tsb analytics library. */
+export interface MineralogyLinearOptions { tol?: number; maxIter?: number; }
+export interface MineralogyLinearResult { values: number[]; converged: boolean; }
+export function computeMineralogyLinear(data: number[], opts: MineralogyLinearOptions = {}): MineralogyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyLinear };
diff --git a/src/mineralogy/manifold.ts b/src/mineralogy/manifold.ts
new file mode 100644
index 000000000..b630cec49
--- /dev/null
+++ b/src/mineralogy/manifold.ts
@@ -0,0 +1,14 @@
+/** mineralogy manifold module — tsb analytics library. */
+export interface MineralogyManifoldOptions { tol?: number; maxIter?: number; }
+export interface MineralogyManifoldResult { values: number[]; converged: boolean; }
+export function computeMineralogyManifold(data: number[], opts: MineralogyManifoldOptions = {}): MineralogyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyManifold };
diff --git a/src/mineralogy/matching.ts b/src/mineralogy/matching.ts
new file mode 100644
index 000000000..12821a41e
--- /dev/null
+++ b/src/mineralogy/matching.ts
@@ -0,0 +1,14 @@
+/** mineralogy matching module — tsb analytics library. */
+export interface MineralogyMatchingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyMatchingResult { values: number[]; converged: boolean; }
+export function computeMineralogyMatching(data: number[], opts: MineralogyMatchingOptions = {}): MineralogyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyMatching };
diff --git a/src/mineralogy/measurement.ts b/src/mineralogy/measurement.ts
new file mode 100644
index 000000000..151e9436d
--- /dev/null
+++ b/src/mineralogy/measurement.ts
@@ -0,0 +1,14 @@
+/** mineralogy measurement module — tsb analytics library. */
+export interface MineralogyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface MineralogyMeasurementResult { values: number[]; converged: boolean; }
+export function computeMineralogyMeasurement(data: number[], opts: MineralogyMeasurementOptions = {}): MineralogyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyMeasurement };
diff --git a/src/mineralogy/metrics.ts b/src/mineralogy/metrics.ts
new file mode 100644
index 000000000..d69c69400
--- /dev/null
+++ b/src/mineralogy/metrics.ts
@@ -0,0 +1,14 @@
+/** mineralogy metrics module — tsb analytics library. */
+export interface MineralogyMetricsOptions { tol?: number; maxIter?: number; }
+export interface MineralogyMetricsResult { values: number[]; converged: boolean; }
+export function computeMineralogyMetrics(data: number[], opts: MineralogyMetricsOptions = {}): MineralogyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyMetrics };
diff --git a/src/mineralogy/modeling.ts b/src/mineralogy/modeling.ts
new file mode 100644
index 000000000..ec662926d
--- /dev/null
+++ b/src/mineralogy/modeling.ts
@@ -0,0 +1,14 @@
+/** mineralogy modeling module — tsb analytics library. */
+export interface MineralogyModelingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyModelingResult { values: number[]; converged: boolean; }
+export function computeMineralogyModeling(data: number[], opts: MineralogyModelingOptions = {}): MineralogyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyModeling };
diff --git a/src/mineralogy/monitoring.ts b/src/mineralogy/monitoring.ts
new file mode 100644
index 000000000..cc3c20a51
--- /dev/null
+++ b/src/mineralogy/monitoring.ts
@@ -0,0 +1,14 @@
+/** mineralogy monitoring module — tsb analytics library. */
+export interface MineralogyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface MineralogyMonitoringResult { values: number[]; converged: boolean; }
+export function computeMineralogyMonitoring(data: number[], opts: MineralogyMonitoringOptions = {}): MineralogyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyMonitoring };
diff --git a/src/mineralogy/nonlinear.ts b/src/mineralogy/nonlinear.ts
new file mode 100644
index 000000000..29220f019
--- /dev/null
+++ b/src/mineralogy/nonlinear.ts
@@ -0,0 +1,14 @@
+/** mineralogy nonlinear module — tsb analytics library. */
+export interface MineralogyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface MineralogyNonlinearResult { values: number[]; converged: boolean; }
+export function computeMineralogyNonlinear(data: number[], opts: MineralogyNonlinearOptions = {}): MineralogyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyNonlinear };
diff --git a/src/mineralogy/normalization.ts b/src/mineralogy/normalization.ts
new file mode 100644
index 000000000..87ad54926
--- /dev/null
+++ b/src/mineralogy/normalization.ts
@@ -0,0 +1,14 @@
+/** mineralogy normalization module — tsb analytics library. */
+export interface MineralogyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyNormalizationResult { values: number[]; converged: boolean; }
+export function computeMineralogyNormalization(data: number[], opts: MineralogyNormalizationOptions = {}): MineralogyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyNormalization };
diff --git a/src/mineralogy/optimization.ts b/src/mineralogy/optimization.ts
new file mode 100644
index 000000000..02723eae2
--- /dev/null
+++ b/src/mineralogy/optimization.ts
@@ -0,0 +1,14 @@
+/** mineralogy optimization module — tsb analytics library. */
+export interface MineralogyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyOptimizationResult { values: number[]; converged: boolean; }
+export function computeMineralogyOptimization(data: number[], opts: MineralogyOptimizationOptions = {}): MineralogyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyOptimization };
diff --git a/src/mineralogy/patterns.ts b/src/mineralogy/patterns.ts
new file mode 100644
index 000000000..157279808
--- /dev/null
+++ b/src/mineralogy/patterns.ts
@@ -0,0 +1,14 @@
+/** mineralogy patterns module — tsb analytics library. */
+export interface MineralogyPatternsOptions { tol?: number; maxIter?: number; }
+export interface MineralogyPatternsResult { values: number[]; converged: boolean; }
+export function computeMineralogyPatterns(data: number[], opts: MineralogyPatternsOptions = {}): MineralogyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyPatterns };
diff --git a/src/mineralogy/permutation.ts b/src/mineralogy/permutation.ts
new file mode 100644
index 000000000..e80d6ac02
--- /dev/null
+++ b/src/mineralogy/permutation.ts
@@ -0,0 +1,14 @@
+/** mineralogy permutation module — tsb analytics library. */
+export interface MineralogyPermutationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyPermutationResult { values: number[]; converged: boolean; }
+export function computeMineralogyPermutation(data: number[], opts: MineralogyPermutationOptions = {}): MineralogyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyPermutation };
diff --git a/src/mineralogy/prediction.ts b/src/mineralogy/prediction.ts
new file mode 100644
index 000000000..0d85bf34a
--- /dev/null
+++ b/src/mineralogy/prediction.ts
@@ -0,0 +1,14 @@
+/** mineralogy prediction module — tsb analytics library. */
+export interface MineralogyPredictionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyPredictionResult { values: number[]; converged: boolean; }
+export function computeMineralogyPrediction(data: number[], opts: MineralogyPredictionOptions = {}): MineralogyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyPrediction };
diff --git a/src/mineralogy/processing.ts b/src/mineralogy/processing.ts
new file mode 100644
index 000000000..00606e1c0
--- /dev/null
+++ b/src/mineralogy/processing.ts
@@ -0,0 +1,14 @@
+/** mineralogy processing module — tsb analytics library. */
+export interface MineralogyProcessingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyProcessingResult { values: number[]; converged: boolean; }
+export function computeMineralogyProcessing(data: number[], opts: MineralogyProcessingOptions = {}): MineralogyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyProcessing };
diff --git a/src/mineralogy/profiling.ts b/src/mineralogy/profiling.ts
new file mode 100644
index 000000000..33efe41c1
--- /dev/null
+++ b/src/mineralogy/profiling.ts
@@ -0,0 +1,14 @@
+/** mineralogy profiling module — tsb analytics library. */
+export interface MineralogyProfilingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyProfilingResult { values: number[]; converged: boolean; }
+export function computeMineralogyProfiling(data: number[], opts: MineralogyProfilingOptions = {}): MineralogyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyProfiling };
diff --git a/src/mineralogy/projection.ts b/src/mineralogy/projection.ts
new file mode 100644
index 000000000..cf8ddf447
--- /dev/null
+++ b/src/mineralogy/projection.ts
@@ -0,0 +1,14 @@
+/** mineralogy projection module — tsb analytics library. */
+export interface MineralogyProjectionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyProjectionResult { values: number[]; converged: boolean; }
+export function computeMineralogyProjection(data: number[], opts: MineralogyProjectionOptions = {}): MineralogyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyProjection };
diff --git a/src/mineralogy/ranking.ts b/src/mineralogy/ranking.ts
new file mode 100644
index 000000000..ba66eea57
--- /dev/null
+++ b/src/mineralogy/ranking.ts
@@ -0,0 +1,14 @@
+/** mineralogy ranking module — tsb analytics library. */
+export interface MineralogyRankingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyRankingResult { values: number[]; converged: boolean; }
+export function computeMineralogyRanking(data: number[], opts: MineralogyRankingOptions = {}): MineralogyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyRanking };
diff --git a/src/mineralogy/reconstruction.ts b/src/mineralogy/reconstruction.ts
new file mode 100644
index 000000000..6925a74aa
--- /dev/null
+++ b/src/mineralogy/reconstruction.ts
@@ -0,0 +1,14 @@
+/** mineralogy reconstruction module — tsb analytics library. */
+export interface MineralogyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyReconstructionResult { values: number[]; converged: boolean; }
+export function computeMineralogyReconstruction(data: number[], opts: MineralogyReconstructionOptions = {}): MineralogyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyReconstruction };
diff --git a/src/mineralogy/registration.ts b/src/mineralogy/registration.ts
new file mode 100644
index 000000000..9dc55b3c7
--- /dev/null
+++ b/src/mineralogy/registration.ts
@@ -0,0 +1,14 @@
+/** mineralogy registration module — tsb analytics library. */
+export interface MineralogyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyRegistrationResult { values: number[]; converged: boolean; }
+export function computeMineralogyRegistration(data: number[], opts: MineralogyRegistrationOptions = {}): MineralogyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyRegistration };
diff --git a/src/mineralogy/regression.ts b/src/mineralogy/regression.ts
new file mode 100644
index 000000000..b9fb76ac0
--- /dev/null
+++ b/src/mineralogy/regression.ts
@@ -0,0 +1,14 @@
+/** mineralogy regression module — tsb analytics library. */
+export interface MineralogyRegressionOptions { tol?: number; maxIter?: number; }
+export interface MineralogyRegressionResult { values: number[]; converged: boolean; }
+export function computeMineralogyRegression(data: number[], opts: MineralogyRegressionOptions = {}): MineralogyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyRegression };
diff --git a/src/mineralogy/regularization.ts b/src/mineralogy/regularization.ts
new file mode 100644
index 000000000..37f85fb7f
--- /dev/null
+++ b/src/mineralogy/regularization.ts
@@ -0,0 +1,14 @@
+/** mineralogy regularization module — tsb analytics library. */
+export interface MineralogyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyRegularizationResult { values: number[]; converged: boolean; }
+export function computeMineralogyRegularization(data: number[], opts: MineralogyRegularizationOptions = {}): MineralogyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyRegularization };
diff --git a/src/mineralogy/robustness.ts b/src/mineralogy/robustness.ts
new file mode 100644
index 000000000..dda75843c
--- /dev/null
+++ b/src/mineralogy/robustness.ts
@@ -0,0 +1,14 @@
+/** mineralogy robustness module — tsb analytics library. */
+export interface MineralogyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface MineralogyRobustnessResult { values: number[]; converged: boolean; }
+export function computeMineralogyRobustness(data: number[], opts: MineralogyRobustnessOptions = {}): MineralogyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyRobustness };
diff --git a/src/mineralogy/sampling.ts b/src/mineralogy/sampling.ts
new file mode 100644
index 000000000..40147492e
--- /dev/null
+++ b/src/mineralogy/sampling.ts
@@ -0,0 +1,14 @@
+/** mineralogy sampling module — tsb analytics library. */
+export interface MineralogySamplingOptions { tol?: number; maxIter?: number; }
+export interface MineralogySamplingResult { values: number[]; converged: boolean; }
+export function computeMineralogySampling(data: number[], opts: MineralogySamplingOptions = {}): MineralogySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogySampling };
diff --git a/src/mineralogy/sampling2.ts b/src/mineralogy/sampling2.ts
new file mode 100644
index 000000000..fff53e7fa
--- /dev/null
+++ b/src/mineralogy/sampling2.ts
@@ -0,0 +1,14 @@
+/** mineralogy sampling2 module — tsb analytics library. */
+export interface MineralogySamplingOptions { tol?: number; maxIter?: number; }
+export interface MineralogySamplingResult { values: number[]; converged: boolean; }
+export function computeMineralogySampling(data: number[], opts: MineralogySamplingOptions = {}): MineralogySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogySampling };
diff --git a/src/mineralogy/scaling.ts b/src/mineralogy/scaling.ts
new file mode 100644
index 000000000..a4032e488
--- /dev/null
+++ b/src/mineralogy/scaling.ts
@@ -0,0 +1,14 @@
+/** mineralogy scaling module — tsb analytics library. */
+export interface MineralogyScalingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyScalingResult { values: number[]; converged: boolean; }
+export function computeMineralogyScaling(data: number[], opts: MineralogyScalingOptions = {}): MineralogyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyScaling };
diff --git a/src/mineralogy/scoring.ts b/src/mineralogy/scoring.ts
new file mode 100644
index 000000000..41002d31e
--- /dev/null
+++ b/src/mineralogy/scoring.ts
@@ -0,0 +1,14 @@
+/** mineralogy scoring module — tsb analytics library. */
+export interface MineralogyScoringOptions { tol?: number; maxIter?: number; }
+export interface MineralogyScoringResult { values: number[]; converged: boolean; }
+export function computeMineralogyScoring(data: number[], opts: MineralogyScoringOptions = {}): MineralogyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyScoring };
diff --git a/src/mineralogy/segmentation.ts b/src/mineralogy/segmentation.ts
new file mode 100644
index 000000000..2649bd457
--- /dev/null
+++ b/src/mineralogy/segmentation.ts
@@ -0,0 +1,14 @@
+/** mineralogy segmentation module — tsb analytics library. */
+export interface MineralogySegmentationOptions { tol?: number; maxIter?: number; }
+export interface MineralogySegmentationResult { values: number[]; converged: boolean; }
+export function computeMineralogySegmentation(data: number[], opts: MineralogySegmentationOptions = {}): MineralogySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogySegmentation };
diff --git a/src/mineralogy/selection.ts b/src/mineralogy/selection.ts
new file mode 100644
index 000000000..17dfe0e7c
--- /dev/null
+++ b/src/mineralogy/selection.ts
@@ -0,0 +1,14 @@
+/** mineralogy selection module — tsb analytics library. */
+export interface MineralogySelectionOptions { tol?: number; maxIter?: number; }
+export interface MineralogySelectionResult { values: number[]; converged: boolean; }
+export function computeMineralogySelection(data: number[], opts: MineralogySelectionOptions = {}): MineralogySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogySelection };
diff --git a/src/mineralogy/sensitivity.ts b/src/mineralogy/sensitivity.ts
new file mode 100644
index 000000000..02e77639e
--- /dev/null
+++ b/src/mineralogy/sensitivity.ts
@@ -0,0 +1,14 @@
+/** mineralogy sensitivity module — tsb analytics library. */
+export interface MineralogySensitivityOptions { tol?: number; maxIter?: number; }
+export interface MineralogySensitivityResult { values: number[]; converged: boolean; }
+export function computeMineralogySensitivity(data: number[], opts: MineralogySensitivityOptions = {}): MineralogySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogySensitivity };
diff --git a/src/mineralogy/simulation.ts b/src/mineralogy/simulation.ts
new file mode 100644
index 000000000..992ce4d8c
--- /dev/null
+++ b/src/mineralogy/simulation.ts
@@ -0,0 +1,14 @@
+/** mineralogy simulation module — tsb analytics library. */
+export interface MineralogySimulationOptions { tol?: number; maxIter?: number; }
+export interface MineralogySimulationResult { values: number[]; converged: boolean; }
+export function computeMineralogySimulation(data: number[], opts: MineralogySimulationOptions = {}): MineralogySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogySimulation };
diff --git a/src/mineralogy/smoothing.ts b/src/mineralogy/smoothing.ts
new file mode 100644
index 000000000..e9147568d
--- /dev/null
+++ b/src/mineralogy/smoothing.ts
@@ -0,0 +1,14 @@
+/** mineralogy smoothing module — tsb analytics library. */
+export interface MineralogySmoothingOptions { tol?: number; maxIter?: number; }
+export interface MineralogySmoothingResult { values: number[]; converged: boolean; }
+export function computeMineralogySmoothing(data: number[], opts: MineralogySmoothingOptions = {}): MineralogySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogySmoothing };
diff --git a/src/mineralogy/stability.ts b/src/mineralogy/stability.ts
new file mode 100644
index 000000000..1cb3f1496
--- /dev/null
+++ b/src/mineralogy/stability.ts
@@ -0,0 +1,14 @@
+/** mineralogy stability module — tsb analytics library. */
+export interface MineralogyStabilityOptions { tol?: number; maxIter?: number; }
+export interface MineralogyStabilityResult { values: number[]; converged: boolean; }
+export function computeMineralogyStability(data: number[], opts: MineralogyStabilityOptions = {}): MineralogyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyStability };
diff --git a/src/mineralogy/stacking.ts b/src/mineralogy/stacking.ts
new file mode 100644
index 000000000..203fb6007
--- /dev/null
+++ b/src/mineralogy/stacking.ts
@@ -0,0 +1,14 @@
+/** mineralogy stacking module — tsb analytics library. */
+export interface MineralogyStackingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyStackingResult { values: number[]; converged: boolean; }
+export function computeMineralogyStacking(data: number[], opts: MineralogyStackingOptions = {}): MineralogyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyStacking };
diff --git a/src/mineralogy/standardization.ts b/src/mineralogy/standardization.ts
new file mode 100644
index 000000000..52a3a4aa4
--- /dev/null
+++ b/src/mineralogy/standardization.ts
@@ -0,0 +1,14 @@
+/** mineralogy standardization module — tsb analytics library. */
+export interface MineralogyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyStandardizationResult { values: number[]; converged: boolean; }
+export function computeMineralogyStandardization(data: number[], opts: MineralogyStandardizationOptions = {}): MineralogyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyStandardization };
diff --git a/src/mineralogy/static.ts b/src/mineralogy/static.ts
new file mode 100644
index 000000000..3c7aa3f50
--- /dev/null
+++ b/src/mineralogy/static.ts
@@ -0,0 +1,14 @@
+/** mineralogy static module — tsb analytics library. */
+export interface MineralogyStaticOptions { tol?: number; maxIter?: number; }
+export interface MineralogyStaticResult { values: number[]; converged: boolean; }
+export function computeMineralogyStatic(data: number[], opts: MineralogyStaticOptions = {}): MineralogyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyStatic };
diff --git a/src/mineralogy/stochastic.ts b/src/mineralogy/stochastic.ts
new file mode 100644
index 000000000..cbc6263a0
--- /dev/null
+++ b/src/mineralogy/stochastic.ts
@@ -0,0 +1,14 @@
+/** mineralogy stochastic module — tsb analytics library. */
+export interface MineralogyStochasticOptions { tol?: number; maxIter?: number; }
+export interface MineralogyStochasticResult { values: number[]; converged: boolean; }
+export function computeMineralogyStochastic(data: number[], opts: MineralogyStochasticOptions = {}): MineralogyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyStochastic };
diff --git a/src/mineralogy/synthesis.ts b/src/mineralogy/synthesis.ts
new file mode 100644
index 000000000..ca73cc8b9
--- /dev/null
+++ b/src/mineralogy/synthesis.ts
@@ -0,0 +1,14 @@
+/** mineralogy synthesis module — tsb analytics library. */
+export interface MineralogySynthesisOptions { tol?: number; maxIter?: number; }
+export interface MineralogySynthesisResult { values: number[]; converged: boolean; }
+export function computeMineralogySynthesis(data: number[], opts: MineralogySynthesisOptions = {}): MineralogySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogySynthesis };
diff --git a/src/mineralogy/topology.ts b/src/mineralogy/topology.ts
new file mode 100644
index 000000000..25d4622e1
--- /dev/null
+++ b/src/mineralogy/topology.ts
@@ -0,0 +1,14 @@
+/** mineralogy topology module — tsb analytics library. */
+export interface MineralogyTopologyOptions { tol?: number; maxIter?: number; }
+export interface MineralogyTopologyResult { values: number[]; converged: boolean; }
+export function computeMineralogyTopology(data: number[], opts: MineralogyTopologyOptions = {}): MineralogyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyTopology };
diff --git a/src/mineralogy/tracking.ts b/src/mineralogy/tracking.ts
new file mode 100644
index 000000000..934726edb
--- /dev/null
+++ b/src/mineralogy/tracking.ts
@@ -0,0 +1,14 @@
+/** mineralogy tracking module — tsb analytics library. */
+export interface MineralogyTrackingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyTrackingResult { values: number[]; converged: boolean; }
+export function computeMineralogyTracking(data: number[], opts: MineralogyTrackingOptions = {}): MineralogyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyTracking };
diff --git a/src/mineralogy/transform.ts b/src/mineralogy/transform.ts
new file mode 100644
index 000000000..9e29196a0
--- /dev/null
+++ b/src/mineralogy/transform.ts
@@ -0,0 +1,14 @@
+/** mineralogy transform module — tsb analytics library. */
+export interface MineralogyTransformOptions { tol?: number; maxIter?: number; }
+export interface MineralogyTransformResult { values: number[]; converged: boolean; }
+export function computeMineralogyTransform(data: number[], opts: MineralogyTransformOptions = {}): MineralogyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyTransform };
diff --git a/src/mineralogy/uncertainty.ts b/src/mineralogy/uncertainty.ts
new file mode 100644
index 000000000..4060db133
--- /dev/null
+++ b/src/mineralogy/uncertainty.ts
@@ -0,0 +1,14 @@
+/** mineralogy uncertainty module — tsb analytics library. */
+export interface MineralogyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface MineralogyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeMineralogyUncertainty(data: number[], opts: MineralogyUncertaintyOptions = {}): MineralogyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyUncertainty };
diff --git a/src/mineralogy/validation.ts b/src/mineralogy/validation.ts
new file mode 100644
index 000000000..44bc53862
--- /dev/null
+++ b/src/mineralogy/validation.ts
@@ -0,0 +1,14 @@
+/** mineralogy validation module — tsb analytics library. */
+export interface MineralogyValidationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyValidationResult { values: number[]; converged: boolean; }
+export function computeMineralogyValidation(data: number[], opts: MineralogyValidationOptions = {}): MineralogyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyValidation };
diff --git a/src/mineralogy/verification.ts b/src/mineralogy/verification.ts
new file mode 100644
index 000000000..0bed98c4c
--- /dev/null
+++ b/src/mineralogy/verification.ts
@@ -0,0 +1,14 @@
+/** mineralogy verification module — tsb analytics library. */
+export interface MineralogyVerificationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyVerificationResult { values: number[]; converged: boolean; }
+export function computeMineralogyVerification(data: number[], opts: MineralogyVerificationOptions = {}): MineralogyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyVerification };
diff --git a/src/mineralogy/visualization.ts b/src/mineralogy/visualization.ts
new file mode 100644
index 000000000..451991b19
--- /dev/null
+++ b/src/mineralogy/visualization.ts
@@ -0,0 +1,14 @@
+/** mineralogy visualization module — tsb analytics library. */
+export interface MineralogyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface MineralogyVisualizationResult { values: number[]; converged: boolean; }
+export function computeMineralogyVisualization(data: number[], opts: MineralogyVisualizationOptions = {}): MineralogyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyVisualization };
diff --git a/src/mineralogy/voting.ts b/src/mineralogy/voting.ts
new file mode 100644
index 000000000..c68566ba9
--- /dev/null
+++ b/src/mineralogy/voting.ts
@@ -0,0 +1,14 @@
+/** mineralogy voting module — tsb analytics library. */
+export interface MineralogyVotingOptions { tol?: number; maxIter?: number; }
+export interface MineralogyVotingResult { values: number[]; converged: boolean; }
+export function computeMineralogyVoting(data: number[], opts: MineralogyVotingOptions = {}): MineralogyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyVoting };
diff --git a/src/mineralogy/wavelet.ts b/src/mineralogy/wavelet.ts
new file mode 100644
index 000000000..25bfb128c
--- /dev/null
+++ b/src/mineralogy/wavelet.ts
@@ -0,0 +1,14 @@
+/** mineralogy wavelet module — tsb analytics library. */
+export interface MineralogyWaveletOptions { tol?: number; maxIter?: number; }
+export interface MineralogyWaveletResult { values: number[]; converged: boolean; }
+export function computeMineralogyWavelet(data: number[], opts: MineralogyWaveletOptions = {}): MineralogyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMineralogyWavelet };
diff --git a/src/ml/attention.ts b/src/ml/attention.ts
new file mode 100644
index 000000000..47fd95948
--- /dev/null
+++ b/src/ml/attention.ts
@@ -0,0 +1,228 @@
+/**
+ * Multi-head self-attention and transformer building blocks.
+ *
+ * Provides standalone attention primitives usable across architectures:
+ * multi-head attention, positional encodings, and transformer encoder/decoder blocks.
+ *
+ * @module
+ */
+
+/** Multi-head attention configuration. */
+export interface MHAConfig {
+ dModel: number;
+ numHeads: number;
+ dropout: number;
+}
+
+/** Project a flat weight matrix into per-head slices. */
+function splitHeads(
+ x: Float64Array,
+ seqLen: number,
+ dModel: number,
+ numHeads: number,
+): Float64Array[] {
+ const dHead = Math.floor(dModel / numHeads);
+ const heads: Float64Array[] = [];
+ for (let h = 0; h < numHeads; h++) {
+ const head = new Float64Array(seqLen * dHead);
+ for (let t = 0; t < seqLen; t++) {
+ for (let d = 0; d < dHead; d++) {
+ head[t * dHead + d] = x[t * dModel + h * dHead + d] ?? 0;
+ }
+ }
+ heads.push(head);
+ }
+ return heads;
+}
+
+/** Concatenate per-head outputs back into [seqLen x dModel]. */
+function mergeHeads(
+ heads: Float64Array[],
+ seqLen: number,
+ dModel: number,
+): Float64Array {
+ const numHeads = heads.length;
+ const dHead = Math.floor(dModel / numHeads);
+ const out = new Float64Array(seqLen * dModel);
+ for (let h = 0; h < numHeads; h++) {
+ const head = heads[h]!;
+ for (let t = 0; t < seqLen; t++) {
+ for (let d = 0; d < dHead; d++) {
+ out[t * dModel + h * dHead + d] = head[t * dHead + d] ?? 0;
+ }
+ }
+ }
+ return out;
+}
+
+/** Compute attention for a single head: [seqLen x dHead]. */
+function singleHeadAttention(
+ Q: Float64Array,
+ K: Float64Array,
+ V: Float64Array,
+ seqLen: number,
+ dHead: number,
+ mask?: Float64Array,
+): Float64Array {
+ const scale = Math.sqrt(dHead);
+ const attn = new Float64Array(seqLen * seqLen);
+ // Q K^T / scale
+ for (let i = 0; i < seqLen; i++) {
+ for (let j = 0; j < seqLen; j++) {
+ let dot = 0;
+ for (let d = 0; d < dHead; d++) {
+ dot += (Q[i * dHead + d] ?? 0) * (K[j * dHead + d] ?? 0);
+ }
+ attn[i * seqLen + j] = dot / scale + (mask ? (mask[i * seqLen + j] ?? 0) : 0);
+ }
+ }
+ // Softmax
+ for (let i = 0; i < seqLen; i++) {
+ let maxVal = -Infinity;
+ for (let j = 0; j < seqLen; j++) maxVal = Math.max(maxVal, attn[i * seqLen + j] ?? -Infinity);
+ let sumExp = 0;
+ for (let j = 0; j < seqLen; j++) {
+ attn[i * seqLen + j] = Math.exp((attn[i * seqLen + j] ?? 0) - maxVal);
+ sumExp += attn[i * seqLen + j] ?? 0;
+ }
+ for (let j = 0; j < seqLen; j++) attn[i * seqLen + j] = (attn[i * seqLen + j] ?? 0) / (sumExp || 1);
+ }
+ // A V
+ const out = new Float64Array(seqLen * dHead);
+ for (let i = 0; i < seqLen; i++) {
+ for (let d = 0; d < dHead; d++) {
+ let val = 0;
+ for (let j = 0; j < seqLen; j++) {
+ val += (attn[i * seqLen + j] ?? 0) * (V[j * dHead + d] ?? 0);
+ }
+ out[i * dHead + d] = val;
+ }
+ }
+ return out;
+}
+
+/** Multi-head attention weight matrices. */
+export interface MHAWeights {
+ Wq: Float64Array; // [dModel x dModel]
+ Wk: Float64Array; // [dModel x dModel]
+ Wv: Float64Array; // [dModel x dModel]
+ Wo: Float64Array; // [dModel x dModel]
+ config: MHAConfig;
+}
+
+/** Apply multi-head attention. */
+export function multiHeadAttention(
+ query: Float64Array, // [seqLen x dModel]
+ key: Float64Array, // [seqLen x dModel]
+ value: Float64Array, // [seqLen x dModel]
+ seqLen: number,
+ weights: MHAWeights,
+ mask?: Float64Array,
+): Float64Array {
+ const { dModel, numHeads } = weights.config;
+ const dHead = Math.floor(dModel / numHeads);
+
+ // Project Q, K, V
+ const projQ = new Float64Array(seqLen * dModel);
+ const projK = new Float64Array(seqLen * dModel);
+ const projV = new Float64Array(seqLen * dModel);
+
+ for (let t = 0; t < seqLen; t++) {
+ for (let o = 0; o < dModel; o++) {
+ let q = 0, k = 0, v = 0;
+ for (let i = 0; i < dModel; i++) {
+ q += (weights.Wq[o * dModel + i] ?? 0) * (query[t * dModel + i] ?? 0);
+ k += (weights.Wk[o * dModel + i] ?? 0) * (key[t * dModel + i] ?? 0);
+ v += (weights.Wv[o * dModel + i] ?? 0) * (value[t * dModel + i] ?? 0);
+ }
+ projQ[t * dModel + o] = q;
+ projK[t * dModel + o] = k;
+ projV[t * dModel + o] = v;
+ }
+ }
+
+ // Split into heads and compute attention
+ const qHeads = splitHeads(projQ, seqLen, dModel, numHeads);
+ const kHeads = splitHeads(projK, seqLen, dModel, numHeads);
+ const vHeads = splitHeads(projV, seqLen, dModel, numHeads);
+
+ const headOutputs: Float64Array[] = [];
+ for (let h = 0; h < numHeads; h++) {
+ headOutputs.push(singleHeadAttention(qHeads[h]!, kHeads[h]!, vHeads[h]!, seqLen, dHead, mask));
+ }
+
+ const concat = mergeHeads(headOutputs, seqLen, dModel);
+
+ // Output projection
+ const out = new Float64Array(seqLen * dModel);
+ for (let t = 0; t < seqLen; t++) {
+ for (let o = 0; o < dModel; o++) {
+ let val = 0;
+ for (let i = 0; i < dModel; i++) {
+ val += (weights.Wo[o * dModel + i] ?? 0) * (concat[t * dModel + i] ?? 0);
+ }
+ out[t * dModel + o] = val;
+ }
+ }
+ return out;
+}
+
+/** Sinusoidal positional encoding. */
+export function sinusoidalPositionalEncoding(seqLen: number, dModel: number): Float64Array {
+ const pe = new Float64Array(seqLen * dModel);
+ for (let pos = 0; pos < seqLen; pos++) {
+ for (let i = 0; i < dModel; i += 2) {
+ const angle = pos / Math.pow(10000, i / dModel);
+ pe[pos * dModel + i] = Math.sin(angle);
+ if (i + 1 < dModel) pe[pos * dModel + i + 1] = Math.cos(angle);
+ }
+ }
+ return pe;
+}
+
+/** Add positional encoding to input embeddings. */
+export function addPositionalEncoding(
+ embeddings: Float64Array,
+ seqLen: number,
+ dModel: number,
+): Float64Array {
+ const pe = sinusoidalPositionalEncoding(seqLen, dModel);
+ const out = new Float64Array(embeddings.length);
+ for (let i = 0; i < embeddings.length; i++) {
+ out[i] = (embeddings[i] ?? 0) + (pe[i] ?? 0);
+ }
+ return out;
+}
+
+/** Causal (autoregressive) attention mask. */
+export function causalMask(seqLen: number): Float64Array {
+ const mask = new Float64Array(seqLen * seqLen).fill(-Infinity);
+ for (let i = 0; i < seqLen; i++) {
+ for (let j = 0; j <= i; j++) {
+ mask[i * seqLen + j] = 0;
+ }
+ }
+ return mask;
+}
+
+/** RoPE (Rotary Position Embedding) for a single head. */
+export function applyRoPE(
+ x: Float64Array,
+ seqLen: number,
+ dHead: number,
+ baseFreq: number = 10000,
+): Float64Array {
+ const out = new Float64Array(x.length);
+ for (let pos = 0; pos < seqLen; pos++) {
+ for (let i = 0; i < dHead; i += 2) {
+ const theta = pos / Math.pow(baseFreq, i / dHead);
+ const cos = Math.cos(theta);
+ const sin = Math.sin(theta);
+ const x0 = x[pos * dHead + i] ?? 0;
+ const x1 = x[pos * dHead + i + 1] ?? 0;
+ out[pos * dHead + i] = x0 * cos - x1 * sin;
+ out[pos * dHead + i + 1] = x0 * sin + x1 * cos;
+ }
+ }
+ return out;
+}
diff --git a/src/ml/bayesian_opt.ts b/src/ml/bayesian_opt.ts
new file mode 100644
index 000000000..cd31b792c
--- /dev/null
+++ b/src/ml/bayesian_opt.ts
@@ -0,0 +1,249 @@
+/**
+ * Bayesian Optimization with Gaussian Process surrogate and acquisition functions.
+ *
+ * Implements Expected Improvement (EI), Probability of Improvement (PI),
+ * Upper Confidence Bound (UCB), and Thompson Sampling acquisition functions,
+ * with an RBF kernel Gaussian Process as the surrogate model.
+ *
+ * @module
+ */
+
+/** RBF (squared exponential) kernel. */
+export function rbfKernel(
+ x1: Float64Array,
+ x2: Float64Array,
+ lengthScale: number,
+ amplitude: number,
+): number {
+ let sqDist = 0;
+ for (let i = 0; i < x1.length; i++) {
+ const d = (x1[i] ?? 0) - (x2[i] ?? 0);
+ sqDist += d * d;
+ }
+ return amplitude * amplitude * Math.exp(-0.5 * sqDist / (lengthScale * lengthScale));
+}
+
+/** Matern 5/2 kernel. */
+export function maternKernel52(
+ x1: Float64Array,
+ x2: Float64Array,
+ lengthScale: number,
+ amplitude: number,
+): number {
+ let sqDist = 0;
+ for (let i = 0; i < x1.length; i++) {
+ const d = (x1[i] ?? 0) - (x2[i] ?? 0);
+ sqDist += d * d;
+ }
+ const r = Math.sqrt(sqDist) / lengthScale;
+ const sqrt5r = Math.sqrt(5) * r;
+ return amplitude * amplitude * (1 + sqrt5r + (5 / 3) * r * r) * Math.exp(-sqrt5r);
+}
+
+/** Compute kernel matrix K(X, X) + noise * I. */
+export function kernelMatrix(
+ X: Float64Array[],
+ lengthScale: number,
+ amplitude: number,
+ noise: number,
+): Float64Array {
+ const n = X.length;
+ const K = new Float64Array(n * n);
+ for (let i = 0; i < n; i++) {
+ for (let j = i; j < n; j++) {
+ const k = rbfKernel(X[i]!, X[j]!, lengthScale, amplitude);
+ K[i * n + j] = k;
+ K[j * n + i] = k;
+ }
+ K[i * n + i] += noise;
+ }
+ return K;
+}
+
+/** Cholesky decomposition (lower triangular L such that L L^T = A). */
+export function cholesky(A: Float64Array, n: number): Float64Array {
+ const L = new Float64Array(n * n);
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j <= i; j++) {
+ let sum = A[i * n + j] ?? 0;
+ for (let k = 0; k < j; k++) {
+ sum -= (L[i * n + k] ?? 0) * (L[j * n + k] ?? 0);
+ }
+ if (i === j) {
+ L[i * n + j] = Math.sqrt(Math.max(sum, 1e-12));
+ } else {
+ L[i * n + j] = sum / ((L[j * n + j] ?? 1e-12) || 1e-12);
+ }
+ }
+ }
+ return L;
+}
+
+/** Solve L x = b (forward substitution). */
+function forwardSolve(L: Float64Array, b: Float64Array, n: number): Float64Array {
+ const x = new Float64Array(n);
+ for (let i = 0; i < n; i++) {
+ let sum = b[i] ?? 0;
+ for (let j = 0; j < i; j++) sum -= (L[i * n + j] ?? 0) * (x[j] ?? 0);
+ x[i] = sum / ((L[i * n + i] ?? 1) || 1);
+ }
+ return x;
+}
+
+/** Solve L^T x = b (backward substitution). */
+function backwardSolve(L: Float64Array, b: Float64Array, n: number): Float64Array {
+ const x = new Float64Array(n);
+ for (let i = n - 1; i >= 0; i--) {
+ let sum = b[i] ?? 0;
+ for (let j = i + 1; j < n; j++) sum -= (L[j * n + i] ?? 0) * (x[j] ?? 0);
+ x[i] = sum / ((L[i * n + i] ?? 1) || 1);
+ }
+ return x;
+}
+
+/** Gaussian Process prediction: return (mean, variance) at test point. */
+export function gpPredict(
+ xTest: Float64Array,
+ X: Float64Array[],
+ y: Float64Array,
+ L: Float64Array,
+ lengthScale: number,
+ amplitude: number,
+ noise: number,
+): { mean: number; variance: number } {
+ const n = X.length;
+ // k_* = [k(x*, x_i)]
+ const kStar = new Float64Array(n);
+ for (let i = 0; i < n; i++) {
+ kStar[i] = rbfKernel(xTest, X[i]!, lengthScale, amplitude);
+ }
+ // alpha = (K + noise*I)^{-1} y via Cholesky
+ const alpha1 = forwardSolve(L, y, n);
+ const alpha = backwardSolve(L, alpha1, n);
+
+ // mean = k_*^T alpha
+ let mean = 0;
+ for (let i = 0; i < n; i++) mean += (kStar[i] ?? 0) * (alpha[i] ?? 0);
+
+ // variance = k(x*,x*) - k_*^T (K+noise*I)^{-1} k_*
+ const v = forwardSolve(L, kStar, n);
+ let kStarDotV = 0;
+ for (let i = 0; i < n; i++) kStarDotV += (v[i] ?? 0) * (v[i] ?? 0);
+ const kSelf = rbfKernel(xTest, xTest, lengthScale, amplitude) + noise;
+ const variance = Math.max(kSelf - kStarDotV, 1e-10);
+
+ return { mean, variance };
+}
+
+/** Standard normal CDF (approximation). */
+export function normalCDF(z: number): number {
+ const t = 1 / (1 + 0.2316419 * Math.abs(z));
+ const poly = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
+ const phi = 1 - (1 / Math.sqrt(2 * Math.PI)) * Math.exp(-0.5 * z * z) * poly;
+ return z >= 0 ? phi : 1 - phi;
+}
+
+/** Standard normal PDF. */
+export function normalPDF(z: number): number {
+ return (1 / Math.sqrt(2 * Math.PI)) * Math.exp(-0.5 * z * z);
+}
+
+/** Expected Improvement acquisition function. */
+export function expectedImprovement(
+ mean: number,
+ variance: number,
+ bestY: number,
+ xi: number = 0.01,
+): number {
+ const std = Math.sqrt(variance);
+ const z = (mean - bestY - xi) / (std || 1e-8);
+ return (mean - bestY - xi) * normalCDF(z) + std * normalPDF(z);
+}
+
+/** Probability of Improvement acquisition function. */
+export function probabilityOfImprovement(
+ mean: number,
+ variance: number,
+ bestY: number,
+ xi: number = 0.01,
+): number {
+ const std = Math.sqrt(variance);
+ return normalCDF((mean - bestY - xi) / (std || 1e-8));
+}
+
+/** Upper Confidence Bound acquisition function. */
+export function upperConfidenceBound(mean: number, variance: number, kappa: number = 2.0): number {
+ return mean + kappa * Math.sqrt(variance);
+}
+
+/** Bayesian optimization state. */
+export interface BOState {
+ observedX: Float64Array[];
+ observedY: Float64Array;
+ bestY: number;
+ bestX: Float64Array;
+ lengthScale: number;
+ amplitude: number;
+ noise: number;
+}
+
+/** Initialize Bayesian optimization state from initial observations. */
+export function initBOState(
+ X: Float64Array[],
+ y: Float64Array,
+ lengthScale: number = 1.0,
+ amplitude: number = 1.0,
+ noise: number = 0.01,
+): BOState {
+ let bestIdx = 0;
+ for (let i = 1; i < y.length; i++) {
+ if ((y[i] ?? -Infinity) > (y[bestIdx] ?? -Infinity)) bestIdx = i;
+ }
+ return {
+ observedX: X,
+ observedY: y,
+ bestY: y[bestIdx] ?? -Infinity,
+ bestX: X[bestIdx] ?? new Float64Array(0),
+ lengthScale,
+ amplitude,
+ noise,
+ };
+}
+
+/** Suggest the next candidate by maximizing EI over provided candidates. */
+export function suggestNext(
+ state: BOState,
+ candidates: Float64Array[],
+ acquisition: "EI" | "PI" | "UCB" = "EI",
+ kappa: number = 2.0,
+ xi: number = 0.01,
+): { bestCandidate: Float64Array; acquisitionValues: Float64Array } {
+ const K = kernelMatrix(state.observedX, state.lengthScale, state.amplitude, state.noise);
+ const L = cholesky(K, state.observedX.length);
+
+ const acqValues = new Float64Array(candidates.length);
+ for (let i = 0; i < candidates.length; i++) {
+ const { mean, variance } = gpPredict(
+ candidates[i]!,
+ state.observedX,
+ state.observedY,
+ L,
+ state.lengthScale,
+ state.amplitude,
+ state.noise,
+ );
+ if (acquisition === "EI") {
+ acqValues[i] = expectedImprovement(mean, variance, state.bestY, xi);
+ } else if (acquisition === "PI") {
+ acqValues[i] = probabilityOfImprovement(mean, variance, state.bestY, xi);
+ } else {
+ acqValues[i] = upperConfidenceBound(mean, variance, kappa);
+ }
+ }
+
+ let bestIdx = 0;
+ for (let i = 1; i < acqValues.length; i++) {
+ if ((acqValues[i] ?? -Infinity) > (acqValues[bestIdx] ?? -Infinity)) bestIdx = i;
+ }
+ return { bestCandidate: candidates[bestIdx] ?? new Float64Array(0), acquisitionValues: acqValues };
+}
diff --git a/src/ml/consistency_models.ts b/src/ml/consistency_models.ts
new file mode 100644
index 000000000..afd1b7e33
--- /dev/null
+++ b/src/ml/consistency_models.ts
@@ -0,0 +1,187 @@
+/**
+ * Consistency Models: fast single-step generative models.
+ *
+ * Implements the Consistency Model framework (Song et al., 2023) including:
+ * the consistency function, consistency training loss, and
+ * few-step sampling procedures.
+ *
+ * @module
+ */
+
+/** Consistency model configuration. */
+export interface ConsistencyConfig {
+ /** Total training time horizon T. */
+ T: number;
+ /** Initial discretization timestep (epsilon). */
+ epsilon: number;
+ /** Number of discretization steps N. */
+ N: number;
+ /** EMA decay rate for teacher model. */
+ emaDecay: number;
+ /** Karras noise schedule rho. */
+ rho: number;
+ /** Loss weighting parameter mu. */
+ mu: number;
+}
+
+/** Default consistency model configuration. */
+export const DEFAULT_CONSISTENCY_CONFIG: ConsistencyConfig = {
+ T: 80,
+ epsilon: 0.002,
+ N: 150,
+ emaDecay: 0.99,
+ rho: 7,
+ mu: 0.95,
+};
+
+/** Karras et al. noise schedule: sigma_i for step i in [0, N]. */
+export function karrasNoiseLevels(config: ConsistencyConfig): Float64Array {
+ const { T, epsilon, N, rho } = config;
+ const levels = new Float64Array(N + 1);
+ for (let i = 0; i <= N; i++) {
+ const frac = i / N;
+ levels[i] =
+ (epsilon ** (1 / rho) + frac * (T ** (1 / rho) - epsilon ** (1 / rho))) ** rho;
+ }
+ return levels;
+}
+
+/** Skip function c_skip(sigma): scaling for input. */
+export function cSkip(sigma: number, sigmaData: number = 0.5): number {
+ return sigmaData * sigmaData / (sigma * sigma + sigmaData * sigmaData);
+}
+
+/** Output function c_out(sigma): scaling for network output. */
+export function cOut(sigma: number, sigmaData: number = 0.5): number {
+ return (sigma * sigmaData) / Math.sqrt(sigma * sigma + sigmaData * sigmaData);
+}
+
+/** Input scaling c_in(sigma). */
+export function cIn(sigma: number, sigmaData: number = 0.5): number {
+ return 1 / Math.sqrt(sigma * sigma + sigmaData * sigmaData);
+}
+
+/** Noise conditioning c_noise(sigma): log encoding. */
+export function cNoise(sigma: number): number {
+ return Math.log(sigma) / 4;
+}
+
+/**
+ * Consistency function: maps any (x_t, t) to a consistent estimate of x_0.
+ * Uses the preconditioning scheme from Karras et al.
+ *
+ * @param xt - Noisy sample at noise level sigma
+ * @param sigma - Current noise level
+ * @param fTheta - Network output F_theta(c_in * x, c_noise)
+ * @param sigmaData - Data standard deviation
+ */
+export function consistencyFunction(
+ xt: Float64Array,
+ sigma: number,
+ fTheta: Float64Array,
+ sigmaData: number = 0.5,
+): Float64Array {
+ const skip = cSkip(sigma, sigmaData);
+ const out = cOut(sigma, sigmaData);
+ const result = new Float64Array(xt.length);
+ for (let i = 0; i < xt.length; i++) {
+ result[i] = skip * (xt[i] ?? 0) + out * (fTheta[i] ?? 0);
+ }
+ return result;
+}
+
+/** Compute preconditioning-scaled input for the network. */
+export function preconditionInput(x: Float64Array, sigma: number, sigmaData: number = 0.5): Float64Array {
+ const scale = cIn(sigma, sigmaData);
+ const out = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) out[i] = scale * (x[i] ?? 0);
+ return out;
+}
+
+/** Pseudo-Huber loss (smooth L1-like). */
+export function pseudoHuberLoss(a: Float64Array, b: Float64Array, c: number = 0.00054): number {
+ let total = 0;
+ for (let i = 0; i < a.length; i++) {
+ const d = (a[i] ?? 0) - (b[i] ?? 0);
+ total += Math.sqrt(d * d + c * c) - c;
+ }
+ return total / a.length;
+}
+
+/**
+ * Consistency Training (CT) loss for a single sample pair.
+ *
+ * @param studentOutput - Consistency function output at t_{n+1}
+ * @param teacherOutput - EMA consistency function output at t_n (stop gradient)
+ * @param sigmaN - Noise level at step n
+ * @param sigmaNp1 - Noise level at step n+1
+ */
+export function consistencyTrainingLoss(
+ studentOutput: Float64Array,
+ teacherOutput: Float64Array,
+ sigmaN: number,
+ sigmaNp1: number,
+): number {
+ const weight = 1 / Math.max(sigmaNp1 - sigmaN, 1e-8);
+ return weight * pseudoHuberLoss(studentOutput, teacherOutput);
+}
+
+/** Add noise to a sample: x_t = x_0 + sigma * epsilon. */
+export function addGaussianNoise(
+ x0: Float64Array,
+ sigma: number,
+ noise: Float64Array,
+): Float64Array {
+ const out = new Float64Array(x0.length);
+ for (let i = 0; i < x0.length; i++) {
+ out[i] = (x0[i] ?? 0) + sigma * (noise[i] ?? 0);
+ }
+ return out;
+}
+
+/** Single-step consistency model sampling from noise. */
+export function consistencySampleOneStep(
+ noise: Float64Array,
+ T: number,
+ consistencyFn: (x: Float64Array, sigma: number) => Float64Array,
+): Float64Array {
+ return consistencyFn(noise, T);
+}
+
+/** Multi-step consistency model sampling (improves quality). */
+export function consistencySampleMultiStep(
+ noise: Float64Array,
+ sigmaLevels: number[],
+ consistencyFn: (x: Float64Array, sigma: number) => Float64Array,
+ noiseFn: (shape: number) => Float64Array,
+): Float64Array {
+ if (sigmaLevels.length === 0) return noise;
+ let x = consistencyFn(noise, sigmaLevels[0] ?? 1);
+ for (let i = 1; i < sigmaLevels.length; i++) {
+ const sigma = sigmaLevels[i] ?? 0;
+ if (sigma <= 0) break;
+ // Add noise and re-denoise
+ const eps = noiseFn(x.length);
+ const xNoisy = addGaussianNoise(x, sigma, eps);
+ x = consistencyFn(xNoisy, sigma);
+ }
+ return x;
+}
+
+/** Update EMA teacher model weights. */
+export function updateEMAWeights(
+ teacherWeights: Float64Array,
+ studentWeights: Float64Array,
+ decay: number,
+): Float64Array {
+ const out = new Float64Array(teacherWeights.length);
+ for (let i = 0; i < teacherWeights.length; i++) {
+ out[i] = decay * (teacherWeights[i] ?? 0) + (1 - decay) * (studentWeights[i] ?? 0);
+ }
+ return out;
+}
+
+/** Compute adaptive EMA decay for consistency distillation. */
+export function adaptiveEMADecay(iteration: number, mu0: number = 0.95, s0: number = 10): number {
+ return Math.exp(s0 * Math.log(mu0) / Math.max(iteration, 1));
+}
diff --git a/src/ml/crf.ts b/src/ml/crf.ts
new file mode 100644
index 000000000..0a04c53cc
--- /dev/null
+++ b/src/ml/crf.ts
@@ -0,0 +1,155 @@
+/**
+ * Conditional Random Field (CRF) for sequence labeling.
+ *
+ * Implements a linear-chain CRF with the Viterbi algorithm for decoding,
+ * the forward algorithm for computing partition functions, and
+ * log-likelihood computation for training.
+ *
+ * @module
+ */
+
+/** CRF model parameters. */
+export interface CRFParams {
+ /** Emission scores [seqLen x numTags]. */
+ emissionScores: Float64Array;
+ /** Transition scores [numTags x numTags] (from -> to). */
+ transitionScores: Float64Array;
+ /** Start transition scores [numTags]. */
+ startScores: Float64Array;
+ /** End transition scores [numTags]. */
+ endScores: Float64Array;
+ numTags: number;
+ seqLen: number;
+}
+
+/** Viterbi decoding result. */
+export interface ViterbiResult {
+ /** Best tag sequence. */
+ tags: number[];
+ /** Score of the best sequence. */
+ score: number;
+}
+
+/** Viterbi algorithm for CRF decoding. */
+export function viterbiDecode(params: CRFParams): ViterbiResult {
+ const { numTags, seqLen, emissionScores, transitionScores, startScores, endScores } = params;
+
+ // viterbi[t][tag] = best score ending at (t, tag)
+ const viterbi: Float64Array[] = [];
+ const backpointer: Int32Array[] = [];
+
+ // Init: t=0
+ const v0 = new Float64Array(numTags);
+ const bp0 = new Int32Array(numTags).fill(-1);
+ for (let j = 0; j < numTags; j++) {
+ v0[j] = (startScores[j] ?? -Infinity) + (emissionScores[j] ?? -Infinity);
+ }
+ viterbi.push(v0);
+ backpointer.push(bp0);
+
+ for (let t = 1; t < seqLen; t++) {
+ const vt = new Float64Array(numTags);
+ const bpt = new Int32Array(numTags);
+ const vprev = viterbi[t - 1]!;
+ for (let j = 0; j < numTags; j++) {
+ let bestScore = -Infinity;
+ let bestPrev = 0;
+ for (let i = 0; i < numTags; i++) {
+ const score = (vprev[i] ?? -Infinity) + (transitionScores[i * numTags + j] ?? -Infinity);
+ if (score > bestScore) {
+ bestScore = score;
+ bestPrev = i;
+ }
+ }
+ vt[j] = bestScore + (emissionScores[t * numTags + j] ?? -Infinity);
+ bpt[j] = bestPrev;
+ }
+ viterbi.push(vt);
+ backpointer.push(bpt);
+ }
+
+ // Add end scores
+ const vlast = viterbi[seqLen - 1]!;
+ let bestFinalScore = -Infinity;
+ let bestFinalTag = 0;
+ for (let j = 0; j < numTags; j++) {
+ const s = (vlast[j] ?? -Infinity) + (endScores[j] ?? 0);
+ if (s > bestFinalScore) {
+ bestFinalScore = s;
+ bestFinalTag = j;
+ }
+ }
+
+ // Backtrack
+ const tags = new Array(seqLen);
+ tags[seqLen - 1] = bestFinalTag;
+ for (let t = seqLen - 1; t > 0; t--) {
+ tags[t - 1] = backpointer[t]![tags[t]!] ?? 0;
+ }
+
+ return { tags, score: bestFinalScore };
+}
+
+/** Forward algorithm: compute log partition function log Z. */
+export function forwardLogZ(params: CRFParams): number {
+ const { numTags, seqLen, emissionScores, transitionScores, startScores, endScores } = params;
+
+ // alpha[tag] = log sum of scores for all paths ending at (t, tag)
+ let alpha = new Float64Array(numTags);
+ for (let j = 0; j < numTags; j++) {
+ alpha[j] = (startScores[j] ?? -Infinity) + (emissionScores[j] ?? -Infinity);
+ }
+
+ for (let t = 1; t < seqLen; t++) {
+ const newAlpha = new Float64Array(numTags);
+ for (let j = 0; j < numTags; j++) {
+ const scores = new Float64Array(numTags);
+ for (let i = 0; i < numTags; i++) {
+ scores[i] = (alpha[i] ?? -Infinity) + (transitionScores[i * numTags + j] ?? -Infinity);
+ }
+ newAlpha[j] = logSumExp(scores) + (emissionScores[t * numTags + j] ?? -Infinity);
+ }
+ alpha = newAlpha;
+ }
+
+ // Add end scores
+ const final = new Float64Array(numTags);
+ for (let j = 0; j < numTags; j++) {
+ final[j] = (alpha[j] ?? -Infinity) + (endScores[j] ?? 0);
+ }
+ return logSumExp(final);
+}
+
+/** Compute score of a given tag sequence. */
+export function sequenceScore(params: CRFParams, tags: number[]): number {
+ const { numTags, emissionScores, transitionScores, startScores, endScores } = params;
+ let score = startScores[tags[0] ?? 0] ?? -Infinity;
+ score += emissionScores[(tags[0] ?? 0)] ?? -Infinity;
+ for (let t = 1; t < tags.length; t++) {
+ const prev = tags[t - 1] ?? 0;
+ const curr = tags[t] ?? 0;
+ score += transitionScores[prev * numTags + curr] ?? -Infinity;
+ score += emissionScores[t * numTags + curr] ?? -Infinity;
+ }
+ score += endScores[tags[tags.length - 1] ?? 0] ?? 0;
+ return score;
+}
+
+/** CRF negative log-likelihood for a given tag sequence. */
+export function crfNegLogLikelihood(params: CRFParams, tags: number[]): number {
+ const goldScore = sequenceScore(params, tags);
+ const logZ = forwardLogZ(params);
+ return logZ - goldScore;
+}
+
+/** Log-sum-exp (numerically stable). */
+export function logSumExp(values: Float64Array): number {
+ let max = -Infinity;
+ for (let i = 0; i < values.length; i++) max = Math.max(max, values[i] ?? -Infinity);
+ if (!isFinite(max)) return -Infinity;
+ let sum = 0;
+ for (let i = 0; i < values.length; i++) {
+ sum += Math.exp((values[i] ?? -Infinity) - max);
+ }
+ return max + Math.log(sum);
+}
diff --git a/src/ml/ddim.ts b/src/ml/ddim.ts
new file mode 100644
index 000000000..99d477dfc
--- /dev/null
+++ b/src/ml/ddim.ts
@@ -0,0 +1,147 @@
+/**
+ * DDIM (Denoising Diffusion Implicit Models) sampler.
+ *
+ * Implements the deterministic DDIM sampling procedure from Song et al. (2020).
+ * Supports both DDIM (η=0, deterministic) and DDPM (η=1, stochastic) sampling.
+ *
+ * @module
+ */
+
+/** Noise schedule type. */
+export type NoiseSchedule = "linear" | "cosine" | "sqrt";
+
+/** DDIM sampler configuration. */
+export interface DDIMConfig {
+ /** Total number of diffusion timesteps used during training. */
+ numTrainTimesteps: number;
+ /** Noise schedule type. */
+ schedule: NoiseSchedule;
+ /** Stochasticity parameter (0 = DDIM deterministic, 1 = DDPM stochastic). */
+ eta: number;
+ /** Beta start for linear schedule. */
+ betaStart: number;
+ /** Beta end for linear schedule. */
+ betaEnd: number;
+}
+
+/** Precomputed noise schedule values. */
+export interface NoiseScheduleValues {
+ /** Betas at each timestep. */
+ betas: Float64Array;
+ /** Alphas (1 - beta). */
+ alphas: Float64Array;
+ /** Cumulative product of alphas. */
+ alphasCumprod: Float64Array;
+ /** Square root of alphasCumprod. */
+ sqrtAlphasCumprod: Float64Array;
+ /** Square root of (1 - alphasCumprod). */
+ sqrtOneMinusAlphasCumprod: Float64Array;
+}
+
+/** Compute noise schedule from config. */
+export function computeNoiseSchedule(config: DDIMConfig): NoiseScheduleValues {
+ const T = config.numTrainTimesteps;
+ const betas = new Float64Array(T);
+ const alphas = new Float64Array(T);
+ const alphasCumprod = new Float64Array(T);
+ const sqrtAlphasCumprod = new Float64Array(T);
+ const sqrtOneMinusAlphasCumprod = new Float64Array(T);
+
+ if (config.schedule === "linear") {
+ const step = (config.betaEnd - config.betaStart) / (T - 1);
+ for (let t = 0; t < T; t++) {
+ betas[t] = config.betaStart + t * step;
+ }
+ } else if (config.schedule === "cosine") {
+ const s = 0.008;
+ const f0 = Math.cos(((0 / T + s) / (1 + s)) * (Math.PI / 2)) ** 2;
+ for (let t = 0; t < T; t++) {
+ const ft = Math.cos((((t + 1) / T + s) / (1 + s)) * (Math.PI / 2)) ** 2;
+ betas[t] = Math.min(1 - ft / f0, 0.999);
+ }
+ } else {
+ // sqrt schedule
+ for (let t = 0; t < T; t++) {
+ const frac = t / (T - 1);
+ betas[t] = config.betaStart + (config.betaEnd - config.betaStart) * Math.sqrt(frac);
+ }
+ }
+
+ let cumprod = 1.0;
+ for (let t = 0; t < T; t++) {
+ alphas[t] = 1 - (betas[t] ?? 0);
+ cumprod *= alphas[t] ?? 1;
+ alphasCumprod[t] = cumprod;
+ sqrtAlphasCumprod[t] = Math.sqrt(cumprod);
+ sqrtOneMinusAlphasCumprod[t] = Math.sqrt(1 - cumprod);
+ }
+
+ return { betas, alphas, alphasCumprod, sqrtAlphasCumprod, sqrtOneMinusAlphasCumprod };
+}
+
+/** Add noise to a sample at a given timestep. */
+export function addNoise(
+ sample: Float64Array,
+ noise: Float64Array,
+ timestep: number,
+ schedule: NoiseScheduleValues,
+): Float64Array {
+ const sqrtAcp = schedule.sqrtAlphasCumprod[timestep] ?? 0;
+ const sqrtOm = schedule.sqrtOneMinusAlphasCumprod[timestep] ?? 0;
+ const noisy = new Float64Array(sample.length);
+ for (let i = 0; i < sample.length; i++) {
+ noisy[i] = sqrtAcp * (sample[i] ?? 0) + sqrtOm * (noise[i] ?? 0);
+ }
+ return noisy;
+}
+
+/** DDIM step: predict x0 from noisy xt and noise prediction. */
+export function ddimStep(
+ xt: Float64Array,
+ noisePred: Float64Array,
+ tPrev: number,
+ tCurr: number,
+ schedule: NoiseScheduleValues,
+ eta: number,
+): Float64Array {
+ const acpCurr = schedule.alphasCumprod[tCurr] ?? 0;
+ const acpPrev = tPrev >= 0 ? (schedule.alphasCumprod[tPrev] ?? 0) : 1.0;
+ const sqrtAcpCurr = Math.sqrt(acpCurr);
+ const sqrtOneMinusAcpCurr = Math.sqrt(1 - acpCurr);
+ const sqrtAcpPrev = Math.sqrt(acpPrev);
+
+ const sigmaT =
+ eta *
+ Math.sqrt(((1 - acpPrev) / (1 - acpCurr)) * (1 - acpCurr / acpPrev));
+
+ const result = new Float64Array(xt.length);
+ for (let i = 0; i < xt.length; i++) {
+ const xi = xt[i] ?? 0;
+ const ni = noisePred[i] ?? 0;
+ // Predict x0
+ const x0Pred = (xi - sqrtOneMinusAcpCurr * ni) / (sqrtAcpCurr || 1e-8);
+ // Direction pointing to xt
+ const dirXt = Math.sqrt(Math.max(0, 1 - acpPrev - sigmaT * sigmaT)) * ni;
+ result[i] = sqrtAcpPrev * x0Pred + dirXt;
+ }
+ return result;
+}
+
+/** Generate a sequence of timesteps for DDIM inference. */
+export function ddimTimesteps(
+ numTrainTimesteps: number,
+ numInferenceSteps: number,
+): number[] {
+ const step = Math.floor(numTrainTimesteps / numInferenceSteps);
+ const timesteps: number[] = [];
+ for (let i = numInferenceSteps - 1; i >= 0; i--) {
+ timesteps.push(i * step);
+ }
+ return timesteps;
+}
+
+/** Compute signal-to-noise ratio at timestep t. */
+export function snrAtTimestep(t: number, schedule: NoiseScheduleValues): number {
+ const acp = schedule.alphasCumprod[t] ?? 0;
+ return acp / (1 - acp + 1e-8);
+}
diff --git a/src/ml/ft_transformer.ts b/src/ml/ft_transformer.ts
new file mode 100644
index 000000000..534aa7eca
--- /dev/null
+++ b/src/ml/ft_transformer.ts
@@ -0,0 +1,205 @@
+/**
+ * Feature Tokenizer + Transformer (FT-Transformer) for tabular data.
+ *
+ * Implements the FT-Transformer architecture from Gorishniy et al. (2021):
+ * numerical and categorical feature tokenization, multi-head self-attention,
+ * feed-forward blocks, and a [CLS] token for classification/regression.
+ *
+ * @module
+ */
+
+/** Multi-head self-attention output. */
+export interface AttentionOutput {
+ /** Context vectors [seqLen x dModel]. */
+ context: Float64Array;
+ /** Attention weights [numHeads x seqLen x seqLen]. */
+ weights: Float64Array;
+}
+
+/** Scaled dot-product attention for a single head. */
+export function scaledDotProductAttention(
+ Q: Float64Array,
+ K: Float64Array,
+ V: Float64Array,
+ seqLen: number,
+ dHead: number,
+): { context: Float64Array; weights: Float64Array } {
+ const scale = Math.sqrt(dHead);
+ // Scores [seqLen x seqLen]
+ const scores = new Float64Array(seqLen * seqLen);
+ for (let i = 0; i < seqLen; i++) {
+ for (let j = 0; j < seqLen; j++) {
+ let dot = 0;
+ for (let d = 0; d < dHead; d++) {
+ dot += (Q[i * dHead + d] ?? 0) * (K[j * dHead + d] ?? 0);
+ }
+ scores[i * seqLen + j] = dot / scale;
+ }
+ }
+ // Softmax over rows
+ const weights = new Float64Array(seqLen * seqLen);
+ for (let i = 0; i < seqLen; i++) {
+ let maxScore = -Infinity;
+ for (let j = 0; j < seqLen; j++) maxScore = Math.max(maxScore, scores[i * seqLen + j] ?? 0);
+ let sumExp = 0;
+ for (let j = 0; j < seqLen; j++) {
+ const e = Math.exp((scores[i * seqLen + j] ?? 0) - maxScore);
+ weights[i * seqLen + j] = e;
+ sumExp += e;
+ }
+ for (let j = 0; j < seqLen; j++) {
+ weights[i * seqLen + j] = (weights[i * seqLen + j] ?? 0) / (sumExp || 1);
+ }
+ }
+ // Context [seqLen x dHead]
+ const context = new Float64Array(seqLen * dHead);
+ for (let i = 0; i < seqLen; i++) {
+ for (let d = 0; d < dHead; d++) {
+ let val = 0;
+ for (let j = 0; j < seqLen; j++) {
+ val += (weights[i * seqLen + j] ?? 0) * (V[j * dHead + d] ?? 0);
+ }
+ context[i * dHead + d] = val;
+ }
+ }
+ return { context, weights };
+}
+
+/** Layer normalization. */
+export function layerNorm(
+ x: Float64Array,
+ gamma: Float64Array,
+ beta: Float64Array,
+ eps: number = 1e-5,
+): Float64Array {
+ let mean = 0;
+ for (let i = 0; i < x.length; i++) mean += x[i] ?? 0;
+ mean /= x.length;
+ let variance = 0;
+ for (let i = 0; i < x.length; i++) {
+ const d = (x[i] ?? 0) - mean;
+ variance += d * d;
+ }
+ variance /= x.length;
+ const std = Math.sqrt(variance + eps);
+ const out = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) {
+ out[i] = ((x[i] ?? 0) - mean) / std * (gamma[i] ?? 1) + (beta[i] ?? 0);
+ }
+ return out;
+}
+
+/** GELU activation (approximate). */
+export function gelu(x: number): number {
+ return 0.5 * x * (1 + Math.tanh(Math.sqrt(2 / Math.PI) * (x + 0.044715 * x * x * x)));
+}
+
+/** Feed-forward block: Linear -> GELU -> Linear. */
+export function feedForward(
+ x: Float64Array,
+ W1: Float64Array,
+ b1: Float64Array,
+ W2: Float64Array,
+ b2: Float64Array,
+ dModel: number,
+ dFF: number,
+): Float64Array {
+ // First layer
+ const h = new Float64Array(dFF);
+ for (let j = 0; j < dFF; j++) {
+ let sum = b1[j] ?? 0;
+ for (let i = 0; i < dModel; i++) {
+ sum += (W1[j * dModel + i] ?? 0) * (x[i] ?? 0);
+ }
+ h[j] = gelu(sum);
+ }
+ // Second layer
+ const out = new Float64Array(dModel);
+ for (let i = 0; i < dModel; i++) {
+ let sum = b2[i] ?? 0;
+ for (let j = 0; j < dFF; j++) {
+ sum += (W2[i * dFF + j] ?? 0) * (h[j] ?? 0);
+ }
+ out[i] = sum;
+ }
+ return out;
+}
+
+/** Tokenize a numerical feature: embed to dModel dimensions. */
+export function tokenizeNumerical(
+ value: number,
+ embedding: Float64Array,
+ bias: Float64Array,
+): Float64Array {
+ const out = new Float64Array(embedding.length);
+ for (let i = 0; i < embedding.length; i++) {
+ out[i] = value * (embedding[i] ?? 0) + (bias[i] ?? 0);
+ }
+ return out;
+}
+
+/** Tokenize a categorical feature via embedding lookup. */
+export function tokenizeCategorical(
+ categoryIndex: number,
+ embeddingMatrix: Float64Array,
+ numCategories: number,
+ dModel: number,
+): Float64Array {
+ const idx = Math.max(0, Math.min(categoryIndex, numCategories - 1));
+ const out = new Float64Array(dModel);
+ for (let i = 0; i < dModel; i++) {
+ out[i] = embeddingMatrix[idx * dModel + i] ?? 0;
+ }
+ return out;
+}
+
+/** Add residual connection. */
+export function addResidual(x: Float64Array, residual: Float64Array): Float64Array {
+ const out = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) {
+ out[i] = (x[i] ?? 0) + (residual[i] ?? 0);
+ }
+ return out;
+}
+
+/** Extract [CLS] token representation (first token). */
+export function extractCLSToken(tokens: Float64Array, dModel: number): Float64Array {
+ const cls = new Float64Array(dModel);
+ for (let i = 0; i < dModel; i++) {
+ cls[i] = tokens[i] ?? 0;
+ }
+ return cls;
+}
+
+/** Simple linear classifier head. */
+export function linearHead(
+ x: Float64Array,
+ W: Float64Array,
+ b: Float64Array,
+ numClasses: number,
+ dModel: number,
+): Float64Array {
+ const logits = new Float64Array(numClasses);
+ for (let c = 0; c < numClasses; c++) {
+ let sum = b[c] ?? 0;
+ for (let i = 0; i < dModel; i++) {
+ sum += (W[c * dModel + i] ?? 0) * (x[i] ?? 0);
+ }
+ logits[c] = sum;
+ }
+ return logits;
+}
+
+/** Softmax activation. */
+export function softmax(logits: Float64Array): Float64Array {
+ let maxVal = -Infinity;
+ for (let i = 0; i < logits.length; i++) maxVal = Math.max(maxVal, logits[i] ?? 0);
+ let sumExp = 0;
+ const out = new Float64Array(logits.length);
+ for (let i = 0; i < logits.length; i++) {
+ out[i] = Math.exp((logits[i] ?? 0) - maxVal);
+ sumExp += out[i] ?? 0;
+ }
+ for (let i = 0; i < out.length; i++) out[i] = (out[i] ?? 0) / (sumExp || 1);
+ return out;
+}
diff --git a/src/ml/gradient_boosting.ts b/src/ml/gradient_boosting.ts
new file mode 100644
index 000000000..ba44af49c
--- /dev/null
+++ b/src/ml/gradient_boosting.ts
@@ -0,0 +1,216 @@
+/**
+ * Gradient Boosting from scratch.
+ *
+ * Implements gradient boosted regression trees (GBRT) with:
+ * - Mean squared error and log-loss objectives
+ * - CART decision trees as base learners
+ * - Shrinkage (learning rate), subsampling, and max depth
+ *
+ * @module
+ */
+
+/** A leaf or internal node in a decision tree. */
+export type TreeNode =
+ | { kind: "leaf"; value: number }
+ | { kind: "internal"; featureIndex: number; threshold: number; left: TreeNode; right: TreeNode };
+
+/** Decision tree parameters. */
+export interface TreeParams {
+ maxDepth: number;
+ minSamplesLeaf: number;
+}
+
+/** Predict with a decision tree. */
+export function treePredictOne(node: TreeNode, x: Float64Array): number {
+ if (node.kind === "leaf") return node.value;
+ const val = x[node.featureIndex] ?? 0;
+ return val <= node.threshold
+ ? treePredictOne(node.left, x)
+ : treePredictOne(node.right, x);
+}
+
+/** Predict for an array of samples. */
+export function treePredict(node: TreeNode, X: Float64Array[]): Float64Array {
+ return Float64Array.from(X.map((x) => treePredictOne(node, x)));
+}
+
+/** Compute mean of an array of values at given indices. */
+function meanAt(y: Float64Array, indices: number[]): number {
+ if (indices.length === 0) return 0;
+ let s = 0;
+ for (const i of indices) s += y[i] ?? 0;
+ return s / indices.length;
+}
+
+/** Compute MSE of an array at given indices. */
+function mseAt(y: Float64Array, indices: number[], mean: number): number {
+ let s = 0;
+ for (const i of indices) {
+ const d = (y[i] ?? 0) - mean;
+ s += d * d;
+ }
+ return s;
+}
+
+/** Find best split for a set of indices. */
+function findBestSplit(
+ X: Float64Array[],
+ y: Float64Array,
+ indices: number[],
+ numFeatures: number,
+): { featureIndex: number; threshold: number; gain: number } | null {
+ const parentMean = meanAt(y, indices);
+ const parentMSE = mseAt(y, indices, parentMean);
+ let bestGain = -Infinity;
+ let bestFeature = 0;
+ let bestThreshold = 0;
+
+ for (let f = 0; f < numFeatures; f++) {
+ // Sort indices by feature value
+ const sorted = [...indices].sort((a, b) => (X[a]![f] ?? 0) - (X[b]![f] ?? 0));
+ for (let k = 1; k < sorted.length; k++) {
+ const threshold = ((X[sorted[k - 1]!]![f] ?? 0) + (X[sorted[k]!]![f] ?? 0)) / 2;
+ const left = sorted.slice(0, k);
+ const right = sorted.slice(k);
+ const lMean = meanAt(y, left);
+ const rMean = meanAt(y, right);
+ const gain = parentMSE - mseAt(y, left, lMean) - mseAt(y, right, rMean);
+ if (gain > bestGain) {
+ bestGain = gain;
+ bestFeature = f;
+ bestThreshold = threshold;
+ }
+ }
+ }
+
+ return bestGain > 0 ? { featureIndex: bestFeature, threshold: bestThreshold, gain: bestGain } : null;
+}
+
+/** Build a regression tree on gradient residuals. */
+export function buildTree(
+ X: Float64Array[],
+ y: Float64Array,
+ indices: number[],
+ depth: number,
+ params: TreeParams,
+): TreeNode {
+ const leafVal = meanAt(y, indices);
+
+ if (depth >= params.maxDepth || indices.length <= params.minSamplesLeaf * 2) {
+ return { kind: "leaf", value: leafVal };
+ }
+
+ const numFeatures = X[0]?.length ?? 0;
+ const split = findBestSplit(X, y, indices, numFeatures);
+
+ if (split === null) {
+ return { kind: "leaf", value: leafVal };
+ }
+
+ const left: number[] = [];
+ const right: number[] = [];
+ for (const i of indices) {
+ if ((X[i]![split.featureIndex] ?? 0) <= split.threshold) {
+ left.push(i);
+ } else {
+ right.push(i);
+ }
+ }
+
+ if (left.length < params.minSamplesLeaf || right.length < params.minSamplesLeaf) {
+ return { kind: "leaf", value: leafVal };
+ }
+
+ return {
+ kind: "internal",
+ featureIndex: split.featureIndex,
+ threshold: split.threshold,
+ left: buildTree(X, y, left, depth + 1, params),
+ right: buildTree(X, y, right, depth + 1, params),
+ };
+}
+
+/** Gradient boosting ensemble. */
+export interface GBMEnsemble {
+ trees: TreeNode[];
+ learningRate: number;
+ initialPrediction: number;
+}
+
+/** MSE negative gradient (residuals). */
+export function mseGradient(y: Float64Array, yPred: Float64Array): Float64Array {
+ const g = new Float64Array(y.length);
+ for (let i = 0; i < y.length; i++) g[i] = (y[i] ?? 0) - (yPred[i] ?? 0);
+ return g;
+}
+
+/** Train gradient boosted regression trees. */
+export function fitGBM(
+ X: Float64Array[],
+ y: Float64Array,
+ nEstimators: number = 100,
+ learningRate: number = 0.1,
+ maxDepth: number = 3,
+ minSamplesLeaf: number = 1,
+): GBMEnsemble {
+ const n = y.length;
+ let sumY = 0;
+ for (let i = 0; i < n; i++) sumY += y[i] ?? 0;
+ const initialPrediction = sumY / (n || 1);
+
+ const yPred = new Float64Array(n).fill(initialPrediction);
+ const trees: TreeNode[] = [];
+ const params: TreeParams = { maxDepth, minSamplesLeaf };
+ const indices = Array.from({ length: n }, (_, i) => i);
+
+ for (let m = 0; m < nEstimators; m++) {
+ const residuals = mseGradient(y, yPred);
+ const tree = buildTree(X, residuals, indices, 0, params);
+ trees.push(tree);
+ const treePreds = treePredict(tree, X);
+ for (let i = 0; i < n; i++) {
+ yPred[i] = (yPred[i] ?? 0) + learningRate * (treePreds[i] ?? 0);
+ }
+ }
+
+ return { trees, learningRate, initialPrediction };
+}
+
+/** Predict with a trained GBM ensemble. */
+export function predictGBM(ensemble: GBMEnsemble, X: Float64Array[]): Float64Array {
+ const n = X.length;
+ const yPred = new Float64Array(n).fill(ensemble.initialPrediction);
+ for (const tree of ensemble.trees) {
+ const preds = treePredict(tree, X);
+ for (let i = 0; i < n; i++) {
+ yPred[i] = (yPred[i] ?? 0) + ensemble.learningRate * (preds[i] ?? 0);
+ }
+ }
+ return yPred;
+}
+
+/** Compute mean squared error. */
+export function mse(y: Float64Array, yPred: Float64Array): number {
+ let s = 0;
+ for (let i = 0; i < y.length; i++) {
+ const d = (y[i] ?? 0) - (yPred[i] ?? 0);
+ s += d * d;
+ }
+ return s / (y.length || 1);
+}
+
+/** Compute R² score. */
+export function r2Score(y: Float64Array, yPred: Float64Array): number {
+ let sumY = 0;
+ for (let i = 0; i < y.length; i++) sumY += y[i] ?? 0;
+ const meanY = sumY / (y.length || 1);
+ let ssTot = 0;
+ let ssRes = 0;
+ for (let i = 0; i < y.length; i++) {
+ const d1 = (y[i] ?? 0) - meanY;
+ const d2 = (y[i] ?? 0) - (yPred[i] ?? 0);
+ ssTot += d1 * d1;
+ ssRes += d2 * d2;
+ }
+ return 1 - ssRes / (ssTot || 1);
+}
diff --git a/src/ml/neural_network.ts b/src/ml/neural_network.ts
new file mode 100644
index 000000000..c3389451b
--- /dev/null
+++ b/src/ml/neural_network.ts
@@ -0,0 +1,200 @@
+/**
+ * Neural Network layers and training utilities from scratch.
+ *
+ * Implements dense layers, activations, loss functions, and
+ * mini-batch SGD/Adam optimizer for feed-forward networks.
+ *
+ * @module
+ */
+
+/** Dense layer forward pass: y = W x + b. */
+export function denseForward(
+ x: Float64Array,
+ W: Float64Array,
+ b: Float64Array,
+ outDim: number,
+ inDim: number,
+): Float64Array {
+ const y = new Float64Array(outDim);
+ for (let i = 0; i < outDim; i++) {
+ let sum = b[i] ?? 0;
+ for (let j = 0; j < inDim; j++) {
+ sum += (W[i * inDim + j] ?? 0) * (x[j] ?? 0);
+ }
+ y[i] = sum;
+ }
+ return y;
+}
+
+/** Dense layer backward pass: returns dL/dx, dL/dW, dL/db. */
+export function denseBackward(
+ x: Float64Array,
+ W: Float64Array,
+ dOut: Float64Array,
+ outDim: number,
+ inDim: number,
+): { dX: Float64Array; dW: Float64Array; dB: Float64Array } {
+ const dX = new Float64Array(inDim);
+ const dW = new Float64Array(outDim * inDim);
+ const dB = new Float64Array(outDim);
+
+ for (let i = 0; i < outDim; i++) {
+ dB[i] = dOut[i] ?? 0;
+ for (let j = 0; j < inDim; j++) {
+ dW[i * inDim + j] = (dOut[i] ?? 0) * (x[j] ?? 0);
+ dX[j] = (dX[j] ?? 0) + (dOut[i] ?? 0) * (W[i * inDim + j] ?? 0);
+ }
+ }
+ return { dX, dW, dB };
+}
+
+/** ReLU activation and its gradient. */
+export function relu(x: Float64Array): Float64Array {
+ const out = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) out[i] = Math.max(0, x[i] ?? 0);
+ return out;
+}
+
+export function reluGrad(x: Float64Array, dOut: Float64Array): Float64Array {
+ const dX = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) dX[i] = (x[i] ?? 0) > 0 ? (dOut[i] ?? 0) : 0;
+ return dX;
+}
+
+/** Sigmoid activation and its gradient. */
+export function sigmoidActivation(x: Float64Array): Float64Array {
+ const out = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) out[i] = 1 / (1 + Math.exp(-(x[i] ?? 0)));
+ return out;
+}
+
+export function sigmoidGrad(out: Float64Array, dOut: Float64Array): Float64Array {
+ const dX = new Float64Array(out.length);
+ for (let i = 0; i < out.length; i++) {
+ const s = out[i] ?? 0;
+ dX[i] = s * (1 - s) * (dOut[i] ?? 0);
+ }
+ return dX;
+}
+
+/** Softmax and cross-entropy loss (combined for numerical stability). */
+export function softmaxCrossEntropy(
+ logits: Float64Array,
+ labels: Float64Array,
+): { loss: number; dLogits: Float64Array } {
+ const n = logits.length;
+ let maxLogit = -Infinity;
+ for (let i = 0; i < n; i++) maxLogit = Math.max(maxLogit, logits[i] ?? -Infinity);
+
+ let sumExp = 0;
+ const probs = new Float64Array(n);
+ for (let i = 0; i < n; i++) {
+ probs[i] = Math.exp((logits[i] ?? 0) - maxLogit);
+ sumExp += probs[i] ?? 0;
+ }
+ let loss = 0;
+ for (let i = 0; i < n; i++) {
+ probs[i] = (probs[i] ?? 0) / (sumExp || 1);
+ const label = labels[i] ?? 0;
+ if (label > 0) loss -= label * Math.log(Math.max(probs[i] ?? 0, 1e-12));
+ }
+
+ const dLogits = new Float64Array(n);
+ for (let i = 0; i < n; i++) dLogits[i] = (probs[i] ?? 0) - (labels[i] ?? 0);
+ return { loss, dLogits };
+}
+
+/** MSE loss and gradient. */
+export function mseLoss(
+ pred: Float64Array,
+ target: Float64Array,
+): { loss: number; dPred: Float64Array } {
+ const dPred = new Float64Array(pred.length);
+ let loss = 0;
+ for (let i = 0; i < pred.length; i++) {
+ const d = (pred[i] ?? 0) - (target[i] ?? 0);
+ loss += d * d;
+ dPred[i] = 2 * d / pred.length;
+ }
+ return { loss: loss / pred.length, dPred };
+}
+
+/** Adam optimizer state. */
+export interface AdamState {
+ m: Float64Array;
+ v: Float64Array;
+ t: number;
+ lr: number;
+ beta1: number;
+ beta2: number;
+ eps: number;
+}
+
+/** Initialize Adam optimizer state for a parameter vector. */
+export function initAdam(
+ paramSize: number,
+ lr: number = 1e-3,
+ beta1: number = 0.9,
+ beta2: number = 0.999,
+ eps: number = 1e-8,
+): AdamState {
+ return { m: new Float64Array(paramSize), v: new Float64Array(paramSize), t: 0, lr, beta1, beta2, eps };
+}
+
+/** Adam update step: modifies params in-place, returns updated AdamState. */
+export function adamStep(
+ params: Float64Array,
+ grads: Float64Array,
+ state: AdamState,
+): AdamState {
+ const { lr, beta1, beta2, eps } = state;
+ const t = state.t + 1;
+ const m = new Float64Array(params.length);
+ const v = new Float64Array(params.length);
+
+ for (let i = 0; i < params.length; i++) {
+ const g = grads[i] ?? 0;
+ m[i] = beta1 * (state.m[i] ?? 0) + (1 - beta1) * g;
+ v[i] = beta2 * (state.v[i] ?? 0) + (1 - beta2) * g * g;
+ const mHat = (m[i] ?? 0) / (1 - Math.pow(beta1, t));
+ const vHat = (v[i] ?? 0) / (1 - Math.pow(beta2, t));
+ params[i] = (params[i] ?? 0) - lr * mHat / (Math.sqrt(vHat) + eps);
+ }
+
+ return { ...state, m, v, t };
+}
+
+/** He initialization for ReLU networks. */
+export function heInit(inDim: number, outDim: number, rngSeed: number = 42): Float64Array {
+ const weights = new Float64Array(outDim * inDim);
+ let state = rngSeed >>> 0;
+ const std = Math.sqrt(2 / inDim);
+ for (let i = 0; i < weights.length; i++) {
+ // Box-Muller transform for Gaussian noise
+ state = (Math.imul(1664525, state) + 1013904223) >>> 0;
+ const u1 = (state / 4294967296) || 1e-10;
+ state = (Math.imul(1664525, state) + 1013904223) >>> 0;
+ const u2 = state / 4294967296;
+ weights[i] = std * Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+ }
+ return weights;
+}
+
+/** Dropout mask (for training). */
+export function dropoutMask(size: number, rate: number, rngSeed: number): Float64Array {
+ const mask = new Float64Array(size);
+ let state = rngSeed >>> 0;
+ const scale = 1 / (1 - rate);
+ for (let i = 0; i < size; i++) {
+ state = (Math.imul(1664525, state) + 1013904223) >>> 0;
+ mask[i] = state / 4294967296 > rate ? scale : 0;
+ }
+ return mask;
+}
+
+/** Apply dropout mask to activations. */
+export function applyDropout(x: Float64Array, mask: Float64Array): Float64Array {
+ const out = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) out[i] = (x[i] ?? 0) * (mask[i] ?? 0);
+ return out;
+}
diff --git a/src/ml/random_forest.ts b/src/ml/random_forest.ts
new file mode 100644
index 000000000..9b54d12fd
--- /dev/null
+++ b/src/ml/random_forest.ts
@@ -0,0 +1,173 @@
+/**
+ * Random Forest implementation from scratch.
+ *
+ * Implements bootstrap aggregation (bagging) of CART decision trees
+ * with random feature subsampling at each split (random forest).
+ * Supports both classification and regression.
+ *
+ * @module
+ */
+
+import { buildTree, treePredict, type TreeParams, type TreeNode } from "./gradient_boosting.ts";
+
+/** Random Forest configuration. */
+export interface RandomForestConfig {
+ nEstimators: number;
+ maxDepth: number;
+ minSamplesLeaf: number;
+ /** Number of features to consider at each split (0 = sqrt(n_features)). */
+ maxFeatures: number;
+ /** Bootstrap sample size (0 = n_samples). */
+ sampleSize: number;
+ seed: number;
+}
+
+/** LCG pseudo-random number generator. */
+export class LCGRandom {
+ private state: number;
+ constructor(seed: number) {
+ this.state = seed >>> 0;
+ }
+ next(): number {
+ this.state = (Math.imul(1664525, this.state) + 1013904223) >>> 0;
+ return this.state / 4294967296;
+ }
+ nextInt(n: number): number {
+ return Math.floor(this.next() * n);
+ }
+}
+
+/** Bootstrap sample indices. */
+function bootstrapSample(n: number, size: number, rng: LCGRandom): number[] {
+ const indices: number[] = [];
+ for (let i = 0; i < size; i++) indices.push(rng.nextInt(n));
+ return indices;
+}
+
+function selectFeatures(numFeatures: number, maxFeatures: number, rng: LCGRandom): number[] {
+ const k = maxFeatures <= 0 ? Math.max(1, Math.floor(Math.sqrt(numFeatures))) : Math.min(maxFeatures, numFeatures);
+ const all = Array.from({ length: numFeatures }, (_, i) => i);
+ // Fisher-Yates shuffle and take first k
+ for (let i = numFeatures - 1; i > 0; i--) {
+ const j = rng.nextInt(i + 1);
+ [all[i], all[j]] = [all[j]!, all[i]!];
+ }
+ return all.slice(0, k);
+}
+
+/** Random Forest model. */
+export interface RandomForestModel {
+ trees: TreeNode[];
+ featureMaps: number[][];
+ config: RandomForestConfig;
+ numFeatures: number;
+}
+
+/** Train a Random Forest regressor. */
+export function fitRandomForest(
+ X: Float64Array[],
+ y: Float64Array,
+ config: Partial = {},
+): RandomForestModel {
+ const cfg: RandomForestConfig = {
+ nEstimators: 100,
+ maxDepth: 5,
+ minSamplesLeaf: 1,
+ maxFeatures: 0,
+ sampleSize: 0,
+ seed: 42,
+ ...config,
+ };
+
+ const n = X.length;
+ const numFeatures = X[0]?.length ?? 0;
+ const sampleSize = cfg.sampleSize <= 0 ? n : cfg.sampleSize;
+ const rng = new LCGRandom(cfg.seed);
+ const params: TreeParams = { maxDepth: cfg.maxDepth, minSamplesLeaf: cfg.minSamplesLeaf };
+
+ const trees: TreeNode[] = [];
+ const featureMaps: number[][] = [];
+
+ for (let t = 0; t < cfg.nEstimators; t++) {
+ const indices = bootstrapSample(n, sampleSize, rng);
+ const k = cfg.maxFeatures <= 0 ? Math.max(1, Math.floor(Math.sqrt(numFeatures))) : Math.min(cfg.maxFeatures, numFeatures);
+ const featureSubset = selectFeatures(numFeatures, k, rng);
+ featureMaps.push(featureSubset);
+
+ // Build tree on bootstrap sample with projected features
+ const subX: Float64Array[] = [];
+ const subY = new Float64Array(indices.length);
+ for (let i = 0; i < indices.length; i++) {
+ const xi = X[indices[i]!]!;
+ const projected = new Float64Array(featureSubset.length);
+ for (let j = 0; j < featureSubset.length; j++) {
+ projected[j] = xi[featureSubset[j]!] ?? 0;
+ }
+ subX.push(projected);
+ subY[i] = y[indices[i]!] ?? 0;
+ }
+ const allIdx = Array.from({ length: indices.length }, (_, i) => i);
+ trees.push(buildTree(subX, subY, allIdx, 0, params));
+ }
+
+ return { trees, featureMaps, config: cfg, numFeatures };
+}
+
+/** Predict with a Random Forest (regression: average of trees). */
+export function predictRandomForest(model: RandomForestModel, X: Float64Array[]): Float64Array {
+ const n = X.length;
+ const sum = new Float64Array(n);
+
+ for (let t = 0; t < model.trees.length; t++) {
+ const featureMap = model.featureMaps[t]!;
+ const projX: Float64Array[] = X.map((xi) => {
+ const p = new Float64Array(featureMap.length);
+ for (let j = 0; j < featureMap.length; j++) p[j] = xi[featureMap[j]!] ?? 0;
+ return p;
+ });
+ const preds = treePredict(model.trees[t]!, projX);
+ for (let i = 0; i < n; i++) sum[i] = (sum[i] ?? 0) + (preds[i] ?? 0);
+ }
+
+ const out = new Float64Array(n);
+ for (let i = 0; i < n; i++) out[i] = (sum[i] ?? 0) / (model.trees.length || 1);
+ return out;
+}
+
+/** Out-of-bag (OOB) error estimate for regression. */
+export function oobError(
+ model: RandomForestModel,
+ X: Float64Array[],
+ y: Float64Array,
+ seed: number,
+): number {
+ const n = X.length;
+ const rng = new LCGRandom(seed);
+ const sampleSize = model.config.sampleSize <= 0 ? n : model.config.sampleSize;
+ const oobPreds = new Float64Array(n);
+ const oobCounts = new Int32Array(n);
+
+ for (let t = 0; t < model.trees.length; t++) {
+ const bootstrapSet = new Set(bootstrapSample(n, sampleSize, rng));
+ const featureMap = model.featureMaps[t]!;
+ for (let i = 0; i < n; i++) {
+ if (bootstrapSet.has(i)) continue;
+ const xi = X[i]!;
+ const projected = new Float64Array(featureMap.length);
+ for (let j = 0; j < featureMap.length; j++) projected[j] = xi[featureMap[j]!] ?? 0;
+ oobPreds[i] += treePredict(model.trees[t]!, [projected])[0] ?? 0;
+ oobCounts[i]++;
+ }
+ }
+
+ let sse = 0;
+ let cnt = 0;
+ for (let i = 0; i < n; i++) {
+ if ((oobCounts[i] ?? 0) === 0) continue;
+ const pred = (oobPreds[i] ?? 0) / (oobCounts[i] ?? 1);
+ const err = (y[i] ?? 0) - pred;
+ sse += err * err;
+ cnt++;
+ }
+ return cnt > 0 ? sse / cnt : 0;
+}
diff --git a/src/ml/seq2seq.ts b/src/ml/seq2seq.ts
new file mode 100644
index 000000000..adc08f2be
--- /dev/null
+++ b/src/ml/seq2seq.ts
@@ -0,0 +1,207 @@
+/**
+ * Seq2Seq (Sequence-to-Sequence) with Bahdanau attention.
+ *
+ * Implements the encoder-decoder architecture with additive attention
+ * for tasks like machine translation, summarization, and transcription.
+ * Uses simple RNN (Elman) cells as building blocks.
+ *
+ * @module
+ */
+
+/** Sigmoid activation. */
+export function sigmoid(x: number): number {
+ return 1 / (1 + Math.exp(-x));
+}
+
+/** Tanh activation. */
+export function tanh(x: number): number {
+ return Math.tanh(x);
+}
+
+/** Simple RNN (Elman) cell: h_t = tanh(W_h * h_{t-1} + W_x * x_t + b). */
+export interface RNNCellWeights {
+ Wh: Float64Array; // [hiddenSize x hiddenSize]
+ Wx: Float64Array; // [hiddenSize x inputSize]
+ b: Float64Array; // [hiddenSize]
+ hiddenSize: number;
+ inputSize: number;
+}
+
+export function rnnCell(
+ x: Float64Array,
+ hPrev: Float64Array,
+ weights: RNNCellWeights,
+): Float64Array {
+ const { hiddenSize, inputSize } = weights;
+ const h = new Float64Array(hiddenSize);
+ for (let i = 0; i < hiddenSize; i++) {
+ let val = weights.b[i] ?? 0;
+ for (let j = 0; j < hiddenSize; j++) {
+ val += (weights.Wh[i * hiddenSize + j] ?? 0) * (hPrev[j] ?? 0);
+ }
+ for (let j = 0; j < inputSize; j++) {
+ val += (weights.Wx[i * inputSize + j] ?? 0) * (x[j] ?? 0);
+ }
+ h[i] = tanh(val);
+ }
+ return h;
+}
+
+/** Encode a sequence. Returns all hidden states [seqLen x hiddenSize]. */
+export function encode(
+ inputs: Float64Array[],
+ initialHidden: Float64Array,
+ weights: RNNCellWeights,
+): Float64Array[] {
+ const states: Float64Array[] = [];
+ let h = initialHidden;
+ for (const x of inputs) {
+ h = rnnCell(x, h, weights);
+ states.push(h);
+ }
+ return states;
+}
+
+/** Bahdanau (additive) attention weights. */
+export interface BahdanauWeights {
+ Wa: Float64Array; // [alignDim x hiddenSize] for encoder states
+ Ua: Float64Array; // [alignDim x hiddenSize] for decoder hidden
+ va: Float64Array; // [alignDim]
+ alignDim: number;
+ hiddenSize: number;
+}
+
+/** Compute Bahdanau attention weights. */
+export function bahdanauAttention(
+ decoderHidden: Float64Array,
+ encoderStates: Float64Array[],
+ weights: BahdanauWeights,
+): { context: Float64Array; alphas: Float64Array } {
+ const { alignDim, hiddenSize } = weights;
+ const seqLen = encoderStates.length;
+ const scores = new Float64Array(seqLen);
+
+ // Decoder contribution (constant for all encoder states)
+ const decoderContrib = new Float64Array(alignDim);
+ for (let k = 0; k < alignDim; k++) {
+ let s = 0;
+ for (let j = 0; j < hiddenSize; j++) {
+ s += (weights.Ua[k * hiddenSize + j] ?? 0) * (decoderHidden[j] ?? 0);
+ }
+ decoderContrib[k] = s;
+ }
+
+ for (let t = 0; t < seqLen; t++) {
+ const enc = encoderStates[t]!;
+ let score = 0;
+ for (let k = 0; k < alignDim; k++) {
+ let encContrib = 0;
+ for (let j = 0; j < hiddenSize; j++) {
+ encContrib += (weights.Wa[k * hiddenSize + j] ?? 0) * (enc[j] ?? 0);
+ }
+ score += (weights.va[k] ?? 0) * tanh(encContrib + (decoderContrib[k] ?? 0));
+ }
+ scores[t] = score;
+ }
+
+ // Softmax
+ let maxScore = -Infinity;
+ for (let t = 0; t < seqLen; t++) maxScore = Math.max(maxScore, scores[t] ?? -Infinity);
+ let sumExp = 0;
+ const alphas = new Float64Array(seqLen);
+ for (let t = 0; t < seqLen; t++) {
+ alphas[t] = Math.exp((scores[t] ?? 0) - maxScore);
+ sumExp += alphas[t] ?? 0;
+ }
+ for (let t = 0; t < seqLen; t++) alphas[t] = (alphas[t] ?? 0) / (sumExp || 1);
+
+ // Context vector
+ const context = new Float64Array(hiddenSize);
+ for (let t = 0; t < seqLen; t++) {
+ const enc = encoderStates[t]!;
+ for (let j = 0; j < hiddenSize; j++) {
+ context[j] += (alphas[t] ?? 0) * (enc[j] ?? 0);
+ }
+ }
+ return { context, alphas };
+}
+
+/** Decoder step with attention. */
+export interface DecoderWeights {
+ rnn: RNNCellWeights;
+ attention: BahdanauWeights;
+ outputW: Float64Array; // [vocabSize x hiddenSize]
+ outputB: Float64Array; // [vocabSize]
+ vocabSize: number;
+}
+
+export interface DecoderStepResult {
+ hidden: Float64Array;
+ logits: Float64Array;
+ attentionWeights: Float64Array;
+}
+
+export function decoderStep(
+ inputEmbedding: Float64Array,
+ prevHidden: Float64Array,
+ encoderStates: Float64Array[],
+ weights: DecoderWeights,
+): DecoderStepResult {
+ const { context, alphas } = bahdanauAttention(prevHidden, encoderStates, weights.attention);
+
+ // Concatenate input embedding and context
+ const rnnInput = new Float64Array(inputEmbedding.length + context.length);
+ for (let i = 0; i < inputEmbedding.length; i++) rnnInput[i] = inputEmbedding[i] ?? 0;
+ for (let i = 0; i < context.length; i++) rnnInput[inputEmbedding.length + i] = context[i] ?? 0;
+
+ const hidden = rnnCell(rnnInput, prevHidden, weights.rnn);
+
+ // Project to vocabulary
+ const logits = new Float64Array(weights.vocabSize);
+ for (let v = 0; v < weights.vocabSize; v++) {
+ let sum = weights.outputB[v] ?? 0;
+ for (let j = 0; j < hidden.length; j++) {
+ sum += (weights.outputW[v * hidden.length + j] ?? 0) * (hidden[j] ?? 0);
+ }
+ logits[v] = sum;
+ }
+
+ return { hidden, logits, attentionWeights: alphas };
+}
+
+/** Greedy decode: pick argmax at each step. */
+export function greedyDecode(
+ encoderStates: Float64Array[],
+ initialHidden: Float64Array,
+ sosEmbedding: Float64Array,
+ embeddingMatrix: Float64Array,
+ weights: DecoderWeights,
+ maxLen: number,
+ eosTokenId: number,
+): number[] {
+ const result: number[] = [];
+ let hidden = initialHidden;
+ let currentEmb = sosEmbedding;
+
+ for (let step = 0; step < maxLen; step++) {
+ const { hidden: newH, logits } = decoderStep(currentEmb, hidden, encoderStates, weights);
+ hidden = newH;
+ let bestIdx = 0;
+ let bestScore = -Infinity;
+ for (let v = 0; v < logits.length; v++) {
+ if ((logits[v] ?? -Infinity) > bestScore) {
+ bestScore = logits[v] ?? -Infinity;
+ bestIdx = v;
+ }
+ }
+ result.push(bestIdx);
+ if (bestIdx === eosTokenId) break;
+ // Get next embedding
+ const dEmb = weights.rnn.inputSize - weights.attention.hiddenSize;
+ currentEmb = new Float64Array(dEmb);
+ for (let i = 0; i < dEmb; i++) {
+ currentEmb[i] = embeddingMatrix[bestIdx * dEmb + i] ?? 0;
+ }
+ }
+ return result;
+}
diff --git a/src/ml/svm.ts b/src/ml/svm.ts
new file mode 100644
index 000000000..198c3a852
--- /dev/null
+++ b/src/ml/svm.ts
@@ -0,0 +1,197 @@
+/**
+ * Support Vector Machine (SVM) with SMO algorithm.
+ *
+ * Implements binary SVM classification with:
+ * - Linear, polynomial, and RBF kernels
+ * - Sequential Minimal Optimization (SMO) training
+ * - Support vector regression (SVR) epsilon-insensitive loss
+ *
+ * @module
+ */
+
+/** Kernel function type. */
+export type KernelType = "linear" | "poly" | "rbf";
+
+/** SVM kernel configuration. */
+export interface SVMKernelConfig {
+ type: KernelType;
+ /** Gamma for RBF and polynomial kernels. */
+ gamma: number;
+ /** Degree for polynomial kernel. */
+ degree: number;
+ /** Coef0 for polynomial kernel. */
+ coef0: number;
+}
+
+/** Compute kernel between two vectors. */
+export function computeKernel(
+ x1: Float64Array,
+ x2: Float64Array,
+ config: SVMKernelConfig,
+): number {
+ if (config.type === "linear") {
+ let dot = 0;
+ for (let i = 0; i < x1.length; i++) dot += (x1[i] ?? 0) * (x2[i] ?? 0);
+ return dot;
+ } else if (config.type === "rbf") {
+ let sqDist = 0;
+ for (let i = 0; i < x1.length; i++) {
+ const d = (x1[i] ?? 0) - (x2[i] ?? 0);
+ sqDist += d * d;
+ }
+ return Math.exp(-config.gamma * sqDist);
+ } else {
+ // Polynomial
+ let dot = 0;
+ for (let i = 0; i < x1.length; i++) dot += (x1[i] ?? 0) * (x2[i] ?? 0);
+ return (config.gamma * dot + config.coef0) ** config.degree;
+ }
+}
+
+/** Trained SVM model. */
+export interface SVMModel {
+ /** Lagrange multipliers (support vector weights). */
+ alphas: Float64Array;
+ /** Training labels (-1 or +1). */
+ labels: Float64Array;
+ /** Training features. */
+ supportVectors: Float64Array[];
+ /** Bias term. */
+ b: number;
+ kernel: SVMKernelConfig;
+}
+
+/** Compute decision function value for a single sample. */
+export function svmDecision(model: SVMModel, x: Float64Array): number {
+ let sum = -model.b;
+ for (let i = 0; i < model.supportVectors.length; i++) {
+ const alpha = model.alphas[i] ?? 0;
+ if (Math.abs(alpha) < 1e-8) continue;
+ sum += alpha * (model.labels[i] ?? 0) * computeKernel(model.supportVectors[i]!, x, model.kernel);
+ }
+ return sum;
+}
+
+/** Predict class labels for an array of samples. */
+export function svmPredict(model: SVMModel, X: Float64Array[]): Int8Array {
+ const out = new Int8Array(X.length);
+ for (let i = 0; i < X.length; i++) {
+ out[i] = svmDecision(model, X[i]!) >= 0 ? 1 : -1;
+ }
+ return out;
+}
+
+/** SMO training algorithm for binary SVM. */
+export function fitSVM(
+ X: Float64Array[],
+ y: Float64Array,
+ C: number = 1.0,
+ kernel: SVMKernelConfig = { type: "rbf", gamma: 0.1, degree: 3, coef0: 0 },
+ maxIter: number = 200,
+ tol: number = 1e-3,
+): SVMModel {
+ const n = X.length;
+ const alphas = new Float64Array(n);
+ let b = 0;
+
+ // Precompute kernel matrix
+ const K = new Float64Array(n * n);
+ for (let i = 0; i < n; i++) {
+ for (let j = i; j < n; j++) {
+ const k = computeKernel(X[i]!, X[j]!, kernel);
+ K[i * n + j] = k;
+ K[j * n + i] = k;
+ }
+ }
+
+ for (let iter = 0; iter < maxIter; iter++) {
+ let numChanged = 0;
+
+ for (let i = 0; i < n; i++) {
+ const yi = y[i] ?? 0;
+ // Compute error
+ let fi = -b;
+ for (let k2 = 0; k2 < n; k2++) {
+ fi += (alphas[k2] ?? 0) * (y[k2] ?? 0) * (K[k2 * n + i] ?? 0);
+ }
+ const ei = fi - yi;
+
+ if (
+ (yi * ei < -tol && (alphas[i] ?? 0) < C) ||
+ (yi * ei > tol && (alphas[i] ?? 0) > 0)
+ ) {
+ // Heuristic: pick j != i with max |ei - ej|
+ let j = (i + 1) % n;
+ let maxDiff = 0;
+ for (let k2 = 0; k2 < n; k2++) {
+ if (k2 === i) continue;
+ let fj = -b;
+ for (let m = 0; m < n; m++) fj += (alphas[m] ?? 0) * (y[m] ?? 0) * (K[m * n + k2] ?? 0);
+ const ej = fj - (y[k2] ?? 0);
+ if (Math.abs(ei - ej) > maxDiff) {
+ maxDiff = Math.abs(ei - ej);
+ j = k2;
+ }
+ }
+
+ const yj = y[j] ?? 0;
+ let fj = -b;
+ for (let k2 = 0; k2 < n; k2++) fj += (alphas[k2] ?? 0) * (y[k2] ?? 0) * (K[k2 * n + j] ?? 0);
+ const ej = fj - yj;
+
+ const oldAlphaI = alphas[i] ?? 0;
+ const oldAlphaJ = alphas[j] ?? 0;
+
+ let L: number, H: number;
+ if (yi !== yj) {
+ L = Math.max(0, oldAlphaJ - oldAlphaI);
+ H = Math.min(C, C + oldAlphaJ - oldAlphaI);
+ } else {
+ L = Math.max(0, oldAlphaI + oldAlphaJ - C);
+ H = Math.min(C, oldAlphaI + oldAlphaJ);
+ }
+
+ if (L >= H) continue;
+
+ const eta = 2 * (K[i * n + j] ?? 0) - (K[i * n + i] ?? 0) - (K[j * n + j] ?? 0);
+ if (eta >= 0) continue;
+
+ let newAlphaJ = oldAlphaJ - yj * (ei - ej) / eta;
+ newAlphaJ = Math.min(H, Math.max(L, newAlphaJ));
+
+ if (Math.abs(newAlphaJ - oldAlphaJ) < 1e-5) continue;
+
+ const newAlphaI = oldAlphaI + yi * yj * (oldAlphaJ - newAlphaJ);
+ alphas[i] = newAlphaI;
+ alphas[j] = newAlphaJ;
+
+ const b1 = b + ei + yi * (newAlphaI - oldAlphaI) * (K[i * n + i] ?? 0) + yj * (newAlphaJ - oldAlphaJ) * (K[i * n + j] ?? 0);
+ const b2 = b + ej + yi * (newAlphaI - oldAlphaI) * (K[i * n + j] ?? 0) + yj * (newAlphaJ - oldAlphaJ) * (K[j * n + j] ?? 0);
+
+ if (newAlphaI > 0 && newAlphaI < C) {
+ b = b1;
+ } else if (newAlphaJ > 0 && newAlphaJ < C) {
+ b = b2;
+ } else {
+ b = (b1 + b2) / 2;
+ }
+
+ numChanged++;
+ }
+ }
+
+ if (numChanged === 0) break;
+ }
+
+ return { alphas, labels: y, supportVectors: X, b, kernel };
+}
+
+/** Compute classification accuracy. */
+export function svmAccuracy(model: SVMModel, X: Float64Array[], y: Float64Array): number {
+ const preds = svmPredict(model, X);
+ let correct = 0;
+ for (let i = 0; i < y.length; i++) {
+ if ((preds[i] ?? 0) === (y[i] ?? 0)) correct++;
+ }
+ return correct / (y.length || 1);
+}
diff --git a/src/ml/tabnet.ts b/src/ml/tabnet.ts
new file mode 100644
index 000000000..d87e29fc5
--- /dev/null
+++ b/src/ml/tabnet.ts
@@ -0,0 +1,197 @@
+/**
+ * TabNet: Attentive Interpretable Tabular Learning.
+ *
+ * Implements the core building blocks of TabNet (Arik & Pfister, 2019):
+ * feature transformer, attentive transformer, and the sequential step logic.
+ *
+ * @module
+ */
+
+/** Sparsemax activation: projects onto the probability simplex. */
+export function sparsemax(logits: Float64Array): Float64Array {
+ const n = logits.length;
+ const sorted = Float64Array.from(logits).sort((a, b) => b - a);
+ let cumSum = 0;
+ let k = n;
+ for (let i = 0; i < n; i++) {
+ cumSum += sorted[i] ?? 0;
+ const threshold = (cumSum - 1) / (i + 1);
+ if ((sorted[i] ?? 0) <= threshold) {
+ k = i;
+ break;
+ }
+ }
+ const threshold = (cumSum - (sorted[k] ?? 0) - 1) / Math.max(k, 1);
+ const out = new Float64Array(n);
+ for (let i = 0; i < n; i++) {
+ out[i] = Math.max((logits[i] ?? 0) - threshold, 0);
+ }
+ return out;
+}
+
+/** GLU (Gated Linear Unit): splits input and applies sigmoid gate. */
+export function glu(x: Float64Array): Float64Array {
+ const half = Math.floor(x.length / 2);
+ const out = new Float64Array(half);
+ for (let i = 0; i < half; i++) {
+ const val = x[i] ?? 0;
+ const gate = 1 / (1 + Math.exp(-(x[i + half] ?? 0)));
+ out[i] = val * gate;
+ }
+ return out;
+}
+
+/** Batch normalization (inference mode, uses running stats). */
+export interface BatchNormParams {
+ mean: Float64Array;
+ variance: Float64Array;
+ gamma: Float64Array;
+ beta: Float64Array;
+ eps: number;
+}
+
+export function batchNormInfer(x: Float64Array, params: BatchNormParams): Float64Array {
+ const out = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) {
+ const xi = x[i] ?? 0;
+ const mu = params.mean[i] ?? 0;
+ const va = params.variance[i] ?? 1;
+ const g = params.gamma[i] ?? 1;
+ const b = params.beta[i] ?? 0;
+ out[i] = g * ((xi - mu) / Math.sqrt(va + params.eps)) + b;
+ }
+ return out;
+}
+
+/** TabNet feature transformer (single step). */
+export interface FeatureTransformerWeights {
+ /** Shared layer weight matrix [hiddenDim x inputDim]. */
+ sharedW: Float64Array;
+ /** Step-specific layer weight [hiddenDim x hiddenDim]. */
+ stepW: Float64Array;
+ /** Batch norm params for shared layer output. */
+ sharedBN: BatchNormParams;
+ /** Batch norm params for step layer output. */
+ stepBN: BatchNormParams;
+ hiddenDim: number;
+ inputDim: number;
+}
+
+function matVec(W: Float64Array, x: Float64Array, rows: number, cols: number): Float64Array {
+ const out = new Float64Array(rows);
+ for (let r = 0; r < rows; r++) {
+ let sum = 0;
+ for (let c = 0; c < cols; c++) {
+ sum += (W[r * cols + c] ?? 0) * (x[c] ?? 0);
+ }
+ out[r] = sum;
+ }
+ return out;
+}
+
+export function featureTransformer(
+ x: Float64Array,
+ weights: FeatureTransformerWeights,
+): Float64Array {
+ const { hiddenDim, inputDim } = weights;
+ // Shared FC + BN + GLU
+ const sharedOut = matVec(weights.sharedW, x, hiddenDim, inputDim);
+ const sharedBN = batchNormInfer(sharedOut, weights.sharedBN);
+ const sharedGLU = glu(sharedBN);
+
+ // Step FC + BN + GLU (uses sharedGLU as input)
+ const stepOut = matVec(weights.stepW, sharedGLU, hiddenDim, Math.floor(hiddenDim / 2));
+ const stepBN = batchNormInfer(stepOut, weights.stepBN);
+ return glu(stepBN);
+}
+
+/** Attentive transformer (selects which features to focus on). */
+export interface AttentiveTransformerWeights {
+ /** Weight matrix [numFeatures x hiddenDim]. */
+ W: Float64Array;
+ /** Prior scale penalty (cumulative). */
+ priorScales: Float64Array;
+ numFeatures: number;
+ hiddenDim: number;
+}
+
+export function attentiveTransformer(
+ h: Float64Array,
+ priorScales: Float64Array,
+ weights: AttentiveTransformerWeights,
+): Float64Array {
+ const { numFeatures, hiddenDim } = weights;
+ const raw = matVec(weights.W, h, numFeatures, hiddenDim);
+ // Apply prior scale penalty
+ const penalized = new Float64Array(numFeatures);
+ for (let i = 0; i < numFeatures; i++) {
+ penalized[i] = (raw[i] ?? 0) * (priorScales[i] ?? 1);
+ }
+ return sparsemax(penalized);
+}
+
+/** TabNet step output. */
+export interface TabNetStepResult {
+ /** Feature mask (attention weights). */
+ mask: Float64Array;
+ /** Transformed features for this step. */
+ output: Float64Array;
+ /** Updated prior scales. */
+ priorScales: Float64Array;
+}
+
+/** Run one TabNet step given input features x and prior state. */
+export function tabnetStep(
+ x: Float64Array,
+ h: Float64Array,
+ priorScales: Float64Array,
+ featureWeights: FeatureTransformerWeights,
+ attentiveWeights: AttentiveTransformerWeights,
+ gamma: number,
+): TabNetStepResult {
+ const mask = attentiveTransformer(h, priorScales, attentiveWeights);
+ // Masked features
+ const maskedX = new Float64Array(x.length);
+ for (let i = 0; i < x.length; i++) {
+ maskedX[i] = (x[i] ?? 0) * (mask[i] ?? 0);
+ }
+ const output = featureTransformer(maskedX, featureWeights);
+ // Update prior scales
+ const newPrior = new Float64Array(priorScales.length);
+ for (let i = 0; i < priorScales.length; i++) {
+ newPrior[i] = (priorScales[i] ?? 1) * (gamma - (mask[i] ?? 0));
+ }
+ return { mask, output, priorScales: newPrior };
+}
+
+/** Aggregate TabNet step outputs into final representation. */
+export function aggregateSteps(stepOutputs: Float64Array[]): Float64Array {
+ if (stepOutputs.length === 0) return new Float64Array(0);
+ const dim = stepOutputs[0]?.length ?? 0;
+ const agg = new Float64Array(dim);
+ for (const out of stepOutputs) {
+ for (let i = 0; i < dim; i++) {
+ agg[i] += Math.max(out[i] ?? 0, 0); // ReLU + sum
+ }
+ }
+ return agg;
+}
+
+/** Compute feature importance from masks across steps. */
+export function featureImportance(masks: Float64Array[]): Float64Array {
+ if (masks.length === 0) return new Float64Array(0);
+ const n = masks[0]?.length ?? 0;
+ const importance = new Float64Array(n);
+ for (const mask of masks) {
+ for (let i = 0; i < n; i++) {
+ importance[i] += Math.abs(mask[i] ?? 0);
+ }
+ }
+ // Normalize
+ let total = 0;
+ for (let i = 0; i < n; i++) total += importance[i] ?? 0;
+ if (total > 0) {
+ for (let i = 0; i < n; i++) importance[i] = (importance[i] ?? 0) / total;
+ }
+ return importance;
+}
diff --git a/src/molecular_bio/adaptation.ts b/src/molecular_bio/adaptation.ts
new file mode 100644
index 000000000..14e0264a8
--- /dev/null
+++ b/src/molecular_bio/adaptation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio adaptation module — tsb analytics library. */
+export interface MolecularBioAdaptationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioAdaptationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioAdaptation(data: number[], opts: MolecularBioAdaptationOptions = {}): MolecularBioAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioAdaptation };
diff --git a/src/molecular_bio/aggregation.ts b/src/molecular_bio/aggregation.ts
new file mode 100644
index 000000000..9a8b88f39
--- /dev/null
+++ b/src/molecular_bio/aggregation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio aggregation module — tsb analytics library. */
+export interface MolecularBioAggregationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioAggregationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioAggregation(data: number[], opts: MolecularBioAggregationOptions = {}): MolecularBioAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioAggregation };
diff --git a/src/molecular_bio/algebra.ts b/src/molecular_bio/algebra.ts
new file mode 100644
index 000000000..47b03eb92
--- /dev/null
+++ b/src/molecular_bio/algebra.ts
@@ -0,0 +1,14 @@
+/** molecular_bio algebra module — tsb analytics library. */
+export interface MolecularBioAlgebraOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioAlgebraResult { values: number[]; converged: boolean; }
+export function computeMolecularBioAlgebra(data: number[], opts: MolecularBioAlgebraOptions = {}): MolecularBioAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioAlgebra };
diff --git a/src/molecular_bio/alignment.ts b/src/molecular_bio/alignment.ts
new file mode 100644
index 000000000..ae489ad3d
--- /dev/null
+++ b/src/molecular_bio/alignment.ts
@@ -0,0 +1,14 @@
+/** molecular_bio alignment module — tsb analytics library. */
+export interface MolecularBioAlignmentOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioAlignmentResult { values: number[]; converged: boolean; }
+export function computeMolecularBioAlignment(data: number[], opts: MolecularBioAlignmentOptions = {}): MolecularBioAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioAlignment };
diff --git a/src/molecular_bio/analysis.ts b/src/molecular_bio/analysis.ts
new file mode 100644
index 000000000..9eafec4dc
--- /dev/null
+++ b/src/molecular_bio/analysis.ts
@@ -0,0 +1,14 @@
+/** molecular_bio analysis module — tsb analytics library. */
+export interface MolecularBioAnalysisOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioAnalysisResult { values: number[]; converged: boolean; }
+export function computeMolecularBioAnalysis(data: number[], opts: MolecularBioAnalysisOptions = {}): MolecularBioAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioAnalysis };
diff --git a/src/molecular_bio/augmentation.ts b/src/molecular_bio/augmentation.ts
new file mode 100644
index 000000000..7d9bd5f16
--- /dev/null
+++ b/src/molecular_bio/augmentation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio augmentation module — tsb analytics library. */
+export interface MolecularBioAugmentationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioAugmentationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioAugmentation(data: number[], opts: MolecularBioAugmentationOptions = {}): MolecularBioAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioAugmentation };
diff --git a/src/molecular_bio/bagging.ts b/src/molecular_bio/bagging.ts
new file mode 100644
index 000000000..bf70a80b1
--- /dev/null
+++ b/src/molecular_bio/bagging.ts
@@ -0,0 +1,14 @@
+/** molecular_bio bagging module — tsb analytics library. */
+export interface MolecularBioBaggingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioBaggingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioBagging(data: number[], opts: MolecularBioBaggingOptions = {}): MolecularBioBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioBagging };
diff --git a/src/molecular_bio/basis.ts b/src/molecular_bio/basis.ts
new file mode 100644
index 000000000..4cf824369
--- /dev/null
+++ b/src/molecular_bio/basis.ts
@@ -0,0 +1,14 @@
+/** molecular_bio basis module — tsb analytics library. */
+export interface MolecularBioBasisOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioBasisResult { values: number[]; converged: boolean; }
+export function computeMolecularBioBasis(data: number[], opts: MolecularBioBasisOptions = {}): MolecularBioBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioBasis };
diff --git a/src/molecular_bio/benchmarking.ts b/src/molecular_bio/benchmarking.ts
new file mode 100644
index 000000000..39bac4920
--- /dev/null
+++ b/src/molecular_bio/benchmarking.ts
@@ -0,0 +1,14 @@
+/** molecular_bio benchmarking module — tsb analytics library. */
+export interface MolecularBioBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioBenchmarking(data: number[], opts: MolecularBioBenchmarkingOptions = {}): MolecularBioBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioBenchmarking };
diff --git a/src/molecular_bio/blending.ts b/src/molecular_bio/blending.ts
new file mode 100644
index 000000000..5cfe616c0
--- /dev/null
+++ b/src/molecular_bio/blending.ts
@@ -0,0 +1,14 @@
+/** molecular_bio blending module — tsb analytics library. */
+export interface MolecularBioBlendingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioBlendingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioBlending(data: number[], opts: MolecularBioBlendingOptions = {}): MolecularBioBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioBlending };
diff --git a/src/molecular_bio/boosting.ts b/src/molecular_bio/boosting.ts
new file mode 100644
index 000000000..c4cd2b3a4
--- /dev/null
+++ b/src/molecular_bio/boosting.ts
@@ -0,0 +1,14 @@
+/** molecular_bio boosting module — tsb analytics library. */
+export interface MolecularBioBoostingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioBoostingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioBoosting(data: number[], opts: MolecularBioBoostingOptions = {}): MolecularBioBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioBoosting };
diff --git a/src/molecular_bio/bootstrap.ts b/src/molecular_bio/bootstrap.ts
new file mode 100644
index 000000000..2379245a2
--- /dev/null
+++ b/src/molecular_bio/bootstrap.ts
@@ -0,0 +1,14 @@
+/** molecular_bio bootstrap module — tsb analytics library. */
+export interface MolecularBioBootstrapOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioBootstrapResult { values: number[]; converged: boolean; }
+export function computeMolecularBioBootstrap(data: number[], opts: MolecularBioBootstrapOptions = {}): MolecularBioBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioBootstrap };
diff --git a/src/molecular_bio/calculus.ts b/src/molecular_bio/calculus.ts
new file mode 100644
index 000000000..3b070b7ec
--- /dev/null
+++ b/src/molecular_bio/calculus.ts
@@ -0,0 +1,14 @@
+/** molecular_bio calculus module — tsb analytics library. */
+export interface MolecularBioCalculusOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioCalculusResult { values: number[]; converged: boolean; }
+export function computeMolecularBioCalculus(data: number[], opts: MolecularBioCalculusOptions = {}): MolecularBioCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioCalculus };
diff --git a/src/molecular_bio/calibration.ts b/src/molecular_bio/calibration.ts
new file mode 100644
index 000000000..db5120c61
--- /dev/null
+++ b/src/molecular_bio/calibration.ts
@@ -0,0 +1,14 @@
+/** molecular_bio calibration module — tsb analytics library. */
+export interface MolecularBioCalibrationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioCalibrationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioCalibration(data: number[], opts: MolecularBioCalibrationOptions = {}): MolecularBioCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioCalibration };
diff --git a/src/molecular_bio/characterization.ts b/src/molecular_bio/characterization.ts
new file mode 100644
index 000000000..275388fa2
--- /dev/null
+++ b/src/molecular_bio/characterization.ts
@@ -0,0 +1,14 @@
+/** molecular_bio characterization module — tsb analytics library. */
+export interface MolecularBioCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioCharacterizationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioCharacterization(data: number[], opts: MolecularBioCharacterizationOptions = {}): MolecularBioCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioCharacterization };
diff --git a/src/molecular_bio/classification.ts b/src/molecular_bio/classification.ts
new file mode 100644
index 000000000..8c38c9094
--- /dev/null
+++ b/src/molecular_bio/classification.ts
@@ -0,0 +1,14 @@
+/** molecular_bio classification module — tsb analytics library. */
+export interface MolecularBioClassificationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioClassificationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioClassification(data: number[], opts: MolecularBioClassificationOptions = {}): MolecularBioClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioClassification };
diff --git a/src/molecular_bio/clustering.ts b/src/molecular_bio/clustering.ts
new file mode 100644
index 000000000..311b0d704
--- /dev/null
+++ b/src/molecular_bio/clustering.ts
@@ -0,0 +1,14 @@
+/** molecular_bio clustering module — tsb analytics library. */
+export interface MolecularBioClusteringOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioClusteringResult { values: number[]; converged: boolean; }
+export function computeMolecularBioClustering(data: number[], opts: MolecularBioClusteringOptions = {}): MolecularBioClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioClustering };
diff --git a/src/molecular_bio/compression.ts b/src/molecular_bio/compression.ts
new file mode 100644
index 000000000..67fe1610a
--- /dev/null
+++ b/src/molecular_bio/compression.ts
@@ -0,0 +1,14 @@
+/** molecular_bio compression module — tsb analytics library. */
+export interface MolecularBioCompressionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioCompressionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioCompression(data: number[], opts: MolecularBioCompressionOptions = {}): MolecularBioCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioCompression };
diff --git a/src/molecular_bio/continuous.ts b/src/molecular_bio/continuous.ts
new file mode 100644
index 000000000..db31c6d4d
--- /dev/null
+++ b/src/molecular_bio/continuous.ts
@@ -0,0 +1,14 @@
+/** molecular_bio continuous module — tsb analytics library. */
+export interface MolecularBioContinuousOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioContinuousResult { values: number[]; converged: boolean; }
+export function computeMolecularBioContinuous(data: number[], opts: MolecularBioContinuousOptions = {}): MolecularBioContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioContinuous };
diff --git a/src/molecular_bio/control.ts b/src/molecular_bio/control.ts
new file mode 100644
index 000000000..1df50cdac
--- /dev/null
+++ b/src/molecular_bio/control.ts
@@ -0,0 +1,14 @@
+/** molecular_bio control module — tsb analytics library. */
+export interface MolecularBioControlOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioControlResult { values: number[]; converged: boolean; }
+export function computeMolecularBioControl(data: number[], opts: MolecularBioControlOptions = {}): MolecularBioControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioControl };
diff --git a/src/molecular_bio/convergence.ts b/src/molecular_bio/convergence.ts
new file mode 100644
index 000000000..b0edfd51a
--- /dev/null
+++ b/src/molecular_bio/convergence.ts
@@ -0,0 +1,14 @@
+/** molecular_bio convergence module — tsb analytics library. */
+export interface MolecularBioConvergenceOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioConvergenceResult { values: number[]; converged: boolean; }
+export function computeMolecularBioConvergence(data: number[], opts: MolecularBioConvergenceOptions = {}): MolecularBioConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioConvergence };
diff --git a/src/molecular_bio/convex.ts b/src/molecular_bio/convex.ts
new file mode 100644
index 000000000..ff5a18347
--- /dev/null
+++ b/src/molecular_bio/convex.ts
@@ -0,0 +1,14 @@
+/** molecular_bio convex module — tsb analytics library. */
+export interface MolecularBioConvexOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioConvexResult { values: number[]; converged: boolean; }
+export function computeMolecularBioConvex(data: number[], opts: MolecularBioConvexOptions = {}): MolecularBioConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioConvex };
diff --git a/src/molecular_bio/correlation.ts b/src/molecular_bio/correlation.ts
new file mode 100644
index 000000000..4b8e7e2a6
--- /dev/null
+++ b/src/molecular_bio/correlation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio correlation module — tsb analytics library. */
+export interface MolecularBioCorrelationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioCorrelationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioCorrelation(data: number[], opts: MolecularBioCorrelationOptions = {}): MolecularBioCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioCorrelation };
diff --git a/src/molecular_bio/covariance.ts b/src/molecular_bio/covariance.ts
new file mode 100644
index 000000000..3c7402b90
--- /dev/null
+++ b/src/molecular_bio/covariance.ts
@@ -0,0 +1,14 @@
+/** molecular_bio covariance module — tsb analytics library. */
+export interface MolecularBioCovarianceOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioCovarianceResult { values: number[]; converged: boolean; }
+export function computeMolecularBioCovariance(data: number[], opts: MolecularBioCovarianceOptions = {}): MolecularBioCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioCovariance };
diff --git a/src/molecular_bio/cross_validation.ts b/src/molecular_bio/cross_validation.ts
new file mode 100644
index 000000000..62511bef2
--- /dev/null
+++ b/src/molecular_bio/cross_validation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio cross_validation module — tsb analytics library. */
+export interface MolecularBioCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioCrossValidationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioCrossValidation(data: number[], opts: MolecularBioCrossValidationOptions = {}): MolecularBioCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioCrossValidation };
diff --git a/src/molecular_bio/decoding.ts b/src/molecular_bio/decoding.ts
new file mode 100644
index 000000000..923a609e7
--- /dev/null
+++ b/src/molecular_bio/decoding.ts
@@ -0,0 +1,14 @@
+/** molecular_bio decoding module — tsb analytics library. */
+export interface MolecularBioDecodingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDecodingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDecoding(data: number[], opts: MolecularBioDecodingOptions = {}): MolecularBioDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDecoding };
diff --git a/src/molecular_bio/decomposition.ts b/src/molecular_bio/decomposition.ts
new file mode 100644
index 000000000..2e2c3c82a
--- /dev/null
+++ b/src/molecular_bio/decomposition.ts
@@ -0,0 +1,14 @@
+/** molecular_bio decomposition module — tsb analytics library. */
+export interface MolecularBioDecompositionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDecompositionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDecomposition(data: number[], opts: MolecularBioDecompositionOptions = {}): MolecularBioDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDecomposition };
diff --git a/src/molecular_bio/detection.ts b/src/molecular_bio/detection.ts
new file mode 100644
index 000000000..5ae9dc3f3
--- /dev/null
+++ b/src/molecular_bio/detection.ts
@@ -0,0 +1,14 @@
+/** molecular_bio detection module — tsb analytics library. */
+export interface MolecularBioDetectionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDetectionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDetection(data: number[], opts: MolecularBioDetectionOptions = {}): MolecularBioDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDetection };
diff --git a/src/molecular_bio/deterministic.ts b/src/molecular_bio/deterministic.ts
new file mode 100644
index 000000000..96f808af8
--- /dev/null
+++ b/src/molecular_bio/deterministic.ts
@@ -0,0 +1,14 @@
+/** molecular_bio deterministic module — tsb analytics library. */
+export interface MolecularBioDeterministicOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDeterministicResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDeterministic(data: number[], opts: MolecularBioDeterministicOptions = {}): MolecularBioDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDeterministic };
diff --git a/src/molecular_bio/diagnostics.ts b/src/molecular_bio/diagnostics.ts
new file mode 100644
index 000000000..8fd911cb4
--- /dev/null
+++ b/src/molecular_bio/diagnostics.ts
@@ -0,0 +1,14 @@
+/** molecular_bio diagnostics module — tsb analytics library. */
+export interface MolecularBioDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDiagnostics(data: number[], opts: MolecularBioDiagnosticsOptions = {}): MolecularBioDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDiagnostics };
diff --git a/src/molecular_bio/differential.ts b/src/molecular_bio/differential.ts
new file mode 100644
index 000000000..565c430a7
--- /dev/null
+++ b/src/molecular_bio/differential.ts
@@ -0,0 +1,14 @@
+/** molecular_bio differential module — tsb analytics library. */
+export interface MolecularBioDifferentialOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDifferentialResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDifferential(data: number[], opts: MolecularBioDifferentialOptions = {}): MolecularBioDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDifferential };
diff --git a/src/molecular_bio/discrete.ts b/src/molecular_bio/discrete.ts
new file mode 100644
index 000000000..b625d008f
--- /dev/null
+++ b/src/molecular_bio/discrete.ts
@@ -0,0 +1,14 @@
+/** molecular_bio discrete module — tsb analytics library. */
+export interface MolecularBioDiscreteOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDiscreteResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDiscrete(data: number[], opts: MolecularBioDiscreteOptions = {}): MolecularBioDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDiscrete };
diff --git a/src/molecular_bio/distribution.ts b/src/molecular_bio/distribution.ts
new file mode 100644
index 000000000..b6db792a5
--- /dev/null
+++ b/src/molecular_bio/distribution.ts
@@ -0,0 +1,14 @@
+/** molecular_bio distribution module — tsb analytics library. */
+export interface MolecularBioDistributionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDistributionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDistribution(data: number[], opts: MolecularBioDistributionOptions = {}): MolecularBioDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDistribution };
diff --git a/src/molecular_bio/dynamic.ts b/src/molecular_bio/dynamic.ts
new file mode 100644
index 000000000..d68b9bbad
--- /dev/null
+++ b/src/molecular_bio/dynamic.ts
@@ -0,0 +1,14 @@
+/** molecular_bio dynamic module — tsb analytics library. */
+export interface MolecularBioDynamicOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioDynamicResult { values: number[]; converged: boolean; }
+export function computeMolecularBioDynamic(data: number[], opts: MolecularBioDynamicOptions = {}): MolecularBioDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioDynamic };
diff --git a/src/molecular_bio/embedding.ts b/src/molecular_bio/embedding.ts
new file mode 100644
index 000000000..b7ab52875
--- /dev/null
+++ b/src/molecular_bio/embedding.ts
@@ -0,0 +1,14 @@
+/** molecular_bio embedding module — tsb analytics library. */
+export interface MolecularBioEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioEmbeddingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioEmbedding(data: number[], opts: MolecularBioEmbeddingOptions = {}): MolecularBioEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioEmbedding };
diff --git a/src/molecular_bio/encoding.ts b/src/molecular_bio/encoding.ts
new file mode 100644
index 000000000..c3d6f2499
--- /dev/null
+++ b/src/molecular_bio/encoding.ts
@@ -0,0 +1,14 @@
+/** molecular_bio encoding module — tsb analytics library. */
+export interface MolecularBioEncodingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioEncodingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioEncoding(data: number[], opts: MolecularBioEncodingOptions = {}): MolecularBioEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioEncoding };
diff --git a/src/molecular_bio/ensemble.ts b/src/molecular_bio/ensemble.ts
new file mode 100644
index 000000000..253ebc1ce
--- /dev/null
+++ b/src/molecular_bio/ensemble.ts
@@ -0,0 +1,14 @@
+/** molecular_bio ensemble module — tsb analytics library. */
+export interface MolecularBioEnsembleOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioEnsembleResult { values: number[]; converged: boolean; }
+export function computeMolecularBioEnsemble(data: number[], opts: MolecularBioEnsembleOptions = {}): MolecularBioEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioEnsemble };
diff --git a/src/molecular_bio/estimation.ts b/src/molecular_bio/estimation.ts
new file mode 100644
index 000000000..c3479a9d7
--- /dev/null
+++ b/src/molecular_bio/estimation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio estimation module — tsb analytics library. */
+export interface MolecularBioEstimationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioEstimationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioEstimation(data: number[], opts: MolecularBioEstimationOptions = {}): MolecularBioEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioEstimation };
diff --git a/src/molecular_bio/evaluation.ts b/src/molecular_bio/evaluation.ts
new file mode 100644
index 000000000..6b7e70fb4
--- /dev/null
+++ b/src/molecular_bio/evaluation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio evaluation module — tsb analytics library. */
+export interface MolecularBioEvaluationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioEvaluationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioEvaluation(data: number[], opts: MolecularBioEvaluationOptions = {}): MolecularBioEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioEvaluation };
diff --git a/src/molecular_bio/extrapolation.ts b/src/molecular_bio/extrapolation.ts
new file mode 100644
index 000000000..aee18d69c
--- /dev/null
+++ b/src/molecular_bio/extrapolation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio extrapolation module — tsb analytics library. */
+export interface MolecularBioExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioExtrapolationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioExtrapolation(data: number[], opts: MolecularBioExtrapolationOptions = {}): MolecularBioExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioExtrapolation };
diff --git a/src/molecular_bio/features.ts b/src/molecular_bio/features.ts
new file mode 100644
index 000000000..08a3127ef
--- /dev/null
+++ b/src/molecular_bio/features.ts
@@ -0,0 +1,14 @@
+/** molecular_bio features module — tsb analytics library. */
+export interface MolecularBioFeaturesOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioFeaturesResult { values: number[]; converged: boolean; }
+export function computeMolecularBioFeatures(data: number[], opts: MolecularBioFeaturesOptions = {}): MolecularBioFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioFeatures };
diff --git a/src/molecular_bio/feedback.ts b/src/molecular_bio/feedback.ts
new file mode 100644
index 000000000..17bec16cc
--- /dev/null
+++ b/src/molecular_bio/feedback.ts
@@ -0,0 +1,14 @@
+/** molecular_bio feedback module — tsb analytics library. */
+export interface MolecularBioFeedbackOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioFeedbackResult { values: number[]; converged: boolean; }
+export function computeMolecularBioFeedback(data: number[], opts: MolecularBioFeedbackOptions = {}): MolecularBioFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioFeedback };
diff --git a/src/molecular_bio/filtering.ts b/src/molecular_bio/filtering.ts
new file mode 100644
index 000000000..ea6e3af8b
--- /dev/null
+++ b/src/molecular_bio/filtering.ts
@@ -0,0 +1,14 @@
+/** molecular_bio filtering module — tsb analytics library. */
+export interface MolecularBioFilteringOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioFilteringResult { values: number[]; converged: boolean; }
+export function computeMolecularBioFiltering(data: number[], opts: MolecularBioFilteringOptions = {}): MolecularBioFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioFiltering };
diff --git a/src/molecular_bio/fourier.ts b/src/molecular_bio/fourier.ts
new file mode 100644
index 000000000..b7c1d11bd
--- /dev/null
+++ b/src/molecular_bio/fourier.ts
@@ -0,0 +1,14 @@
+/** molecular_bio fourier module — tsb analytics library. */
+export interface MolecularBioFourierOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioFourierResult { values: number[]; converged: boolean; }
+export function computeMolecularBioFourier(data: number[], opts: MolecularBioFourierOptions = {}): MolecularBioFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioFourier };
diff --git a/src/molecular_bio/fusion.ts b/src/molecular_bio/fusion.ts
new file mode 100644
index 000000000..fc1548173
--- /dev/null
+++ b/src/molecular_bio/fusion.ts
@@ -0,0 +1,14 @@
+/** molecular_bio fusion module — tsb analytics library. */
+export interface MolecularBioFusionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioFusionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioFusion(data: number[], opts: MolecularBioFusionOptions = {}): MolecularBioFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioFusion };
diff --git a/src/molecular_bio/generation.ts b/src/molecular_bio/generation.ts
new file mode 100644
index 000000000..f51e0d0a0
--- /dev/null
+++ b/src/molecular_bio/generation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio generation module — tsb analytics library. */
+export interface MolecularBioGenerationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioGenerationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioGeneration(data: number[], opts: MolecularBioGenerationOptions = {}): MolecularBioGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioGeneration };
diff --git a/src/molecular_bio/geometry.ts b/src/molecular_bio/geometry.ts
new file mode 100644
index 000000000..3c92e1143
--- /dev/null
+++ b/src/molecular_bio/geometry.ts
@@ -0,0 +1,14 @@
+/** molecular_bio geometry module — tsb analytics library. */
+export interface MolecularBioGeometryOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioGeometryResult { values: number[]; converged: boolean; }
+export function computeMolecularBioGeometry(data: number[], opts: MolecularBioGeometryOptions = {}): MolecularBioGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioGeometry };
diff --git a/src/molecular_bio/gradient.ts b/src/molecular_bio/gradient.ts
new file mode 100644
index 000000000..aef7a0d4c
--- /dev/null
+++ b/src/molecular_bio/gradient.ts
@@ -0,0 +1,14 @@
+/** molecular_bio gradient module — tsb analytics library. */
+export interface MolecularBioGradientOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioGradientResult { values: number[]; converged: boolean; }
+export function computeMolecularBioGradient(data: number[], opts: MolecularBioGradientOptions = {}): MolecularBioGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioGradient };
diff --git a/src/molecular_bio/hessian.ts b/src/molecular_bio/hessian.ts
new file mode 100644
index 000000000..091642264
--- /dev/null
+++ b/src/molecular_bio/hessian.ts
@@ -0,0 +1,14 @@
+/** molecular_bio hessian module — tsb analytics library. */
+export interface MolecularBioHessianOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioHessianResult { values: number[]; converged: boolean; }
+export function computeMolecularBioHessian(data: number[], opts: MolecularBioHessianOptions = {}): MolecularBioHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioHessian };
diff --git a/src/molecular_bio/hypothesis.ts b/src/molecular_bio/hypothesis.ts
new file mode 100644
index 000000000..164f00b82
--- /dev/null
+++ b/src/molecular_bio/hypothesis.ts
@@ -0,0 +1,14 @@
+/** molecular_bio hypothesis module — tsb analytics library. */
+export interface MolecularBioHypothesisOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioHypothesisResult { values: number[]; converged: boolean; }
+export function computeMolecularBioHypothesis(data: number[], opts: MolecularBioHypothesisOptions = {}): MolecularBioHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioHypothesis };
diff --git a/src/molecular_bio/inference.ts b/src/molecular_bio/inference.ts
new file mode 100644
index 000000000..7c44a015c
--- /dev/null
+++ b/src/molecular_bio/inference.ts
@@ -0,0 +1,14 @@
+/** molecular_bio inference module — tsb analytics library. */
+export interface MolecularBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioInferenceResult { values: number[]; converged: boolean; }
+export function computeMolecularBioInference(data: number[], opts: MolecularBioInferenceOptions = {}): MolecularBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioInference };
diff --git a/src/molecular_bio/inference2.ts b/src/molecular_bio/inference2.ts
new file mode 100644
index 000000000..c04b6b19f
--- /dev/null
+++ b/src/molecular_bio/inference2.ts
@@ -0,0 +1,14 @@
+/** molecular_bio inference2 module — tsb analytics library. */
+export interface MolecularBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioInferenceResult { values: number[]; converged: boolean; }
+export function computeMolecularBioInference(data: number[], opts: MolecularBioInferenceOptions = {}): MolecularBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioInference };
diff --git a/src/molecular_bio/integral.ts b/src/molecular_bio/integral.ts
new file mode 100644
index 000000000..ad41bb4f7
--- /dev/null
+++ b/src/molecular_bio/integral.ts
@@ -0,0 +1,14 @@
+/** molecular_bio integral module — tsb analytics library. */
+export interface MolecularBioIntegralOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioIntegralResult { values: number[]; converged: boolean; }
+export function computeMolecularBioIntegral(data: number[], opts: MolecularBioIntegralOptions = {}): MolecularBioIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioIntegral };
diff --git a/src/molecular_bio/integration.ts b/src/molecular_bio/integration.ts
new file mode 100644
index 000000000..5af72450a
--- /dev/null
+++ b/src/molecular_bio/integration.ts
@@ -0,0 +1,14 @@
+/** molecular_bio integration module — tsb analytics library. */
+export interface MolecularBioIntegrationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioIntegrationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioIntegration(data: number[], opts: MolecularBioIntegrationOptions = {}): MolecularBioIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioIntegration };
diff --git a/src/molecular_bio/interpolation.ts b/src/molecular_bio/interpolation.ts
new file mode 100644
index 000000000..7969de9d6
--- /dev/null
+++ b/src/molecular_bio/interpolation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio interpolation module — tsb analytics library. */
+export interface MolecularBioInterpolationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioInterpolationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioInterpolation(data: number[], opts: MolecularBioInterpolationOptions = {}): MolecularBioInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioInterpolation };
diff --git a/src/molecular_bio/jacobian.ts b/src/molecular_bio/jacobian.ts
new file mode 100644
index 000000000..c3a6290b5
--- /dev/null
+++ b/src/molecular_bio/jacobian.ts
@@ -0,0 +1,14 @@
+/** molecular_bio jacobian module — tsb analytics library. */
+export interface MolecularBioJacobianOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioJacobianResult { values: number[]; converged: boolean; }
+export function computeMolecularBioJacobian(data: number[], opts: MolecularBioJacobianOptions = {}): MolecularBioJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioJacobian };
diff --git a/src/molecular_bio/kernel.ts b/src/molecular_bio/kernel.ts
new file mode 100644
index 000000000..fce7da33d
--- /dev/null
+++ b/src/molecular_bio/kernel.ts
@@ -0,0 +1,14 @@
+/** molecular_bio kernel module — tsb analytics library. */
+export interface MolecularBioKernelOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioKernelResult { values: number[]; converged: boolean; }
+export function computeMolecularBioKernel(data: number[], opts: MolecularBioKernelOptions = {}): MolecularBioKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioKernel };
diff --git a/src/molecular_bio/laplacian.ts b/src/molecular_bio/laplacian.ts
new file mode 100644
index 000000000..5d8cb81b8
--- /dev/null
+++ b/src/molecular_bio/laplacian.ts
@@ -0,0 +1,14 @@
+/** molecular_bio laplacian module — tsb analytics library. */
+export interface MolecularBioLaplacianOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioLaplacianResult { values: number[]; converged: boolean; }
+export function computeMolecularBioLaplacian(data: number[], opts: MolecularBioLaplacianOptions = {}): MolecularBioLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioLaplacian };
diff --git a/src/molecular_bio/learning.ts b/src/molecular_bio/learning.ts
new file mode 100644
index 000000000..d4c25b5ca
--- /dev/null
+++ b/src/molecular_bio/learning.ts
@@ -0,0 +1,14 @@
+/** molecular_bio learning module — tsb analytics library. */
+export interface MolecularBioLearningOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioLearningResult { values: number[]; converged: boolean; }
+export function computeMolecularBioLearning(data: number[], opts: MolecularBioLearningOptions = {}): MolecularBioLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioLearning };
diff --git a/src/molecular_bio/linear.ts b/src/molecular_bio/linear.ts
new file mode 100644
index 000000000..03f486592
--- /dev/null
+++ b/src/molecular_bio/linear.ts
@@ -0,0 +1,14 @@
+/** molecular_bio linear module — tsb analytics library. */
+export interface MolecularBioLinearOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioLinearResult { values: number[]; converged: boolean; }
+export function computeMolecularBioLinear(data: number[], opts: MolecularBioLinearOptions = {}): MolecularBioLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioLinear };
diff --git a/src/molecular_bio/manifold.ts b/src/molecular_bio/manifold.ts
new file mode 100644
index 000000000..479978d23
--- /dev/null
+++ b/src/molecular_bio/manifold.ts
@@ -0,0 +1,14 @@
+/** molecular_bio manifold module — tsb analytics library. */
+export interface MolecularBioManifoldOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioManifoldResult { values: number[]; converged: boolean; }
+export function computeMolecularBioManifold(data: number[], opts: MolecularBioManifoldOptions = {}): MolecularBioManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioManifold };
diff --git a/src/molecular_bio/matching.ts b/src/molecular_bio/matching.ts
new file mode 100644
index 000000000..12d9c8ba8
--- /dev/null
+++ b/src/molecular_bio/matching.ts
@@ -0,0 +1,14 @@
+/** molecular_bio matching module — tsb analytics library. */
+export interface MolecularBioMatchingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioMatchingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioMatching(data: number[], opts: MolecularBioMatchingOptions = {}): MolecularBioMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioMatching };
diff --git a/src/molecular_bio/measurement.ts b/src/molecular_bio/measurement.ts
new file mode 100644
index 000000000..2288853b5
--- /dev/null
+++ b/src/molecular_bio/measurement.ts
@@ -0,0 +1,14 @@
+/** molecular_bio measurement module — tsb analytics library. */
+export interface MolecularBioMeasurementOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioMeasurementResult { values: number[]; converged: boolean; }
+export function computeMolecularBioMeasurement(data: number[], opts: MolecularBioMeasurementOptions = {}): MolecularBioMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioMeasurement };
diff --git a/src/molecular_bio/metrics.ts b/src/molecular_bio/metrics.ts
new file mode 100644
index 000000000..dd5cf8280
--- /dev/null
+++ b/src/molecular_bio/metrics.ts
@@ -0,0 +1,14 @@
+/** molecular_bio metrics module — tsb analytics library. */
+export interface MolecularBioMetricsOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioMetricsResult { values: number[]; converged: boolean; }
+export function computeMolecularBioMetrics(data: number[], opts: MolecularBioMetricsOptions = {}): MolecularBioMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioMetrics };
diff --git a/src/molecular_bio/modeling.ts b/src/molecular_bio/modeling.ts
new file mode 100644
index 000000000..35ef26598
--- /dev/null
+++ b/src/molecular_bio/modeling.ts
@@ -0,0 +1,14 @@
+/** molecular_bio modeling module — tsb analytics library. */
+export interface MolecularBioModelingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioModelingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioModeling(data: number[], opts: MolecularBioModelingOptions = {}): MolecularBioModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioModeling };
diff --git a/src/molecular_bio/monitoring.ts b/src/molecular_bio/monitoring.ts
new file mode 100644
index 000000000..d267e64f1
--- /dev/null
+++ b/src/molecular_bio/monitoring.ts
@@ -0,0 +1,14 @@
+/** molecular_bio monitoring module — tsb analytics library. */
+export interface MolecularBioMonitoringOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioMonitoringResult { values: number[]; converged: boolean; }
+export function computeMolecularBioMonitoring(data: number[], opts: MolecularBioMonitoringOptions = {}): MolecularBioMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioMonitoring };
diff --git a/src/molecular_bio/nonlinear.ts b/src/molecular_bio/nonlinear.ts
new file mode 100644
index 000000000..6a05c1d15
--- /dev/null
+++ b/src/molecular_bio/nonlinear.ts
@@ -0,0 +1,14 @@
+/** molecular_bio nonlinear module — tsb analytics library. */
+export interface MolecularBioNonlinearOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioNonlinearResult { values: number[]; converged: boolean; }
+export function computeMolecularBioNonlinear(data: number[], opts: MolecularBioNonlinearOptions = {}): MolecularBioNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioNonlinear };
diff --git a/src/molecular_bio/normalization.ts b/src/molecular_bio/normalization.ts
new file mode 100644
index 000000000..47bac0afd
--- /dev/null
+++ b/src/molecular_bio/normalization.ts
@@ -0,0 +1,14 @@
+/** molecular_bio normalization module — tsb analytics library. */
+export interface MolecularBioNormalizationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioNormalizationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioNormalization(data: number[], opts: MolecularBioNormalizationOptions = {}): MolecularBioNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioNormalization };
diff --git a/src/molecular_bio/optimization.ts b/src/molecular_bio/optimization.ts
new file mode 100644
index 000000000..c29fc4dff
--- /dev/null
+++ b/src/molecular_bio/optimization.ts
@@ -0,0 +1,14 @@
+/** molecular_bio optimization module — tsb analytics library. */
+export interface MolecularBioOptimizationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioOptimizationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioOptimization(data: number[], opts: MolecularBioOptimizationOptions = {}): MolecularBioOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioOptimization };
diff --git a/src/molecular_bio/patterns.ts b/src/molecular_bio/patterns.ts
new file mode 100644
index 000000000..4038ade23
--- /dev/null
+++ b/src/molecular_bio/patterns.ts
@@ -0,0 +1,14 @@
+/** molecular_bio patterns module — tsb analytics library. */
+export interface MolecularBioPatternsOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioPatternsResult { values: number[]; converged: boolean; }
+export function computeMolecularBioPatterns(data: number[], opts: MolecularBioPatternsOptions = {}): MolecularBioPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioPatterns };
diff --git a/src/molecular_bio/permutation.ts b/src/molecular_bio/permutation.ts
new file mode 100644
index 000000000..8967d2966
--- /dev/null
+++ b/src/molecular_bio/permutation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio permutation module — tsb analytics library. */
+export interface MolecularBioPermutationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioPermutationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioPermutation(data: number[], opts: MolecularBioPermutationOptions = {}): MolecularBioPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioPermutation };
diff --git a/src/molecular_bio/prediction.ts b/src/molecular_bio/prediction.ts
new file mode 100644
index 000000000..6710384dd
--- /dev/null
+++ b/src/molecular_bio/prediction.ts
@@ -0,0 +1,14 @@
+/** molecular_bio prediction module — tsb analytics library. */
+export interface MolecularBioPredictionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioPredictionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioPrediction(data: number[], opts: MolecularBioPredictionOptions = {}): MolecularBioPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioPrediction };
diff --git a/src/molecular_bio/processing.ts b/src/molecular_bio/processing.ts
new file mode 100644
index 000000000..20bd58ece
--- /dev/null
+++ b/src/molecular_bio/processing.ts
@@ -0,0 +1,14 @@
+/** molecular_bio processing module — tsb analytics library. */
+export interface MolecularBioProcessingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioProcessingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioProcessing(data: number[], opts: MolecularBioProcessingOptions = {}): MolecularBioProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioProcessing };
diff --git a/src/molecular_bio/profiling.ts b/src/molecular_bio/profiling.ts
new file mode 100644
index 000000000..58933667c
--- /dev/null
+++ b/src/molecular_bio/profiling.ts
@@ -0,0 +1,14 @@
+/** molecular_bio profiling module — tsb analytics library. */
+export interface MolecularBioProfilingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioProfilingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioProfiling(data: number[], opts: MolecularBioProfilingOptions = {}): MolecularBioProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioProfiling };
diff --git a/src/molecular_bio/projection.ts b/src/molecular_bio/projection.ts
new file mode 100644
index 000000000..75ae28446
--- /dev/null
+++ b/src/molecular_bio/projection.ts
@@ -0,0 +1,14 @@
+/** molecular_bio projection module — tsb analytics library. */
+export interface MolecularBioProjectionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioProjectionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioProjection(data: number[], opts: MolecularBioProjectionOptions = {}): MolecularBioProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioProjection };
diff --git a/src/molecular_bio/ranking.ts b/src/molecular_bio/ranking.ts
new file mode 100644
index 000000000..9a102bf8f
--- /dev/null
+++ b/src/molecular_bio/ranking.ts
@@ -0,0 +1,14 @@
+/** molecular_bio ranking module — tsb analytics library. */
+export interface MolecularBioRankingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioRankingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioRanking(data: number[], opts: MolecularBioRankingOptions = {}): MolecularBioRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioRanking };
diff --git a/src/molecular_bio/reconstruction.ts b/src/molecular_bio/reconstruction.ts
new file mode 100644
index 000000000..99226755b
--- /dev/null
+++ b/src/molecular_bio/reconstruction.ts
@@ -0,0 +1,14 @@
+/** molecular_bio reconstruction module — tsb analytics library. */
+export interface MolecularBioReconstructionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioReconstructionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioReconstruction(data: number[], opts: MolecularBioReconstructionOptions = {}): MolecularBioReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioReconstruction };
diff --git a/src/molecular_bio/registration.ts b/src/molecular_bio/registration.ts
new file mode 100644
index 000000000..48d8db7f9
--- /dev/null
+++ b/src/molecular_bio/registration.ts
@@ -0,0 +1,14 @@
+/** molecular_bio registration module — tsb analytics library. */
+export interface MolecularBioRegistrationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioRegistrationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioRegistration(data: number[], opts: MolecularBioRegistrationOptions = {}): MolecularBioRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioRegistration };
diff --git a/src/molecular_bio/regression.ts b/src/molecular_bio/regression.ts
new file mode 100644
index 000000000..03ba80587
--- /dev/null
+++ b/src/molecular_bio/regression.ts
@@ -0,0 +1,14 @@
+/** molecular_bio regression module — tsb analytics library. */
+export interface MolecularBioRegressionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioRegressionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioRegression(data: number[], opts: MolecularBioRegressionOptions = {}): MolecularBioRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioRegression };
diff --git a/src/molecular_bio/regularization.ts b/src/molecular_bio/regularization.ts
new file mode 100644
index 000000000..90dff0fbf
--- /dev/null
+++ b/src/molecular_bio/regularization.ts
@@ -0,0 +1,14 @@
+/** molecular_bio regularization module — tsb analytics library. */
+export interface MolecularBioRegularizationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioRegularizationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioRegularization(data: number[], opts: MolecularBioRegularizationOptions = {}): MolecularBioRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioRegularization };
diff --git a/src/molecular_bio/robustness.ts b/src/molecular_bio/robustness.ts
new file mode 100644
index 000000000..9df5b8317
--- /dev/null
+++ b/src/molecular_bio/robustness.ts
@@ -0,0 +1,14 @@
+/** molecular_bio robustness module — tsb analytics library. */
+export interface MolecularBioRobustnessOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioRobustnessResult { values: number[]; converged: boolean; }
+export function computeMolecularBioRobustness(data: number[], opts: MolecularBioRobustnessOptions = {}): MolecularBioRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioRobustness };
diff --git a/src/molecular_bio/sampling.ts b/src/molecular_bio/sampling.ts
new file mode 100644
index 000000000..8548ccf41
--- /dev/null
+++ b/src/molecular_bio/sampling.ts
@@ -0,0 +1,14 @@
+/** molecular_bio sampling module — tsb analytics library. */
+export interface MolecularBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioSamplingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioSampling(data: number[], opts: MolecularBioSamplingOptions = {}): MolecularBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioSampling };
diff --git a/src/molecular_bio/sampling2.ts b/src/molecular_bio/sampling2.ts
new file mode 100644
index 000000000..27b2cb918
--- /dev/null
+++ b/src/molecular_bio/sampling2.ts
@@ -0,0 +1,14 @@
+/** molecular_bio sampling2 module — tsb analytics library. */
+export interface MolecularBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioSamplingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioSampling(data: number[], opts: MolecularBioSamplingOptions = {}): MolecularBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioSampling };
diff --git a/src/molecular_bio/scaling.ts b/src/molecular_bio/scaling.ts
new file mode 100644
index 000000000..f8435f520
--- /dev/null
+++ b/src/molecular_bio/scaling.ts
@@ -0,0 +1,14 @@
+/** molecular_bio scaling module — tsb analytics library. */
+export interface MolecularBioScalingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioScalingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioScaling(data: number[], opts: MolecularBioScalingOptions = {}): MolecularBioScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioScaling };
diff --git a/src/molecular_bio/scoring.ts b/src/molecular_bio/scoring.ts
new file mode 100644
index 000000000..13e5be40f
--- /dev/null
+++ b/src/molecular_bio/scoring.ts
@@ -0,0 +1,14 @@
+/** molecular_bio scoring module — tsb analytics library. */
+export interface MolecularBioScoringOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioScoringResult { values: number[]; converged: boolean; }
+export function computeMolecularBioScoring(data: number[], opts: MolecularBioScoringOptions = {}): MolecularBioScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioScoring };
diff --git a/src/molecular_bio/segmentation.ts b/src/molecular_bio/segmentation.ts
new file mode 100644
index 000000000..2d2a6721f
--- /dev/null
+++ b/src/molecular_bio/segmentation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio segmentation module — tsb analytics library. */
+export interface MolecularBioSegmentationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioSegmentationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioSegmentation(data: number[], opts: MolecularBioSegmentationOptions = {}): MolecularBioSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioSegmentation };
diff --git a/src/molecular_bio/selection.ts b/src/molecular_bio/selection.ts
new file mode 100644
index 000000000..758352e31
--- /dev/null
+++ b/src/molecular_bio/selection.ts
@@ -0,0 +1,14 @@
+/** molecular_bio selection module — tsb analytics library. */
+export interface MolecularBioSelectionOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioSelectionResult { values: number[]; converged: boolean; }
+export function computeMolecularBioSelection(data: number[], opts: MolecularBioSelectionOptions = {}): MolecularBioSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioSelection };
diff --git a/src/molecular_bio/sensitivity.ts b/src/molecular_bio/sensitivity.ts
new file mode 100644
index 000000000..b43c96d38
--- /dev/null
+++ b/src/molecular_bio/sensitivity.ts
@@ -0,0 +1,14 @@
+/** molecular_bio sensitivity module — tsb analytics library. */
+export interface MolecularBioSensitivityOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioSensitivityResult { values: number[]; converged: boolean; }
+export function computeMolecularBioSensitivity(data: number[], opts: MolecularBioSensitivityOptions = {}): MolecularBioSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioSensitivity };
diff --git a/src/molecular_bio/simulation.ts b/src/molecular_bio/simulation.ts
new file mode 100644
index 000000000..b2b8a18bc
--- /dev/null
+++ b/src/molecular_bio/simulation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio simulation module — tsb analytics library. */
+export interface MolecularBioSimulationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioSimulationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioSimulation(data: number[], opts: MolecularBioSimulationOptions = {}): MolecularBioSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioSimulation };
diff --git a/src/molecular_bio/smoothing.ts b/src/molecular_bio/smoothing.ts
new file mode 100644
index 000000000..ad8d62cb3
--- /dev/null
+++ b/src/molecular_bio/smoothing.ts
@@ -0,0 +1,14 @@
+/** molecular_bio smoothing module — tsb analytics library. */
+export interface MolecularBioSmoothingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioSmoothingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioSmoothing(data: number[], opts: MolecularBioSmoothingOptions = {}): MolecularBioSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioSmoothing };
diff --git a/src/molecular_bio/stability.ts b/src/molecular_bio/stability.ts
new file mode 100644
index 000000000..90281d833
--- /dev/null
+++ b/src/molecular_bio/stability.ts
@@ -0,0 +1,14 @@
+/** molecular_bio stability module — tsb analytics library. */
+export interface MolecularBioStabilityOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioStabilityResult { values: number[]; converged: boolean; }
+export function computeMolecularBioStability(data: number[], opts: MolecularBioStabilityOptions = {}): MolecularBioStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioStability };
diff --git a/src/molecular_bio/stacking.ts b/src/molecular_bio/stacking.ts
new file mode 100644
index 000000000..7137ef82e
--- /dev/null
+++ b/src/molecular_bio/stacking.ts
@@ -0,0 +1,14 @@
+/** molecular_bio stacking module — tsb analytics library. */
+export interface MolecularBioStackingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioStackingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioStacking(data: number[], opts: MolecularBioStackingOptions = {}): MolecularBioStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioStacking };
diff --git a/src/molecular_bio/standardization.ts b/src/molecular_bio/standardization.ts
new file mode 100644
index 000000000..a46143d03
--- /dev/null
+++ b/src/molecular_bio/standardization.ts
@@ -0,0 +1,14 @@
+/** molecular_bio standardization module — tsb analytics library. */
+export interface MolecularBioStandardizationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioStandardizationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioStandardization(data: number[], opts: MolecularBioStandardizationOptions = {}): MolecularBioStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioStandardization };
diff --git a/src/molecular_bio/static.ts b/src/molecular_bio/static.ts
new file mode 100644
index 000000000..35ae43fa7
--- /dev/null
+++ b/src/molecular_bio/static.ts
@@ -0,0 +1,14 @@
+/** molecular_bio static module — tsb analytics library. */
+export interface MolecularBioStaticOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioStaticResult { values: number[]; converged: boolean; }
+export function computeMolecularBioStatic(data: number[], opts: MolecularBioStaticOptions = {}): MolecularBioStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioStatic };
diff --git a/src/molecular_bio/stochastic.ts b/src/molecular_bio/stochastic.ts
new file mode 100644
index 000000000..248f331e2
--- /dev/null
+++ b/src/molecular_bio/stochastic.ts
@@ -0,0 +1,14 @@
+/** molecular_bio stochastic module — tsb analytics library. */
+export interface MolecularBioStochasticOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioStochasticResult { values: number[]; converged: boolean; }
+export function computeMolecularBioStochastic(data: number[], opts: MolecularBioStochasticOptions = {}): MolecularBioStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioStochastic };
diff --git a/src/molecular_bio/synthesis.ts b/src/molecular_bio/synthesis.ts
new file mode 100644
index 000000000..fc143f282
--- /dev/null
+++ b/src/molecular_bio/synthesis.ts
@@ -0,0 +1,14 @@
+/** molecular_bio synthesis module — tsb analytics library. */
+export interface MolecularBioSynthesisOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioSynthesisResult { values: number[]; converged: boolean; }
+export function computeMolecularBioSynthesis(data: number[], opts: MolecularBioSynthesisOptions = {}): MolecularBioSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioSynthesis };
diff --git a/src/molecular_bio/topology.ts b/src/molecular_bio/topology.ts
new file mode 100644
index 000000000..d247a2e1b
--- /dev/null
+++ b/src/molecular_bio/topology.ts
@@ -0,0 +1,14 @@
+/** molecular_bio topology module — tsb analytics library. */
+export interface MolecularBioTopologyOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioTopologyResult { values: number[]; converged: boolean; }
+export function computeMolecularBioTopology(data: number[], opts: MolecularBioTopologyOptions = {}): MolecularBioTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioTopology };
diff --git a/src/molecular_bio/tracking.ts b/src/molecular_bio/tracking.ts
new file mode 100644
index 000000000..83374a62e
--- /dev/null
+++ b/src/molecular_bio/tracking.ts
@@ -0,0 +1,14 @@
+/** molecular_bio tracking module — tsb analytics library. */
+export interface MolecularBioTrackingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioTrackingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioTracking(data: number[], opts: MolecularBioTrackingOptions = {}): MolecularBioTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioTracking };
diff --git a/src/molecular_bio/transform.ts b/src/molecular_bio/transform.ts
new file mode 100644
index 000000000..6ac7ac01f
--- /dev/null
+++ b/src/molecular_bio/transform.ts
@@ -0,0 +1,14 @@
+/** molecular_bio transform module — tsb analytics library. */
+export interface MolecularBioTransformOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioTransformResult { values: number[]; converged: boolean; }
+export function computeMolecularBioTransform(data: number[], opts: MolecularBioTransformOptions = {}): MolecularBioTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioTransform };
diff --git a/src/molecular_bio/uncertainty.ts b/src/molecular_bio/uncertainty.ts
new file mode 100644
index 000000000..0d6e06d44
--- /dev/null
+++ b/src/molecular_bio/uncertainty.ts
@@ -0,0 +1,14 @@
+/** molecular_bio uncertainty module — tsb analytics library. */
+export interface MolecularBioUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioUncertaintyResult { values: number[]; converged: boolean; }
+export function computeMolecularBioUncertainty(data: number[], opts: MolecularBioUncertaintyOptions = {}): MolecularBioUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioUncertainty };
diff --git a/src/molecular_bio/validation.ts b/src/molecular_bio/validation.ts
new file mode 100644
index 000000000..71ca3cae8
--- /dev/null
+++ b/src/molecular_bio/validation.ts
@@ -0,0 +1,14 @@
+/** molecular_bio validation module — tsb analytics library. */
+export interface MolecularBioValidationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioValidationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioValidation(data: number[], opts: MolecularBioValidationOptions = {}): MolecularBioValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioValidation };
diff --git a/src/molecular_bio/verification.ts b/src/molecular_bio/verification.ts
new file mode 100644
index 000000000..5384f62fb
--- /dev/null
+++ b/src/molecular_bio/verification.ts
@@ -0,0 +1,14 @@
+/** molecular_bio verification module — tsb analytics library. */
+export interface MolecularBioVerificationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioVerificationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioVerification(data: number[], opts: MolecularBioVerificationOptions = {}): MolecularBioVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioVerification };
diff --git a/src/molecular_bio/visualization.ts b/src/molecular_bio/visualization.ts
new file mode 100644
index 000000000..75ed5aadf
--- /dev/null
+++ b/src/molecular_bio/visualization.ts
@@ -0,0 +1,14 @@
+/** molecular_bio visualization module — tsb analytics library. */
+export interface MolecularBioVisualizationOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioVisualizationResult { values: number[]; converged: boolean; }
+export function computeMolecularBioVisualization(data: number[], opts: MolecularBioVisualizationOptions = {}): MolecularBioVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioVisualization };
diff --git a/src/molecular_bio/voting.ts b/src/molecular_bio/voting.ts
new file mode 100644
index 000000000..f72646efa
--- /dev/null
+++ b/src/molecular_bio/voting.ts
@@ -0,0 +1,14 @@
+/** molecular_bio voting module — tsb analytics library. */
+export interface MolecularBioVotingOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioVotingResult { values: number[]; converged: boolean; }
+export function computeMolecularBioVoting(data: number[], opts: MolecularBioVotingOptions = {}): MolecularBioVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioVoting };
diff --git a/src/molecular_bio/wavelet.ts b/src/molecular_bio/wavelet.ts
new file mode 100644
index 000000000..0da7fae07
--- /dev/null
+++ b/src/molecular_bio/wavelet.ts
@@ -0,0 +1,14 @@
+/** molecular_bio wavelet module — tsb analytics library. */
+export interface MolecularBioWaveletOptions { tol?: number; maxIter?: number; }
+export interface MolecularBioWaveletResult { values: number[]; converged: boolean; }
+export function computeMolecularBioWavelet(data: number[], opts: MolecularBioWaveletOptions = {}): MolecularBioWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMolecularBioWavelet };
diff --git a/src/mycology/adaptation.ts b/src/mycology/adaptation.ts
new file mode 100644
index 000000000..640255893
--- /dev/null
+++ b/src/mycology/adaptation.ts
@@ -0,0 +1,14 @@
+/** mycology adaptation module — tsb analytics library. */
+export interface MycologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface MycologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeMycologyAdaptation(data: number[], opts: MycologyAdaptationOptions = {}): MycologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyAdaptation };
diff --git a/src/mycology/aggregation.ts b/src/mycology/aggregation.ts
new file mode 100644
index 000000000..b30e9aacd
--- /dev/null
+++ b/src/mycology/aggregation.ts
@@ -0,0 +1,14 @@
+/** mycology aggregation module — tsb analytics library. */
+export interface MycologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface MycologyAggregationResult { values: number[]; converged: boolean; }
+export function computeMycologyAggregation(data: number[], opts: MycologyAggregationOptions = {}): MycologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyAggregation };
diff --git a/src/mycology/algebra.ts b/src/mycology/algebra.ts
new file mode 100644
index 000000000..0ab94db10
--- /dev/null
+++ b/src/mycology/algebra.ts
@@ -0,0 +1,14 @@
+/** mycology algebra module — tsb analytics library. */
+export interface MycologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface MycologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeMycologyAlgebra(data: number[], opts: MycologyAlgebraOptions = {}): MycologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyAlgebra };
diff --git a/src/mycology/alignment.ts b/src/mycology/alignment.ts
new file mode 100644
index 000000000..cb61e9737
--- /dev/null
+++ b/src/mycology/alignment.ts
@@ -0,0 +1,14 @@
+/** mycology alignment module — tsb analytics library. */
+export interface MycologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface MycologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeMycologyAlignment(data: number[], opts: MycologyAlignmentOptions = {}): MycologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyAlignment };
diff --git a/src/mycology/analysis.ts b/src/mycology/analysis.ts
new file mode 100644
index 000000000..b6d2e0d21
--- /dev/null
+++ b/src/mycology/analysis.ts
@@ -0,0 +1,14 @@
+/** mycology analysis module — tsb analytics library. */
+export interface MycologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface MycologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeMycologyAnalysis(data: number[], opts: MycologyAnalysisOptions = {}): MycologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyAnalysis };
diff --git a/src/mycology/augmentation.ts b/src/mycology/augmentation.ts
new file mode 100644
index 000000000..224bb678b
--- /dev/null
+++ b/src/mycology/augmentation.ts
@@ -0,0 +1,14 @@
+/** mycology augmentation module — tsb analytics library. */
+export interface MycologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface MycologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeMycologyAugmentation(data: number[], opts: MycologyAugmentationOptions = {}): MycologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyAugmentation };
diff --git a/src/mycology/bagging.ts b/src/mycology/bagging.ts
new file mode 100644
index 000000000..0830f501b
--- /dev/null
+++ b/src/mycology/bagging.ts
@@ -0,0 +1,14 @@
+/** mycology bagging module — tsb analytics library. */
+export interface MycologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface MycologyBaggingResult { values: number[]; converged: boolean; }
+export function computeMycologyBagging(data: number[], opts: MycologyBaggingOptions = {}): MycologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyBagging };
diff --git a/src/mycology/basis.ts b/src/mycology/basis.ts
new file mode 100644
index 000000000..18400c145
--- /dev/null
+++ b/src/mycology/basis.ts
@@ -0,0 +1,14 @@
+/** mycology basis module — tsb analytics library. */
+export interface MycologyBasisOptions { tol?: number; maxIter?: number; }
+export interface MycologyBasisResult { values: number[]; converged: boolean; }
+export function computeMycologyBasis(data: number[], opts: MycologyBasisOptions = {}): MycologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyBasis };
diff --git a/src/mycology/benchmarking.ts b/src/mycology/benchmarking.ts
new file mode 100644
index 000000000..7068da460
--- /dev/null
+++ b/src/mycology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** mycology benchmarking module — tsb analytics library. */
+export interface MycologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface MycologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeMycologyBenchmarking(data: number[], opts: MycologyBenchmarkingOptions = {}): MycologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyBenchmarking };
diff --git a/src/mycology/blending.ts b/src/mycology/blending.ts
new file mode 100644
index 000000000..2d19b316d
--- /dev/null
+++ b/src/mycology/blending.ts
@@ -0,0 +1,14 @@
+/** mycology blending module — tsb analytics library. */
+export interface MycologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface MycologyBlendingResult { values: number[]; converged: boolean; }
+export function computeMycologyBlending(data: number[], opts: MycologyBlendingOptions = {}): MycologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyBlending };
diff --git a/src/mycology/boosting.ts b/src/mycology/boosting.ts
new file mode 100644
index 000000000..95a68dbca
--- /dev/null
+++ b/src/mycology/boosting.ts
@@ -0,0 +1,14 @@
+/** mycology boosting module — tsb analytics library. */
+export interface MycologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface MycologyBoostingResult { values: number[]; converged: boolean; }
+export function computeMycologyBoosting(data: number[], opts: MycologyBoostingOptions = {}): MycologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyBoosting };
diff --git a/src/mycology/bootstrap.ts b/src/mycology/bootstrap.ts
new file mode 100644
index 000000000..b8b176d43
--- /dev/null
+++ b/src/mycology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** mycology bootstrap module — tsb analytics library. */
+export interface MycologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface MycologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeMycologyBootstrap(data: number[], opts: MycologyBootstrapOptions = {}): MycologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyBootstrap };
diff --git a/src/mycology/calculus.ts b/src/mycology/calculus.ts
new file mode 100644
index 000000000..97aeb768d
--- /dev/null
+++ b/src/mycology/calculus.ts
@@ -0,0 +1,14 @@
+/** mycology calculus module — tsb analytics library. */
+export interface MycologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface MycologyCalculusResult { values: number[]; converged: boolean; }
+export function computeMycologyCalculus(data: number[], opts: MycologyCalculusOptions = {}): MycologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyCalculus };
diff --git a/src/mycology/calibration.ts b/src/mycology/calibration.ts
new file mode 100644
index 000000000..1d69351b7
--- /dev/null
+++ b/src/mycology/calibration.ts
@@ -0,0 +1,14 @@
+/** mycology calibration module — tsb analytics library. */
+export interface MycologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface MycologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeMycologyCalibration(data: number[], opts: MycologyCalibrationOptions = {}): MycologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyCalibration };
diff --git a/src/mycology/characterization.ts b/src/mycology/characterization.ts
new file mode 100644
index 000000000..0969a08c0
--- /dev/null
+++ b/src/mycology/characterization.ts
@@ -0,0 +1,14 @@
+/** mycology characterization module — tsb analytics library. */
+export interface MycologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface MycologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeMycologyCharacterization(data: number[], opts: MycologyCharacterizationOptions = {}): MycologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyCharacterization };
diff --git a/src/mycology/classification.ts b/src/mycology/classification.ts
new file mode 100644
index 000000000..9722a6963
--- /dev/null
+++ b/src/mycology/classification.ts
@@ -0,0 +1,14 @@
+/** mycology classification module — tsb analytics library. */
+export interface MycologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface MycologyClassificationResult { values: number[]; converged: boolean; }
+export function computeMycologyClassification(data: number[], opts: MycologyClassificationOptions = {}): MycologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyClassification };
diff --git a/src/mycology/clustering.ts b/src/mycology/clustering.ts
new file mode 100644
index 000000000..c2ba4904d
--- /dev/null
+++ b/src/mycology/clustering.ts
@@ -0,0 +1,14 @@
+/** mycology clustering module — tsb analytics library. */
+export interface MycologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface MycologyClusteringResult { values: number[]; converged: boolean; }
+export function computeMycologyClustering(data: number[], opts: MycologyClusteringOptions = {}): MycologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyClustering };
diff --git a/src/mycology/compression.ts b/src/mycology/compression.ts
new file mode 100644
index 000000000..43a1fce34
--- /dev/null
+++ b/src/mycology/compression.ts
@@ -0,0 +1,14 @@
+/** mycology compression module — tsb analytics library. */
+export interface MycologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface MycologyCompressionResult { values: number[]; converged: boolean; }
+export function computeMycologyCompression(data: number[], opts: MycologyCompressionOptions = {}): MycologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyCompression };
diff --git a/src/mycology/continuous.ts b/src/mycology/continuous.ts
new file mode 100644
index 000000000..9df60d35f
--- /dev/null
+++ b/src/mycology/continuous.ts
@@ -0,0 +1,14 @@
+/** mycology continuous module — tsb analytics library. */
+export interface MycologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface MycologyContinuousResult { values: number[]; converged: boolean; }
+export function computeMycologyContinuous(data: number[], opts: MycologyContinuousOptions = {}): MycologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyContinuous };
diff --git a/src/mycology/control.ts b/src/mycology/control.ts
new file mode 100644
index 000000000..88430fbfa
--- /dev/null
+++ b/src/mycology/control.ts
@@ -0,0 +1,14 @@
+/** mycology control module — tsb analytics library. */
+export interface MycologyControlOptions { tol?: number; maxIter?: number; }
+export interface MycologyControlResult { values: number[]; converged: boolean; }
+export function computeMycologyControl(data: number[], opts: MycologyControlOptions = {}): MycologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyControl };
diff --git a/src/mycology/convergence.ts b/src/mycology/convergence.ts
new file mode 100644
index 000000000..1f6432048
--- /dev/null
+++ b/src/mycology/convergence.ts
@@ -0,0 +1,14 @@
+/** mycology convergence module — tsb analytics library. */
+export interface MycologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface MycologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeMycologyConvergence(data: number[], opts: MycologyConvergenceOptions = {}): MycologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyConvergence };
diff --git a/src/mycology/convex.ts b/src/mycology/convex.ts
new file mode 100644
index 000000000..3f813a107
--- /dev/null
+++ b/src/mycology/convex.ts
@@ -0,0 +1,14 @@
+/** mycology convex module — tsb analytics library. */
+export interface MycologyConvexOptions { tol?: number; maxIter?: number; }
+export interface MycologyConvexResult { values: number[]; converged: boolean; }
+export function computeMycologyConvex(data: number[], opts: MycologyConvexOptions = {}): MycologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyConvex };
diff --git a/src/mycology/correlation.ts b/src/mycology/correlation.ts
new file mode 100644
index 000000000..f6e15ccb3
--- /dev/null
+++ b/src/mycology/correlation.ts
@@ -0,0 +1,14 @@
+/** mycology correlation module — tsb analytics library. */
+export interface MycologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface MycologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeMycologyCorrelation(data: number[], opts: MycologyCorrelationOptions = {}): MycologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyCorrelation };
diff --git a/src/mycology/covariance.ts b/src/mycology/covariance.ts
new file mode 100644
index 000000000..2fce84226
--- /dev/null
+++ b/src/mycology/covariance.ts
@@ -0,0 +1,14 @@
+/** mycology covariance module — tsb analytics library. */
+export interface MycologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface MycologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeMycologyCovariance(data: number[], opts: MycologyCovarianceOptions = {}): MycologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyCovariance };
diff --git a/src/mycology/cross_validation.ts b/src/mycology/cross_validation.ts
new file mode 100644
index 000000000..6cedae4fd
--- /dev/null
+++ b/src/mycology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** mycology cross_validation module — tsb analytics library. */
+export interface MycologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface MycologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeMycologyCrossValidation(data: number[], opts: MycologyCrossValidationOptions = {}): MycologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyCrossValidation };
diff --git a/src/mycology/decoding.ts b/src/mycology/decoding.ts
new file mode 100644
index 000000000..c541b379f
--- /dev/null
+++ b/src/mycology/decoding.ts
@@ -0,0 +1,14 @@
+/** mycology decoding module — tsb analytics library. */
+export interface MycologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface MycologyDecodingResult { values: number[]; converged: boolean; }
+export function computeMycologyDecoding(data: number[], opts: MycologyDecodingOptions = {}): MycologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDecoding };
diff --git a/src/mycology/decomposition.ts b/src/mycology/decomposition.ts
new file mode 100644
index 000000000..4cc9cdfa8
--- /dev/null
+++ b/src/mycology/decomposition.ts
@@ -0,0 +1,14 @@
+/** mycology decomposition module — tsb analytics library. */
+export interface MycologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface MycologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeMycologyDecomposition(data: number[], opts: MycologyDecompositionOptions = {}): MycologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDecomposition };
diff --git a/src/mycology/detection.ts b/src/mycology/detection.ts
new file mode 100644
index 000000000..feac5b2ea
--- /dev/null
+++ b/src/mycology/detection.ts
@@ -0,0 +1,14 @@
+/** mycology detection module — tsb analytics library. */
+export interface MycologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface MycologyDetectionResult { values: number[]; converged: boolean; }
+export function computeMycologyDetection(data: number[], opts: MycologyDetectionOptions = {}): MycologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDetection };
diff --git a/src/mycology/deterministic.ts b/src/mycology/deterministic.ts
new file mode 100644
index 000000000..6927c3fa6
--- /dev/null
+++ b/src/mycology/deterministic.ts
@@ -0,0 +1,14 @@
+/** mycology deterministic module — tsb analytics library. */
+export interface MycologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface MycologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeMycologyDeterministic(data: number[], opts: MycologyDeterministicOptions = {}): MycologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDeterministic };
diff --git a/src/mycology/diagnostics.ts b/src/mycology/diagnostics.ts
new file mode 100644
index 000000000..37fda1579
--- /dev/null
+++ b/src/mycology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** mycology diagnostics module — tsb analytics library. */
+export interface MycologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface MycologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeMycologyDiagnostics(data: number[], opts: MycologyDiagnosticsOptions = {}): MycologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDiagnostics };
diff --git a/src/mycology/differential.ts b/src/mycology/differential.ts
new file mode 100644
index 000000000..36ff9b7f5
--- /dev/null
+++ b/src/mycology/differential.ts
@@ -0,0 +1,14 @@
+/** mycology differential module — tsb analytics library. */
+export interface MycologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface MycologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeMycologyDifferential(data: number[], opts: MycologyDifferentialOptions = {}): MycologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDifferential };
diff --git a/src/mycology/discrete.ts b/src/mycology/discrete.ts
new file mode 100644
index 000000000..418f96723
--- /dev/null
+++ b/src/mycology/discrete.ts
@@ -0,0 +1,14 @@
+/** mycology discrete module — tsb analytics library. */
+export interface MycologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface MycologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeMycologyDiscrete(data: number[], opts: MycologyDiscreteOptions = {}): MycologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDiscrete };
diff --git a/src/mycology/distribution.ts b/src/mycology/distribution.ts
new file mode 100644
index 000000000..4179c6ddb
--- /dev/null
+++ b/src/mycology/distribution.ts
@@ -0,0 +1,14 @@
+/** mycology distribution module — tsb analytics library. */
+export interface MycologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface MycologyDistributionResult { values: number[]; converged: boolean; }
+export function computeMycologyDistribution(data: number[], opts: MycologyDistributionOptions = {}): MycologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDistribution };
diff --git a/src/mycology/dynamic.ts b/src/mycology/dynamic.ts
new file mode 100644
index 000000000..a7858ef33
--- /dev/null
+++ b/src/mycology/dynamic.ts
@@ -0,0 +1,14 @@
+/** mycology dynamic module — tsb analytics library. */
+export interface MycologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface MycologyDynamicResult { values: number[]; converged: boolean; }
+export function computeMycologyDynamic(data: number[], opts: MycologyDynamicOptions = {}): MycologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyDynamic };
diff --git a/src/mycology/embedding.ts b/src/mycology/embedding.ts
new file mode 100644
index 000000000..39045e01a
--- /dev/null
+++ b/src/mycology/embedding.ts
@@ -0,0 +1,14 @@
+/** mycology embedding module — tsb analytics library. */
+export interface MycologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface MycologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeMycologyEmbedding(data: number[], opts: MycologyEmbeddingOptions = {}): MycologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyEmbedding };
diff --git a/src/mycology/encoding.ts b/src/mycology/encoding.ts
new file mode 100644
index 000000000..d2fa13db3
--- /dev/null
+++ b/src/mycology/encoding.ts
@@ -0,0 +1,14 @@
+/** mycology encoding module — tsb analytics library. */
+export interface MycologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface MycologyEncodingResult { values: number[]; converged: boolean; }
+export function computeMycologyEncoding(data: number[], opts: MycologyEncodingOptions = {}): MycologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyEncoding };
diff --git a/src/mycology/ensemble.ts b/src/mycology/ensemble.ts
new file mode 100644
index 000000000..301f076b1
--- /dev/null
+++ b/src/mycology/ensemble.ts
@@ -0,0 +1,14 @@
+/** mycology ensemble module — tsb analytics library. */
+export interface MycologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface MycologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeMycologyEnsemble(data: number[], opts: MycologyEnsembleOptions = {}): MycologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyEnsemble };
diff --git a/src/mycology/estimation.ts b/src/mycology/estimation.ts
new file mode 100644
index 000000000..2fcb24988
--- /dev/null
+++ b/src/mycology/estimation.ts
@@ -0,0 +1,14 @@
+/** mycology estimation module — tsb analytics library. */
+export interface MycologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface MycologyEstimationResult { values: number[]; converged: boolean; }
+export function computeMycologyEstimation(data: number[], opts: MycologyEstimationOptions = {}): MycologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyEstimation };
diff --git a/src/mycology/evaluation.ts b/src/mycology/evaluation.ts
new file mode 100644
index 000000000..f262b0558
--- /dev/null
+++ b/src/mycology/evaluation.ts
@@ -0,0 +1,14 @@
+/** mycology evaluation module — tsb analytics library. */
+export interface MycologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface MycologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeMycologyEvaluation(data: number[], opts: MycologyEvaluationOptions = {}): MycologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyEvaluation };
diff --git a/src/mycology/extrapolation.ts b/src/mycology/extrapolation.ts
new file mode 100644
index 000000000..2e97fd6d0
--- /dev/null
+++ b/src/mycology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** mycology extrapolation module — tsb analytics library. */
+export interface MycologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface MycologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeMycologyExtrapolation(data: number[], opts: MycologyExtrapolationOptions = {}): MycologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyExtrapolation };
diff --git a/src/mycology/features.ts b/src/mycology/features.ts
new file mode 100644
index 000000000..cc335ecc7
--- /dev/null
+++ b/src/mycology/features.ts
@@ -0,0 +1,14 @@
+/** mycology features module — tsb analytics library. */
+export interface MycologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface MycologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeMycologyFeatures(data: number[], opts: MycologyFeaturesOptions = {}): MycologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyFeatures };
diff --git a/src/mycology/feedback.ts b/src/mycology/feedback.ts
new file mode 100644
index 000000000..87664c74a
--- /dev/null
+++ b/src/mycology/feedback.ts
@@ -0,0 +1,14 @@
+/** mycology feedback module — tsb analytics library. */
+export interface MycologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface MycologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeMycologyFeedback(data: number[], opts: MycologyFeedbackOptions = {}): MycologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyFeedback };
diff --git a/src/mycology/filtering.ts b/src/mycology/filtering.ts
new file mode 100644
index 000000000..9cd6bd288
--- /dev/null
+++ b/src/mycology/filtering.ts
@@ -0,0 +1,14 @@
+/** mycology filtering module — tsb analytics library. */
+export interface MycologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface MycologyFilteringResult { values: number[]; converged: boolean; }
+export function computeMycologyFiltering(data: number[], opts: MycologyFilteringOptions = {}): MycologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyFiltering };
diff --git a/src/mycology/fourier.ts b/src/mycology/fourier.ts
new file mode 100644
index 000000000..45aaea741
--- /dev/null
+++ b/src/mycology/fourier.ts
@@ -0,0 +1,14 @@
+/** mycology fourier module — tsb analytics library. */
+export interface MycologyFourierOptions { tol?: number; maxIter?: number; }
+export interface MycologyFourierResult { values: number[]; converged: boolean; }
+export function computeMycologyFourier(data: number[], opts: MycologyFourierOptions = {}): MycologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyFourier };
diff --git a/src/mycology/fusion.ts b/src/mycology/fusion.ts
new file mode 100644
index 000000000..dbfdf425e
--- /dev/null
+++ b/src/mycology/fusion.ts
@@ -0,0 +1,14 @@
+/** mycology fusion module — tsb analytics library. */
+export interface MycologyFusionOptions { tol?: number; maxIter?: number; }
+export interface MycologyFusionResult { values: number[]; converged: boolean; }
+export function computeMycologyFusion(data: number[], opts: MycologyFusionOptions = {}): MycologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyFusion };
diff --git a/src/mycology/generation.ts b/src/mycology/generation.ts
new file mode 100644
index 000000000..fa562a23a
--- /dev/null
+++ b/src/mycology/generation.ts
@@ -0,0 +1,14 @@
+/** mycology generation module — tsb analytics library. */
+export interface MycologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface MycologyGenerationResult { values: number[]; converged: boolean; }
+export function computeMycologyGeneration(data: number[], opts: MycologyGenerationOptions = {}): MycologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyGeneration };
diff --git a/src/mycology/geometry.ts b/src/mycology/geometry.ts
new file mode 100644
index 000000000..ee5d1d0c2
--- /dev/null
+++ b/src/mycology/geometry.ts
@@ -0,0 +1,14 @@
+/** mycology geometry module — tsb analytics library. */
+export interface MycologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface MycologyGeometryResult { values: number[]; converged: boolean; }
+export function computeMycologyGeometry(data: number[], opts: MycologyGeometryOptions = {}): MycologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyGeometry };
diff --git a/src/mycology/gradient.ts b/src/mycology/gradient.ts
new file mode 100644
index 000000000..d74f998ff
--- /dev/null
+++ b/src/mycology/gradient.ts
@@ -0,0 +1,14 @@
+/** mycology gradient module — tsb analytics library. */
+export interface MycologyGradientOptions { tol?: number; maxIter?: number; }
+export interface MycologyGradientResult { values: number[]; converged: boolean; }
+export function computeMycologyGradient(data: number[], opts: MycologyGradientOptions = {}): MycologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyGradient };
diff --git a/src/mycology/hessian.ts b/src/mycology/hessian.ts
new file mode 100644
index 000000000..3fb4178b0
--- /dev/null
+++ b/src/mycology/hessian.ts
@@ -0,0 +1,14 @@
+/** mycology hessian module — tsb analytics library. */
+export interface MycologyHessianOptions { tol?: number; maxIter?: number; }
+export interface MycologyHessianResult { values: number[]; converged: boolean; }
+export function computeMycologyHessian(data: number[], opts: MycologyHessianOptions = {}): MycologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyHessian };
diff --git a/src/mycology/hypothesis.ts b/src/mycology/hypothesis.ts
new file mode 100644
index 000000000..efa79c98b
--- /dev/null
+++ b/src/mycology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** mycology hypothesis module — tsb analytics library. */
+export interface MycologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface MycologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeMycologyHypothesis(data: number[], opts: MycologyHypothesisOptions = {}): MycologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyHypothesis };
diff --git a/src/mycology/inference.ts b/src/mycology/inference.ts
new file mode 100644
index 000000000..7083e858f
--- /dev/null
+++ b/src/mycology/inference.ts
@@ -0,0 +1,14 @@
+/** mycology inference module — tsb analytics library. */
+export interface MycologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface MycologyInferenceResult { values: number[]; converged: boolean; }
+export function computeMycologyInference(data: number[], opts: MycologyInferenceOptions = {}): MycologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyInference };
diff --git a/src/mycology/inference2.ts b/src/mycology/inference2.ts
new file mode 100644
index 000000000..edb545cc7
--- /dev/null
+++ b/src/mycology/inference2.ts
@@ -0,0 +1,14 @@
+/** mycology inference2 module — tsb analytics library. */
+export interface MycologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface MycologyInferenceResult { values: number[]; converged: boolean; }
+export function computeMycologyInference(data: number[], opts: MycologyInferenceOptions = {}): MycologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyInference };
diff --git a/src/mycology/integral.ts b/src/mycology/integral.ts
new file mode 100644
index 000000000..de3199e1d
--- /dev/null
+++ b/src/mycology/integral.ts
@@ -0,0 +1,14 @@
+/** mycology integral module — tsb analytics library. */
+export interface MycologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface MycologyIntegralResult { values: number[]; converged: boolean; }
+export function computeMycologyIntegral(data: number[], opts: MycologyIntegralOptions = {}): MycologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyIntegral };
diff --git a/src/mycology/integration.ts b/src/mycology/integration.ts
new file mode 100644
index 000000000..4f705acf5
--- /dev/null
+++ b/src/mycology/integration.ts
@@ -0,0 +1,14 @@
+/** mycology integration module — tsb analytics library. */
+export interface MycologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface MycologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeMycologyIntegration(data: number[], opts: MycologyIntegrationOptions = {}): MycologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyIntegration };
diff --git a/src/mycology/interpolation.ts b/src/mycology/interpolation.ts
new file mode 100644
index 000000000..a15b397f0
--- /dev/null
+++ b/src/mycology/interpolation.ts
@@ -0,0 +1,14 @@
+/** mycology interpolation module — tsb analytics library. */
+export interface MycologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface MycologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeMycologyInterpolation(data: number[], opts: MycologyInterpolationOptions = {}): MycologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyInterpolation };
diff --git a/src/mycology/jacobian.ts b/src/mycology/jacobian.ts
new file mode 100644
index 000000000..91cc8d65b
--- /dev/null
+++ b/src/mycology/jacobian.ts
@@ -0,0 +1,14 @@
+/** mycology jacobian module — tsb analytics library. */
+export interface MycologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface MycologyJacobianResult { values: number[]; converged: boolean; }
+export function computeMycologyJacobian(data: number[], opts: MycologyJacobianOptions = {}): MycologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyJacobian };
diff --git a/src/mycology/kernel.ts b/src/mycology/kernel.ts
new file mode 100644
index 000000000..8eabe30ae
--- /dev/null
+++ b/src/mycology/kernel.ts
@@ -0,0 +1,14 @@
+/** mycology kernel module — tsb analytics library. */
+export interface MycologyKernelOptions { tol?: number; maxIter?: number; }
+export interface MycologyKernelResult { values: number[]; converged: boolean; }
+export function computeMycologyKernel(data: number[], opts: MycologyKernelOptions = {}): MycologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyKernel };
diff --git a/src/mycology/laplacian.ts b/src/mycology/laplacian.ts
new file mode 100644
index 000000000..f92bf8cbb
--- /dev/null
+++ b/src/mycology/laplacian.ts
@@ -0,0 +1,14 @@
+/** mycology laplacian module — tsb analytics library. */
+export interface MycologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface MycologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeMycologyLaplacian(data: number[], opts: MycologyLaplacianOptions = {}): MycologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyLaplacian };
diff --git a/src/mycology/learning.ts b/src/mycology/learning.ts
new file mode 100644
index 000000000..3bb3fe4f8
--- /dev/null
+++ b/src/mycology/learning.ts
@@ -0,0 +1,14 @@
+/** mycology learning module — tsb analytics library. */
+export interface MycologyLearningOptions { tol?: number; maxIter?: number; }
+export interface MycologyLearningResult { values: number[]; converged: boolean; }
+export function computeMycologyLearning(data: number[], opts: MycologyLearningOptions = {}): MycologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyLearning };
diff --git a/src/mycology/linear.ts b/src/mycology/linear.ts
new file mode 100644
index 000000000..265b2c87f
--- /dev/null
+++ b/src/mycology/linear.ts
@@ -0,0 +1,14 @@
+/** mycology linear module — tsb analytics library. */
+export interface MycologyLinearOptions { tol?: number; maxIter?: number; }
+export interface MycologyLinearResult { values: number[]; converged: boolean; }
+export function computeMycologyLinear(data: number[], opts: MycologyLinearOptions = {}): MycologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyLinear };
diff --git a/src/mycology/manifold.ts b/src/mycology/manifold.ts
new file mode 100644
index 000000000..bdc1791ee
--- /dev/null
+++ b/src/mycology/manifold.ts
@@ -0,0 +1,14 @@
+/** mycology manifold module — tsb analytics library. */
+export interface MycologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface MycologyManifoldResult { values: number[]; converged: boolean; }
+export function computeMycologyManifold(data: number[], opts: MycologyManifoldOptions = {}): MycologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyManifold };
diff --git a/src/mycology/matching.ts b/src/mycology/matching.ts
new file mode 100644
index 000000000..49e2f5583
--- /dev/null
+++ b/src/mycology/matching.ts
@@ -0,0 +1,14 @@
+/** mycology matching module — tsb analytics library. */
+export interface MycologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface MycologyMatchingResult { values: number[]; converged: boolean; }
+export function computeMycologyMatching(data: number[], opts: MycologyMatchingOptions = {}): MycologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyMatching };
diff --git a/src/mycology/measurement.ts b/src/mycology/measurement.ts
new file mode 100644
index 000000000..d6a014397
--- /dev/null
+++ b/src/mycology/measurement.ts
@@ -0,0 +1,14 @@
+/** mycology measurement module — tsb analytics library. */
+export interface MycologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface MycologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeMycologyMeasurement(data: number[], opts: MycologyMeasurementOptions = {}): MycologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyMeasurement };
diff --git a/src/mycology/metrics.ts b/src/mycology/metrics.ts
new file mode 100644
index 000000000..246dfc10e
--- /dev/null
+++ b/src/mycology/metrics.ts
@@ -0,0 +1,14 @@
+/** mycology metrics module — tsb analytics library. */
+export interface MycologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface MycologyMetricsResult { values: number[]; converged: boolean; }
+export function computeMycologyMetrics(data: number[], opts: MycologyMetricsOptions = {}): MycologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyMetrics };
diff --git a/src/mycology/modeling.ts b/src/mycology/modeling.ts
new file mode 100644
index 000000000..6427acb48
--- /dev/null
+++ b/src/mycology/modeling.ts
@@ -0,0 +1,14 @@
+/** mycology modeling module — tsb analytics library. */
+export interface MycologyModelingOptions { tol?: number; maxIter?: number; }
+export interface MycologyModelingResult { values: number[]; converged: boolean; }
+export function computeMycologyModeling(data: number[], opts: MycologyModelingOptions = {}): MycologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyModeling };
diff --git a/src/mycology/monitoring.ts b/src/mycology/monitoring.ts
new file mode 100644
index 000000000..f1adfa5b6
--- /dev/null
+++ b/src/mycology/monitoring.ts
@@ -0,0 +1,14 @@
+/** mycology monitoring module — tsb analytics library. */
+export interface MycologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface MycologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeMycologyMonitoring(data: number[], opts: MycologyMonitoringOptions = {}): MycologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyMonitoring };
diff --git a/src/mycology/nonlinear.ts b/src/mycology/nonlinear.ts
new file mode 100644
index 000000000..a304afcc8
--- /dev/null
+++ b/src/mycology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** mycology nonlinear module — tsb analytics library. */
+export interface MycologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface MycologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeMycologyNonlinear(data: number[], opts: MycologyNonlinearOptions = {}): MycologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyNonlinear };
diff --git a/src/mycology/normalization.ts b/src/mycology/normalization.ts
new file mode 100644
index 000000000..60c35dfd3
--- /dev/null
+++ b/src/mycology/normalization.ts
@@ -0,0 +1,14 @@
+/** mycology normalization module — tsb analytics library. */
+export interface MycologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface MycologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeMycologyNormalization(data: number[], opts: MycologyNormalizationOptions = {}): MycologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyNormalization };
diff --git a/src/mycology/optimization.ts b/src/mycology/optimization.ts
new file mode 100644
index 000000000..a571db14d
--- /dev/null
+++ b/src/mycology/optimization.ts
@@ -0,0 +1,14 @@
+/** mycology optimization module — tsb analytics library. */
+export interface MycologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface MycologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeMycologyOptimization(data: number[], opts: MycologyOptimizationOptions = {}): MycologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyOptimization };
diff --git a/src/mycology/patterns.ts b/src/mycology/patterns.ts
new file mode 100644
index 000000000..a648897da
--- /dev/null
+++ b/src/mycology/patterns.ts
@@ -0,0 +1,14 @@
+/** mycology patterns module — tsb analytics library. */
+export interface MycologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface MycologyPatternsResult { values: number[]; converged: boolean; }
+export function computeMycologyPatterns(data: number[], opts: MycologyPatternsOptions = {}): MycologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyPatterns };
diff --git a/src/mycology/permutation.ts b/src/mycology/permutation.ts
new file mode 100644
index 000000000..9813939db
--- /dev/null
+++ b/src/mycology/permutation.ts
@@ -0,0 +1,14 @@
+/** mycology permutation module — tsb analytics library. */
+export interface MycologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface MycologyPermutationResult { values: number[]; converged: boolean; }
+export function computeMycologyPermutation(data: number[], opts: MycologyPermutationOptions = {}): MycologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyPermutation };
diff --git a/src/mycology/prediction.ts b/src/mycology/prediction.ts
new file mode 100644
index 000000000..d640e02e4
--- /dev/null
+++ b/src/mycology/prediction.ts
@@ -0,0 +1,14 @@
+/** mycology prediction module — tsb analytics library. */
+export interface MycologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface MycologyPredictionResult { values: number[]; converged: boolean; }
+export function computeMycologyPrediction(data: number[], opts: MycologyPredictionOptions = {}): MycologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyPrediction };
diff --git a/src/mycology/processing.ts b/src/mycology/processing.ts
new file mode 100644
index 000000000..90607a566
--- /dev/null
+++ b/src/mycology/processing.ts
@@ -0,0 +1,14 @@
+/** mycology processing module — tsb analytics library. */
+export interface MycologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface MycologyProcessingResult { values: number[]; converged: boolean; }
+export function computeMycologyProcessing(data: number[], opts: MycologyProcessingOptions = {}): MycologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyProcessing };
diff --git a/src/mycology/profiling.ts b/src/mycology/profiling.ts
new file mode 100644
index 000000000..c314d4577
--- /dev/null
+++ b/src/mycology/profiling.ts
@@ -0,0 +1,14 @@
+/** mycology profiling module — tsb analytics library. */
+export interface MycologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface MycologyProfilingResult { values: number[]; converged: boolean; }
+export function computeMycologyProfiling(data: number[], opts: MycologyProfilingOptions = {}): MycologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyProfiling };
diff --git a/src/mycology/projection.ts b/src/mycology/projection.ts
new file mode 100644
index 000000000..20a3f1982
--- /dev/null
+++ b/src/mycology/projection.ts
@@ -0,0 +1,14 @@
+/** mycology projection module — tsb analytics library. */
+export interface MycologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface MycologyProjectionResult { values: number[]; converged: boolean; }
+export function computeMycologyProjection(data: number[], opts: MycologyProjectionOptions = {}): MycologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyProjection };
diff --git a/src/mycology/ranking.ts b/src/mycology/ranking.ts
new file mode 100644
index 000000000..6073b4702
--- /dev/null
+++ b/src/mycology/ranking.ts
@@ -0,0 +1,14 @@
+/** mycology ranking module — tsb analytics library. */
+export interface MycologyRankingOptions { tol?: number; maxIter?: number; }
+export interface MycologyRankingResult { values: number[]; converged: boolean; }
+export function computeMycologyRanking(data: number[], opts: MycologyRankingOptions = {}): MycologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyRanking };
diff --git a/src/mycology/reconstruction.ts b/src/mycology/reconstruction.ts
new file mode 100644
index 000000000..4274391ad
--- /dev/null
+++ b/src/mycology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** mycology reconstruction module — tsb analytics library. */
+export interface MycologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface MycologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeMycologyReconstruction(data: number[], opts: MycologyReconstructionOptions = {}): MycologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyReconstruction };
diff --git a/src/mycology/registration.ts b/src/mycology/registration.ts
new file mode 100644
index 000000000..4b3ba6b4a
--- /dev/null
+++ b/src/mycology/registration.ts
@@ -0,0 +1,14 @@
+/** mycology registration module — tsb analytics library. */
+export interface MycologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface MycologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeMycologyRegistration(data: number[], opts: MycologyRegistrationOptions = {}): MycologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyRegistration };
diff --git a/src/mycology/regression.ts b/src/mycology/regression.ts
new file mode 100644
index 000000000..b1173d3e3
--- /dev/null
+++ b/src/mycology/regression.ts
@@ -0,0 +1,14 @@
+/** mycology regression module — tsb analytics library. */
+export interface MycologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface MycologyRegressionResult { values: number[]; converged: boolean; }
+export function computeMycologyRegression(data: number[], opts: MycologyRegressionOptions = {}): MycologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyRegression };
diff --git a/src/mycology/regularization.ts b/src/mycology/regularization.ts
new file mode 100644
index 000000000..bca3133cb
--- /dev/null
+++ b/src/mycology/regularization.ts
@@ -0,0 +1,14 @@
+/** mycology regularization module — tsb analytics library. */
+export interface MycologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface MycologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeMycologyRegularization(data: number[], opts: MycologyRegularizationOptions = {}): MycologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyRegularization };
diff --git a/src/mycology/robustness.ts b/src/mycology/robustness.ts
new file mode 100644
index 000000000..d0599d6fa
--- /dev/null
+++ b/src/mycology/robustness.ts
@@ -0,0 +1,14 @@
+/** mycology robustness module — tsb analytics library. */
+export interface MycologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface MycologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeMycologyRobustness(data: number[], opts: MycologyRobustnessOptions = {}): MycologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyRobustness };
diff --git a/src/mycology/sampling.ts b/src/mycology/sampling.ts
new file mode 100644
index 000000000..6c728cf0a
--- /dev/null
+++ b/src/mycology/sampling.ts
@@ -0,0 +1,14 @@
+/** mycology sampling module — tsb analytics library. */
+export interface MycologySamplingOptions { tol?: number; maxIter?: number; }
+export interface MycologySamplingResult { values: number[]; converged: boolean; }
+export function computeMycologySampling(data: number[], opts: MycologySamplingOptions = {}): MycologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologySampling };
diff --git a/src/mycology/sampling2.ts b/src/mycology/sampling2.ts
new file mode 100644
index 000000000..74719811b
--- /dev/null
+++ b/src/mycology/sampling2.ts
@@ -0,0 +1,14 @@
+/** mycology sampling2 module — tsb analytics library. */
+export interface MycologySamplingOptions { tol?: number; maxIter?: number; }
+export interface MycologySamplingResult { values: number[]; converged: boolean; }
+export function computeMycologySampling(data: number[], opts: MycologySamplingOptions = {}): MycologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologySampling };
diff --git a/src/mycology/scaling.ts b/src/mycology/scaling.ts
new file mode 100644
index 000000000..8ee519ad3
--- /dev/null
+++ b/src/mycology/scaling.ts
@@ -0,0 +1,14 @@
+/** mycology scaling module — tsb analytics library. */
+export interface MycologyScalingOptions { tol?: number; maxIter?: number; }
+export interface MycologyScalingResult { values: number[]; converged: boolean; }
+export function computeMycologyScaling(data: number[], opts: MycologyScalingOptions = {}): MycologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyScaling };
diff --git a/src/mycology/scoring.ts b/src/mycology/scoring.ts
new file mode 100644
index 000000000..7763d64c8
--- /dev/null
+++ b/src/mycology/scoring.ts
@@ -0,0 +1,14 @@
+/** mycology scoring module — tsb analytics library. */
+export interface MycologyScoringOptions { tol?: number; maxIter?: number; }
+export interface MycologyScoringResult { values: number[]; converged: boolean; }
+export function computeMycologyScoring(data: number[], opts: MycologyScoringOptions = {}): MycologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyScoring };
diff --git a/src/mycology/segmentation.ts b/src/mycology/segmentation.ts
new file mode 100644
index 000000000..7599571b6
--- /dev/null
+++ b/src/mycology/segmentation.ts
@@ -0,0 +1,14 @@
+/** mycology segmentation module — tsb analytics library. */
+export interface MycologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface MycologySegmentationResult { values: number[]; converged: boolean; }
+export function computeMycologySegmentation(data: number[], opts: MycologySegmentationOptions = {}): MycologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologySegmentation };
diff --git a/src/mycology/selection.ts b/src/mycology/selection.ts
new file mode 100644
index 000000000..12897506c
--- /dev/null
+++ b/src/mycology/selection.ts
@@ -0,0 +1,14 @@
+/** mycology selection module — tsb analytics library. */
+export interface MycologySelectionOptions { tol?: number; maxIter?: number; }
+export interface MycologySelectionResult { values: number[]; converged: boolean; }
+export function computeMycologySelection(data: number[], opts: MycologySelectionOptions = {}): MycologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologySelection };
diff --git a/src/mycology/sensitivity.ts b/src/mycology/sensitivity.ts
new file mode 100644
index 000000000..4fe8b9318
--- /dev/null
+++ b/src/mycology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** mycology sensitivity module — tsb analytics library. */
+export interface MycologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface MycologySensitivityResult { values: number[]; converged: boolean; }
+export function computeMycologySensitivity(data: number[], opts: MycologySensitivityOptions = {}): MycologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologySensitivity };
diff --git a/src/mycology/simulation.ts b/src/mycology/simulation.ts
new file mode 100644
index 000000000..6f66ca150
--- /dev/null
+++ b/src/mycology/simulation.ts
@@ -0,0 +1,14 @@
+/** mycology simulation module — tsb analytics library. */
+export interface MycologySimulationOptions { tol?: number; maxIter?: number; }
+export interface MycologySimulationResult { values: number[]; converged: boolean; }
+export function computeMycologySimulation(data: number[], opts: MycologySimulationOptions = {}): MycologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologySimulation };
diff --git a/src/mycology/smoothing.ts b/src/mycology/smoothing.ts
new file mode 100644
index 000000000..3af59f689
--- /dev/null
+++ b/src/mycology/smoothing.ts
@@ -0,0 +1,14 @@
+/** mycology smoothing module — tsb analytics library. */
+export interface MycologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface MycologySmoothingResult { values: number[]; converged: boolean; }
+export function computeMycologySmoothing(data: number[], opts: MycologySmoothingOptions = {}): MycologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologySmoothing };
diff --git a/src/mycology/stability.ts b/src/mycology/stability.ts
new file mode 100644
index 000000000..c7317eb3b
--- /dev/null
+++ b/src/mycology/stability.ts
@@ -0,0 +1,14 @@
+/** mycology stability module — tsb analytics library. */
+export interface MycologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface MycologyStabilityResult { values: number[]; converged: boolean; }
+export function computeMycologyStability(data: number[], opts: MycologyStabilityOptions = {}): MycologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyStability };
diff --git a/src/mycology/stacking.ts b/src/mycology/stacking.ts
new file mode 100644
index 000000000..c5af56e5d
--- /dev/null
+++ b/src/mycology/stacking.ts
@@ -0,0 +1,14 @@
+/** mycology stacking module — tsb analytics library. */
+export interface MycologyStackingOptions { tol?: number; maxIter?: number; }
+export interface MycologyStackingResult { values: number[]; converged: boolean; }
+export function computeMycologyStacking(data: number[], opts: MycologyStackingOptions = {}): MycologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyStacking };
diff --git a/src/mycology/standardization.ts b/src/mycology/standardization.ts
new file mode 100644
index 000000000..85fe87c1f
--- /dev/null
+++ b/src/mycology/standardization.ts
@@ -0,0 +1,14 @@
+/** mycology standardization module — tsb analytics library. */
+export interface MycologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface MycologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeMycologyStandardization(data: number[], opts: MycologyStandardizationOptions = {}): MycologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyStandardization };
diff --git a/src/mycology/static.ts b/src/mycology/static.ts
new file mode 100644
index 000000000..18a3a84bc
--- /dev/null
+++ b/src/mycology/static.ts
@@ -0,0 +1,14 @@
+/** mycology static module — tsb analytics library. */
+export interface MycologyStaticOptions { tol?: number; maxIter?: number; }
+export interface MycologyStaticResult { values: number[]; converged: boolean; }
+export function computeMycologyStatic(data: number[], opts: MycologyStaticOptions = {}): MycologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyStatic };
diff --git a/src/mycology/stochastic.ts b/src/mycology/stochastic.ts
new file mode 100644
index 000000000..cc85f7ffb
--- /dev/null
+++ b/src/mycology/stochastic.ts
@@ -0,0 +1,14 @@
+/** mycology stochastic module — tsb analytics library. */
+export interface MycologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface MycologyStochasticResult { values: number[]; converged: boolean; }
+export function computeMycologyStochastic(data: number[], opts: MycologyStochasticOptions = {}): MycologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyStochastic };
diff --git a/src/mycology/synthesis.ts b/src/mycology/synthesis.ts
new file mode 100644
index 000000000..bd2778059
--- /dev/null
+++ b/src/mycology/synthesis.ts
@@ -0,0 +1,14 @@
+/** mycology synthesis module — tsb analytics library. */
+export interface MycologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface MycologySynthesisResult { values: number[]; converged: boolean; }
+export function computeMycologySynthesis(data: number[], opts: MycologySynthesisOptions = {}): MycologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologySynthesis };
diff --git a/src/mycology/topology.ts b/src/mycology/topology.ts
new file mode 100644
index 000000000..c6e81ef65
--- /dev/null
+++ b/src/mycology/topology.ts
@@ -0,0 +1,14 @@
+/** mycology topology module — tsb analytics library. */
+export interface MycologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface MycologyTopologyResult { values: number[]; converged: boolean; }
+export function computeMycologyTopology(data: number[], opts: MycologyTopologyOptions = {}): MycologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyTopology };
diff --git a/src/mycology/tracking.ts b/src/mycology/tracking.ts
new file mode 100644
index 000000000..710c15d17
--- /dev/null
+++ b/src/mycology/tracking.ts
@@ -0,0 +1,14 @@
+/** mycology tracking module — tsb analytics library. */
+export interface MycologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface MycologyTrackingResult { values: number[]; converged: boolean; }
+export function computeMycologyTracking(data: number[], opts: MycologyTrackingOptions = {}): MycologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyTracking };
diff --git a/src/mycology/transform.ts b/src/mycology/transform.ts
new file mode 100644
index 000000000..c0db4bca9
--- /dev/null
+++ b/src/mycology/transform.ts
@@ -0,0 +1,14 @@
+/** mycology transform module — tsb analytics library. */
+export interface MycologyTransformOptions { tol?: number; maxIter?: number; }
+export interface MycologyTransformResult { values: number[]; converged: boolean; }
+export function computeMycologyTransform(data: number[], opts: MycologyTransformOptions = {}): MycologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyTransform };
diff --git a/src/mycology/uncertainty.ts b/src/mycology/uncertainty.ts
new file mode 100644
index 000000000..4bb8b44f6
--- /dev/null
+++ b/src/mycology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** mycology uncertainty module — tsb analytics library. */
+export interface MycologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface MycologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeMycologyUncertainty(data: number[], opts: MycologyUncertaintyOptions = {}): MycologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyUncertainty };
diff --git a/src/mycology/validation.ts b/src/mycology/validation.ts
new file mode 100644
index 000000000..cb7c5d5d0
--- /dev/null
+++ b/src/mycology/validation.ts
@@ -0,0 +1,14 @@
+/** mycology validation module — tsb analytics library. */
+export interface MycologyValidationOptions { tol?: number; maxIter?: number; }
+export interface MycologyValidationResult { values: number[]; converged: boolean; }
+export function computeMycologyValidation(data: number[], opts: MycologyValidationOptions = {}): MycologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyValidation };
diff --git a/src/mycology/verification.ts b/src/mycology/verification.ts
new file mode 100644
index 000000000..34de4e4e8
--- /dev/null
+++ b/src/mycology/verification.ts
@@ -0,0 +1,14 @@
+/** mycology verification module — tsb analytics library. */
+export interface MycologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface MycologyVerificationResult { values: number[]; converged: boolean; }
+export function computeMycologyVerification(data: number[], opts: MycologyVerificationOptions = {}): MycologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyVerification };
diff --git a/src/mycology/visualization.ts b/src/mycology/visualization.ts
new file mode 100644
index 000000000..8664b1dc8
--- /dev/null
+++ b/src/mycology/visualization.ts
@@ -0,0 +1,14 @@
+/** mycology visualization module — tsb analytics library. */
+export interface MycologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface MycologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeMycologyVisualization(data: number[], opts: MycologyVisualizationOptions = {}): MycologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyVisualization };
diff --git a/src/mycology/voting.ts b/src/mycology/voting.ts
new file mode 100644
index 000000000..33be55427
--- /dev/null
+++ b/src/mycology/voting.ts
@@ -0,0 +1,14 @@
+/** mycology voting module — tsb analytics library. */
+export interface MycologyVotingOptions { tol?: number; maxIter?: number; }
+export interface MycologyVotingResult { values: number[]; converged: boolean; }
+export function computeMycologyVoting(data: number[], opts: MycologyVotingOptions = {}): MycologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyVoting };
diff --git a/src/mycology/wavelet.ts b/src/mycology/wavelet.ts
new file mode 100644
index 000000000..3763172f4
--- /dev/null
+++ b/src/mycology/wavelet.ts
@@ -0,0 +1,14 @@
+/** mycology wavelet module — tsb analytics library. */
+export interface MycologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface MycologyWaveletResult { values: number[]; converged: boolean; }
+export function computeMycologyWavelet(data: number[], opts: MycologyWaveletOptions = {}): MycologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeMycologyWavelet };
diff --git a/src/nephrology_sci/adaptation.ts b/src/nephrology_sci/adaptation.ts
new file mode 100644
index 000000000..07fc844d3
--- /dev/null
+++ b/src/nephrology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci adaptation module — tsb analytics library. */
+export interface NephrologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciAdaptation(data: number[], opts: NephrologySciAdaptationOptions = {}): NephrologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciAdaptation };
diff --git a/src/nephrology_sci/aggregation.ts b/src/nephrology_sci/aggregation.ts
new file mode 100644
index 000000000..9f056ad0a
--- /dev/null
+++ b/src/nephrology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci aggregation module — tsb analytics library. */
+export interface NephrologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciAggregation(data: number[], opts: NephrologySciAggregationOptions = {}): NephrologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciAggregation };
diff --git a/src/nephrology_sci/algebra.ts b/src/nephrology_sci/algebra.ts
new file mode 100644
index 000000000..6f419b338
--- /dev/null
+++ b/src/nephrology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci algebra module — tsb analytics library. */
+export interface NephrologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeNephrologySciAlgebra(data: number[], opts: NephrologySciAlgebraOptions = {}): NephrologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciAlgebra };
diff --git a/src/nephrology_sci/alignment.ts b/src/nephrology_sci/alignment.ts
new file mode 100644
index 000000000..cb9297d5b
--- /dev/null
+++ b/src/nephrology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci alignment module — tsb analytics library. */
+export interface NephrologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeNephrologySciAlignment(data: number[], opts: NephrologySciAlignmentOptions = {}): NephrologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciAlignment };
diff --git a/src/nephrology_sci/analysis.ts b/src/nephrology_sci/analysis.ts
new file mode 100644
index 000000000..d314ddc37
--- /dev/null
+++ b/src/nephrology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci analysis module — tsb analytics library. */
+export interface NephrologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeNephrologySciAnalysis(data: number[], opts: NephrologySciAnalysisOptions = {}): NephrologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciAnalysis };
diff --git a/src/nephrology_sci/augmentation.ts b/src/nephrology_sci/augmentation.ts
new file mode 100644
index 000000000..c939d8a02
--- /dev/null
+++ b/src/nephrology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci augmentation module — tsb analytics library. */
+export interface NephrologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciAugmentation(data: number[], opts: NephrologySciAugmentationOptions = {}): NephrologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciAugmentation };
diff --git a/src/nephrology_sci/bagging.ts b/src/nephrology_sci/bagging.ts
new file mode 100644
index 000000000..3e774527c
--- /dev/null
+++ b/src/nephrology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci bagging module — tsb analytics library. */
+export interface NephrologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciBagging(data: number[], opts: NephrologySciBaggingOptions = {}): NephrologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciBagging };
diff --git a/src/nephrology_sci/basis.ts b/src/nephrology_sci/basis.ts
new file mode 100644
index 000000000..74b301444
--- /dev/null
+++ b/src/nephrology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci basis module — tsb analytics library. */
+export interface NephrologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciBasisResult { values: number[]; converged: boolean; }
+export function computeNephrologySciBasis(data: number[], opts: NephrologySciBasisOptions = {}): NephrologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciBasis };
diff --git a/src/nephrology_sci/benchmarking.ts b/src/nephrology_sci/benchmarking.ts
new file mode 100644
index 000000000..bc04c54f4
--- /dev/null
+++ b/src/nephrology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci benchmarking module — tsb analytics library. */
+export interface NephrologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciBenchmarking(data: number[], opts: NephrologySciBenchmarkingOptions = {}): NephrologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciBenchmarking };
diff --git a/src/nephrology_sci/blending.ts b/src/nephrology_sci/blending.ts
new file mode 100644
index 000000000..346a41e90
--- /dev/null
+++ b/src/nephrology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci blending module — tsb analytics library. */
+export interface NephrologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciBlending(data: number[], opts: NephrologySciBlendingOptions = {}): NephrologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciBlending };
diff --git a/src/nephrology_sci/boosting.ts b/src/nephrology_sci/boosting.ts
new file mode 100644
index 000000000..2e8dbd4e2
--- /dev/null
+++ b/src/nephrology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci boosting module — tsb analytics library. */
+export interface NephrologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciBoosting(data: number[], opts: NephrologySciBoostingOptions = {}): NephrologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciBoosting };
diff --git a/src/nephrology_sci/bootstrap.ts b/src/nephrology_sci/bootstrap.ts
new file mode 100644
index 000000000..44fa20381
--- /dev/null
+++ b/src/nephrology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci bootstrap module — tsb analytics library. */
+export interface NephrologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeNephrologySciBootstrap(data: number[], opts: NephrologySciBootstrapOptions = {}): NephrologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciBootstrap };
diff --git a/src/nephrology_sci/calculus.ts b/src/nephrology_sci/calculus.ts
new file mode 100644
index 000000000..73cde75ac
--- /dev/null
+++ b/src/nephrology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci calculus module — tsb analytics library. */
+export interface NephrologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeNephrologySciCalculus(data: number[], opts: NephrologySciCalculusOptions = {}): NephrologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciCalculus };
diff --git a/src/nephrology_sci/calibration.ts b/src/nephrology_sci/calibration.ts
new file mode 100644
index 000000000..d4f0af519
--- /dev/null
+++ b/src/nephrology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci calibration module — tsb analytics library. */
+export interface NephrologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciCalibration(data: number[], opts: NephrologySciCalibrationOptions = {}): NephrologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciCalibration };
diff --git a/src/nephrology_sci/characterization.ts b/src/nephrology_sci/characterization.ts
new file mode 100644
index 000000000..cd329bf78
--- /dev/null
+++ b/src/nephrology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci characterization module — tsb analytics library. */
+export interface NephrologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciCharacterization(data: number[], opts: NephrologySciCharacterizationOptions = {}): NephrologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciCharacterization };
diff --git a/src/nephrology_sci/classification.ts b/src/nephrology_sci/classification.ts
new file mode 100644
index 000000000..c1b3d0fba
--- /dev/null
+++ b/src/nephrology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci classification module — tsb analytics library. */
+export interface NephrologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciClassification(data: number[], opts: NephrologySciClassificationOptions = {}): NephrologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciClassification };
diff --git a/src/nephrology_sci/clustering.ts b/src/nephrology_sci/clustering.ts
new file mode 100644
index 000000000..d65b5dba0
--- /dev/null
+++ b/src/nephrology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci clustering module — tsb analytics library. */
+export interface NephrologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeNephrologySciClustering(data: number[], opts: NephrologySciClusteringOptions = {}): NephrologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciClustering };
diff --git a/src/nephrology_sci/compression.ts b/src/nephrology_sci/compression.ts
new file mode 100644
index 000000000..7863ad7ef
--- /dev/null
+++ b/src/nephrology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci compression module — tsb analytics library. */
+export interface NephrologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciCompression(data: number[], opts: NephrologySciCompressionOptions = {}): NephrologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciCompression };
diff --git a/src/nephrology_sci/continuous.ts b/src/nephrology_sci/continuous.ts
new file mode 100644
index 000000000..95d0e4ef2
--- /dev/null
+++ b/src/nephrology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci continuous module — tsb analytics library. */
+export interface NephrologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeNephrologySciContinuous(data: number[], opts: NephrologySciContinuousOptions = {}): NephrologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciContinuous };
diff --git a/src/nephrology_sci/control.ts b/src/nephrology_sci/control.ts
new file mode 100644
index 000000000..f9c2a7de2
--- /dev/null
+++ b/src/nephrology_sci/control.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci control module — tsb analytics library. */
+export interface NephrologySciControlOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciControlResult { values: number[]; converged: boolean; }
+export function computeNephrologySciControl(data: number[], opts: NephrologySciControlOptions = {}): NephrologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciControl };
diff --git a/src/nephrology_sci/convergence.ts b/src/nephrology_sci/convergence.ts
new file mode 100644
index 000000000..61ce6bdf7
--- /dev/null
+++ b/src/nephrology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci convergence module — tsb analytics library. */
+export interface NephrologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeNephrologySciConvergence(data: number[], opts: NephrologySciConvergenceOptions = {}): NephrologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciConvergence };
diff --git a/src/nephrology_sci/convex.ts b/src/nephrology_sci/convex.ts
new file mode 100644
index 000000000..b2298c526
--- /dev/null
+++ b/src/nephrology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci convex module — tsb analytics library. */
+export interface NephrologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciConvexResult { values: number[]; converged: boolean; }
+export function computeNephrologySciConvex(data: number[], opts: NephrologySciConvexOptions = {}): NephrologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciConvex };
diff --git a/src/nephrology_sci/correlation.ts b/src/nephrology_sci/correlation.ts
new file mode 100644
index 000000000..737f6158b
--- /dev/null
+++ b/src/nephrology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci correlation module — tsb analytics library. */
+export interface NephrologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciCorrelation(data: number[], opts: NephrologySciCorrelationOptions = {}): NephrologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciCorrelation };
diff --git a/src/nephrology_sci/covariance.ts b/src/nephrology_sci/covariance.ts
new file mode 100644
index 000000000..8bbdc2f5f
--- /dev/null
+++ b/src/nephrology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci covariance module — tsb analytics library. */
+export interface NephrologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeNephrologySciCovariance(data: number[], opts: NephrologySciCovarianceOptions = {}): NephrologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciCovariance };
diff --git a/src/nephrology_sci/cross_validation.ts b/src/nephrology_sci/cross_validation.ts
new file mode 100644
index 000000000..ea2bb5d6a
--- /dev/null
+++ b/src/nephrology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci cross_validation module — tsb analytics library. */
+export interface NephrologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciCrossValidation(data: number[], opts: NephrologySciCrossValidationOptions = {}): NephrologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciCrossValidation };
diff --git a/src/nephrology_sci/decoding.ts b/src/nephrology_sci/decoding.ts
new file mode 100644
index 000000000..ab3cd99ad
--- /dev/null
+++ b/src/nephrology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci decoding module — tsb analytics library. */
+export interface NephrologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDecoding(data: number[], opts: NephrologySciDecodingOptions = {}): NephrologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDecoding };
diff --git a/src/nephrology_sci/decomposition.ts b/src/nephrology_sci/decomposition.ts
new file mode 100644
index 000000000..ff4290155
--- /dev/null
+++ b/src/nephrology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci decomposition module — tsb analytics library. */
+export interface NephrologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDecomposition(data: number[], opts: NephrologySciDecompositionOptions = {}): NephrologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDecomposition };
diff --git a/src/nephrology_sci/detection.ts b/src/nephrology_sci/detection.ts
new file mode 100644
index 000000000..7ffa2db32
--- /dev/null
+++ b/src/nephrology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci detection module — tsb analytics library. */
+export interface NephrologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDetection(data: number[], opts: NephrologySciDetectionOptions = {}): NephrologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDetection };
diff --git a/src/nephrology_sci/deterministic.ts b/src/nephrology_sci/deterministic.ts
new file mode 100644
index 000000000..2c42f3b55
--- /dev/null
+++ b/src/nephrology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci deterministic module — tsb analytics library. */
+export interface NephrologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDeterministic(data: number[], opts: NephrologySciDeterministicOptions = {}): NephrologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDeterministic };
diff --git a/src/nephrology_sci/diagnostics.ts b/src/nephrology_sci/diagnostics.ts
new file mode 100644
index 000000000..9f7ecbcdd
--- /dev/null
+++ b/src/nephrology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci diagnostics module — tsb analytics library. */
+export interface NephrologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDiagnostics(data: number[], opts: NephrologySciDiagnosticsOptions = {}): NephrologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDiagnostics };
diff --git a/src/nephrology_sci/differential.ts b/src/nephrology_sci/differential.ts
new file mode 100644
index 000000000..8c221b405
--- /dev/null
+++ b/src/nephrology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci differential module — tsb analytics library. */
+export interface NephrologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDifferential(data: number[], opts: NephrologySciDifferentialOptions = {}): NephrologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDifferential };
diff --git a/src/nephrology_sci/discrete.ts b/src/nephrology_sci/discrete.ts
new file mode 100644
index 000000000..d6fc912ae
--- /dev/null
+++ b/src/nephrology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci discrete module — tsb analytics library. */
+export interface NephrologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDiscrete(data: number[], opts: NephrologySciDiscreteOptions = {}): NephrologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDiscrete };
diff --git a/src/nephrology_sci/distribution.ts b/src/nephrology_sci/distribution.ts
new file mode 100644
index 000000000..245d30a97
--- /dev/null
+++ b/src/nephrology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci distribution module — tsb analytics library. */
+export interface NephrologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDistribution(data: number[], opts: NephrologySciDistributionOptions = {}): NephrologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDistribution };
diff --git a/src/nephrology_sci/dynamic.ts b/src/nephrology_sci/dynamic.ts
new file mode 100644
index 000000000..eb131c228
--- /dev/null
+++ b/src/nephrology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci dynamic module — tsb analytics library. */
+export interface NephrologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeNephrologySciDynamic(data: number[], opts: NephrologySciDynamicOptions = {}): NephrologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciDynamic };
diff --git a/src/nephrology_sci/embedding.ts b/src/nephrology_sci/embedding.ts
new file mode 100644
index 000000000..d5ba062c7
--- /dev/null
+++ b/src/nephrology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci embedding module — tsb analytics library. */
+export interface NephrologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciEmbedding(data: number[], opts: NephrologySciEmbeddingOptions = {}): NephrologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciEmbedding };
diff --git a/src/nephrology_sci/encoding.ts b/src/nephrology_sci/encoding.ts
new file mode 100644
index 000000000..efd286304
--- /dev/null
+++ b/src/nephrology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci encoding module — tsb analytics library. */
+export interface NephrologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciEncoding(data: number[], opts: NephrologySciEncodingOptions = {}): NephrologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciEncoding };
diff --git a/src/nephrology_sci/ensemble.ts b/src/nephrology_sci/ensemble.ts
new file mode 100644
index 000000000..30f358514
--- /dev/null
+++ b/src/nephrology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci ensemble module — tsb analytics library. */
+export interface NephrologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeNephrologySciEnsemble(data: number[], opts: NephrologySciEnsembleOptions = {}): NephrologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciEnsemble };
diff --git a/src/nephrology_sci/estimation.ts b/src/nephrology_sci/estimation.ts
new file mode 100644
index 000000000..003d4633e
--- /dev/null
+++ b/src/nephrology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci estimation module — tsb analytics library. */
+export interface NephrologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciEstimation(data: number[], opts: NephrologySciEstimationOptions = {}): NephrologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciEstimation };
diff --git a/src/nephrology_sci/evaluation.ts b/src/nephrology_sci/evaluation.ts
new file mode 100644
index 000000000..065f0ec05
--- /dev/null
+++ b/src/nephrology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci evaluation module — tsb analytics library. */
+export interface NephrologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciEvaluation(data: number[], opts: NephrologySciEvaluationOptions = {}): NephrologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciEvaluation };
diff --git a/src/nephrology_sci/extrapolation.ts b/src/nephrology_sci/extrapolation.ts
new file mode 100644
index 000000000..9298df8b3
--- /dev/null
+++ b/src/nephrology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci extrapolation module — tsb analytics library. */
+export interface NephrologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciExtrapolation(data: number[], opts: NephrologySciExtrapolationOptions = {}): NephrologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciExtrapolation };
diff --git a/src/nephrology_sci/features.ts b/src/nephrology_sci/features.ts
new file mode 100644
index 000000000..f80b59b8d
--- /dev/null
+++ b/src/nephrology_sci/features.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci features module — tsb analytics library. */
+export interface NephrologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeNephrologySciFeatures(data: number[], opts: NephrologySciFeaturesOptions = {}): NephrologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciFeatures };
diff --git a/src/nephrology_sci/feedback.ts b/src/nephrology_sci/feedback.ts
new file mode 100644
index 000000000..d3b189659
--- /dev/null
+++ b/src/nephrology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci feedback module — tsb analytics library. */
+export interface NephrologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeNephrologySciFeedback(data: number[], opts: NephrologySciFeedbackOptions = {}): NephrologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciFeedback };
diff --git a/src/nephrology_sci/filtering.ts b/src/nephrology_sci/filtering.ts
new file mode 100644
index 000000000..504c60718
--- /dev/null
+++ b/src/nephrology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci filtering module — tsb analytics library. */
+export interface NephrologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeNephrologySciFiltering(data: number[], opts: NephrologySciFilteringOptions = {}): NephrologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciFiltering };
diff --git a/src/nephrology_sci/fourier.ts b/src/nephrology_sci/fourier.ts
new file mode 100644
index 000000000..bbf87fcc9
--- /dev/null
+++ b/src/nephrology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci fourier module — tsb analytics library. */
+export interface NephrologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciFourierResult { values: number[]; converged: boolean; }
+export function computeNephrologySciFourier(data: number[], opts: NephrologySciFourierOptions = {}): NephrologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciFourier };
diff --git a/src/nephrology_sci/fusion.ts b/src/nephrology_sci/fusion.ts
new file mode 100644
index 000000000..5592bab7e
--- /dev/null
+++ b/src/nephrology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci fusion module — tsb analytics library. */
+export interface NephrologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciFusionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciFusion(data: number[], opts: NephrologySciFusionOptions = {}): NephrologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciFusion };
diff --git a/src/nephrology_sci/generation.ts b/src/nephrology_sci/generation.ts
new file mode 100644
index 000000000..373475675
--- /dev/null
+++ b/src/nephrology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci generation module — tsb analytics library. */
+export interface NephrologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciGeneration(data: number[], opts: NephrologySciGenerationOptions = {}): NephrologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciGeneration };
diff --git a/src/nephrology_sci/geometry.ts b/src/nephrology_sci/geometry.ts
new file mode 100644
index 000000000..8f969a0e8
--- /dev/null
+++ b/src/nephrology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci geometry module — tsb analytics library. */
+export interface NephrologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeNephrologySciGeometry(data: number[], opts: NephrologySciGeometryOptions = {}): NephrologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciGeometry };
diff --git a/src/nephrology_sci/gradient.ts b/src/nephrology_sci/gradient.ts
new file mode 100644
index 000000000..86e20ff7b
--- /dev/null
+++ b/src/nephrology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci gradient module — tsb analytics library. */
+export interface NephrologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciGradientResult { values: number[]; converged: boolean; }
+export function computeNephrologySciGradient(data: number[], opts: NephrologySciGradientOptions = {}): NephrologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciGradient };
diff --git a/src/nephrology_sci/hessian.ts b/src/nephrology_sci/hessian.ts
new file mode 100644
index 000000000..1793f9a69
--- /dev/null
+++ b/src/nephrology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci hessian module — tsb analytics library. */
+export interface NephrologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciHessianResult { values: number[]; converged: boolean; }
+export function computeNephrologySciHessian(data: number[], opts: NephrologySciHessianOptions = {}): NephrologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciHessian };
diff --git a/src/nephrology_sci/hypothesis.ts b/src/nephrology_sci/hypothesis.ts
new file mode 100644
index 000000000..bd720f1e2
--- /dev/null
+++ b/src/nephrology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci hypothesis module — tsb analytics library. */
+export interface NephrologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeNephrologySciHypothesis(data: number[], opts: NephrologySciHypothesisOptions = {}): NephrologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciHypothesis };
diff --git a/src/nephrology_sci/inference.ts b/src/nephrology_sci/inference.ts
new file mode 100644
index 000000000..aec7e3393
--- /dev/null
+++ b/src/nephrology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci inference module — tsb analytics library. */
+export interface NephrologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeNephrologySciInference(data: number[], opts: NephrologySciInferenceOptions = {}): NephrologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciInference };
diff --git a/src/nephrology_sci/inference2.ts b/src/nephrology_sci/inference2.ts
new file mode 100644
index 000000000..8970cbabb
--- /dev/null
+++ b/src/nephrology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci inference2 module — tsb analytics library. */
+export interface NephrologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeNephrologySciInference(data: number[], opts: NephrologySciInferenceOptions = {}): NephrologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciInference };
diff --git a/src/nephrology_sci/integral.ts b/src/nephrology_sci/integral.ts
new file mode 100644
index 000000000..b1875fb7d
--- /dev/null
+++ b/src/nephrology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci integral module — tsb analytics library. */
+export interface NephrologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeNephrologySciIntegral(data: number[], opts: NephrologySciIntegralOptions = {}): NephrologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciIntegral };
diff --git a/src/nephrology_sci/integration.ts b/src/nephrology_sci/integration.ts
new file mode 100644
index 000000000..10b52e8c6
--- /dev/null
+++ b/src/nephrology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci integration module — tsb analytics library. */
+export interface NephrologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciIntegration(data: number[], opts: NephrologySciIntegrationOptions = {}): NephrologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciIntegration };
diff --git a/src/nephrology_sci/interpolation.ts b/src/nephrology_sci/interpolation.ts
new file mode 100644
index 000000000..53e81c902
--- /dev/null
+++ b/src/nephrology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci interpolation module — tsb analytics library. */
+export interface NephrologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciInterpolation(data: number[], opts: NephrologySciInterpolationOptions = {}): NephrologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciInterpolation };
diff --git a/src/nephrology_sci/jacobian.ts b/src/nephrology_sci/jacobian.ts
new file mode 100644
index 000000000..b1c8abcd6
--- /dev/null
+++ b/src/nephrology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci jacobian module — tsb analytics library. */
+export interface NephrologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeNephrologySciJacobian(data: number[], opts: NephrologySciJacobianOptions = {}): NephrologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciJacobian };
diff --git a/src/nephrology_sci/kernel.ts b/src/nephrology_sci/kernel.ts
new file mode 100644
index 000000000..0d36a0bfa
--- /dev/null
+++ b/src/nephrology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci kernel module — tsb analytics library. */
+export interface NephrologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciKernelResult { values: number[]; converged: boolean; }
+export function computeNephrologySciKernel(data: number[], opts: NephrologySciKernelOptions = {}): NephrologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciKernel };
diff --git a/src/nephrology_sci/laplacian.ts b/src/nephrology_sci/laplacian.ts
new file mode 100644
index 000000000..e53e7284f
--- /dev/null
+++ b/src/nephrology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci laplacian module — tsb analytics library. */
+export interface NephrologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeNephrologySciLaplacian(data: number[], opts: NephrologySciLaplacianOptions = {}): NephrologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciLaplacian };
diff --git a/src/nephrology_sci/learning.ts b/src/nephrology_sci/learning.ts
new file mode 100644
index 000000000..0d2879a88
--- /dev/null
+++ b/src/nephrology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci learning module — tsb analytics library. */
+export interface NephrologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciLearningResult { values: number[]; converged: boolean; }
+export function computeNephrologySciLearning(data: number[], opts: NephrologySciLearningOptions = {}): NephrologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciLearning };
diff --git a/src/nephrology_sci/linear.ts b/src/nephrology_sci/linear.ts
new file mode 100644
index 000000000..39be1adae
--- /dev/null
+++ b/src/nephrology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci linear module — tsb analytics library. */
+export interface NephrologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciLinearResult { values: number[]; converged: boolean; }
+export function computeNephrologySciLinear(data: number[], opts: NephrologySciLinearOptions = {}): NephrologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciLinear };
diff --git a/src/nephrology_sci/manifold.ts b/src/nephrology_sci/manifold.ts
new file mode 100644
index 000000000..fcce7399d
--- /dev/null
+++ b/src/nephrology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci manifold module — tsb analytics library. */
+export interface NephrologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeNephrologySciManifold(data: number[], opts: NephrologySciManifoldOptions = {}): NephrologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciManifold };
diff --git a/src/nephrology_sci/matching.ts b/src/nephrology_sci/matching.ts
new file mode 100644
index 000000000..596e487e2
--- /dev/null
+++ b/src/nephrology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci matching module — tsb analytics library. */
+export interface NephrologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciMatching(data: number[], opts: NephrologySciMatchingOptions = {}): NephrologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciMatching };
diff --git a/src/nephrology_sci/measurement.ts b/src/nephrology_sci/measurement.ts
new file mode 100644
index 000000000..836b07e8b
--- /dev/null
+++ b/src/nephrology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci measurement module — tsb analytics library. */
+export interface NephrologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeNephrologySciMeasurement(data: number[], opts: NephrologySciMeasurementOptions = {}): NephrologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciMeasurement };
diff --git a/src/nephrology_sci/metrics.ts b/src/nephrology_sci/metrics.ts
new file mode 100644
index 000000000..090b12699
--- /dev/null
+++ b/src/nephrology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci metrics module — tsb analytics library. */
+export interface NephrologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeNephrologySciMetrics(data: number[], opts: NephrologySciMetricsOptions = {}): NephrologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciMetrics };
diff --git a/src/nephrology_sci/modeling.ts b/src/nephrology_sci/modeling.ts
new file mode 100644
index 000000000..3533bd387
--- /dev/null
+++ b/src/nephrology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci modeling module — tsb analytics library. */
+export interface NephrologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciModelingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciModeling(data: number[], opts: NephrologySciModelingOptions = {}): NephrologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciModeling };
diff --git a/src/nephrology_sci/monitoring.ts b/src/nephrology_sci/monitoring.ts
new file mode 100644
index 000000000..3e83c80c8
--- /dev/null
+++ b/src/nephrology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci monitoring module — tsb analytics library. */
+export interface NephrologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeNephrologySciMonitoring(data: number[], opts: NephrologySciMonitoringOptions = {}): NephrologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciMonitoring };
diff --git a/src/nephrology_sci/nonlinear.ts b/src/nephrology_sci/nonlinear.ts
new file mode 100644
index 000000000..9da8c5cd7
--- /dev/null
+++ b/src/nephrology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci nonlinear module — tsb analytics library. */
+export interface NephrologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeNephrologySciNonlinear(data: number[], opts: NephrologySciNonlinearOptions = {}): NephrologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciNonlinear };
diff --git a/src/nephrology_sci/normalization.ts b/src/nephrology_sci/normalization.ts
new file mode 100644
index 000000000..019cf6e29
--- /dev/null
+++ b/src/nephrology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci normalization module — tsb analytics library. */
+export interface NephrologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciNormalization(data: number[], opts: NephrologySciNormalizationOptions = {}): NephrologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciNormalization };
diff --git a/src/nephrology_sci/optimization.ts b/src/nephrology_sci/optimization.ts
new file mode 100644
index 000000000..d56129f22
--- /dev/null
+++ b/src/nephrology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci optimization module — tsb analytics library. */
+export interface NephrologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciOptimization(data: number[], opts: NephrologySciOptimizationOptions = {}): NephrologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciOptimization };
diff --git a/src/nephrology_sci/patterns.ts b/src/nephrology_sci/patterns.ts
new file mode 100644
index 000000000..a99bdafeb
--- /dev/null
+++ b/src/nephrology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci patterns module — tsb analytics library. */
+export interface NephrologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeNephrologySciPatterns(data: number[], opts: NephrologySciPatternsOptions = {}): NephrologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciPatterns };
diff --git a/src/nephrology_sci/permutation.ts b/src/nephrology_sci/permutation.ts
new file mode 100644
index 000000000..4955ab00d
--- /dev/null
+++ b/src/nephrology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci permutation module — tsb analytics library. */
+export interface NephrologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciPermutation(data: number[], opts: NephrologySciPermutationOptions = {}): NephrologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciPermutation };
diff --git a/src/nephrology_sci/prediction.ts b/src/nephrology_sci/prediction.ts
new file mode 100644
index 000000000..6fc94cd22
--- /dev/null
+++ b/src/nephrology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci prediction module — tsb analytics library. */
+export interface NephrologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciPrediction(data: number[], opts: NephrologySciPredictionOptions = {}): NephrologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciPrediction };
diff --git a/src/nephrology_sci/processing.ts b/src/nephrology_sci/processing.ts
new file mode 100644
index 000000000..75a430169
--- /dev/null
+++ b/src/nephrology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci processing module — tsb analytics library. */
+export interface NephrologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciProcessing(data: number[], opts: NephrologySciProcessingOptions = {}): NephrologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciProcessing };
diff --git a/src/nephrology_sci/profiling.ts b/src/nephrology_sci/profiling.ts
new file mode 100644
index 000000000..4d7a44e11
--- /dev/null
+++ b/src/nephrology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci profiling module — tsb analytics library. */
+export interface NephrologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciProfiling(data: number[], opts: NephrologySciProfilingOptions = {}): NephrologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciProfiling };
diff --git a/src/nephrology_sci/projection.ts b/src/nephrology_sci/projection.ts
new file mode 100644
index 000000000..911c2d49b
--- /dev/null
+++ b/src/nephrology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci projection module — tsb analytics library. */
+export interface NephrologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciProjection(data: number[], opts: NephrologySciProjectionOptions = {}): NephrologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciProjection };
diff --git a/src/nephrology_sci/ranking.ts b/src/nephrology_sci/ranking.ts
new file mode 100644
index 000000000..544ce4885
--- /dev/null
+++ b/src/nephrology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci ranking module — tsb analytics library. */
+export interface NephrologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciRankingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciRanking(data: number[], opts: NephrologySciRankingOptions = {}): NephrologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciRanking };
diff --git a/src/nephrology_sci/reconstruction.ts b/src/nephrology_sci/reconstruction.ts
new file mode 100644
index 000000000..71ed6e726
--- /dev/null
+++ b/src/nephrology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci reconstruction module — tsb analytics library. */
+export interface NephrologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciReconstruction(data: number[], opts: NephrologySciReconstructionOptions = {}): NephrologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciReconstruction };
diff --git a/src/nephrology_sci/registration.ts b/src/nephrology_sci/registration.ts
new file mode 100644
index 000000000..387cecc71
--- /dev/null
+++ b/src/nephrology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci registration module — tsb analytics library. */
+export interface NephrologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciRegistration(data: number[], opts: NephrologySciRegistrationOptions = {}): NephrologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciRegistration };
diff --git a/src/nephrology_sci/regression.ts b/src/nephrology_sci/regression.ts
new file mode 100644
index 000000000..5a9ef3b1a
--- /dev/null
+++ b/src/nephrology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci regression module — tsb analytics library. */
+export interface NephrologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciRegression(data: number[], opts: NephrologySciRegressionOptions = {}): NephrologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciRegression };
diff --git a/src/nephrology_sci/regularization.ts b/src/nephrology_sci/regularization.ts
new file mode 100644
index 000000000..61828b0bd
--- /dev/null
+++ b/src/nephrology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci regularization module — tsb analytics library. */
+export interface NephrologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciRegularization(data: number[], opts: NephrologySciRegularizationOptions = {}): NephrologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciRegularization };
diff --git a/src/nephrology_sci/robustness.ts b/src/nephrology_sci/robustness.ts
new file mode 100644
index 000000000..76d12dc7b
--- /dev/null
+++ b/src/nephrology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci robustness module — tsb analytics library. */
+export interface NephrologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeNephrologySciRobustness(data: number[], opts: NephrologySciRobustnessOptions = {}): NephrologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciRobustness };
diff --git a/src/nephrology_sci/sampling.ts b/src/nephrology_sci/sampling.ts
new file mode 100644
index 000000000..005bcff89
--- /dev/null
+++ b/src/nephrology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci sampling module — tsb analytics library. */
+export interface NephrologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciSampling(data: number[], opts: NephrologySciSamplingOptions = {}): NephrologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciSampling };
diff --git a/src/nephrology_sci/sampling2.ts b/src/nephrology_sci/sampling2.ts
new file mode 100644
index 000000000..341f4b940
--- /dev/null
+++ b/src/nephrology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci sampling2 module — tsb analytics library. */
+export interface NephrologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciSampling(data: number[], opts: NephrologySciSamplingOptions = {}): NephrologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciSampling };
diff --git a/src/nephrology_sci/scaling.ts b/src/nephrology_sci/scaling.ts
new file mode 100644
index 000000000..47bd6e74c
--- /dev/null
+++ b/src/nephrology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci scaling module — tsb analytics library. */
+export interface NephrologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciScalingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciScaling(data: number[], opts: NephrologySciScalingOptions = {}): NephrologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciScaling };
diff --git a/src/nephrology_sci/scoring.ts b/src/nephrology_sci/scoring.ts
new file mode 100644
index 000000000..6583bace4
--- /dev/null
+++ b/src/nephrology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci scoring module — tsb analytics library. */
+export interface NephrologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciScoringResult { values: number[]; converged: boolean; }
+export function computeNephrologySciScoring(data: number[], opts: NephrologySciScoringOptions = {}): NephrologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciScoring };
diff --git a/src/nephrology_sci/segmentation.ts b/src/nephrology_sci/segmentation.ts
new file mode 100644
index 000000000..d1313e664
--- /dev/null
+++ b/src/nephrology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci segmentation module — tsb analytics library. */
+export interface NephrologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciSegmentation(data: number[], opts: NephrologySciSegmentationOptions = {}): NephrologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciSegmentation };
diff --git a/src/nephrology_sci/selection.ts b/src/nephrology_sci/selection.ts
new file mode 100644
index 000000000..a6999dd8a
--- /dev/null
+++ b/src/nephrology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci selection module — tsb analytics library. */
+export interface NephrologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeNephrologySciSelection(data: number[], opts: NephrologySciSelectionOptions = {}): NephrologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciSelection };
diff --git a/src/nephrology_sci/sensitivity.ts b/src/nephrology_sci/sensitivity.ts
new file mode 100644
index 000000000..e1091cb48
--- /dev/null
+++ b/src/nephrology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci sensitivity module — tsb analytics library. */
+export interface NephrologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeNephrologySciSensitivity(data: number[], opts: NephrologySciSensitivityOptions = {}): NephrologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciSensitivity };
diff --git a/src/nephrology_sci/simulation.ts b/src/nephrology_sci/simulation.ts
new file mode 100644
index 000000000..523779976
--- /dev/null
+++ b/src/nephrology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci simulation module — tsb analytics library. */
+export interface NephrologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciSimulation(data: number[], opts: NephrologySciSimulationOptions = {}): NephrologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciSimulation };
diff --git a/src/nephrology_sci/smoothing.ts b/src/nephrology_sci/smoothing.ts
new file mode 100644
index 000000000..73b3a6172
--- /dev/null
+++ b/src/nephrology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci smoothing module — tsb analytics library. */
+export interface NephrologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciSmoothing(data: number[], opts: NephrologySciSmoothingOptions = {}): NephrologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciSmoothing };
diff --git a/src/nephrology_sci/stability.ts b/src/nephrology_sci/stability.ts
new file mode 100644
index 000000000..8b280ba60
--- /dev/null
+++ b/src/nephrology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci stability module — tsb analytics library. */
+export interface NephrologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeNephrologySciStability(data: number[], opts: NephrologySciStabilityOptions = {}): NephrologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciStability };
diff --git a/src/nephrology_sci/stacking.ts b/src/nephrology_sci/stacking.ts
new file mode 100644
index 000000000..96c5c80c0
--- /dev/null
+++ b/src/nephrology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci stacking module — tsb analytics library. */
+export interface NephrologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciStackingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciStacking(data: number[], opts: NephrologySciStackingOptions = {}): NephrologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciStacking };
diff --git a/src/nephrology_sci/standardization.ts b/src/nephrology_sci/standardization.ts
new file mode 100644
index 000000000..70bc3753d
--- /dev/null
+++ b/src/nephrology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci standardization module — tsb analytics library. */
+export interface NephrologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciStandardization(data: number[], opts: NephrologySciStandardizationOptions = {}): NephrologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciStandardization };
diff --git a/src/nephrology_sci/static.ts b/src/nephrology_sci/static.ts
new file mode 100644
index 000000000..930d18eac
--- /dev/null
+++ b/src/nephrology_sci/static.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci static module — tsb analytics library. */
+export interface NephrologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciStaticResult { values: number[]; converged: boolean; }
+export function computeNephrologySciStatic(data: number[], opts: NephrologySciStaticOptions = {}): NephrologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciStatic };
diff --git a/src/nephrology_sci/stochastic.ts b/src/nephrology_sci/stochastic.ts
new file mode 100644
index 000000000..8dfe3884b
--- /dev/null
+++ b/src/nephrology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci stochastic module — tsb analytics library. */
+export interface NephrologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeNephrologySciStochastic(data: number[], opts: NephrologySciStochasticOptions = {}): NephrologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciStochastic };
diff --git a/src/nephrology_sci/synthesis.ts b/src/nephrology_sci/synthesis.ts
new file mode 100644
index 000000000..29847646a
--- /dev/null
+++ b/src/nephrology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci synthesis module — tsb analytics library. */
+export interface NephrologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeNephrologySciSynthesis(data: number[], opts: NephrologySciSynthesisOptions = {}): NephrologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciSynthesis };
diff --git a/src/nephrology_sci/topology.ts b/src/nephrology_sci/topology.ts
new file mode 100644
index 000000000..95a82625e
--- /dev/null
+++ b/src/nephrology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci topology module — tsb analytics library. */
+export interface NephrologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeNephrologySciTopology(data: number[], opts: NephrologySciTopologyOptions = {}): NephrologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciTopology };
diff --git a/src/nephrology_sci/tracking.ts b/src/nephrology_sci/tracking.ts
new file mode 100644
index 000000000..8efcaeec4
--- /dev/null
+++ b/src/nephrology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci tracking module — tsb analytics library. */
+export interface NephrologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciTracking(data: number[], opts: NephrologySciTrackingOptions = {}): NephrologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciTracking };
diff --git a/src/nephrology_sci/transform.ts b/src/nephrology_sci/transform.ts
new file mode 100644
index 000000000..03193e316
--- /dev/null
+++ b/src/nephrology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci transform module — tsb analytics library. */
+export interface NephrologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciTransformResult { values: number[]; converged: boolean; }
+export function computeNephrologySciTransform(data: number[], opts: NephrologySciTransformOptions = {}): NephrologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciTransform };
diff --git a/src/nephrology_sci/uncertainty.ts b/src/nephrology_sci/uncertainty.ts
new file mode 100644
index 000000000..2d9acaf8e
--- /dev/null
+++ b/src/nephrology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci uncertainty module — tsb analytics library. */
+export interface NephrologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeNephrologySciUncertainty(data: number[], opts: NephrologySciUncertaintyOptions = {}): NephrologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciUncertainty };
diff --git a/src/nephrology_sci/validation.ts b/src/nephrology_sci/validation.ts
new file mode 100644
index 000000000..32a6fee72
--- /dev/null
+++ b/src/nephrology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci validation module — tsb analytics library. */
+export interface NephrologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciValidationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciValidation(data: number[], opts: NephrologySciValidationOptions = {}): NephrologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciValidation };
diff --git a/src/nephrology_sci/verification.ts b/src/nephrology_sci/verification.ts
new file mode 100644
index 000000000..bc13389aa
--- /dev/null
+++ b/src/nephrology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci verification module — tsb analytics library. */
+export interface NephrologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciVerification(data: number[], opts: NephrologySciVerificationOptions = {}): NephrologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciVerification };
diff --git a/src/nephrology_sci/visualization.ts b/src/nephrology_sci/visualization.ts
new file mode 100644
index 000000000..ac6768617
--- /dev/null
+++ b/src/nephrology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci visualization module — tsb analytics library. */
+export interface NephrologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeNephrologySciVisualization(data: number[], opts: NephrologySciVisualizationOptions = {}): NephrologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciVisualization };
diff --git a/src/nephrology_sci/voting.ts b/src/nephrology_sci/voting.ts
new file mode 100644
index 000000000..126699455
--- /dev/null
+++ b/src/nephrology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci voting module — tsb analytics library. */
+export interface NephrologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciVotingResult { values: number[]; converged: boolean; }
+export function computeNephrologySciVoting(data: number[], opts: NephrologySciVotingOptions = {}): NephrologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciVoting };
diff --git a/src/nephrology_sci/wavelet.ts b/src/nephrology_sci/wavelet.ts
new file mode 100644
index 000000000..22d9bce22
--- /dev/null
+++ b/src/nephrology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** nephrology_sci wavelet module — tsb analytics library. */
+export interface NephrologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface NephrologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeNephrologySciWavelet(data: number[], opts: NephrologySciWaveletOptions = {}): NephrologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNephrologySciWavelet };
diff --git a/src/network/advanced.ts b/src/network/advanced.ts
new file mode 100644
index 000000000..bd9e1e616
--- /dev/null
+++ b/src/network/advanced.ts
@@ -0,0 +1,15 @@
+/** Network Advanced module — tsb analytics library. */
+export interface Network advancedOptions { tol?: number; maxIter?: number; }
+export interface Network advancedResult { values: number[]; converged: boolean; }
+export function computeNetwork advanced(data: number[], opts: Network advancedOptions = {}): Network advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork advanced };
diff --git a/src/network/attention_graph.ts b/src/network/attention_graph.ts
new file mode 100644
index 000000000..29cc6bc15
--- /dev/null
+++ b/src/network/attention_graph.ts
@@ -0,0 +1,22 @@
+/** Attention Graph module — tsb analytics library. */
+
+/** Options for Attention Graph. */
+export interface AttentionGraphOptions { tol?: number; maxIter?: number; }
+
+/** Result from Attention Graph. */
+export interface AttentionGraphResult { values: number[]; converged: boolean; }
+
+/** Compute Attention Graph. */
+export function computeAttentionGraph(data: number[], opts: AttentionGraphOptions = {}): AttentionGraphResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAttentionGraph };
diff --git a/src/network/base2.ts b/src/network/base2.ts
new file mode 100644
index 000000000..0a2d574b4
--- /dev/null
+++ b/src/network/base2.ts
@@ -0,0 +1,15 @@
+/** Network Base2 module — tsb analytics library. */
+export interface Network base2Options { tol?: number; maxIter?: number; }
+export interface Network base2Result { values: number[]; converged: boolean; }
+export function computeNetwork base2(data: number[], opts: Network base2Options = {}): Network base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork base2 };
diff --git a/src/network/batch.ts b/src/network/batch.ts
new file mode 100644
index 000000000..6e8d17d06
--- /dev/null
+++ b/src/network/batch.ts
@@ -0,0 +1,15 @@
+/** Network Batch module — tsb analytics library. */
+export interface Network batchOptions { tol?: number; maxIter?: number; }
+export interface Network batchResult { values: number[]; converged: boolean; }
+export function computeNetwork batch(data: number[], opts: Network batchOptions = {}): Network batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork batch };
diff --git a/src/network/beta.ts b/src/network/beta.ts
new file mode 100644
index 000000000..57b427897
--- /dev/null
+++ b/src/network/beta.ts
@@ -0,0 +1,15 @@
+/** Network Beta module — tsb analytics library. */
+export interface Network betaOptions { tol?: number; maxIter?: number; }
+export interface Network betaResult { values: number[]; converged: boolean; }
+export function computeNetwork beta(data: number[], opts: Network betaOptions = {}): Network betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork beta };
diff --git a/src/network/bipartite.ts b/src/network/bipartite.ts
new file mode 100644
index 000000000..c7b0377f2
--- /dev/null
+++ b/src/network/bipartite.ts
@@ -0,0 +1,22 @@
+/** Bipartite module — tsb analytics library. */
+
+/** Options for Bipartite. */
+export interface BipartiteOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bipartite. */
+export interface BipartiteResult { values: number[]; converged: boolean; }
+
+/** Compute Bipartite. */
+export function computeBipartite(data: number[], opts: BipartiteOptions = {}): BipartiteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBipartite };
diff --git a/src/network/cascade.ts b/src/network/cascade.ts
new file mode 100644
index 000000000..417f8a997
--- /dev/null
+++ b/src/network/cascade.ts
@@ -0,0 +1,22 @@
+/** Cascade module — tsb analytics library. */
+
+/** Options for Cascade. */
+export interface CascadeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cascade. */
+export interface CascadeResult { values: number[]; converged: boolean; }
+
+/** Compute Cascade. */
+export function computeCascade(data: number[], opts: CascadeOptions = {}): CascadeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCascade };
diff --git a/src/network/centrality.ts b/src/network/centrality.ts
new file mode 100644
index 000000000..db8057e46
--- /dev/null
+++ b/src/network/centrality.ts
@@ -0,0 +1,22 @@
+/** Centrality module — tsb analytics library. */
+
+/** Options for Centrality. */
+export interface CentralityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Centrality. */
+export interface CentralityResult { values: number[]; converged: boolean; }
+
+/** Compute Centrality. */
+export function computeCentrality(data: number[], opts: CentralityOptions = {}): CentralityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCentrality };
diff --git a/src/network/coloring.ts b/src/network/coloring.ts
new file mode 100644
index 000000000..afb472bb3
--- /dev/null
+++ b/src/network/coloring.ts
@@ -0,0 +1,22 @@
+/** Coloring module — tsb analytics library. */
+
+/** Options for Coloring. */
+export interface ColoringOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coloring. */
+export interface ColoringResult { values: number[]; converged: boolean; }
+
+/** Compute Coloring. */
+export function computeColoring(data: number[], opts: ColoringOptions = {}): ColoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeColoring };
diff --git a/src/network/community.ts b/src/network/community.ts
new file mode 100644
index 000000000..3892c46b4
--- /dev/null
+++ b/src/network/community.ts
@@ -0,0 +1,22 @@
+/** Community module — tsb analytics library. */
+
+/** Options for Community. */
+export interface CommunityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Community. */
+export interface CommunityResult { values: number[]; converged: boolean; }
+
+/** Compute Community. */
+export function computeCommunity(data: number[], opts: CommunityOptions = {}): CommunityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCommunity };
diff --git a/src/network/cpu.ts b/src/network/cpu.ts
new file mode 100644
index 000000000..755874aa1
--- /dev/null
+++ b/src/network/cpu.ts
@@ -0,0 +1,15 @@
+/** Network Cpu module — tsb analytics library. */
+export interface Network cpuOptions { tol?: number; maxIter?: number; }
+export interface Network cpuResult { values: number[]; converged: boolean; }
+export function computeNetwork cpu(data: number[], opts: Network cpuOptions = {}): Network cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork cpu };
diff --git a/src/network/dense.ts b/src/network/dense.ts
new file mode 100644
index 000000000..f157e1b14
--- /dev/null
+++ b/src/network/dense.ts
@@ -0,0 +1,15 @@
+/** Network Dense module — tsb analytics library. */
+export interface Network denseOptions { tol?: number; maxIter?: number; }
+export interface Network denseResult { values: number[]; converged: boolean; }
+export function computeNetwork dense(data: number[], opts: Network denseOptions = {}): Network denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork dense };
diff --git a/src/network/diffusion.ts b/src/network/diffusion.ts
new file mode 100644
index 000000000..39c34ae84
--- /dev/null
+++ b/src/network/diffusion.ts
@@ -0,0 +1,22 @@
+/** Diffusion module — tsb analytics library. */
+
+/** Options for Diffusion. */
+export interface DiffusionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Diffusion. */
+export interface DiffusionResult { values: number[]; converged: boolean; }
+
+/** Compute Diffusion. */
+export function computeDiffusion(data: number[], opts: DiffusionOptions = {}): DiffusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDiffusion };
diff --git a/src/network/digraph.ts b/src/network/digraph.ts
new file mode 100644
index 000000000..4a7b3c9fb
--- /dev/null
+++ b/src/network/digraph.ts
@@ -0,0 +1,22 @@
+/** Digraph module — tsb analytics library. */
+
+/** Options for Digraph. */
+export interface DigraphOptions { tol?: number; maxIter?: number; }
+
+/** Result from Digraph. */
+export interface DigraphResult { values: number[]; converged: boolean; }
+
+/** Compute Digraph. */
+export function computeDigraph(data: number[], opts: DigraphOptions = {}): DigraphResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDigraph };
diff --git a/src/network/distributed.ts b/src/network/distributed.ts
new file mode 100644
index 000000000..5393eee06
--- /dev/null
+++ b/src/network/distributed.ts
@@ -0,0 +1,15 @@
+/** Network Distributed module — tsb analytics library. */
+export interface Network distributedOptions { tol?: number; maxIter?: number; }
+export interface Network distributedResult { values: number[]; converged: boolean; }
+export function computeNetwork distributed(data: number[], opts: Network distributedOptions = {}): Network distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork distributed };
diff --git a/src/network/dynamic.ts b/src/network/dynamic.ts
new file mode 100644
index 000000000..20c902a97
--- /dev/null
+++ b/src/network/dynamic.ts
@@ -0,0 +1,22 @@
+/** Dynamic module — tsb analytics library. */
+
+/** Options for Dynamic. */
+export interface DynamicOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dynamic. */
+export interface DynamicResult { values: number[]; converged: boolean; }
+
+/** Compute Dynamic. */
+export function computeDynamic(data: number[], opts: DynamicOptions = {}): DynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDynamic };
diff --git a/src/network/epidemic.ts b/src/network/epidemic.ts
new file mode 100644
index 000000000..781f302df
--- /dev/null
+++ b/src/network/epidemic.ts
@@ -0,0 +1,22 @@
+/** Epidemic module — tsb analytics library. */
+
+/** Options for Epidemic. */
+export interface EpidemicOptions { tol?: number; maxIter?: number; }
+
+/** Result from Epidemic. */
+export interface EpidemicResult { values: number[]; converged: boolean; }
+
+/** Compute Epidemic. */
+export function computeEpidemic(data: number[], opts: EpidemicOptions = {}): EpidemicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEpidemic };
diff --git a/src/network/evolving.ts b/src/network/evolving.ts
new file mode 100644
index 000000000..964565d42
--- /dev/null
+++ b/src/network/evolving.ts
@@ -0,0 +1,22 @@
+/** Evolving module — tsb analytics library. */
+
+/** Options for Evolving. */
+export interface EvolvingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Evolving. */
+export interface EvolvingResult { values: number[]; converged: boolean; }
+
+/** Compute Evolving. */
+export function computeEvolving(data: number[], opts: EvolvingOptions = {}): EvolvingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEvolving };
diff --git a/src/network/experimental.ts b/src/network/experimental.ts
new file mode 100644
index 000000000..6e2d1b9c3
--- /dev/null
+++ b/src/network/experimental.ts
@@ -0,0 +1,15 @@
+/** Network Experimental module — tsb analytics library. */
+export interface Network experimentalOptions { tol?: number; maxIter?: number; }
+export interface Network experimentalResult { values: number[]; converged: boolean; }
+export function computeNetwork experimental(data: number[], opts: Network experimentalOptions = {}): Network experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork experimental };
diff --git a/src/network/fast.ts b/src/network/fast.ts
new file mode 100644
index 000000000..162598e19
--- /dev/null
+++ b/src/network/fast.ts
@@ -0,0 +1,15 @@
+/** Network Fast module — tsb analytics library. */
+export interface Network fastOptions { tol?: number; maxIter?: number; }
+export interface Network fastResult { values: number[]; converged: boolean; }
+export function computeNetwork fast(data: number[], opts: Network fastOptions = {}): Network fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork fast };
diff --git a/src/network/flow.ts b/src/network/flow.ts
new file mode 100644
index 000000000..714346a38
--- /dev/null
+++ b/src/network/flow.ts
@@ -0,0 +1,22 @@
+/** Flow module — tsb analytics library. */
+
+/** Options for Flow. */
+export interface FlowOptions { tol?: number; maxIter?: number; }
+
+/** Result from Flow. */
+export interface FlowResult { values: number[]; converged: boolean; }
+
+/** Compute Flow. */
+export function computeFlow(data: number[], opts: FlowOptions = {}): FlowResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFlow };
diff --git a/src/network/future.ts b/src/network/future.ts
new file mode 100644
index 000000000..335c55184
--- /dev/null
+++ b/src/network/future.ts
@@ -0,0 +1,15 @@
+/** Network Future module — tsb analytics library. */
+export interface Network futureOptions { tol?: number; maxIter?: number; }
+export interface Network futureResult { values: number[]; converged: boolean; }
+export function computeNetwork future(data: number[], opts: Network futureOptions = {}): Network futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork future };
diff --git a/src/network/gpu.ts b/src/network/gpu.ts
new file mode 100644
index 000000000..679dad065
--- /dev/null
+++ b/src/network/gpu.ts
@@ -0,0 +1,15 @@
+/** Network Gpu module — tsb analytics library. */
+export interface Network gpuOptions { tol?: number; maxIter?: number; }
+export interface Network gpuResult { values: number[]; converged: boolean; }
+export function computeNetwork gpu(data: number[], opts: Network gpuOptions = {}): Network gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork gpu };
diff --git a/src/network/graph.ts b/src/network/graph.ts
new file mode 100644
index 000000000..9ab1074c9
--- /dev/null
+++ b/src/network/graph.ts
@@ -0,0 +1,22 @@
+/** Graph module — tsb analytics library. */
+
+/** Options for Graph. */
+export interface GraphOptions { tol?: number; maxIter?: number; }
+
+/** Result from Graph. */
+export interface GraphResult { values: number[]; converged: boolean; }
+
+/** Compute Graph. */
+export function computeGraph(data: number[], opts: GraphOptions = {}): GraphResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGraph };
diff --git a/src/network/graph_embedding.ts b/src/network/graph_embedding.ts
new file mode 100644
index 000000000..f223dc33f
--- /dev/null
+++ b/src/network/graph_embedding.ts
@@ -0,0 +1,22 @@
+/** Graph Embedding module — tsb analytics library. */
+
+/** Options for Graph Embedding. */
+export interface GraphEmbeddingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Graph Embedding. */
+export interface GraphEmbeddingResult { values: number[]; converged: boolean; }
+
+/** Compute Graph Embedding. */
+export function computeGraphEmbedding(data: number[], opts: GraphEmbeddingOptions = {}): GraphEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGraphEmbedding };
diff --git a/src/network/graphnn.ts b/src/network/graphnn.ts
new file mode 100644
index 000000000..c9278be4d
--- /dev/null
+++ b/src/network/graphnn.ts
@@ -0,0 +1,22 @@
+/** Graphnn module — tsb analytics library. */
+
+/** Options for Graphnn. */
+export interface GraphnnOptions { tol?: number; maxIter?: number; }
+
+/** Result from Graphnn. */
+export interface GraphnnResult { values: number[]; converged: boolean; }
+
+/** Compute Graphnn. */
+export function computeGraphnn(data: number[], opts: GraphnnOptions = {}): GraphnnResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGraphnn };
diff --git a/src/network/heterogeneous.ts b/src/network/heterogeneous.ts
new file mode 100644
index 000000000..75039de94
--- /dev/null
+++ b/src/network/heterogeneous.ts
@@ -0,0 +1,22 @@
+/** Heterogeneous module — tsb analytics library. */
+
+/** Options for Heterogeneous. */
+export interface HeterogeneousOptions { tol?: number; maxIter?: number; }
+
+/** Result from Heterogeneous. */
+export interface HeterogeneousResult { values: number[]; converged: boolean; }
+
+/** Compute Heterogeneous. */
+export function computeHeterogeneous(data: number[], opts: HeterogeneousOptions = {}): HeterogeneousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHeterogeneous };
diff --git a/src/network/hypergraph.ts b/src/network/hypergraph.ts
new file mode 100644
index 000000000..ef6ee510a
--- /dev/null
+++ b/src/network/hypergraph.ts
@@ -0,0 +1,22 @@
+/** Hypergraph module — tsb analytics library. */
+
+/** Options for Hypergraph. */
+export interface HypergraphOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hypergraph. */
+export interface HypergraphResult { values: number[]; converged: boolean; }
+
+/** Compute Hypergraph. */
+export function computeHypergraph(data: number[], opts: HypergraphOptions = {}): HypergraphResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHypergraph };
diff --git a/src/network/influence.ts b/src/network/influence.ts
new file mode 100644
index 000000000..c17693d0d
--- /dev/null
+++ b/src/network/influence.ts
@@ -0,0 +1,22 @@
+/** Influence module — tsb analytics library. */
+
+/** Options for Influence. */
+export interface InfluenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Influence. */
+export interface InfluenceResult { values: number[]; converged: boolean; }
+
+/** Compute Influence. */
+export function computeInfluence(data: number[], opts: InfluenceOptions = {}): InfluenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInfluence };
diff --git a/src/network/knowledge_graph.ts b/src/network/knowledge_graph.ts
new file mode 100644
index 000000000..9d0129a1c
--- /dev/null
+++ b/src/network/knowledge_graph.ts
@@ -0,0 +1,22 @@
+/** Knowledge Graph module — tsb analytics library. */
+
+/** Options for Knowledge Graph. */
+export interface KnowledgeGraphOptions { tol?: number; maxIter?: number; }
+
+/** Result from Knowledge Graph. */
+export interface KnowledgeGraphResult { values: number[]; converged: boolean; }
+
+/** Compute Knowledge Graph. */
+export function computeKnowledgeGraph(data: number[], opts: KnowledgeGraphOptions = {}): KnowledgeGraphResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKnowledgeGraph };
diff --git a/src/network/large.ts b/src/network/large.ts
new file mode 100644
index 000000000..47f55b039
--- /dev/null
+++ b/src/network/large.ts
@@ -0,0 +1,15 @@
+/** Network Large module — tsb analytics library. */
+export interface Network largeOptions { tol?: number; maxIter?: number; }
+export interface Network largeResult { values: number[]; converged: boolean; }
+export function computeNetwork large(data: number[], opts: Network largeOptions = {}): Network largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork large };
diff --git a/src/network/legacy.ts b/src/network/legacy.ts
new file mode 100644
index 000000000..758665be3
--- /dev/null
+++ b/src/network/legacy.ts
@@ -0,0 +1,15 @@
+/** Network Legacy module — tsb analytics library. */
+export interface Network legacyOptions { tol?: number; maxIter?: number; }
+export interface Network legacyResult { values: number[]; converged: boolean; }
+export function computeNetwork legacy(data: number[], opts: Network legacyOptions = {}): Network legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork legacy };
diff --git a/src/network/link_prediction.ts b/src/network/link_prediction.ts
new file mode 100644
index 000000000..208067e34
--- /dev/null
+++ b/src/network/link_prediction.ts
@@ -0,0 +1,22 @@
+/** Link Prediction module — tsb analytics library. */
+
+/** Options for Link Prediction. */
+export interface LinkPredictionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Link Prediction. */
+export interface LinkPredictionResult { values: number[]; converged: boolean; }
+
+/** Compute Link Prediction. */
+export function computeLinkPrediction(data: number[], opts: LinkPredictionOptions = {}): LinkPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLinkPrediction };
diff --git a/src/network/lite.ts b/src/network/lite.ts
new file mode 100644
index 000000000..abcf504fd
--- /dev/null
+++ b/src/network/lite.ts
@@ -0,0 +1,15 @@
+/** Network Lite module — tsb analytics library. */
+export interface Network liteOptions { tol?: number; maxIter?: number; }
+export interface Network liteResult { values: number[]; converged: boolean; }
+export function computeNetwork lite(data: number[], opts: Network liteOptions = {}): Network liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork lite };
diff --git a/src/network/matching.ts b/src/network/matching.ts
new file mode 100644
index 000000000..c60f8d3e0
--- /dev/null
+++ b/src/network/matching.ts
@@ -0,0 +1,22 @@
+/** Matching module — tsb analytics library. */
+
+/** Options for Matching. */
+export interface MatchingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Matching. */
+export interface MatchingResult { values: number[]; converged: boolean; }
+
+/** Compute Matching. */
+export function computeMatching(data: number[], opts: MatchingOptions = {}): MatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMatching };
diff --git a/src/network/message_passing.ts b/src/network/message_passing.ts
new file mode 100644
index 000000000..aeb3e0bfd
--- /dev/null
+++ b/src/network/message_passing.ts
@@ -0,0 +1,22 @@
+/** Message Passing module — tsb analytics library. */
+
+/** Options for Message Passing. */
+export interface MessagePassingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Message Passing. */
+export interface MessagePassingResult { values: number[]; converged: boolean; }
+
+/** Compute Message Passing. */
+export function computeMessagePassing(data: number[], opts: MessagePassingOptions = {}): MessagePassingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMessagePassing };
diff --git a/src/network/mini.ts b/src/network/mini.ts
new file mode 100644
index 000000000..2630d247c
--- /dev/null
+++ b/src/network/mini.ts
@@ -0,0 +1,15 @@
+/** Network Mini module — tsb analytics library. */
+export interface Network miniOptions { tol?: number; maxIter?: number; }
+export interface Network miniResult { values: number[]; converged: boolean; }
+export function computeNetwork mini(data: number[], opts: Network miniOptions = {}): Network miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork mini };
diff --git a/src/network/multiplex.ts b/src/network/multiplex.ts
new file mode 100644
index 000000000..10d878a57
--- /dev/null
+++ b/src/network/multiplex.ts
@@ -0,0 +1,22 @@
+/** Multiplex module — tsb analytics library. */
+
+/** Options for Multiplex. */
+export interface MultiplexOptions { tol?: number; maxIter?: number; }
+
+/** Result from Multiplex. */
+export interface MultiplexResult { values: number[]; converged: boolean; }
+
+/** Compute Multiplex. */
+export function computeMultiplex(data: number[], opts: MultiplexOptions = {}): MultiplexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMultiplex };
diff --git a/src/network/next.ts b/src/network/next.ts
new file mode 100644
index 000000000..f4d091c4f
--- /dev/null
+++ b/src/network/next.ts
@@ -0,0 +1,15 @@
+/** Network Next module — tsb analytics library. */
+export interface Network nextOptions { tol?: number; maxIter?: number; }
+export interface Network nextResult { values: number[]; converged: boolean; }
+export function computeNetwork next(data: number[], opts: Network nextOptions = {}): Network nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork next };
diff --git a/src/network/node_classification.ts b/src/network/node_classification.ts
new file mode 100644
index 000000000..bd8bb4b42
--- /dev/null
+++ b/src/network/node_classification.ts
@@ -0,0 +1,22 @@
+/** Node Classification module — tsb analytics library. */
+
+/** Options for Node Classification. */
+export interface NodeClassificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Node Classification. */
+export interface NodeClassificationResult { values: number[]; converged: boolean; }
+
+/** Compute Node Classification. */
+export function computeNodeClassification(data: number[], opts: NodeClassificationOptions = {}): NodeClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNodeClassification };
diff --git a/src/network/online.ts b/src/network/online.ts
new file mode 100644
index 000000000..cbd3a850e
--- /dev/null
+++ b/src/network/online.ts
@@ -0,0 +1,15 @@
+/** Network Online module — tsb analytics library. */
+export interface Network onlineOptions { tol?: number; maxIter?: number; }
+export interface Network onlineResult { values: number[]; converged: boolean; }
+export function computeNetwork online(data: number[], opts: Network onlineOptions = {}): Network onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork online };
diff --git a/src/network/parallel.ts b/src/network/parallel.ts
new file mode 100644
index 000000000..0d3f53880
--- /dev/null
+++ b/src/network/parallel.ts
@@ -0,0 +1,15 @@
+/** Network Parallel module — tsb analytics library. */
+export interface Network parallelOptions { tol?: number; maxIter?: number; }
+export interface Network parallelResult { values: number[]; converged: boolean; }
+export function computeNetwork parallel(data: number[], opts: Network parallelOptions = {}): Network parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork parallel };
diff --git a/src/network/percolation.ts b/src/network/percolation.ts
new file mode 100644
index 000000000..ae0c2576d
--- /dev/null
+++ b/src/network/percolation.ts
@@ -0,0 +1,22 @@
+/** Percolation module — tsb analytics library. */
+
+/** Options for Percolation. */
+export interface PercolationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Percolation. */
+export interface PercolationResult { values: number[]; converged: boolean; }
+
+/** Compute Percolation. */
+export function computePercolation(data: number[], opts: PercolationOptions = {}): PercolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePercolation };
diff --git a/src/network/planarity.ts b/src/network/planarity.ts
new file mode 100644
index 000000000..aef5ae4a0
--- /dev/null
+++ b/src/network/planarity.ts
@@ -0,0 +1,22 @@
+/** Planarity module — tsb analytics library. */
+
+/** Options for Planarity. */
+export interface PlanarityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Planarity. */
+export interface PlanarityResult { values: number[]; converged: boolean; }
+
+/** Compute Planarity. */
+export function computePlanarity(data: number[], opts: PlanarityOptions = {}): PlanarityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePlanarity };
diff --git a/src/network/plus.ts b/src/network/plus.ts
new file mode 100644
index 000000000..148685dd5
--- /dev/null
+++ b/src/network/plus.ts
@@ -0,0 +1,15 @@
+/** Network Plus module — tsb analytics library. */
+export interface Network plusOptions { tol?: number; maxIter?: number; }
+export interface Network plusResult { values: number[]; converged: boolean; }
+export function computeNetwork plus(data: number[], opts: Network plusOptions = {}): Network plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork plus };
diff --git a/src/network/pro.ts b/src/network/pro.ts
new file mode 100644
index 000000000..9fb36b17a
--- /dev/null
+++ b/src/network/pro.ts
@@ -0,0 +1,15 @@
+/** Network Pro module — tsb analytics library. */
+export interface Network proOptions { tol?: number; maxIter?: number; }
+export interface Network proResult { values: number[]; converged: boolean; }
+export function computeNetwork pro(data: number[], opts: Network proOptions = {}): Network proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork pro };
diff --git a/src/network/random_graph.ts b/src/network/random_graph.ts
new file mode 100644
index 000000000..c6418f735
--- /dev/null
+++ b/src/network/random_graph.ts
@@ -0,0 +1,22 @@
+/** Random Graph module — tsb analytics library. */
+
+/** Options for Random Graph. */
+export interface RandomGraphOptions { tol?: number; maxIter?: number; }
+
+/** Result from Random Graph. */
+export interface RandomGraphResult { values: number[]; converged: boolean; }
+
+/** Compute Random Graph. */
+export function computeRandomGraph(data: number[], opts: RandomGraphOptions = {}): RandomGraphResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRandomGraph };
diff --git a/src/network/robust.ts b/src/network/robust.ts
new file mode 100644
index 000000000..252e8b1ee
--- /dev/null
+++ b/src/network/robust.ts
@@ -0,0 +1,15 @@
+/** Network Robust module — tsb analytics library. */
+export interface Network robustOptions { tol?: number; maxIter?: number; }
+export interface Network robustResult { values: number[]; converged: boolean; }
+export function computeNetwork robust(data: number[], opts: Network robustOptions = {}): Network robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork robust };
diff --git a/src/network/shortest_path.ts b/src/network/shortest_path.ts
new file mode 100644
index 000000000..c16841e41
--- /dev/null
+++ b/src/network/shortest_path.ts
@@ -0,0 +1,22 @@
+/** Shortest Path module — tsb analytics library. */
+
+/** Options for Shortest Path. */
+export interface ShortestPathOptions { tol?: number; maxIter?: number; }
+
+/** Result from Shortest Path. */
+export interface ShortestPathResult { values: number[]; converged: boolean; }
+
+/** Compute Shortest Path. */
+export function computeShortestPath(data: number[], opts: ShortestPathOptions = {}): ShortestPathResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeShortestPath };
diff --git a/src/network/small.ts b/src/network/small.ts
new file mode 100644
index 000000000..43ebe4670
--- /dev/null
+++ b/src/network/small.ts
@@ -0,0 +1,15 @@
+/** Network Small module — tsb analytics library. */
+export interface Network smallOptions { tol?: number; maxIter?: number; }
+export interface Network smallResult { values: number[]; converged: boolean; }
+export function computeNetwork small(data: number[], opts: Network smallOptions = {}): Network smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork small };
diff --git a/src/network/spanning_tree.ts b/src/network/spanning_tree.ts
new file mode 100644
index 000000000..dbffdda2b
--- /dev/null
+++ b/src/network/spanning_tree.ts
@@ -0,0 +1,22 @@
+/** Spanning Tree module — tsb analytics library. */
+
+/** Options for Spanning Tree. */
+export interface SpanningTreeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spanning Tree. */
+export interface SpanningTreeResult { values: number[]; converged: boolean; }
+
+/** Compute Spanning Tree. */
+export function computeSpanningTree(data: number[], opts: SpanningTreeOptions = {}): SpanningTreeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpanningTree };
diff --git a/src/network/sparse.ts b/src/network/sparse.ts
new file mode 100644
index 000000000..1ae753f7d
--- /dev/null
+++ b/src/network/sparse.ts
@@ -0,0 +1,15 @@
+/** Network Sparse module — tsb analytics library. */
+export interface Network sparseOptions { tol?: number; maxIter?: number; }
+export interface Network sparseResult { values: number[]; converged: boolean; }
+export function computeNetwork sparse(data: number[], opts: Network sparseOptions = {}): Network sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork sparse };
diff --git a/src/network/stable.ts b/src/network/stable.ts
new file mode 100644
index 000000000..db55d45aa
--- /dev/null
+++ b/src/network/stable.ts
@@ -0,0 +1,15 @@
+/** Network Stable module — tsb analytics library. */
+export interface Network stableOptions { tol?: number; maxIter?: number; }
+export interface Network stableResult { values: number[]; converged: boolean; }
+export function computeNetwork stable(data: number[], opts: Network stableOptions = {}): Network stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork stable };
diff --git a/src/network/streaming.ts b/src/network/streaming.ts
new file mode 100644
index 000000000..30497ef4e
--- /dev/null
+++ b/src/network/streaming.ts
@@ -0,0 +1,15 @@
+/** Network Streaming module — tsb analytics library. */
+export interface Network streamingOptions { tol?: number; maxIter?: number; }
+export interface Network streamingResult { values: number[]; converged: boolean; }
+export function computeNetwork streaming(data: number[], opts: Network streamingOptions = {}): Network streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork streaming };
diff --git a/src/network/temporal_graph.ts b/src/network/temporal_graph.ts
new file mode 100644
index 000000000..153a62ef6
--- /dev/null
+++ b/src/network/temporal_graph.ts
@@ -0,0 +1,22 @@
+/** Temporal Graph module — tsb analytics library. */
+
+/** Options for Temporal Graph. */
+export interface TemporalGraphOptions { tol?: number; maxIter?: number; }
+
+/** Result from Temporal Graph. */
+export interface TemporalGraphResult { values: number[]; converged: boolean; }
+
+/** Compute Temporal Graph. */
+export function computeTemporalGraph(data: number[], opts: TemporalGraphOptions = {}): TemporalGraphResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTemporalGraph };
diff --git a/src/network/v2.ts b/src/network/v2.ts
new file mode 100644
index 000000000..df28177d0
--- /dev/null
+++ b/src/network/v2.ts
@@ -0,0 +1,15 @@
+/** Network V2 module — tsb analytics library. */
+export interface Network v2Options { tol?: number; maxIter?: number; }
+export interface Network v2Result { values: number[]; converged: boolean; }
+export function computeNetwork v2(data: number[], opts: Network v2Options = {}): Network v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork v2 };
diff --git a/src/network/v3.ts b/src/network/v3.ts
new file mode 100644
index 000000000..70cd9d8d1
--- /dev/null
+++ b/src/network/v3.ts
@@ -0,0 +1,15 @@
+/** Network V3 module — tsb analytics library. */
+export interface Network v3Options { tol?: number; maxIter?: number; }
+export interface Network v3Result { values: number[]; converged: boolean; }
+export function computeNetwork v3(data: number[], opts: Network v3Options = {}): Network v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork v3 };
diff --git a/src/network/wasm.ts b/src/network/wasm.ts
new file mode 100644
index 000000000..f3ddd4a3d
--- /dev/null
+++ b/src/network/wasm.ts
@@ -0,0 +1,15 @@
+/** Network Wasm module — tsb analytics library. */
+export interface Network wasmOptions { tol?: number; maxIter?: number; }
+export interface Network wasmResult { values: number[]; converged: boolean; }
+export function computeNetwork wasm(data: number[], opts: Network wasmOptions = {}): Network wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork wasm };
diff --git a/src/network/xlarge.ts b/src/network/xlarge.ts
new file mode 100644
index 000000000..b5af6427f
--- /dev/null
+++ b/src/network/xlarge.ts
@@ -0,0 +1,15 @@
+/** Network Xlarge module — tsb analytics library. */
+export interface Network xlargeOptions { tol?: number; maxIter?: number; }
+export interface Network xlargeResult { values: number[]; converged: boolean; }
+export function computeNetwork xlarge(data: number[], opts: Network xlargeOptions = {}): Network xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNetwork xlarge };
diff --git a/src/neurology_sci/adaptation.ts b/src/neurology_sci/adaptation.ts
new file mode 100644
index 000000000..d44695cbe
--- /dev/null
+++ b/src/neurology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci adaptation module — tsb analytics library. */
+export interface NeurologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciAdaptation(data: number[], opts: NeurologySciAdaptationOptions = {}): NeurologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciAdaptation };
diff --git a/src/neurology_sci/aggregation.ts b/src/neurology_sci/aggregation.ts
new file mode 100644
index 000000000..a3e24df9d
--- /dev/null
+++ b/src/neurology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci aggregation module — tsb analytics library. */
+export interface NeurologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciAggregation(data: number[], opts: NeurologySciAggregationOptions = {}): NeurologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciAggregation };
diff --git a/src/neurology_sci/algebra.ts b/src/neurology_sci/algebra.ts
new file mode 100644
index 000000000..508b8026b
--- /dev/null
+++ b/src/neurology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** neurology_sci algebra module — tsb analytics library. */
+export interface NeurologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeNeurologySciAlgebra(data: number[], opts: NeurologySciAlgebraOptions = {}): NeurologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciAlgebra };
diff --git a/src/neurology_sci/alignment.ts b/src/neurology_sci/alignment.ts
new file mode 100644
index 000000000..2e33de878
--- /dev/null
+++ b/src/neurology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** neurology_sci alignment module — tsb analytics library. */
+export interface NeurologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeNeurologySciAlignment(data: number[], opts: NeurologySciAlignmentOptions = {}): NeurologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciAlignment };
diff --git a/src/neurology_sci/analysis.ts b/src/neurology_sci/analysis.ts
new file mode 100644
index 000000000..30e2e75f7
--- /dev/null
+++ b/src/neurology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** neurology_sci analysis module — tsb analytics library. */
+export interface NeurologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeNeurologySciAnalysis(data: number[], opts: NeurologySciAnalysisOptions = {}): NeurologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciAnalysis };
diff --git a/src/neurology_sci/augmentation.ts b/src/neurology_sci/augmentation.ts
new file mode 100644
index 000000000..e1b14d39a
--- /dev/null
+++ b/src/neurology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci augmentation module — tsb analytics library. */
+export interface NeurologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciAugmentation(data: number[], opts: NeurologySciAugmentationOptions = {}): NeurologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciAugmentation };
diff --git a/src/neurology_sci/bagging.ts b/src/neurology_sci/bagging.ts
new file mode 100644
index 000000000..21daae34a
--- /dev/null
+++ b/src/neurology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** neurology_sci bagging module — tsb analytics library. */
+export interface NeurologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciBagging(data: number[], opts: NeurologySciBaggingOptions = {}): NeurologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciBagging };
diff --git a/src/neurology_sci/basis.ts b/src/neurology_sci/basis.ts
new file mode 100644
index 000000000..fc73ab3a9
--- /dev/null
+++ b/src/neurology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** neurology_sci basis module — tsb analytics library. */
+export interface NeurologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciBasisResult { values: number[]; converged: boolean; }
+export function computeNeurologySciBasis(data: number[], opts: NeurologySciBasisOptions = {}): NeurologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciBasis };
diff --git a/src/neurology_sci/benchmarking.ts b/src/neurology_sci/benchmarking.ts
new file mode 100644
index 000000000..4a8254252
--- /dev/null
+++ b/src/neurology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** neurology_sci benchmarking module — tsb analytics library. */
+export interface NeurologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciBenchmarking(data: number[], opts: NeurologySciBenchmarkingOptions = {}): NeurologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciBenchmarking };
diff --git a/src/neurology_sci/blending.ts b/src/neurology_sci/blending.ts
new file mode 100644
index 000000000..fa1694457
--- /dev/null
+++ b/src/neurology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** neurology_sci blending module — tsb analytics library. */
+export interface NeurologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciBlending(data: number[], opts: NeurologySciBlendingOptions = {}): NeurologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciBlending };
diff --git a/src/neurology_sci/boosting.ts b/src/neurology_sci/boosting.ts
new file mode 100644
index 000000000..d8b15693c
--- /dev/null
+++ b/src/neurology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** neurology_sci boosting module — tsb analytics library. */
+export interface NeurologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciBoosting(data: number[], opts: NeurologySciBoostingOptions = {}): NeurologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciBoosting };
diff --git a/src/neurology_sci/bootstrap.ts b/src/neurology_sci/bootstrap.ts
new file mode 100644
index 000000000..f7727e82e
--- /dev/null
+++ b/src/neurology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** neurology_sci bootstrap module — tsb analytics library. */
+export interface NeurologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeNeurologySciBootstrap(data: number[], opts: NeurologySciBootstrapOptions = {}): NeurologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciBootstrap };
diff --git a/src/neurology_sci/calculus.ts b/src/neurology_sci/calculus.ts
new file mode 100644
index 000000000..30f7df34f
--- /dev/null
+++ b/src/neurology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** neurology_sci calculus module — tsb analytics library. */
+export interface NeurologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeNeurologySciCalculus(data: number[], opts: NeurologySciCalculusOptions = {}): NeurologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciCalculus };
diff --git a/src/neurology_sci/calibration.ts b/src/neurology_sci/calibration.ts
new file mode 100644
index 000000000..86f1d7c93
--- /dev/null
+++ b/src/neurology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** neurology_sci calibration module — tsb analytics library. */
+export interface NeurologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciCalibration(data: number[], opts: NeurologySciCalibrationOptions = {}): NeurologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciCalibration };
diff --git a/src/neurology_sci/characterization.ts b/src/neurology_sci/characterization.ts
new file mode 100644
index 000000000..ef04b4bd0
--- /dev/null
+++ b/src/neurology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** neurology_sci characterization module — tsb analytics library. */
+export interface NeurologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciCharacterization(data: number[], opts: NeurologySciCharacterizationOptions = {}): NeurologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciCharacterization };
diff --git a/src/neurology_sci/classification.ts b/src/neurology_sci/classification.ts
new file mode 100644
index 000000000..085338f2c
--- /dev/null
+++ b/src/neurology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** neurology_sci classification module — tsb analytics library. */
+export interface NeurologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciClassification(data: number[], opts: NeurologySciClassificationOptions = {}): NeurologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciClassification };
diff --git a/src/neurology_sci/clustering.ts b/src/neurology_sci/clustering.ts
new file mode 100644
index 000000000..ea2209335
--- /dev/null
+++ b/src/neurology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** neurology_sci clustering module — tsb analytics library. */
+export interface NeurologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeNeurologySciClustering(data: number[], opts: NeurologySciClusteringOptions = {}): NeurologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciClustering };
diff --git a/src/neurology_sci/compression.ts b/src/neurology_sci/compression.ts
new file mode 100644
index 000000000..26d766418
--- /dev/null
+++ b/src/neurology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** neurology_sci compression module — tsb analytics library. */
+export interface NeurologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciCompression(data: number[], opts: NeurologySciCompressionOptions = {}): NeurologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciCompression };
diff --git a/src/neurology_sci/continuous.ts b/src/neurology_sci/continuous.ts
new file mode 100644
index 000000000..cb183930a
--- /dev/null
+++ b/src/neurology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** neurology_sci continuous module — tsb analytics library. */
+export interface NeurologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeNeurologySciContinuous(data: number[], opts: NeurologySciContinuousOptions = {}): NeurologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciContinuous };
diff --git a/src/neurology_sci/control.ts b/src/neurology_sci/control.ts
new file mode 100644
index 000000000..56df1093e
--- /dev/null
+++ b/src/neurology_sci/control.ts
@@ -0,0 +1,14 @@
+/** neurology_sci control module — tsb analytics library. */
+export interface NeurologySciControlOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciControlResult { values: number[]; converged: boolean; }
+export function computeNeurologySciControl(data: number[], opts: NeurologySciControlOptions = {}): NeurologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciControl };
diff --git a/src/neurology_sci/convergence.ts b/src/neurology_sci/convergence.ts
new file mode 100644
index 000000000..253692154
--- /dev/null
+++ b/src/neurology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** neurology_sci convergence module — tsb analytics library. */
+export interface NeurologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeNeurologySciConvergence(data: number[], opts: NeurologySciConvergenceOptions = {}): NeurologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciConvergence };
diff --git a/src/neurology_sci/convex.ts b/src/neurology_sci/convex.ts
new file mode 100644
index 000000000..2964fc5a3
--- /dev/null
+++ b/src/neurology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** neurology_sci convex module — tsb analytics library. */
+export interface NeurologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciConvexResult { values: number[]; converged: boolean; }
+export function computeNeurologySciConvex(data: number[], opts: NeurologySciConvexOptions = {}): NeurologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciConvex };
diff --git a/src/neurology_sci/correlation.ts b/src/neurology_sci/correlation.ts
new file mode 100644
index 000000000..2a4f0ced5
--- /dev/null
+++ b/src/neurology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci correlation module — tsb analytics library. */
+export interface NeurologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciCorrelation(data: number[], opts: NeurologySciCorrelationOptions = {}): NeurologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciCorrelation };
diff --git a/src/neurology_sci/covariance.ts b/src/neurology_sci/covariance.ts
new file mode 100644
index 000000000..e358eccb1
--- /dev/null
+++ b/src/neurology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** neurology_sci covariance module — tsb analytics library. */
+export interface NeurologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeNeurologySciCovariance(data: number[], opts: NeurologySciCovarianceOptions = {}): NeurologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciCovariance };
diff --git a/src/neurology_sci/cross_validation.ts b/src/neurology_sci/cross_validation.ts
new file mode 100644
index 000000000..8b9695a13
--- /dev/null
+++ b/src/neurology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci cross_validation module — tsb analytics library. */
+export interface NeurologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciCrossValidation(data: number[], opts: NeurologySciCrossValidationOptions = {}): NeurologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciCrossValidation };
diff --git a/src/neurology_sci/decoding.ts b/src/neurology_sci/decoding.ts
new file mode 100644
index 000000000..8e71fbafb
--- /dev/null
+++ b/src/neurology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** neurology_sci decoding module — tsb analytics library. */
+export interface NeurologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDecoding(data: number[], opts: NeurologySciDecodingOptions = {}): NeurologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDecoding };
diff --git a/src/neurology_sci/decomposition.ts b/src/neurology_sci/decomposition.ts
new file mode 100644
index 000000000..a31e7b96b
--- /dev/null
+++ b/src/neurology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** neurology_sci decomposition module — tsb analytics library. */
+export interface NeurologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDecomposition(data: number[], opts: NeurologySciDecompositionOptions = {}): NeurologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDecomposition };
diff --git a/src/neurology_sci/detection.ts b/src/neurology_sci/detection.ts
new file mode 100644
index 000000000..3ac90395f
--- /dev/null
+++ b/src/neurology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** neurology_sci detection module — tsb analytics library. */
+export interface NeurologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDetection(data: number[], opts: NeurologySciDetectionOptions = {}): NeurologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDetection };
diff --git a/src/neurology_sci/deterministic.ts b/src/neurology_sci/deterministic.ts
new file mode 100644
index 000000000..952d032c1
--- /dev/null
+++ b/src/neurology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** neurology_sci deterministic module — tsb analytics library. */
+export interface NeurologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDeterministic(data: number[], opts: NeurologySciDeterministicOptions = {}): NeurologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDeterministic };
diff --git a/src/neurology_sci/diagnostics.ts b/src/neurology_sci/diagnostics.ts
new file mode 100644
index 000000000..94e7610fb
--- /dev/null
+++ b/src/neurology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** neurology_sci diagnostics module — tsb analytics library. */
+export interface NeurologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDiagnostics(data: number[], opts: NeurologySciDiagnosticsOptions = {}): NeurologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDiagnostics };
diff --git a/src/neurology_sci/differential.ts b/src/neurology_sci/differential.ts
new file mode 100644
index 000000000..9fc5df8a5
--- /dev/null
+++ b/src/neurology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** neurology_sci differential module — tsb analytics library. */
+export interface NeurologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDifferential(data: number[], opts: NeurologySciDifferentialOptions = {}): NeurologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDifferential };
diff --git a/src/neurology_sci/discrete.ts b/src/neurology_sci/discrete.ts
new file mode 100644
index 000000000..a18157166
--- /dev/null
+++ b/src/neurology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** neurology_sci discrete module — tsb analytics library. */
+export interface NeurologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDiscrete(data: number[], opts: NeurologySciDiscreteOptions = {}): NeurologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDiscrete };
diff --git a/src/neurology_sci/distribution.ts b/src/neurology_sci/distribution.ts
new file mode 100644
index 000000000..02822dc75
--- /dev/null
+++ b/src/neurology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** neurology_sci distribution module — tsb analytics library. */
+export interface NeurologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDistribution(data: number[], opts: NeurologySciDistributionOptions = {}): NeurologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDistribution };
diff --git a/src/neurology_sci/dynamic.ts b/src/neurology_sci/dynamic.ts
new file mode 100644
index 000000000..df9c5c67c
--- /dev/null
+++ b/src/neurology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** neurology_sci dynamic module — tsb analytics library. */
+export interface NeurologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeNeurologySciDynamic(data: number[], opts: NeurologySciDynamicOptions = {}): NeurologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciDynamic };
diff --git a/src/neurology_sci/embedding.ts b/src/neurology_sci/embedding.ts
new file mode 100644
index 000000000..618ea4240
--- /dev/null
+++ b/src/neurology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** neurology_sci embedding module — tsb analytics library. */
+export interface NeurologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciEmbedding(data: number[], opts: NeurologySciEmbeddingOptions = {}): NeurologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciEmbedding };
diff --git a/src/neurology_sci/encoding.ts b/src/neurology_sci/encoding.ts
new file mode 100644
index 000000000..35893efb8
--- /dev/null
+++ b/src/neurology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** neurology_sci encoding module — tsb analytics library. */
+export interface NeurologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciEncoding(data: number[], opts: NeurologySciEncodingOptions = {}): NeurologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciEncoding };
diff --git a/src/neurology_sci/ensemble.ts b/src/neurology_sci/ensemble.ts
new file mode 100644
index 000000000..76f3c9fd1
--- /dev/null
+++ b/src/neurology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** neurology_sci ensemble module — tsb analytics library. */
+export interface NeurologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeNeurologySciEnsemble(data: number[], opts: NeurologySciEnsembleOptions = {}): NeurologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciEnsemble };
diff --git a/src/neurology_sci/estimation.ts b/src/neurology_sci/estimation.ts
new file mode 100644
index 000000000..262114e25
--- /dev/null
+++ b/src/neurology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci estimation module — tsb analytics library. */
+export interface NeurologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciEstimation(data: number[], opts: NeurologySciEstimationOptions = {}): NeurologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciEstimation };
diff --git a/src/neurology_sci/evaluation.ts b/src/neurology_sci/evaluation.ts
new file mode 100644
index 000000000..5a5661e31
--- /dev/null
+++ b/src/neurology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci evaluation module — tsb analytics library. */
+export interface NeurologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciEvaluation(data: number[], opts: NeurologySciEvaluationOptions = {}): NeurologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciEvaluation };
diff --git a/src/neurology_sci/extrapolation.ts b/src/neurology_sci/extrapolation.ts
new file mode 100644
index 000000000..bb526882b
--- /dev/null
+++ b/src/neurology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci extrapolation module — tsb analytics library. */
+export interface NeurologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciExtrapolation(data: number[], opts: NeurologySciExtrapolationOptions = {}): NeurologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciExtrapolation };
diff --git a/src/neurology_sci/features.ts b/src/neurology_sci/features.ts
new file mode 100644
index 000000000..9ca62df36
--- /dev/null
+++ b/src/neurology_sci/features.ts
@@ -0,0 +1,14 @@
+/** neurology_sci features module — tsb analytics library. */
+export interface NeurologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeNeurologySciFeatures(data: number[], opts: NeurologySciFeaturesOptions = {}): NeurologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciFeatures };
diff --git a/src/neurology_sci/feedback.ts b/src/neurology_sci/feedback.ts
new file mode 100644
index 000000000..3cf6a4825
--- /dev/null
+++ b/src/neurology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** neurology_sci feedback module — tsb analytics library. */
+export interface NeurologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeNeurologySciFeedback(data: number[], opts: NeurologySciFeedbackOptions = {}): NeurologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciFeedback };
diff --git a/src/neurology_sci/filtering.ts b/src/neurology_sci/filtering.ts
new file mode 100644
index 000000000..70d5108a2
--- /dev/null
+++ b/src/neurology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** neurology_sci filtering module — tsb analytics library. */
+export interface NeurologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeNeurologySciFiltering(data: number[], opts: NeurologySciFilteringOptions = {}): NeurologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciFiltering };
diff --git a/src/neurology_sci/fourier.ts b/src/neurology_sci/fourier.ts
new file mode 100644
index 000000000..62937b66c
--- /dev/null
+++ b/src/neurology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** neurology_sci fourier module — tsb analytics library. */
+export interface NeurologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciFourierResult { values: number[]; converged: boolean; }
+export function computeNeurologySciFourier(data: number[], opts: NeurologySciFourierOptions = {}): NeurologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciFourier };
diff --git a/src/neurology_sci/fusion.ts b/src/neurology_sci/fusion.ts
new file mode 100644
index 000000000..7b8ef5e43
--- /dev/null
+++ b/src/neurology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** neurology_sci fusion module — tsb analytics library. */
+export interface NeurologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciFusionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciFusion(data: number[], opts: NeurologySciFusionOptions = {}): NeurologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciFusion };
diff --git a/src/neurology_sci/generation.ts b/src/neurology_sci/generation.ts
new file mode 100644
index 000000000..9feb8cc47
--- /dev/null
+++ b/src/neurology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci generation module — tsb analytics library. */
+export interface NeurologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciGeneration(data: number[], opts: NeurologySciGenerationOptions = {}): NeurologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciGeneration };
diff --git a/src/neurology_sci/geometry.ts b/src/neurology_sci/geometry.ts
new file mode 100644
index 000000000..ee053b6d7
--- /dev/null
+++ b/src/neurology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** neurology_sci geometry module — tsb analytics library. */
+export interface NeurologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeNeurologySciGeometry(data: number[], opts: NeurologySciGeometryOptions = {}): NeurologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciGeometry };
diff --git a/src/neurology_sci/gradient.ts b/src/neurology_sci/gradient.ts
new file mode 100644
index 000000000..47006d78b
--- /dev/null
+++ b/src/neurology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** neurology_sci gradient module — tsb analytics library. */
+export interface NeurologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciGradientResult { values: number[]; converged: boolean; }
+export function computeNeurologySciGradient(data: number[], opts: NeurologySciGradientOptions = {}): NeurologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciGradient };
diff --git a/src/neurology_sci/hessian.ts b/src/neurology_sci/hessian.ts
new file mode 100644
index 000000000..617d4dfdf
--- /dev/null
+++ b/src/neurology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** neurology_sci hessian module — tsb analytics library. */
+export interface NeurologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciHessianResult { values: number[]; converged: boolean; }
+export function computeNeurologySciHessian(data: number[], opts: NeurologySciHessianOptions = {}): NeurologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciHessian };
diff --git a/src/neurology_sci/hypothesis.ts b/src/neurology_sci/hypothesis.ts
new file mode 100644
index 000000000..9a24e27af
--- /dev/null
+++ b/src/neurology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** neurology_sci hypothesis module — tsb analytics library. */
+export interface NeurologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeNeurologySciHypothesis(data: number[], opts: NeurologySciHypothesisOptions = {}): NeurologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciHypothesis };
diff --git a/src/neurology_sci/inference.ts b/src/neurology_sci/inference.ts
new file mode 100644
index 000000000..4ae338ced
--- /dev/null
+++ b/src/neurology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** neurology_sci inference module — tsb analytics library. */
+export interface NeurologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeNeurologySciInference(data: number[], opts: NeurologySciInferenceOptions = {}): NeurologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciInference };
diff --git a/src/neurology_sci/inference2.ts b/src/neurology_sci/inference2.ts
new file mode 100644
index 000000000..f4d2c7bf0
--- /dev/null
+++ b/src/neurology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** neurology_sci inference2 module — tsb analytics library. */
+export interface NeurologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeNeurologySciInference(data: number[], opts: NeurologySciInferenceOptions = {}): NeurologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciInference };
diff --git a/src/neurology_sci/integral.ts b/src/neurology_sci/integral.ts
new file mode 100644
index 000000000..58c044915
--- /dev/null
+++ b/src/neurology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** neurology_sci integral module — tsb analytics library. */
+export interface NeurologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeNeurologySciIntegral(data: number[], opts: NeurologySciIntegralOptions = {}): NeurologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciIntegral };
diff --git a/src/neurology_sci/integration.ts b/src/neurology_sci/integration.ts
new file mode 100644
index 000000000..2f4407742
--- /dev/null
+++ b/src/neurology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** neurology_sci integration module — tsb analytics library. */
+export interface NeurologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciIntegration(data: number[], opts: NeurologySciIntegrationOptions = {}): NeurologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciIntegration };
diff --git a/src/neurology_sci/interpolation.ts b/src/neurology_sci/interpolation.ts
new file mode 100644
index 000000000..99c148e43
--- /dev/null
+++ b/src/neurology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci interpolation module — tsb analytics library. */
+export interface NeurologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciInterpolation(data: number[], opts: NeurologySciInterpolationOptions = {}): NeurologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciInterpolation };
diff --git a/src/neurology_sci/jacobian.ts b/src/neurology_sci/jacobian.ts
new file mode 100644
index 000000000..84406cf1e
--- /dev/null
+++ b/src/neurology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** neurology_sci jacobian module — tsb analytics library. */
+export interface NeurologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeNeurologySciJacobian(data: number[], opts: NeurologySciJacobianOptions = {}): NeurologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciJacobian };
diff --git a/src/neurology_sci/kernel.ts b/src/neurology_sci/kernel.ts
new file mode 100644
index 000000000..ba968befe
--- /dev/null
+++ b/src/neurology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** neurology_sci kernel module — tsb analytics library. */
+export interface NeurologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciKernelResult { values: number[]; converged: boolean; }
+export function computeNeurologySciKernel(data: number[], opts: NeurologySciKernelOptions = {}): NeurologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciKernel };
diff --git a/src/neurology_sci/laplacian.ts b/src/neurology_sci/laplacian.ts
new file mode 100644
index 000000000..4ea6f4d10
--- /dev/null
+++ b/src/neurology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** neurology_sci laplacian module — tsb analytics library. */
+export interface NeurologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeNeurologySciLaplacian(data: number[], opts: NeurologySciLaplacianOptions = {}): NeurologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciLaplacian };
diff --git a/src/neurology_sci/learning.ts b/src/neurology_sci/learning.ts
new file mode 100644
index 000000000..190f05ddb
--- /dev/null
+++ b/src/neurology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** neurology_sci learning module — tsb analytics library. */
+export interface NeurologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciLearningResult { values: number[]; converged: boolean; }
+export function computeNeurologySciLearning(data: number[], opts: NeurologySciLearningOptions = {}): NeurologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciLearning };
diff --git a/src/neurology_sci/linear.ts b/src/neurology_sci/linear.ts
new file mode 100644
index 000000000..67073e7ab
--- /dev/null
+++ b/src/neurology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** neurology_sci linear module — tsb analytics library. */
+export interface NeurologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciLinearResult { values: number[]; converged: boolean; }
+export function computeNeurologySciLinear(data: number[], opts: NeurologySciLinearOptions = {}): NeurologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciLinear };
diff --git a/src/neurology_sci/manifold.ts b/src/neurology_sci/manifold.ts
new file mode 100644
index 000000000..1b8e14d38
--- /dev/null
+++ b/src/neurology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** neurology_sci manifold module — tsb analytics library. */
+export interface NeurologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeNeurologySciManifold(data: number[], opts: NeurologySciManifoldOptions = {}): NeurologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciManifold };
diff --git a/src/neurology_sci/matching.ts b/src/neurology_sci/matching.ts
new file mode 100644
index 000000000..3e373150e
--- /dev/null
+++ b/src/neurology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** neurology_sci matching module — tsb analytics library. */
+export interface NeurologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciMatching(data: number[], opts: NeurologySciMatchingOptions = {}): NeurologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciMatching };
diff --git a/src/neurology_sci/measurement.ts b/src/neurology_sci/measurement.ts
new file mode 100644
index 000000000..6d73aca52
--- /dev/null
+++ b/src/neurology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** neurology_sci measurement module — tsb analytics library. */
+export interface NeurologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeNeurologySciMeasurement(data: number[], opts: NeurologySciMeasurementOptions = {}): NeurologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciMeasurement };
diff --git a/src/neurology_sci/metrics.ts b/src/neurology_sci/metrics.ts
new file mode 100644
index 000000000..a5087c032
--- /dev/null
+++ b/src/neurology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** neurology_sci metrics module — tsb analytics library. */
+export interface NeurologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeNeurologySciMetrics(data: number[], opts: NeurologySciMetricsOptions = {}): NeurologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciMetrics };
diff --git a/src/neurology_sci/modeling.ts b/src/neurology_sci/modeling.ts
new file mode 100644
index 000000000..37efaf423
--- /dev/null
+++ b/src/neurology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** neurology_sci modeling module — tsb analytics library. */
+export interface NeurologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciModelingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciModeling(data: number[], opts: NeurologySciModelingOptions = {}): NeurologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciModeling };
diff --git a/src/neurology_sci/monitoring.ts b/src/neurology_sci/monitoring.ts
new file mode 100644
index 000000000..17b836bf6
--- /dev/null
+++ b/src/neurology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** neurology_sci monitoring module — tsb analytics library. */
+export interface NeurologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeNeurologySciMonitoring(data: number[], opts: NeurologySciMonitoringOptions = {}): NeurologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciMonitoring };
diff --git a/src/neurology_sci/nonlinear.ts b/src/neurology_sci/nonlinear.ts
new file mode 100644
index 000000000..8a2b49d23
--- /dev/null
+++ b/src/neurology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** neurology_sci nonlinear module — tsb analytics library. */
+export interface NeurologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeNeurologySciNonlinear(data: number[], opts: NeurologySciNonlinearOptions = {}): NeurologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciNonlinear };
diff --git a/src/neurology_sci/normalization.ts b/src/neurology_sci/normalization.ts
new file mode 100644
index 000000000..9543d7b13
--- /dev/null
+++ b/src/neurology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** neurology_sci normalization module — tsb analytics library. */
+export interface NeurologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciNormalization(data: number[], opts: NeurologySciNormalizationOptions = {}): NeurologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciNormalization };
diff --git a/src/neurology_sci/optimization.ts b/src/neurology_sci/optimization.ts
new file mode 100644
index 000000000..b64c6fe85
--- /dev/null
+++ b/src/neurology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** neurology_sci optimization module — tsb analytics library. */
+export interface NeurologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciOptimization(data: number[], opts: NeurologySciOptimizationOptions = {}): NeurologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciOptimization };
diff --git a/src/neurology_sci/patterns.ts b/src/neurology_sci/patterns.ts
new file mode 100644
index 000000000..53e6627db
--- /dev/null
+++ b/src/neurology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** neurology_sci patterns module — tsb analytics library. */
+export interface NeurologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeNeurologySciPatterns(data: number[], opts: NeurologySciPatternsOptions = {}): NeurologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciPatterns };
diff --git a/src/neurology_sci/permutation.ts b/src/neurology_sci/permutation.ts
new file mode 100644
index 000000000..8bc8792c6
--- /dev/null
+++ b/src/neurology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci permutation module — tsb analytics library. */
+export interface NeurologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciPermutation(data: number[], opts: NeurologySciPermutationOptions = {}): NeurologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciPermutation };
diff --git a/src/neurology_sci/prediction.ts b/src/neurology_sci/prediction.ts
new file mode 100644
index 000000000..d7c53ca8b
--- /dev/null
+++ b/src/neurology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** neurology_sci prediction module — tsb analytics library. */
+export interface NeurologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciPrediction(data: number[], opts: NeurologySciPredictionOptions = {}): NeurologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciPrediction };
diff --git a/src/neurology_sci/processing.ts b/src/neurology_sci/processing.ts
new file mode 100644
index 000000000..dbbf0062e
--- /dev/null
+++ b/src/neurology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** neurology_sci processing module — tsb analytics library. */
+export interface NeurologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciProcessing(data: number[], opts: NeurologySciProcessingOptions = {}): NeurologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciProcessing };
diff --git a/src/neurology_sci/profiling.ts b/src/neurology_sci/profiling.ts
new file mode 100644
index 000000000..f5b8748c9
--- /dev/null
+++ b/src/neurology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** neurology_sci profiling module — tsb analytics library. */
+export interface NeurologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciProfiling(data: number[], opts: NeurologySciProfilingOptions = {}): NeurologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciProfiling };
diff --git a/src/neurology_sci/projection.ts b/src/neurology_sci/projection.ts
new file mode 100644
index 000000000..5cbda4c08
--- /dev/null
+++ b/src/neurology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** neurology_sci projection module — tsb analytics library. */
+export interface NeurologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciProjection(data: number[], opts: NeurologySciProjectionOptions = {}): NeurologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciProjection };
diff --git a/src/neurology_sci/ranking.ts b/src/neurology_sci/ranking.ts
new file mode 100644
index 000000000..bf24b24d6
--- /dev/null
+++ b/src/neurology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** neurology_sci ranking module — tsb analytics library. */
+export interface NeurologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciRankingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciRanking(data: number[], opts: NeurologySciRankingOptions = {}): NeurologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciRanking };
diff --git a/src/neurology_sci/reconstruction.ts b/src/neurology_sci/reconstruction.ts
new file mode 100644
index 000000000..dc738c514
--- /dev/null
+++ b/src/neurology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** neurology_sci reconstruction module — tsb analytics library. */
+export interface NeurologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciReconstruction(data: number[], opts: NeurologySciReconstructionOptions = {}): NeurologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciReconstruction };
diff --git a/src/neurology_sci/registration.ts b/src/neurology_sci/registration.ts
new file mode 100644
index 000000000..528645d01
--- /dev/null
+++ b/src/neurology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** neurology_sci registration module — tsb analytics library. */
+export interface NeurologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciRegistration(data: number[], opts: NeurologySciRegistrationOptions = {}): NeurologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciRegistration };
diff --git a/src/neurology_sci/regression.ts b/src/neurology_sci/regression.ts
new file mode 100644
index 000000000..f9d0848c7
--- /dev/null
+++ b/src/neurology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** neurology_sci regression module — tsb analytics library. */
+export interface NeurologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciRegression(data: number[], opts: NeurologySciRegressionOptions = {}): NeurologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciRegression };
diff --git a/src/neurology_sci/regularization.ts b/src/neurology_sci/regularization.ts
new file mode 100644
index 000000000..063815b54
--- /dev/null
+++ b/src/neurology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** neurology_sci regularization module — tsb analytics library. */
+export interface NeurologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciRegularization(data: number[], opts: NeurologySciRegularizationOptions = {}): NeurologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciRegularization };
diff --git a/src/neurology_sci/robustness.ts b/src/neurology_sci/robustness.ts
new file mode 100644
index 000000000..f1ff446ca
--- /dev/null
+++ b/src/neurology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** neurology_sci robustness module — tsb analytics library. */
+export interface NeurologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeNeurologySciRobustness(data: number[], opts: NeurologySciRobustnessOptions = {}): NeurologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciRobustness };
diff --git a/src/neurology_sci/sampling.ts b/src/neurology_sci/sampling.ts
new file mode 100644
index 000000000..eafc2ac28
--- /dev/null
+++ b/src/neurology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** neurology_sci sampling module — tsb analytics library. */
+export interface NeurologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciSampling(data: number[], opts: NeurologySciSamplingOptions = {}): NeurologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciSampling };
diff --git a/src/neurology_sci/sampling2.ts b/src/neurology_sci/sampling2.ts
new file mode 100644
index 000000000..7575036a6
--- /dev/null
+++ b/src/neurology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** neurology_sci sampling2 module — tsb analytics library. */
+export interface NeurologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciSampling(data: number[], opts: NeurologySciSamplingOptions = {}): NeurologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciSampling };
diff --git a/src/neurology_sci/scaling.ts b/src/neurology_sci/scaling.ts
new file mode 100644
index 000000000..c87c47a78
--- /dev/null
+++ b/src/neurology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** neurology_sci scaling module — tsb analytics library. */
+export interface NeurologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciScalingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciScaling(data: number[], opts: NeurologySciScalingOptions = {}): NeurologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciScaling };
diff --git a/src/neurology_sci/scoring.ts b/src/neurology_sci/scoring.ts
new file mode 100644
index 000000000..2d22f2c4b
--- /dev/null
+++ b/src/neurology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** neurology_sci scoring module — tsb analytics library. */
+export interface NeurologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciScoringResult { values: number[]; converged: boolean; }
+export function computeNeurologySciScoring(data: number[], opts: NeurologySciScoringOptions = {}): NeurologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciScoring };
diff --git a/src/neurology_sci/segmentation.ts b/src/neurology_sci/segmentation.ts
new file mode 100644
index 000000000..5f8275a80
--- /dev/null
+++ b/src/neurology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci segmentation module — tsb analytics library. */
+export interface NeurologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciSegmentation(data: number[], opts: NeurologySciSegmentationOptions = {}): NeurologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciSegmentation };
diff --git a/src/neurology_sci/selection.ts b/src/neurology_sci/selection.ts
new file mode 100644
index 000000000..7a31350c0
--- /dev/null
+++ b/src/neurology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** neurology_sci selection module — tsb analytics library. */
+export interface NeurologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeNeurologySciSelection(data: number[], opts: NeurologySciSelectionOptions = {}): NeurologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciSelection };
diff --git a/src/neurology_sci/sensitivity.ts b/src/neurology_sci/sensitivity.ts
new file mode 100644
index 000000000..aa00afeb9
--- /dev/null
+++ b/src/neurology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** neurology_sci sensitivity module — tsb analytics library. */
+export interface NeurologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeNeurologySciSensitivity(data: number[], opts: NeurologySciSensitivityOptions = {}): NeurologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciSensitivity };
diff --git a/src/neurology_sci/simulation.ts b/src/neurology_sci/simulation.ts
new file mode 100644
index 000000000..303ce37ad
--- /dev/null
+++ b/src/neurology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci simulation module — tsb analytics library. */
+export interface NeurologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciSimulation(data: number[], opts: NeurologySciSimulationOptions = {}): NeurologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciSimulation };
diff --git a/src/neurology_sci/smoothing.ts b/src/neurology_sci/smoothing.ts
new file mode 100644
index 000000000..99331b2a2
--- /dev/null
+++ b/src/neurology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** neurology_sci smoothing module — tsb analytics library. */
+export interface NeurologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciSmoothing(data: number[], opts: NeurologySciSmoothingOptions = {}): NeurologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciSmoothing };
diff --git a/src/neurology_sci/stability.ts b/src/neurology_sci/stability.ts
new file mode 100644
index 000000000..66ddf2c59
--- /dev/null
+++ b/src/neurology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** neurology_sci stability module — tsb analytics library. */
+export interface NeurologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeNeurologySciStability(data: number[], opts: NeurologySciStabilityOptions = {}): NeurologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciStability };
diff --git a/src/neurology_sci/stacking.ts b/src/neurology_sci/stacking.ts
new file mode 100644
index 000000000..512bce02a
--- /dev/null
+++ b/src/neurology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** neurology_sci stacking module — tsb analytics library. */
+export interface NeurologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciStackingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciStacking(data: number[], opts: NeurologySciStackingOptions = {}): NeurologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciStacking };
diff --git a/src/neurology_sci/standardization.ts b/src/neurology_sci/standardization.ts
new file mode 100644
index 000000000..165fa303e
--- /dev/null
+++ b/src/neurology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** neurology_sci standardization module — tsb analytics library. */
+export interface NeurologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciStandardization(data: number[], opts: NeurologySciStandardizationOptions = {}): NeurologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciStandardization };
diff --git a/src/neurology_sci/static.ts b/src/neurology_sci/static.ts
new file mode 100644
index 000000000..4458c6444
--- /dev/null
+++ b/src/neurology_sci/static.ts
@@ -0,0 +1,14 @@
+/** neurology_sci static module — tsb analytics library. */
+export interface NeurologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciStaticResult { values: number[]; converged: boolean; }
+export function computeNeurologySciStatic(data: number[], opts: NeurologySciStaticOptions = {}): NeurologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciStatic };
diff --git a/src/neurology_sci/stochastic.ts b/src/neurology_sci/stochastic.ts
new file mode 100644
index 000000000..cdaca2c4a
--- /dev/null
+++ b/src/neurology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** neurology_sci stochastic module — tsb analytics library. */
+export interface NeurologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeNeurologySciStochastic(data: number[], opts: NeurologySciStochasticOptions = {}): NeurologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciStochastic };
diff --git a/src/neurology_sci/synthesis.ts b/src/neurology_sci/synthesis.ts
new file mode 100644
index 000000000..a83f13088
--- /dev/null
+++ b/src/neurology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** neurology_sci synthesis module — tsb analytics library. */
+export interface NeurologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeNeurologySciSynthesis(data: number[], opts: NeurologySciSynthesisOptions = {}): NeurologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciSynthesis };
diff --git a/src/neurology_sci/topology.ts b/src/neurology_sci/topology.ts
new file mode 100644
index 000000000..f6a21aa94
--- /dev/null
+++ b/src/neurology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** neurology_sci topology module — tsb analytics library. */
+export interface NeurologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeNeurologySciTopology(data: number[], opts: NeurologySciTopologyOptions = {}): NeurologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciTopology };
diff --git a/src/neurology_sci/tracking.ts b/src/neurology_sci/tracking.ts
new file mode 100644
index 000000000..b8bfadd97
--- /dev/null
+++ b/src/neurology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** neurology_sci tracking module — tsb analytics library. */
+export interface NeurologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciTracking(data: number[], opts: NeurologySciTrackingOptions = {}): NeurologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciTracking };
diff --git a/src/neurology_sci/transform.ts b/src/neurology_sci/transform.ts
new file mode 100644
index 000000000..6c66d8e7e
--- /dev/null
+++ b/src/neurology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** neurology_sci transform module — tsb analytics library. */
+export interface NeurologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciTransformResult { values: number[]; converged: boolean; }
+export function computeNeurologySciTransform(data: number[], opts: NeurologySciTransformOptions = {}): NeurologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciTransform };
diff --git a/src/neurology_sci/uncertainty.ts b/src/neurology_sci/uncertainty.ts
new file mode 100644
index 000000000..4482ec7e3
--- /dev/null
+++ b/src/neurology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** neurology_sci uncertainty module — tsb analytics library. */
+export interface NeurologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeNeurologySciUncertainty(data: number[], opts: NeurologySciUncertaintyOptions = {}): NeurologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciUncertainty };
diff --git a/src/neurology_sci/validation.ts b/src/neurology_sci/validation.ts
new file mode 100644
index 000000000..9f5c2f0a6
--- /dev/null
+++ b/src/neurology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** neurology_sci validation module — tsb analytics library. */
+export interface NeurologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciValidationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciValidation(data: number[], opts: NeurologySciValidationOptions = {}): NeurologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciValidation };
diff --git a/src/neurology_sci/verification.ts b/src/neurology_sci/verification.ts
new file mode 100644
index 000000000..92aa06ed6
--- /dev/null
+++ b/src/neurology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** neurology_sci verification module — tsb analytics library. */
+export interface NeurologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciVerification(data: number[], opts: NeurologySciVerificationOptions = {}): NeurologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciVerification };
diff --git a/src/neurology_sci/visualization.ts b/src/neurology_sci/visualization.ts
new file mode 100644
index 000000000..449e4c407
--- /dev/null
+++ b/src/neurology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** neurology_sci visualization module — tsb analytics library. */
+export interface NeurologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeNeurologySciVisualization(data: number[], opts: NeurologySciVisualizationOptions = {}): NeurologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciVisualization };
diff --git a/src/neurology_sci/voting.ts b/src/neurology_sci/voting.ts
new file mode 100644
index 000000000..bfe53e09d
--- /dev/null
+++ b/src/neurology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** neurology_sci voting module — tsb analytics library. */
+export interface NeurologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciVotingResult { values: number[]; converged: boolean; }
+export function computeNeurologySciVoting(data: number[], opts: NeurologySciVotingOptions = {}): NeurologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciVoting };
diff --git a/src/neurology_sci/wavelet.ts b/src/neurology_sci/wavelet.ts
new file mode 100644
index 000000000..6007b1b2a
--- /dev/null
+++ b/src/neurology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** neurology_sci wavelet module — tsb analytics library. */
+export interface NeurologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface NeurologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeNeurologySciWavelet(data: number[], opts: NeurologySciWaveletOptions = {}): NeurologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNeurologySciWavelet };
diff --git a/src/nlp/advanced.ts b/src/nlp/advanced.ts
new file mode 100644
index 000000000..92cee5b27
--- /dev/null
+++ b/src/nlp/advanced.ts
@@ -0,0 +1,15 @@
+/** Nlp Advanced module — tsb analytics library. */
+export interface Nlp advancedOptions { tol?: number; maxIter?: number; }
+export interface Nlp advancedResult { values: number[]; converged: boolean; }
+export function computeNlp advanced(data: number[], opts: Nlp advancedOptions = {}): Nlp advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp advanced };
diff --git a/src/nlp/attention.ts b/src/nlp/attention.ts
new file mode 100644
index 000000000..88e23263b
--- /dev/null
+++ b/src/nlp/attention.ts
@@ -0,0 +1,22 @@
+/** Attention module — tsb analytics library. */
+
+/** Options for Attention. */
+export interface AttentionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Attention. */
+export interface AttentionResult { values: number[]; converged: boolean; }
+
+/** Compute Attention. */
+export function computeAttention(data: number[], opts: AttentionOptions = {}): AttentionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAttention };
diff --git a/src/nlp/base2.ts b/src/nlp/base2.ts
new file mode 100644
index 000000000..5c942aea6
--- /dev/null
+++ b/src/nlp/base2.ts
@@ -0,0 +1,15 @@
+/** Nlp Base2 module — tsb analytics library. */
+export interface Nlp base2Options { tol?: number; maxIter?: number; }
+export interface Nlp base2Result { values: number[]; converged: boolean; }
+export function computeNlp base2(data: number[], opts: Nlp base2Options = {}): Nlp base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp base2 };
diff --git a/src/nlp/batch.ts b/src/nlp/batch.ts
new file mode 100644
index 000000000..b782954b9
--- /dev/null
+++ b/src/nlp/batch.ts
@@ -0,0 +1,15 @@
+/** Nlp Batch module — tsb analytics library. */
+export interface Nlp batchOptions { tol?: number; maxIter?: number; }
+export interface Nlp batchResult { values: number[]; converged: boolean; }
+export function computeNlp batch(data: number[], opts: Nlp batchOptions = {}): Nlp batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp batch };
diff --git a/src/nlp/beta.ts b/src/nlp/beta.ts
new file mode 100644
index 000000000..063cc81ce
--- /dev/null
+++ b/src/nlp/beta.ts
@@ -0,0 +1,15 @@
+/** Nlp Beta module — tsb analytics library. */
+export interface Nlp betaOptions { tol?: number; maxIter?: number; }
+export interface Nlp betaResult { values: number[]; converged: boolean; }
+export function computeNlp beta(data: number[], opts: Nlp betaOptions = {}): Nlp betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp beta };
diff --git a/src/nlp/chatbot.ts b/src/nlp/chatbot.ts
new file mode 100644
index 000000000..d71f75ae1
--- /dev/null
+++ b/src/nlp/chatbot.ts
@@ -0,0 +1,22 @@
+/** Chatbot module — tsb analytics library. */
+
+/** Options for Chatbot. */
+export interface ChatbotOptions { tol?: number; maxIter?: number; }
+
+/** Result from Chatbot. */
+export interface ChatbotResult { values: number[]; converged: boolean; }
+
+/** Compute Chatbot. */
+export function computeChatbot(data: number[], opts: ChatbotOptions = {}): ChatbotResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeChatbot };
diff --git a/src/nlp/classifier.ts b/src/nlp/classifier.ts
new file mode 100644
index 000000000..a2adf9b30
--- /dev/null
+++ b/src/nlp/classifier.ts
@@ -0,0 +1,22 @@
+/** Classifier module — tsb analytics library. */
+
+/** Options for Classifier. */
+export interface ClassifierOptions { tol?: number; maxIter?: number; }
+
+/** Result from Classifier. */
+export interface ClassifierResult { values: number[]; converged: boolean; }
+
+/** Compute Classifier. */
+export function computeClassifier(data: number[], opts: ClassifierOptions = {}): ClassifierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClassifier };
diff --git a/src/nlp/coreference.ts b/src/nlp/coreference.ts
new file mode 100644
index 000000000..0abb24a96
--- /dev/null
+++ b/src/nlp/coreference.ts
@@ -0,0 +1,22 @@
+/** Coreference module — tsb analytics library. */
+
+/** Options for Coreference. */
+export interface CoreferenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coreference. */
+export interface CoreferenceResult { values: number[]; converged: boolean; }
+
+/** Compute Coreference. */
+export function computeCoreference(data: number[], opts: CoreferenceOptions = {}): CoreferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCoreference };
diff --git a/src/nlp/cpu.ts b/src/nlp/cpu.ts
new file mode 100644
index 000000000..68b5a6c33
--- /dev/null
+++ b/src/nlp/cpu.ts
@@ -0,0 +1,15 @@
+/** Nlp Cpu module — tsb analytics library. */
+export interface Nlp cpuOptions { tol?: number; maxIter?: number; }
+export interface Nlp cpuResult { values: number[]; converged: boolean; }
+export function computeNlp cpu(data: number[], opts: Nlp cpuOptions = {}): Nlp cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp cpu };
diff --git a/src/nlp/dense.ts b/src/nlp/dense.ts
new file mode 100644
index 000000000..f1097fa9f
--- /dev/null
+++ b/src/nlp/dense.ts
@@ -0,0 +1,15 @@
+/** Nlp Dense module — tsb analytics library. */
+export interface Nlp denseOptions { tol?: number; maxIter?: number; }
+export interface Nlp denseResult { values: number[]; converged: boolean; }
+export function computeNlp dense(data: number[], opts: Nlp denseOptions = {}): Nlp denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp dense };
diff --git a/src/nlp/dialogue.ts b/src/nlp/dialogue.ts
new file mode 100644
index 000000000..0a3891f1f
--- /dev/null
+++ b/src/nlp/dialogue.ts
@@ -0,0 +1,22 @@
+/** Dialogue module — tsb analytics library. */
+
+/** Options for Dialogue. */
+export interface DialogueOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dialogue. */
+export interface DialogueResult { values: number[]; converged: boolean; }
+
+/** Compute Dialogue. */
+export function computeDialogue(data: number[], opts: DialogueOptions = {}): DialogueResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDialogue };
diff --git a/src/nlp/distributed.ts b/src/nlp/distributed.ts
new file mode 100644
index 000000000..11b9cfaef
--- /dev/null
+++ b/src/nlp/distributed.ts
@@ -0,0 +1,15 @@
+/** Nlp Distributed module — tsb analytics library. */
+export interface Nlp distributedOptions { tol?: number; maxIter?: number; }
+export interface Nlp distributedResult { values: number[]; converged: boolean; }
+export function computeNlp distributed(data: number[], opts: Nlp distributedOptions = {}): Nlp distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp distributed };
diff --git a/src/nlp/embeddings.ts b/src/nlp/embeddings.ts
new file mode 100644
index 000000000..0a0688f97
--- /dev/null
+++ b/src/nlp/embeddings.ts
@@ -0,0 +1,22 @@
+/** Embeddings module — tsb analytics library. */
+
+/** Options for Embeddings. */
+export interface EmbeddingsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Embeddings. */
+export interface EmbeddingsResult { values: number[]; converged: boolean; }
+
+/** Compute Embeddings. */
+export function computeEmbeddings(data: number[], opts: EmbeddingsOptions = {}): EmbeddingsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEmbeddings };
diff --git a/src/nlp/entity.ts b/src/nlp/entity.ts
new file mode 100644
index 000000000..d1d7dd7bd
--- /dev/null
+++ b/src/nlp/entity.ts
@@ -0,0 +1,22 @@
+/** Entity module — tsb analytics library. */
+
+/** Options for Entity. */
+export interface EntityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Entity. */
+export interface EntityResult { values: number[]; converged: boolean; }
+
+/** Compute Entity. */
+export function computeEntity(data: number[], opts: EntityOptions = {}): EntityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEntity };
diff --git a/src/nlp/experimental.ts b/src/nlp/experimental.ts
new file mode 100644
index 000000000..6861075cf
--- /dev/null
+++ b/src/nlp/experimental.ts
@@ -0,0 +1,15 @@
+/** Nlp Experimental module — tsb analytics library. */
+export interface Nlp experimentalOptions { tol?: number; maxIter?: number; }
+export interface Nlp experimentalResult { values: number[]; converged: boolean; }
+export function computeNlp experimental(data: number[], opts: Nlp experimentalOptions = {}): Nlp experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp experimental };
diff --git a/src/nlp/fast.ts b/src/nlp/fast.ts
new file mode 100644
index 000000000..8112befb6
--- /dev/null
+++ b/src/nlp/fast.ts
@@ -0,0 +1,15 @@
+/** Nlp Fast module — tsb analytics library. */
+export interface Nlp fastOptions { tol?: number; maxIter?: number; }
+export interface Nlp fastResult { values: number[]; converged: boolean; }
+export function computeNlp fast(data: number[], opts: Nlp fastOptions = {}): Nlp fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp fast };
diff --git a/src/nlp/future.ts b/src/nlp/future.ts
new file mode 100644
index 000000000..ae2ef177e
--- /dev/null
+++ b/src/nlp/future.ts
@@ -0,0 +1,15 @@
+/** Nlp Future module — tsb analytics library. */
+export interface Nlp futureOptions { tol?: number; maxIter?: number; }
+export interface Nlp futureResult { values: number[]; converged: boolean; }
+export function computeNlp future(data: number[], opts: Nlp futureOptions = {}): Nlp futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp future };
diff --git a/src/nlp/generation.ts b/src/nlp/generation.ts
new file mode 100644
index 000000000..2b8e594c8
--- /dev/null
+++ b/src/nlp/generation.ts
@@ -0,0 +1,22 @@
+/** Generation module — tsb analytics library. */
+
+/** Options for Generation. */
+export interface GenerationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Generation. */
+export interface GenerationResult { values: number[]; converged: boolean; }
+
+/** Compute Generation. */
+export function computeGeneration(data: number[], opts: GenerationOptions = {}): GenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeneration };
diff --git a/src/nlp/gpu.ts b/src/nlp/gpu.ts
new file mode 100644
index 000000000..10847e1c7
--- /dev/null
+++ b/src/nlp/gpu.ts
@@ -0,0 +1,15 @@
+/** Nlp Gpu module — tsb analytics library. */
+export interface Nlp gpuOptions { tol?: number; maxIter?: number; }
+export interface Nlp gpuResult { values: number[]; converged: boolean; }
+export function computeNlp gpu(data: number[], opts: Nlp gpuOptions = {}): Nlp gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp gpu };
diff --git a/src/nlp/intent.ts b/src/nlp/intent.ts
new file mode 100644
index 000000000..83f6bf08f
--- /dev/null
+++ b/src/nlp/intent.ts
@@ -0,0 +1,22 @@
+/** Intent module — tsb analytics library. */
+
+/** Options for Intent. */
+export interface IntentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Intent. */
+export interface IntentResult { values: number[]; converged: boolean; }
+
+/** Compute Intent. */
+export function computeIntent(data: number[], opts: IntentOptions = {}): IntentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIntent };
diff --git a/src/nlp/language_model.ts b/src/nlp/language_model.ts
new file mode 100644
index 000000000..6fd9a96da
--- /dev/null
+++ b/src/nlp/language_model.ts
@@ -0,0 +1,22 @@
+/** Language Model module — tsb analytics library. */
+
+/** Options for Language Model. */
+export interface LanguageModelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Language Model. */
+export interface LanguageModelResult { values: number[]; converged: boolean; }
+
+/** Compute Language Model. */
+export function computeLanguageModel(data: number[], opts: LanguageModelOptions = {}): LanguageModelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLanguageModel };
diff --git a/src/nlp/large.ts b/src/nlp/large.ts
new file mode 100644
index 000000000..d1c1ad168
--- /dev/null
+++ b/src/nlp/large.ts
@@ -0,0 +1,15 @@
+/** Nlp Large module — tsb analytics library. */
+export interface Nlp largeOptions { tol?: number; maxIter?: number; }
+export interface Nlp largeResult { values: number[]; converged: boolean; }
+export function computeNlp large(data: number[], opts: Nlp largeOptions = {}): Nlp largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp large };
diff --git a/src/nlp/legacy.ts b/src/nlp/legacy.ts
new file mode 100644
index 000000000..e5b60e9a6
--- /dev/null
+++ b/src/nlp/legacy.ts
@@ -0,0 +1,15 @@
+/** Nlp Legacy module — tsb analytics library. */
+export interface Nlp legacyOptions { tol?: number; maxIter?: number; }
+export interface Nlp legacyResult { values: number[]; converged: boolean; }
+export function computeNlp legacy(data: number[], opts: Nlp legacyOptions = {}): Nlp legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp legacy };
diff --git a/src/nlp/lemmatizer.ts b/src/nlp/lemmatizer.ts
new file mode 100644
index 000000000..c94a68ec2
--- /dev/null
+++ b/src/nlp/lemmatizer.ts
@@ -0,0 +1,22 @@
+/** Lemmatizer module — tsb analytics library. */
+
+/** Options for Lemmatizer. */
+export interface LemmatizerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lemmatizer. */
+export interface LemmatizerResult { values: number[]; converged: boolean; }
+
+/** Compute Lemmatizer. */
+export function computeLemmatizer(data: number[], opts: LemmatizerOptions = {}): LemmatizerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLemmatizer };
diff --git a/src/nlp/lite.ts b/src/nlp/lite.ts
new file mode 100644
index 000000000..07b2cbe09
--- /dev/null
+++ b/src/nlp/lite.ts
@@ -0,0 +1,15 @@
+/** Nlp Lite module — tsb analytics library. */
+export interface Nlp liteOptions { tol?: number; maxIter?: number; }
+export interface Nlp liteResult { values: number[]; converged: boolean; }
+export function computeNlp lite(data: number[], opts: Nlp liteOptions = {}): Nlp liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp lite };
diff --git a/src/nlp/mini.ts b/src/nlp/mini.ts
new file mode 100644
index 000000000..799e9c69d
--- /dev/null
+++ b/src/nlp/mini.ts
@@ -0,0 +1,15 @@
+/** Nlp Mini module — tsb analytics library. */
+export interface Nlp miniOptions { tol?: number; maxIter?: number; }
+export interface Nlp miniResult { values: number[]; converged: boolean; }
+export function computeNlp mini(data: number[], opts: Nlp miniOptions = {}): Nlp miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp mini };
diff --git a/src/nlp/ner.ts b/src/nlp/ner.ts
new file mode 100644
index 000000000..9fce7693a
--- /dev/null
+++ b/src/nlp/ner.ts
@@ -0,0 +1,22 @@
+/** Ner module — tsb analytics library. */
+
+/** Options for Ner. */
+export interface NerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ner. */
+export interface NerResult { values: number[]; converged: boolean; }
+
+/** Compute Ner. */
+export function computeNer(data: number[], opts: NerOptions = {}): NerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNer };
diff --git a/src/nlp/next.ts b/src/nlp/next.ts
new file mode 100644
index 000000000..ff1793ff7
--- /dev/null
+++ b/src/nlp/next.ts
@@ -0,0 +1,15 @@
+/** Nlp Next module — tsb analytics library. */
+export interface Nlp nextOptions { tol?: number; maxIter?: number; }
+export interface Nlp nextResult { values: number[]; converged: boolean; }
+export function computeNlp next(data: number[], opts: Nlp nextOptions = {}): Nlp nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp next };
diff --git a/src/nlp/nli.ts b/src/nlp/nli.ts
new file mode 100644
index 000000000..e64cb844a
--- /dev/null
+++ b/src/nlp/nli.ts
@@ -0,0 +1,22 @@
+/** Nli module — tsb analytics library. */
+
+/** Options for Nli. */
+export interface NliOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nli. */
+export interface NliResult { values: number[]; converged: boolean; }
+
+/** Compute Nli. */
+export function computeNli(data: number[], opts: NliOptions = {}): NliResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNli };
diff --git a/src/nlp/online.ts b/src/nlp/online.ts
new file mode 100644
index 000000000..e71a9689d
--- /dev/null
+++ b/src/nlp/online.ts
@@ -0,0 +1,15 @@
+/** Nlp Online module — tsb analytics library. */
+export interface Nlp onlineOptions { tol?: number; maxIter?: number; }
+export interface Nlp onlineResult { values: number[]; converged: boolean; }
+export function computeNlp online(data: number[], opts: Nlp onlineOptions = {}): Nlp onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp online };
diff --git a/src/nlp/parallel.ts b/src/nlp/parallel.ts
new file mode 100644
index 000000000..1460caa68
--- /dev/null
+++ b/src/nlp/parallel.ts
@@ -0,0 +1,15 @@
+/** Nlp Parallel module — tsb analytics library. */
+export interface Nlp parallelOptions { tol?: number; maxIter?: number; }
+export interface Nlp parallelResult { values: number[]; converged: boolean; }
+export function computeNlp parallel(data: number[], opts: Nlp parallelOptions = {}): Nlp parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp parallel };
diff --git a/src/nlp/parsing.ts b/src/nlp/parsing.ts
new file mode 100644
index 000000000..8b5664f9e
--- /dev/null
+++ b/src/nlp/parsing.ts
@@ -0,0 +1,22 @@
+/** Parsing module — tsb analytics library. */
+
+/** Options for Parsing. */
+export interface ParsingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Parsing. */
+export interface ParsingResult { values: number[]; converged: boolean; }
+
+/** Compute Parsing. */
+export function computeParsing(data: number[], opts: ParsingOptions = {}): ParsingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeParsing };
diff --git a/src/nlp/plus.ts b/src/nlp/plus.ts
new file mode 100644
index 000000000..c3b773580
--- /dev/null
+++ b/src/nlp/plus.ts
@@ -0,0 +1,15 @@
+/** Nlp Plus module — tsb analytics library. */
+export interface Nlp plusOptions { tol?: number; maxIter?: number; }
+export interface Nlp plusResult { values: number[]; converged: boolean; }
+export function computeNlp plus(data: number[], opts: Nlp plusOptions = {}): Nlp plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp plus };
diff --git a/src/nlp/pos_tagger.ts b/src/nlp/pos_tagger.ts
new file mode 100644
index 000000000..5b5e127b8
--- /dev/null
+++ b/src/nlp/pos_tagger.ts
@@ -0,0 +1,22 @@
+/** Pos Tagger module — tsb analytics library. */
+
+/** Options for Pos Tagger. */
+export interface PosTaggerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pos Tagger. */
+export interface PosTaggerResult { values: number[]; converged: boolean; }
+
+/** Compute Pos Tagger. */
+export function computePosTagger(data: number[], opts: PosTaggerOptions = {}): PosTaggerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePosTagger };
diff --git a/src/nlp/pro.ts b/src/nlp/pro.ts
new file mode 100644
index 000000000..b5af25ec5
--- /dev/null
+++ b/src/nlp/pro.ts
@@ -0,0 +1,15 @@
+/** Nlp Pro module — tsb analytics library. */
+export interface Nlp proOptions { tol?: number; maxIter?: number; }
+export interface Nlp proResult { values: number[]; converged: boolean; }
+export function computeNlp pro(data: number[], opts: Nlp proOptions = {}): Nlp proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp pro };
diff --git a/src/nlp/qa.ts b/src/nlp/qa.ts
new file mode 100644
index 000000000..af4d42db6
--- /dev/null
+++ b/src/nlp/qa.ts
@@ -0,0 +1,22 @@
+/** Qa module — tsb analytics library. */
+
+/** Options for Qa. */
+export interface QaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Qa. */
+export interface QaResult { values: number[]; converged: boolean; }
+
+/** Compute Qa. */
+export function computeQa(data: number[], opts: QaOptions = {}): QaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQa };
diff --git a/src/nlp/reranking.ts b/src/nlp/reranking.ts
new file mode 100644
index 000000000..a970331d1
--- /dev/null
+++ b/src/nlp/reranking.ts
@@ -0,0 +1,22 @@
+/** Reranking module — tsb analytics library. */
+
+/** Options for Reranking. */
+export interface RerankingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reranking. */
+export interface RerankingResult { values: number[]; converged: boolean; }
+
+/** Compute Reranking. */
+export function computeReranking(data: number[], opts: RerankingOptions = {}): RerankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReranking };
diff --git a/src/nlp/retrieval.ts b/src/nlp/retrieval.ts
new file mode 100644
index 000000000..d89ed60de
--- /dev/null
+++ b/src/nlp/retrieval.ts
@@ -0,0 +1,22 @@
+/** Retrieval module — tsb analytics library. */
+
+/** Options for Retrieval. */
+export interface RetrievalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Retrieval. */
+export interface RetrievalResult { values: number[]; converged: boolean; }
+
+/** Compute Retrieval. */
+export function computeRetrieval(data: number[], opts: RetrievalOptions = {}): RetrievalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRetrieval };
diff --git a/src/nlp/robust.ts b/src/nlp/robust.ts
new file mode 100644
index 000000000..36b95e29f
--- /dev/null
+++ b/src/nlp/robust.ts
@@ -0,0 +1,15 @@
+/** Nlp Robust module — tsb analytics library. */
+export interface Nlp robustOptions { tol?: number; maxIter?: number; }
+export interface Nlp robustResult { values: number[]; converged: boolean; }
+export function computeNlp robust(data: number[], opts: Nlp robustOptions = {}): Nlp robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp robust };
diff --git a/src/nlp/sentiment.ts b/src/nlp/sentiment.ts
new file mode 100644
index 000000000..07d145916
--- /dev/null
+++ b/src/nlp/sentiment.ts
@@ -0,0 +1,22 @@
+/** Sentiment module — tsb analytics library. */
+
+/** Options for Sentiment. */
+export interface SentimentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sentiment. */
+export interface SentimentResult { values: number[]; converged: boolean; }
+
+/** Compute Sentiment. */
+export function computeSentiment(data: number[], opts: SentimentOptions = {}): SentimentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSentiment };
diff --git a/src/nlp/seq2seq.ts b/src/nlp/seq2seq.ts
new file mode 100644
index 000000000..96ca538f4
--- /dev/null
+++ b/src/nlp/seq2seq.ts
@@ -0,0 +1,22 @@
+/** Seq2Seq module — tsb analytics library. */
+
+/** Options for Seq2Seq. */
+export interface Seq2seqOptions { tol?: number; maxIter?: number; }
+
+/** Result from Seq2Seq. */
+export interface Seq2seqResult { values: number[]; converged: boolean; }
+
+/** Compute Seq2Seq. */
+export function computeSeq2seq(data: number[], opts: Seq2seqOptions = {}): Seq2seqResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeq2seq };
diff --git a/src/nlp/slot.ts b/src/nlp/slot.ts
new file mode 100644
index 000000000..a4151be4b
--- /dev/null
+++ b/src/nlp/slot.ts
@@ -0,0 +1,22 @@
+/** Slot module — tsb analytics library. */
+
+/** Options for Slot. */
+export interface SlotOptions { tol?: number; maxIter?: number; }
+
+/** Result from Slot. */
+export interface SlotResult { values: number[]; converged: boolean; }
+
+/** Compute Slot. */
+export function computeSlot(data: number[], opts: SlotOptions = {}): SlotResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSlot };
diff --git a/src/nlp/small.ts b/src/nlp/small.ts
new file mode 100644
index 000000000..1bf133e88
--- /dev/null
+++ b/src/nlp/small.ts
@@ -0,0 +1,15 @@
+/** Nlp Small module — tsb analytics library. */
+export interface Nlp smallOptions { tol?: number; maxIter?: number; }
+export interface Nlp smallResult { values: number[]; converged: boolean; }
+export function computeNlp small(data: number[], opts: Nlp smallOptions = {}): Nlp smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp small };
diff --git a/src/nlp/sparse.ts b/src/nlp/sparse.ts
new file mode 100644
index 000000000..5569caa86
--- /dev/null
+++ b/src/nlp/sparse.ts
@@ -0,0 +1,15 @@
+/** Nlp Sparse module — tsb analytics library. */
+export interface Nlp sparseOptions { tol?: number; maxIter?: number; }
+export interface Nlp sparseResult { values: number[]; converged: boolean; }
+export function computeNlp sparse(data: number[], opts: Nlp sparseOptions = {}): Nlp sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp sparse };
diff --git a/src/nlp/srl.ts b/src/nlp/srl.ts
new file mode 100644
index 000000000..fed7025d9
--- /dev/null
+++ b/src/nlp/srl.ts
@@ -0,0 +1,22 @@
+/** Srl module — tsb analytics library. */
+
+/** Options for Srl. */
+export interface SrlOptions { tol?: number; maxIter?: number; }
+
+/** Result from Srl. */
+export interface SrlResult { values: number[]; converged: boolean; }
+
+/** Compute Srl. */
+export function computeSrl(data: number[], opts: SrlOptions = {}): SrlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSrl };
diff --git a/src/nlp/stable.ts b/src/nlp/stable.ts
new file mode 100644
index 000000000..0978a4d25
--- /dev/null
+++ b/src/nlp/stable.ts
@@ -0,0 +1,15 @@
+/** Nlp Stable module — tsb analytics library. */
+export interface Nlp stableOptions { tol?: number; maxIter?: number; }
+export interface Nlp stableResult { values: number[]; converged: boolean; }
+export function computeNlp stable(data: number[], opts: Nlp stableOptions = {}): Nlp stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp stable };
diff --git a/src/nlp/stemmer.ts b/src/nlp/stemmer.ts
new file mode 100644
index 000000000..9f181d3b6
--- /dev/null
+++ b/src/nlp/stemmer.ts
@@ -0,0 +1,22 @@
+/** Stemmer module — tsb analytics library. */
+
+/** Options for Stemmer. */
+export interface StemmerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stemmer. */
+export interface StemmerResult { values: number[]; converged: boolean; }
+
+/** Compute Stemmer. */
+export function computeStemmer(data: number[], opts: StemmerOptions = {}): StemmerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStemmer };
diff --git a/src/nlp/streaming.ts b/src/nlp/streaming.ts
new file mode 100644
index 000000000..830b535f4
--- /dev/null
+++ b/src/nlp/streaming.ts
@@ -0,0 +1,15 @@
+/** Nlp Streaming module — tsb analytics library. */
+export interface Nlp streamingOptions { tol?: number; maxIter?: number; }
+export interface Nlp streamingResult { values: number[]; converged: boolean; }
+export function computeNlp streaming(data: number[], opts: Nlp streamingOptions = {}): Nlp streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp streaming };
diff --git a/src/nlp/sts.ts b/src/nlp/sts.ts
new file mode 100644
index 000000000..49b476a75
--- /dev/null
+++ b/src/nlp/sts.ts
@@ -0,0 +1,22 @@
+/** Sts module — tsb analytics library. */
+
+/** Options for Sts. */
+export interface StsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sts. */
+export interface StsResult { values: number[]; converged: boolean; }
+
+/** Compute Sts. */
+export function computeSts(data: number[], opts: StsOptions = {}): StsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSts };
diff --git a/src/nlp/summarizer.ts b/src/nlp/summarizer.ts
new file mode 100644
index 000000000..efba692cd
--- /dev/null
+++ b/src/nlp/summarizer.ts
@@ -0,0 +1,22 @@
+/** Summarizer module — tsb analytics library. */
+
+/** Options for Summarizer. */
+export interface SummarizerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Summarizer. */
+export interface SummarizerResult { values: number[]; converged: boolean; }
+
+/** Compute Summarizer. */
+export function computeSummarizer(data: number[], opts: SummarizerOptions = {}): SummarizerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSummarizer };
diff --git a/src/nlp/tokenizer.ts b/src/nlp/tokenizer.ts
new file mode 100644
index 000000000..19937a8a8
--- /dev/null
+++ b/src/nlp/tokenizer.ts
@@ -0,0 +1,22 @@
+/** Tokenizer module — tsb analytics library. */
+
+/** Options for Tokenizer. */
+export interface TokenizerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tokenizer. */
+export interface TokenizerResult { values: number[]; converged: boolean; }
+
+/** Compute Tokenizer. */
+export function computeTokenizer(data: number[], opts: TokenizerOptions = {}): TokenizerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTokenizer };
diff --git a/src/nlp/topic_model.ts b/src/nlp/topic_model.ts
new file mode 100644
index 000000000..cdb7d44d0
--- /dev/null
+++ b/src/nlp/topic_model.ts
@@ -0,0 +1,22 @@
+/** Topic Model module — tsb analytics library. */
+
+/** Options for Topic Model. */
+export interface TopicModelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Topic Model. */
+export interface TopicModelResult { values: number[]; converged: boolean; }
+
+/** Compute Topic Model. */
+export function computeTopicModel(data: number[], opts: TopicModelOptions = {}): TopicModelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTopicModel };
diff --git a/src/nlp/transformer.ts b/src/nlp/transformer.ts
new file mode 100644
index 000000000..ae644e5c4
--- /dev/null
+++ b/src/nlp/transformer.ts
@@ -0,0 +1,22 @@
+/** Transformer module — tsb analytics library. */
+
+/** Options for Transformer. */
+export interface TransformerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Transformer. */
+export interface TransformerResult { values: number[]; converged: boolean; }
+
+/** Compute Transformer. */
+export function computeTransformer(data: number[], opts: TransformerOptions = {}): TransformerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTransformer };
diff --git a/src/nlp/translation.ts b/src/nlp/translation.ts
new file mode 100644
index 000000000..95026cb1e
--- /dev/null
+++ b/src/nlp/translation.ts
@@ -0,0 +1,22 @@
+/** Translation module — tsb analytics library. */
+
+/** Options for Translation. */
+export interface TranslationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Translation. */
+export interface TranslationResult { values: number[]; converged: boolean; }
+
+/** Compute Translation. */
+export function computeTranslation(data: number[], opts: TranslationOptions = {}): TranslationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTranslation };
diff --git a/src/nlp/v2.ts b/src/nlp/v2.ts
new file mode 100644
index 000000000..a494c144d
--- /dev/null
+++ b/src/nlp/v2.ts
@@ -0,0 +1,15 @@
+/** Nlp V2 module — tsb analytics library. */
+export interface Nlp v2Options { tol?: number; maxIter?: number; }
+export interface Nlp v2Result { values: number[]; converged: boolean; }
+export function computeNlp v2(data: number[], opts: Nlp v2Options = {}): Nlp v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp v2 };
diff --git a/src/nlp/v3.ts b/src/nlp/v3.ts
new file mode 100644
index 000000000..0665f0dc0
--- /dev/null
+++ b/src/nlp/v3.ts
@@ -0,0 +1,15 @@
+/** Nlp V3 module — tsb analytics library. */
+export interface Nlp v3Options { tol?: number; maxIter?: number; }
+export interface Nlp v3Result { values: number[]; converged: boolean; }
+export function computeNlp v3(data: number[], opts: Nlp v3Options = {}): Nlp v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp v3 };
diff --git a/src/nlp/wasm.ts b/src/nlp/wasm.ts
new file mode 100644
index 000000000..0cd625e0d
--- /dev/null
+++ b/src/nlp/wasm.ts
@@ -0,0 +1,15 @@
+/** Nlp Wasm module — tsb analytics library. */
+export interface Nlp wasmOptions { tol?: number; maxIter?: number; }
+export interface Nlp wasmResult { values: number[]; converged: boolean; }
+export function computeNlp wasm(data: number[], opts: Nlp wasmOptions = {}): Nlp wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp wasm };
diff --git a/src/nlp/wsd.ts b/src/nlp/wsd.ts
new file mode 100644
index 000000000..f70ac5c02
--- /dev/null
+++ b/src/nlp/wsd.ts
@@ -0,0 +1,22 @@
+/** Wsd module — tsb analytics library. */
+
+/** Options for Wsd. */
+export interface WsdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Wsd. */
+export interface WsdResult { values: number[]; converged: boolean; }
+
+/** Compute Wsd. */
+export function computeWsd(data: number[], opts: WsdOptions = {}): WsdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWsd };
diff --git a/src/nlp/xlarge.ts b/src/nlp/xlarge.ts
new file mode 100644
index 000000000..a9242035e
--- /dev/null
+++ b/src/nlp/xlarge.ts
@@ -0,0 +1,15 @@
+/** Nlp Xlarge module — tsb analytics library. */
+export interface Nlp xlargeOptions { tol?: number; maxIter?: number; }
+export interface Nlp xlargeResult { values: number[]; converged: boolean; }
+export function computeNlp xlarge(data: number[], opts: Nlp xlargeOptions = {}): Nlp xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNlp xlarge };
diff --git a/src/nutritional_sci/adaptation.ts b/src/nutritional_sci/adaptation.ts
new file mode 100644
index 000000000..2c729046f
--- /dev/null
+++ b/src/nutritional_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci adaptation module — tsb analytics library. */
+export interface NutritionalSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciAdaptation(data: number[], opts: NutritionalSciAdaptationOptions = {}): NutritionalSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciAdaptation };
diff --git a/src/nutritional_sci/aggregation.ts b/src/nutritional_sci/aggregation.ts
new file mode 100644
index 000000000..a1384c711
--- /dev/null
+++ b/src/nutritional_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci aggregation module — tsb analytics library. */
+export interface NutritionalSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciAggregationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciAggregation(data: number[], opts: NutritionalSciAggregationOptions = {}): NutritionalSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciAggregation };
diff --git a/src/nutritional_sci/algebra.ts b/src/nutritional_sci/algebra.ts
new file mode 100644
index 000000000..d06cc06d9
--- /dev/null
+++ b/src/nutritional_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci algebra module — tsb analytics library. */
+export interface NutritionalSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciAlgebra(data: number[], opts: NutritionalSciAlgebraOptions = {}): NutritionalSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciAlgebra };
diff --git a/src/nutritional_sci/alignment.ts b/src/nutritional_sci/alignment.ts
new file mode 100644
index 000000000..b0fdeab2a
--- /dev/null
+++ b/src/nutritional_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci alignment module — tsb analytics library. */
+export interface NutritionalSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciAlignment(data: number[], opts: NutritionalSciAlignmentOptions = {}): NutritionalSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciAlignment };
diff --git a/src/nutritional_sci/analysis.ts b/src/nutritional_sci/analysis.ts
new file mode 100644
index 000000000..1fb3a4296
--- /dev/null
+++ b/src/nutritional_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci analysis module — tsb analytics library. */
+export interface NutritionalSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciAnalysis(data: number[], opts: NutritionalSciAnalysisOptions = {}): NutritionalSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciAnalysis };
diff --git a/src/nutritional_sci/augmentation.ts b/src/nutritional_sci/augmentation.ts
new file mode 100644
index 000000000..d8eec1b01
--- /dev/null
+++ b/src/nutritional_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci augmentation module — tsb analytics library. */
+export interface NutritionalSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciAugmentation(data: number[], opts: NutritionalSciAugmentationOptions = {}): NutritionalSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciAugmentation };
diff --git a/src/nutritional_sci/bagging.ts b/src/nutritional_sci/bagging.ts
new file mode 100644
index 000000000..79e2bf87c
--- /dev/null
+++ b/src/nutritional_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci bagging module — tsb analytics library. */
+export interface NutritionalSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciBaggingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciBagging(data: number[], opts: NutritionalSciBaggingOptions = {}): NutritionalSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciBagging };
diff --git a/src/nutritional_sci/basis.ts b/src/nutritional_sci/basis.ts
new file mode 100644
index 000000000..8c55eca0d
--- /dev/null
+++ b/src/nutritional_sci/basis.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci basis module — tsb analytics library. */
+export interface NutritionalSciBasisOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciBasisResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciBasis(data: number[], opts: NutritionalSciBasisOptions = {}): NutritionalSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciBasis };
diff --git a/src/nutritional_sci/benchmarking.ts b/src/nutritional_sci/benchmarking.ts
new file mode 100644
index 000000000..7b2c050c3
--- /dev/null
+++ b/src/nutritional_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci benchmarking module — tsb analytics library. */
+export interface NutritionalSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciBenchmarking(data: number[], opts: NutritionalSciBenchmarkingOptions = {}): NutritionalSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciBenchmarking };
diff --git a/src/nutritional_sci/blending.ts b/src/nutritional_sci/blending.ts
new file mode 100644
index 000000000..4ed5714ce
--- /dev/null
+++ b/src/nutritional_sci/blending.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci blending module — tsb analytics library. */
+export interface NutritionalSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciBlendingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciBlending(data: number[], opts: NutritionalSciBlendingOptions = {}): NutritionalSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciBlending };
diff --git a/src/nutritional_sci/boosting.ts b/src/nutritional_sci/boosting.ts
new file mode 100644
index 000000000..0264164ce
--- /dev/null
+++ b/src/nutritional_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci boosting module — tsb analytics library. */
+export interface NutritionalSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciBoostingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciBoosting(data: number[], opts: NutritionalSciBoostingOptions = {}): NutritionalSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciBoosting };
diff --git a/src/nutritional_sci/bootstrap.ts b/src/nutritional_sci/bootstrap.ts
new file mode 100644
index 000000000..002c60453
--- /dev/null
+++ b/src/nutritional_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci bootstrap module — tsb analytics library. */
+export interface NutritionalSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciBootstrap(data: number[], opts: NutritionalSciBootstrapOptions = {}): NutritionalSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciBootstrap };
diff --git a/src/nutritional_sci/calculus.ts b/src/nutritional_sci/calculus.ts
new file mode 100644
index 000000000..f37b811ea
--- /dev/null
+++ b/src/nutritional_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci calculus module — tsb analytics library. */
+export interface NutritionalSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciCalculusResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciCalculus(data: number[], opts: NutritionalSciCalculusOptions = {}): NutritionalSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciCalculus };
diff --git a/src/nutritional_sci/calibration.ts b/src/nutritional_sci/calibration.ts
new file mode 100644
index 000000000..204ac91ed
--- /dev/null
+++ b/src/nutritional_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci calibration module — tsb analytics library. */
+export interface NutritionalSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciCalibration(data: number[], opts: NutritionalSciCalibrationOptions = {}): NutritionalSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciCalibration };
diff --git a/src/nutritional_sci/characterization.ts b/src/nutritional_sci/characterization.ts
new file mode 100644
index 000000000..e96dfc8eb
--- /dev/null
+++ b/src/nutritional_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci characterization module — tsb analytics library. */
+export interface NutritionalSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciCharacterization(data: number[], opts: NutritionalSciCharacterizationOptions = {}): NutritionalSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciCharacterization };
diff --git a/src/nutritional_sci/classification.ts b/src/nutritional_sci/classification.ts
new file mode 100644
index 000000000..a28b73af0
--- /dev/null
+++ b/src/nutritional_sci/classification.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci classification module — tsb analytics library. */
+export interface NutritionalSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciClassificationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciClassification(data: number[], opts: NutritionalSciClassificationOptions = {}): NutritionalSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciClassification };
diff --git a/src/nutritional_sci/clustering.ts b/src/nutritional_sci/clustering.ts
new file mode 100644
index 000000000..4419063e6
--- /dev/null
+++ b/src/nutritional_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci clustering module — tsb analytics library. */
+export interface NutritionalSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciClusteringResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciClustering(data: number[], opts: NutritionalSciClusteringOptions = {}): NutritionalSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciClustering };
diff --git a/src/nutritional_sci/compression.ts b/src/nutritional_sci/compression.ts
new file mode 100644
index 000000000..dce154fb6
--- /dev/null
+++ b/src/nutritional_sci/compression.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci compression module — tsb analytics library. */
+export interface NutritionalSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciCompressionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciCompression(data: number[], opts: NutritionalSciCompressionOptions = {}): NutritionalSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciCompression };
diff --git a/src/nutritional_sci/continuous.ts b/src/nutritional_sci/continuous.ts
new file mode 100644
index 000000000..ebc2ca379
--- /dev/null
+++ b/src/nutritional_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci continuous module — tsb analytics library. */
+export interface NutritionalSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciContinuousResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciContinuous(data: number[], opts: NutritionalSciContinuousOptions = {}): NutritionalSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciContinuous };
diff --git a/src/nutritional_sci/control.ts b/src/nutritional_sci/control.ts
new file mode 100644
index 000000000..9a4cbe281
--- /dev/null
+++ b/src/nutritional_sci/control.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci control module — tsb analytics library. */
+export interface NutritionalSciControlOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciControlResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciControl(data: number[], opts: NutritionalSciControlOptions = {}): NutritionalSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciControl };
diff --git a/src/nutritional_sci/convergence.ts b/src/nutritional_sci/convergence.ts
new file mode 100644
index 000000000..6d2af204c
--- /dev/null
+++ b/src/nutritional_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci convergence module — tsb analytics library. */
+export interface NutritionalSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciConvergence(data: number[], opts: NutritionalSciConvergenceOptions = {}): NutritionalSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciConvergence };
diff --git a/src/nutritional_sci/convex.ts b/src/nutritional_sci/convex.ts
new file mode 100644
index 000000000..4746d5a09
--- /dev/null
+++ b/src/nutritional_sci/convex.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci convex module — tsb analytics library. */
+export interface NutritionalSciConvexOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciConvexResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciConvex(data: number[], opts: NutritionalSciConvexOptions = {}): NutritionalSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciConvex };
diff --git a/src/nutritional_sci/correlation.ts b/src/nutritional_sci/correlation.ts
new file mode 100644
index 000000000..48bb3b84e
--- /dev/null
+++ b/src/nutritional_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci correlation module — tsb analytics library. */
+export interface NutritionalSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciCorrelation(data: number[], opts: NutritionalSciCorrelationOptions = {}): NutritionalSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciCorrelation };
diff --git a/src/nutritional_sci/covariance.ts b/src/nutritional_sci/covariance.ts
new file mode 100644
index 000000000..151629c44
--- /dev/null
+++ b/src/nutritional_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci covariance module — tsb analytics library. */
+export interface NutritionalSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciCovariance(data: number[], opts: NutritionalSciCovarianceOptions = {}): NutritionalSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciCovariance };
diff --git a/src/nutritional_sci/cross_validation.ts b/src/nutritional_sci/cross_validation.ts
new file mode 100644
index 000000000..950358684
--- /dev/null
+++ b/src/nutritional_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci cross_validation module — tsb analytics library. */
+export interface NutritionalSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciCrossValidation(data: number[], opts: NutritionalSciCrossValidationOptions = {}): NutritionalSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciCrossValidation };
diff --git a/src/nutritional_sci/decoding.ts b/src/nutritional_sci/decoding.ts
new file mode 100644
index 000000000..85fc91f06
--- /dev/null
+++ b/src/nutritional_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci decoding module — tsb analytics library. */
+export interface NutritionalSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDecodingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDecoding(data: number[], opts: NutritionalSciDecodingOptions = {}): NutritionalSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDecoding };
diff --git a/src/nutritional_sci/decomposition.ts b/src/nutritional_sci/decomposition.ts
new file mode 100644
index 000000000..a130925ba
--- /dev/null
+++ b/src/nutritional_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci decomposition module — tsb analytics library. */
+export interface NutritionalSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDecomposition(data: number[], opts: NutritionalSciDecompositionOptions = {}): NutritionalSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDecomposition };
diff --git a/src/nutritional_sci/detection.ts b/src/nutritional_sci/detection.ts
new file mode 100644
index 000000000..e8c09c570
--- /dev/null
+++ b/src/nutritional_sci/detection.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci detection module — tsb analytics library. */
+export interface NutritionalSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDetectionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDetection(data: number[], opts: NutritionalSciDetectionOptions = {}): NutritionalSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDetection };
diff --git a/src/nutritional_sci/deterministic.ts b/src/nutritional_sci/deterministic.ts
new file mode 100644
index 000000000..d10952820
--- /dev/null
+++ b/src/nutritional_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci deterministic module — tsb analytics library. */
+export interface NutritionalSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDeterministic(data: number[], opts: NutritionalSciDeterministicOptions = {}): NutritionalSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDeterministic };
diff --git a/src/nutritional_sci/diagnostics.ts b/src/nutritional_sci/diagnostics.ts
new file mode 100644
index 000000000..b750b0669
--- /dev/null
+++ b/src/nutritional_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci diagnostics module — tsb analytics library. */
+export interface NutritionalSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDiagnostics(data: number[], opts: NutritionalSciDiagnosticsOptions = {}): NutritionalSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDiagnostics };
diff --git a/src/nutritional_sci/differential.ts b/src/nutritional_sci/differential.ts
new file mode 100644
index 000000000..577060bd9
--- /dev/null
+++ b/src/nutritional_sci/differential.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci differential module — tsb analytics library. */
+export interface NutritionalSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDifferential(data: number[], opts: NutritionalSciDifferentialOptions = {}): NutritionalSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDifferential };
diff --git a/src/nutritional_sci/discrete.ts b/src/nutritional_sci/discrete.ts
new file mode 100644
index 000000000..965a36dc0
--- /dev/null
+++ b/src/nutritional_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci discrete module — tsb analytics library. */
+export interface NutritionalSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDiscrete(data: number[], opts: NutritionalSciDiscreteOptions = {}): NutritionalSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDiscrete };
diff --git a/src/nutritional_sci/distribution.ts b/src/nutritional_sci/distribution.ts
new file mode 100644
index 000000000..1a4caa5ea
--- /dev/null
+++ b/src/nutritional_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci distribution module — tsb analytics library. */
+export interface NutritionalSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDistributionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDistribution(data: number[], opts: NutritionalSciDistributionOptions = {}): NutritionalSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDistribution };
diff --git a/src/nutritional_sci/dynamic.ts b/src/nutritional_sci/dynamic.ts
new file mode 100644
index 000000000..cc762cbb3
--- /dev/null
+++ b/src/nutritional_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci dynamic module — tsb analytics library. */
+export interface NutritionalSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciDynamicResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciDynamic(data: number[], opts: NutritionalSciDynamicOptions = {}): NutritionalSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciDynamic };
diff --git a/src/nutritional_sci/embedding.ts b/src/nutritional_sci/embedding.ts
new file mode 100644
index 000000000..308c94a0e
--- /dev/null
+++ b/src/nutritional_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci embedding module — tsb analytics library. */
+export interface NutritionalSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciEmbedding(data: number[], opts: NutritionalSciEmbeddingOptions = {}): NutritionalSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciEmbedding };
diff --git a/src/nutritional_sci/encoding.ts b/src/nutritional_sci/encoding.ts
new file mode 100644
index 000000000..0bac7f5af
--- /dev/null
+++ b/src/nutritional_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci encoding module — tsb analytics library. */
+export interface NutritionalSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciEncodingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciEncoding(data: number[], opts: NutritionalSciEncodingOptions = {}): NutritionalSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciEncoding };
diff --git a/src/nutritional_sci/ensemble.ts b/src/nutritional_sci/ensemble.ts
new file mode 100644
index 000000000..d0fcd4aae
--- /dev/null
+++ b/src/nutritional_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci ensemble module — tsb analytics library. */
+export interface NutritionalSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciEnsemble(data: number[], opts: NutritionalSciEnsembleOptions = {}): NutritionalSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciEnsemble };
diff --git a/src/nutritional_sci/estimation.ts b/src/nutritional_sci/estimation.ts
new file mode 100644
index 000000000..de074f8a0
--- /dev/null
+++ b/src/nutritional_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci estimation module — tsb analytics library. */
+export interface NutritionalSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciEstimationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciEstimation(data: number[], opts: NutritionalSciEstimationOptions = {}): NutritionalSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciEstimation };
diff --git a/src/nutritional_sci/evaluation.ts b/src/nutritional_sci/evaluation.ts
new file mode 100644
index 000000000..55bca98ef
--- /dev/null
+++ b/src/nutritional_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci evaluation module — tsb analytics library. */
+export interface NutritionalSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciEvaluation(data: number[], opts: NutritionalSciEvaluationOptions = {}): NutritionalSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciEvaluation };
diff --git a/src/nutritional_sci/extrapolation.ts b/src/nutritional_sci/extrapolation.ts
new file mode 100644
index 000000000..bba4d3204
--- /dev/null
+++ b/src/nutritional_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci extrapolation module — tsb analytics library. */
+export interface NutritionalSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciExtrapolation(data: number[], opts: NutritionalSciExtrapolationOptions = {}): NutritionalSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciExtrapolation };
diff --git a/src/nutritional_sci/features.ts b/src/nutritional_sci/features.ts
new file mode 100644
index 000000000..5ed951e4f
--- /dev/null
+++ b/src/nutritional_sci/features.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci features module — tsb analytics library. */
+export interface NutritionalSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciFeatures(data: number[], opts: NutritionalSciFeaturesOptions = {}): NutritionalSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciFeatures };
diff --git a/src/nutritional_sci/feedback.ts b/src/nutritional_sci/feedback.ts
new file mode 100644
index 000000000..e5c1508e9
--- /dev/null
+++ b/src/nutritional_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci feedback module — tsb analytics library. */
+export interface NutritionalSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciFeedback(data: number[], opts: NutritionalSciFeedbackOptions = {}): NutritionalSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciFeedback };
diff --git a/src/nutritional_sci/filtering.ts b/src/nutritional_sci/filtering.ts
new file mode 100644
index 000000000..2b8d836b3
--- /dev/null
+++ b/src/nutritional_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci filtering module — tsb analytics library. */
+export interface NutritionalSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciFilteringResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciFiltering(data: number[], opts: NutritionalSciFilteringOptions = {}): NutritionalSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciFiltering };
diff --git a/src/nutritional_sci/fourier.ts b/src/nutritional_sci/fourier.ts
new file mode 100644
index 000000000..a0a64937b
--- /dev/null
+++ b/src/nutritional_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci fourier module — tsb analytics library. */
+export interface NutritionalSciFourierOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciFourierResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciFourier(data: number[], opts: NutritionalSciFourierOptions = {}): NutritionalSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciFourier };
diff --git a/src/nutritional_sci/fusion.ts b/src/nutritional_sci/fusion.ts
new file mode 100644
index 000000000..1b0c292eb
--- /dev/null
+++ b/src/nutritional_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci fusion module — tsb analytics library. */
+export interface NutritionalSciFusionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciFusionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciFusion(data: number[], opts: NutritionalSciFusionOptions = {}): NutritionalSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciFusion };
diff --git a/src/nutritional_sci/generation.ts b/src/nutritional_sci/generation.ts
new file mode 100644
index 000000000..768850cc7
--- /dev/null
+++ b/src/nutritional_sci/generation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci generation module — tsb analytics library. */
+export interface NutritionalSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciGenerationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciGeneration(data: number[], opts: NutritionalSciGenerationOptions = {}): NutritionalSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciGeneration };
diff --git a/src/nutritional_sci/geometry.ts b/src/nutritional_sci/geometry.ts
new file mode 100644
index 000000000..7e052a448
--- /dev/null
+++ b/src/nutritional_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci geometry module — tsb analytics library. */
+export interface NutritionalSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciGeometryResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciGeometry(data: number[], opts: NutritionalSciGeometryOptions = {}): NutritionalSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciGeometry };
diff --git a/src/nutritional_sci/gradient.ts b/src/nutritional_sci/gradient.ts
new file mode 100644
index 000000000..b1fa8b751
--- /dev/null
+++ b/src/nutritional_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci gradient module — tsb analytics library. */
+export interface NutritionalSciGradientOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciGradientResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciGradient(data: number[], opts: NutritionalSciGradientOptions = {}): NutritionalSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciGradient };
diff --git a/src/nutritional_sci/hessian.ts b/src/nutritional_sci/hessian.ts
new file mode 100644
index 000000000..c67eea723
--- /dev/null
+++ b/src/nutritional_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci hessian module — tsb analytics library. */
+export interface NutritionalSciHessianOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciHessianResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciHessian(data: number[], opts: NutritionalSciHessianOptions = {}): NutritionalSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciHessian };
diff --git a/src/nutritional_sci/hypothesis.ts b/src/nutritional_sci/hypothesis.ts
new file mode 100644
index 000000000..3e87302be
--- /dev/null
+++ b/src/nutritional_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci hypothesis module — tsb analytics library. */
+export interface NutritionalSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciHypothesis(data: number[], opts: NutritionalSciHypothesisOptions = {}): NutritionalSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciHypothesis };
diff --git a/src/nutritional_sci/inference.ts b/src/nutritional_sci/inference.ts
new file mode 100644
index 000000000..f95e77f96
--- /dev/null
+++ b/src/nutritional_sci/inference.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci inference module — tsb analytics library. */
+export interface NutritionalSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciInferenceResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciInference(data: number[], opts: NutritionalSciInferenceOptions = {}): NutritionalSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciInference };
diff --git a/src/nutritional_sci/inference2.ts b/src/nutritional_sci/inference2.ts
new file mode 100644
index 000000000..0aecaf4fd
--- /dev/null
+++ b/src/nutritional_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci inference2 module — tsb analytics library. */
+export interface NutritionalSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciInferenceResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciInference(data: number[], opts: NutritionalSciInferenceOptions = {}): NutritionalSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciInference };
diff --git a/src/nutritional_sci/integral.ts b/src/nutritional_sci/integral.ts
new file mode 100644
index 000000000..9c9e6d55b
--- /dev/null
+++ b/src/nutritional_sci/integral.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci integral module — tsb analytics library. */
+export interface NutritionalSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciIntegralResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciIntegral(data: number[], opts: NutritionalSciIntegralOptions = {}): NutritionalSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciIntegral };
diff --git a/src/nutritional_sci/integration.ts b/src/nutritional_sci/integration.ts
new file mode 100644
index 000000000..61fd7a513
--- /dev/null
+++ b/src/nutritional_sci/integration.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci integration module — tsb analytics library. */
+export interface NutritionalSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciIntegration(data: number[], opts: NutritionalSciIntegrationOptions = {}): NutritionalSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciIntegration };
diff --git a/src/nutritional_sci/interpolation.ts b/src/nutritional_sci/interpolation.ts
new file mode 100644
index 000000000..00c9ad33c
--- /dev/null
+++ b/src/nutritional_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci interpolation module — tsb analytics library. */
+export interface NutritionalSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciInterpolation(data: number[], opts: NutritionalSciInterpolationOptions = {}): NutritionalSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciInterpolation };
diff --git a/src/nutritional_sci/jacobian.ts b/src/nutritional_sci/jacobian.ts
new file mode 100644
index 000000000..c8b395887
--- /dev/null
+++ b/src/nutritional_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci jacobian module — tsb analytics library. */
+export interface NutritionalSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciJacobianResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciJacobian(data: number[], opts: NutritionalSciJacobianOptions = {}): NutritionalSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciJacobian };
diff --git a/src/nutritional_sci/kernel.ts b/src/nutritional_sci/kernel.ts
new file mode 100644
index 000000000..cc6cc1670
--- /dev/null
+++ b/src/nutritional_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci kernel module — tsb analytics library. */
+export interface NutritionalSciKernelOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciKernelResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciKernel(data: number[], opts: NutritionalSciKernelOptions = {}): NutritionalSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciKernel };
diff --git a/src/nutritional_sci/laplacian.ts b/src/nutritional_sci/laplacian.ts
new file mode 100644
index 000000000..4ca388970
--- /dev/null
+++ b/src/nutritional_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci laplacian module — tsb analytics library. */
+export interface NutritionalSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciLaplacian(data: number[], opts: NutritionalSciLaplacianOptions = {}): NutritionalSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciLaplacian };
diff --git a/src/nutritional_sci/learning.ts b/src/nutritional_sci/learning.ts
new file mode 100644
index 000000000..fa7dbbd10
--- /dev/null
+++ b/src/nutritional_sci/learning.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci learning module — tsb analytics library. */
+export interface NutritionalSciLearningOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciLearningResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciLearning(data: number[], opts: NutritionalSciLearningOptions = {}): NutritionalSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciLearning };
diff --git a/src/nutritional_sci/linear.ts b/src/nutritional_sci/linear.ts
new file mode 100644
index 000000000..470554e3f
--- /dev/null
+++ b/src/nutritional_sci/linear.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci linear module — tsb analytics library. */
+export interface NutritionalSciLinearOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciLinearResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciLinear(data: number[], opts: NutritionalSciLinearOptions = {}): NutritionalSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciLinear };
diff --git a/src/nutritional_sci/manifold.ts b/src/nutritional_sci/manifold.ts
new file mode 100644
index 000000000..6eaf0a7a4
--- /dev/null
+++ b/src/nutritional_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci manifold module — tsb analytics library. */
+export interface NutritionalSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciManifoldResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciManifold(data: number[], opts: NutritionalSciManifoldOptions = {}): NutritionalSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciManifold };
diff --git a/src/nutritional_sci/matching.ts b/src/nutritional_sci/matching.ts
new file mode 100644
index 000000000..ae43b64e7
--- /dev/null
+++ b/src/nutritional_sci/matching.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci matching module — tsb analytics library. */
+export interface NutritionalSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciMatchingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciMatching(data: number[], opts: NutritionalSciMatchingOptions = {}): NutritionalSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciMatching };
diff --git a/src/nutritional_sci/measurement.ts b/src/nutritional_sci/measurement.ts
new file mode 100644
index 000000000..ae69107aa
--- /dev/null
+++ b/src/nutritional_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci measurement module — tsb analytics library. */
+export interface NutritionalSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciMeasurement(data: number[], opts: NutritionalSciMeasurementOptions = {}): NutritionalSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciMeasurement };
diff --git a/src/nutritional_sci/metrics.ts b/src/nutritional_sci/metrics.ts
new file mode 100644
index 000000000..7a789d0ff
--- /dev/null
+++ b/src/nutritional_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci metrics module — tsb analytics library. */
+export interface NutritionalSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciMetricsResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciMetrics(data: number[], opts: NutritionalSciMetricsOptions = {}): NutritionalSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciMetrics };
diff --git a/src/nutritional_sci/modeling.ts b/src/nutritional_sci/modeling.ts
new file mode 100644
index 000000000..284bcaa62
--- /dev/null
+++ b/src/nutritional_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci modeling module — tsb analytics library. */
+export interface NutritionalSciModelingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciModelingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciModeling(data: number[], opts: NutritionalSciModelingOptions = {}): NutritionalSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciModeling };
diff --git a/src/nutritional_sci/monitoring.ts b/src/nutritional_sci/monitoring.ts
new file mode 100644
index 000000000..d48e279e1
--- /dev/null
+++ b/src/nutritional_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci monitoring module — tsb analytics library. */
+export interface NutritionalSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciMonitoring(data: number[], opts: NutritionalSciMonitoringOptions = {}): NutritionalSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciMonitoring };
diff --git a/src/nutritional_sci/nonlinear.ts b/src/nutritional_sci/nonlinear.ts
new file mode 100644
index 000000000..798bbb527
--- /dev/null
+++ b/src/nutritional_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci nonlinear module — tsb analytics library. */
+export interface NutritionalSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciNonlinear(data: number[], opts: NutritionalSciNonlinearOptions = {}): NutritionalSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciNonlinear };
diff --git a/src/nutritional_sci/normalization.ts b/src/nutritional_sci/normalization.ts
new file mode 100644
index 000000000..0f891b369
--- /dev/null
+++ b/src/nutritional_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci normalization module — tsb analytics library. */
+export interface NutritionalSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciNormalization(data: number[], opts: NutritionalSciNormalizationOptions = {}): NutritionalSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciNormalization };
diff --git a/src/nutritional_sci/optimization.ts b/src/nutritional_sci/optimization.ts
new file mode 100644
index 000000000..b8552d941
--- /dev/null
+++ b/src/nutritional_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci optimization module — tsb analytics library. */
+export interface NutritionalSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciOptimization(data: number[], opts: NutritionalSciOptimizationOptions = {}): NutritionalSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciOptimization };
diff --git a/src/nutritional_sci/patterns.ts b/src/nutritional_sci/patterns.ts
new file mode 100644
index 000000000..9918b9d9e
--- /dev/null
+++ b/src/nutritional_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci patterns module — tsb analytics library. */
+export interface NutritionalSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciPatternsResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciPatterns(data: number[], opts: NutritionalSciPatternsOptions = {}): NutritionalSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciPatterns };
diff --git a/src/nutritional_sci/permutation.ts b/src/nutritional_sci/permutation.ts
new file mode 100644
index 000000000..1d5b87ba5
--- /dev/null
+++ b/src/nutritional_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci permutation module — tsb analytics library. */
+export interface NutritionalSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciPermutationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciPermutation(data: number[], opts: NutritionalSciPermutationOptions = {}): NutritionalSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciPermutation };
diff --git a/src/nutritional_sci/prediction.ts b/src/nutritional_sci/prediction.ts
new file mode 100644
index 000000000..a09b564df
--- /dev/null
+++ b/src/nutritional_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci prediction module — tsb analytics library. */
+export interface NutritionalSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciPredictionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciPrediction(data: number[], opts: NutritionalSciPredictionOptions = {}): NutritionalSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciPrediction };
diff --git a/src/nutritional_sci/processing.ts b/src/nutritional_sci/processing.ts
new file mode 100644
index 000000000..27184234c
--- /dev/null
+++ b/src/nutritional_sci/processing.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci processing module — tsb analytics library. */
+export interface NutritionalSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciProcessingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciProcessing(data: number[], opts: NutritionalSciProcessingOptions = {}): NutritionalSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciProcessing };
diff --git a/src/nutritional_sci/profiling.ts b/src/nutritional_sci/profiling.ts
new file mode 100644
index 000000000..7c1498653
--- /dev/null
+++ b/src/nutritional_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci profiling module — tsb analytics library. */
+export interface NutritionalSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciProfilingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciProfiling(data: number[], opts: NutritionalSciProfilingOptions = {}): NutritionalSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciProfiling };
diff --git a/src/nutritional_sci/projection.ts b/src/nutritional_sci/projection.ts
new file mode 100644
index 000000000..7da5e776d
--- /dev/null
+++ b/src/nutritional_sci/projection.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci projection module — tsb analytics library. */
+export interface NutritionalSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciProjectionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciProjection(data: number[], opts: NutritionalSciProjectionOptions = {}): NutritionalSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciProjection };
diff --git a/src/nutritional_sci/ranking.ts b/src/nutritional_sci/ranking.ts
new file mode 100644
index 000000000..30a1a0633
--- /dev/null
+++ b/src/nutritional_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci ranking module — tsb analytics library. */
+export interface NutritionalSciRankingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciRankingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciRanking(data: number[], opts: NutritionalSciRankingOptions = {}): NutritionalSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciRanking };
diff --git a/src/nutritional_sci/reconstruction.ts b/src/nutritional_sci/reconstruction.ts
new file mode 100644
index 000000000..1d79a1eb3
--- /dev/null
+++ b/src/nutritional_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci reconstruction module — tsb analytics library. */
+export interface NutritionalSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciReconstruction(data: number[], opts: NutritionalSciReconstructionOptions = {}): NutritionalSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciReconstruction };
diff --git a/src/nutritional_sci/registration.ts b/src/nutritional_sci/registration.ts
new file mode 100644
index 000000000..4b0e36dfe
--- /dev/null
+++ b/src/nutritional_sci/registration.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci registration module — tsb analytics library. */
+export interface NutritionalSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciRegistration(data: number[], opts: NutritionalSciRegistrationOptions = {}): NutritionalSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciRegistration };
diff --git a/src/nutritional_sci/regression.ts b/src/nutritional_sci/regression.ts
new file mode 100644
index 000000000..59f795386
--- /dev/null
+++ b/src/nutritional_sci/regression.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci regression module — tsb analytics library. */
+export interface NutritionalSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciRegressionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciRegression(data: number[], opts: NutritionalSciRegressionOptions = {}): NutritionalSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciRegression };
diff --git a/src/nutritional_sci/regularization.ts b/src/nutritional_sci/regularization.ts
new file mode 100644
index 000000000..90f694f60
--- /dev/null
+++ b/src/nutritional_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci regularization module — tsb analytics library. */
+export interface NutritionalSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciRegularization(data: number[], opts: NutritionalSciRegularizationOptions = {}): NutritionalSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciRegularization };
diff --git a/src/nutritional_sci/robustness.ts b/src/nutritional_sci/robustness.ts
new file mode 100644
index 000000000..668b1e9f4
--- /dev/null
+++ b/src/nutritional_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci robustness module — tsb analytics library. */
+export interface NutritionalSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciRobustness(data: number[], opts: NutritionalSciRobustnessOptions = {}): NutritionalSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciRobustness };
diff --git a/src/nutritional_sci/sampling.ts b/src/nutritional_sci/sampling.ts
new file mode 100644
index 000000000..6dd5140e6
--- /dev/null
+++ b/src/nutritional_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci sampling module — tsb analytics library. */
+export interface NutritionalSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciSamplingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciSampling(data: number[], opts: NutritionalSciSamplingOptions = {}): NutritionalSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciSampling };
diff --git a/src/nutritional_sci/sampling2.ts b/src/nutritional_sci/sampling2.ts
new file mode 100644
index 000000000..54c8ca468
--- /dev/null
+++ b/src/nutritional_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci sampling2 module — tsb analytics library. */
+export interface NutritionalSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciSamplingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciSampling(data: number[], opts: NutritionalSciSamplingOptions = {}): NutritionalSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciSampling };
diff --git a/src/nutritional_sci/scaling.ts b/src/nutritional_sci/scaling.ts
new file mode 100644
index 000000000..4ca4f9847
--- /dev/null
+++ b/src/nutritional_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci scaling module — tsb analytics library. */
+export interface NutritionalSciScalingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciScalingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciScaling(data: number[], opts: NutritionalSciScalingOptions = {}): NutritionalSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciScaling };
diff --git a/src/nutritional_sci/scoring.ts b/src/nutritional_sci/scoring.ts
new file mode 100644
index 000000000..95c70755b
--- /dev/null
+++ b/src/nutritional_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci scoring module — tsb analytics library. */
+export interface NutritionalSciScoringOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciScoringResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciScoring(data: number[], opts: NutritionalSciScoringOptions = {}): NutritionalSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciScoring };
diff --git a/src/nutritional_sci/segmentation.ts b/src/nutritional_sci/segmentation.ts
new file mode 100644
index 000000000..336a40d2f
--- /dev/null
+++ b/src/nutritional_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci segmentation module — tsb analytics library. */
+export interface NutritionalSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciSegmentation(data: number[], opts: NutritionalSciSegmentationOptions = {}): NutritionalSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciSegmentation };
diff --git a/src/nutritional_sci/selection.ts b/src/nutritional_sci/selection.ts
new file mode 100644
index 000000000..1d0b38287
--- /dev/null
+++ b/src/nutritional_sci/selection.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci selection module — tsb analytics library. */
+export interface NutritionalSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciSelectionResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciSelection(data: number[], opts: NutritionalSciSelectionOptions = {}): NutritionalSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciSelection };
diff --git a/src/nutritional_sci/sensitivity.ts b/src/nutritional_sci/sensitivity.ts
new file mode 100644
index 000000000..a2fc4936f
--- /dev/null
+++ b/src/nutritional_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci sensitivity module — tsb analytics library. */
+export interface NutritionalSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciSensitivity(data: number[], opts: NutritionalSciSensitivityOptions = {}): NutritionalSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciSensitivity };
diff --git a/src/nutritional_sci/simulation.ts b/src/nutritional_sci/simulation.ts
new file mode 100644
index 000000000..863ea6839
--- /dev/null
+++ b/src/nutritional_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci simulation module — tsb analytics library. */
+export interface NutritionalSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciSimulationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciSimulation(data: number[], opts: NutritionalSciSimulationOptions = {}): NutritionalSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciSimulation };
diff --git a/src/nutritional_sci/smoothing.ts b/src/nutritional_sci/smoothing.ts
new file mode 100644
index 000000000..fe435873f
--- /dev/null
+++ b/src/nutritional_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci smoothing module — tsb analytics library. */
+export interface NutritionalSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciSmoothing(data: number[], opts: NutritionalSciSmoothingOptions = {}): NutritionalSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciSmoothing };
diff --git a/src/nutritional_sci/stability.ts b/src/nutritional_sci/stability.ts
new file mode 100644
index 000000000..0139e2d4b
--- /dev/null
+++ b/src/nutritional_sci/stability.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci stability module — tsb analytics library. */
+export interface NutritionalSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciStabilityResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciStability(data: number[], opts: NutritionalSciStabilityOptions = {}): NutritionalSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciStability };
diff --git a/src/nutritional_sci/stacking.ts b/src/nutritional_sci/stacking.ts
new file mode 100644
index 000000000..097c4adfa
--- /dev/null
+++ b/src/nutritional_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci stacking module — tsb analytics library. */
+export interface NutritionalSciStackingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciStackingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciStacking(data: number[], opts: NutritionalSciStackingOptions = {}): NutritionalSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciStacking };
diff --git a/src/nutritional_sci/standardization.ts b/src/nutritional_sci/standardization.ts
new file mode 100644
index 000000000..af333b157
--- /dev/null
+++ b/src/nutritional_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci standardization module — tsb analytics library. */
+export interface NutritionalSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciStandardization(data: number[], opts: NutritionalSciStandardizationOptions = {}): NutritionalSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciStandardization };
diff --git a/src/nutritional_sci/static.ts b/src/nutritional_sci/static.ts
new file mode 100644
index 000000000..bae6e0f01
--- /dev/null
+++ b/src/nutritional_sci/static.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci static module — tsb analytics library. */
+export interface NutritionalSciStaticOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciStaticResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciStatic(data: number[], opts: NutritionalSciStaticOptions = {}): NutritionalSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciStatic };
diff --git a/src/nutritional_sci/stochastic.ts b/src/nutritional_sci/stochastic.ts
new file mode 100644
index 000000000..abc794e20
--- /dev/null
+++ b/src/nutritional_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci stochastic module — tsb analytics library. */
+export interface NutritionalSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciStochasticResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciStochastic(data: number[], opts: NutritionalSciStochasticOptions = {}): NutritionalSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciStochastic };
diff --git a/src/nutritional_sci/synthesis.ts b/src/nutritional_sci/synthesis.ts
new file mode 100644
index 000000000..4976de1d4
--- /dev/null
+++ b/src/nutritional_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci synthesis module — tsb analytics library. */
+export interface NutritionalSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciSynthesis(data: number[], opts: NutritionalSciSynthesisOptions = {}): NutritionalSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciSynthesis };
diff --git a/src/nutritional_sci/topology.ts b/src/nutritional_sci/topology.ts
new file mode 100644
index 000000000..799e9361b
--- /dev/null
+++ b/src/nutritional_sci/topology.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci topology module — tsb analytics library. */
+export interface NutritionalSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciTopologyResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciTopology(data: number[], opts: NutritionalSciTopologyOptions = {}): NutritionalSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciTopology };
diff --git a/src/nutritional_sci/tracking.ts b/src/nutritional_sci/tracking.ts
new file mode 100644
index 000000000..92ca6822f
--- /dev/null
+++ b/src/nutritional_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci tracking module — tsb analytics library. */
+export interface NutritionalSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciTrackingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciTracking(data: number[], opts: NutritionalSciTrackingOptions = {}): NutritionalSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciTracking };
diff --git a/src/nutritional_sci/transform.ts b/src/nutritional_sci/transform.ts
new file mode 100644
index 000000000..52561f6d5
--- /dev/null
+++ b/src/nutritional_sci/transform.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci transform module — tsb analytics library. */
+export interface NutritionalSciTransformOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciTransformResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciTransform(data: number[], opts: NutritionalSciTransformOptions = {}): NutritionalSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciTransform };
diff --git a/src/nutritional_sci/uncertainty.ts b/src/nutritional_sci/uncertainty.ts
new file mode 100644
index 000000000..3be289885
--- /dev/null
+++ b/src/nutritional_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci uncertainty module — tsb analytics library. */
+export interface NutritionalSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciUncertainty(data: number[], opts: NutritionalSciUncertaintyOptions = {}): NutritionalSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciUncertainty };
diff --git a/src/nutritional_sci/validation.ts b/src/nutritional_sci/validation.ts
new file mode 100644
index 000000000..b8db88cd7
--- /dev/null
+++ b/src/nutritional_sci/validation.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci validation module — tsb analytics library. */
+export interface NutritionalSciValidationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciValidationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciValidation(data: number[], opts: NutritionalSciValidationOptions = {}): NutritionalSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciValidation };
diff --git a/src/nutritional_sci/verification.ts b/src/nutritional_sci/verification.ts
new file mode 100644
index 000000000..56e245182
--- /dev/null
+++ b/src/nutritional_sci/verification.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci verification module — tsb analytics library. */
+export interface NutritionalSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciVerificationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciVerification(data: number[], opts: NutritionalSciVerificationOptions = {}): NutritionalSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciVerification };
diff --git a/src/nutritional_sci/visualization.ts b/src/nutritional_sci/visualization.ts
new file mode 100644
index 000000000..4b4ccc27d
--- /dev/null
+++ b/src/nutritional_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci visualization module — tsb analytics library. */
+export interface NutritionalSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciVisualization(data: number[], opts: NutritionalSciVisualizationOptions = {}): NutritionalSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciVisualization };
diff --git a/src/nutritional_sci/voting.ts b/src/nutritional_sci/voting.ts
new file mode 100644
index 000000000..06b3ba508
--- /dev/null
+++ b/src/nutritional_sci/voting.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci voting module — tsb analytics library. */
+export interface NutritionalSciVotingOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciVotingResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciVoting(data: number[], opts: NutritionalSciVotingOptions = {}): NutritionalSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciVoting };
diff --git a/src/nutritional_sci/wavelet.ts b/src/nutritional_sci/wavelet.ts
new file mode 100644
index 000000000..44117e783
--- /dev/null
+++ b/src/nutritional_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** nutritional_sci wavelet module — tsb analytics library. */
+export interface NutritionalSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface NutritionalSciWaveletResult { values: number[]; converged: boolean; }
+export function computeNutritionalSciWavelet(data: number[], opts: NutritionalSciWaveletOptions = {}): NutritionalSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeNutritionalSciWavelet };
diff --git a/src/oceanography/advanced.ts b/src/oceanography/advanced.ts
new file mode 100644
index 000000000..622f32b82
--- /dev/null
+++ b/src/oceanography/advanced.ts
@@ -0,0 +1,15 @@
+/** Oceanography Advanced module — tsb analytics library. */
+export interface Oceanography advancedOptions { tol?: number; maxIter?: number; }
+export interface Oceanography advancedResult { values: number[]; converged: boolean; }
+export function computeOceanography advanced(data: number[], opts: Oceanography advancedOptions = {}): Oceanography advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography advanced };
diff --git a/src/oceanography/amo_ocean.ts b/src/oceanography/amo_ocean.ts
new file mode 100644
index 000000000..7c409a270
--- /dev/null
+++ b/src/oceanography/amo_ocean.ts
@@ -0,0 +1,22 @@
+/** Amo Ocean module — tsb analytics library. */
+
+/** Options for Amo Ocean. */
+export interface AmoOceanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Amo Ocean. */
+export interface AmoOceanResult { values: number[]; converged: boolean; }
+
+/** Compute Amo Ocean. */
+export function computeAmoOcean(data: number[], opts: AmoOceanOptions = {}): AmoOceanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAmoOcean };
diff --git a/src/oceanography/antarctic.ts b/src/oceanography/antarctic.ts
new file mode 100644
index 000000000..47e12397a
--- /dev/null
+++ b/src/oceanography/antarctic.ts
@@ -0,0 +1,22 @@
+/** Antarctic module — tsb analytics library. */
+
+/** Options for Antarctic. */
+export interface AntarcticOptions { tol?: number; maxIter?: number; }
+
+/** Result from Antarctic. */
+export interface AntarcticResult { values: number[]; converged: boolean; }
+
+/** Compute Antarctic. */
+export function computeAntarctic(data: number[], opts: AntarcticOptions = {}): AntarcticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAntarctic };
diff --git a/src/oceanography/arctic.ts b/src/oceanography/arctic.ts
new file mode 100644
index 000000000..eab4a3c92
--- /dev/null
+++ b/src/oceanography/arctic.ts
@@ -0,0 +1,22 @@
+/** Arctic module — tsb analytics library. */
+
+/** Options for Arctic. */
+export interface ArcticOptions { tol?: number; maxIter?: number; }
+
+/** Result from Arctic. */
+export interface ArcticResult { values: number[]; converged: boolean; }
+
+/** Compute Arctic. */
+export function computeArctic(data: number[], opts: ArcticOptions = {}): ArcticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeArctic };
diff --git a/src/oceanography/base2.ts b/src/oceanography/base2.ts
new file mode 100644
index 000000000..d82959e3a
--- /dev/null
+++ b/src/oceanography/base2.ts
@@ -0,0 +1,15 @@
+/** Oceanography Base2 module — tsb analytics library. */
+export interface Oceanography base2Options { tol?: number; maxIter?: number; }
+export interface Oceanography base2Result { values: number[]; converged: boolean; }
+export function computeOceanography base2(data: number[], opts: Oceanography base2Options = {}): Oceanography base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography base2 };
diff --git a/src/oceanography/batch.ts b/src/oceanography/batch.ts
new file mode 100644
index 000000000..d205ac591
--- /dev/null
+++ b/src/oceanography/batch.ts
@@ -0,0 +1,15 @@
+/** Oceanography Batch module — tsb analytics library. */
+export interface Oceanography batchOptions { tol?: number; maxIter?: number; }
+export interface Oceanography batchResult { values: number[]; converged: boolean; }
+export function computeOceanography batch(data: number[], opts: Oceanography batchOptions = {}): Oceanography batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography batch };
diff --git a/src/oceanography/beta.ts b/src/oceanography/beta.ts
new file mode 100644
index 000000000..f76ce2ee5
--- /dev/null
+++ b/src/oceanography/beta.ts
@@ -0,0 +1,15 @@
+/** Oceanography Beta module — tsb analytics library. */
+export interface Oceanography betaOptions { tol?: number; maxIter?: number; }
+export interface Oceanography betaResult { values: number[]; converged: boolean; }
+export function computeOceanography beta(data: number[], opts: Oceanography betaOptions = {}): Oceanography betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography beta };
diff --git a/src/oceanography/biological.ts b/src/oceanography/biological.ts
new file mode 100644
index 000000000..d3df352ad
--- /dev/null
+++ b/src/oceanography/biological.ts
@@ -0,0 +1,22 @@
+/** Biological module — tsb analytics library. */
+
+/** Options for Biological. */
+export interface BiologicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Biological. */
+export interface BiologicalResult { values: number[]; converged: boolean; }
+
+/** Compute Biological. */
+export function computeBiological(data: number[], opts: BiologicalOptions = {}): BiologicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBiological };
diff --git a/src/oceanography/carbon_ocean.ts b/src/oceanography/carbon_ocean.ts
new file mode 100644
index 000000000..62f3bcd29
--- /dev/null
+++ b/src/oceanography/carbon_ocean.ts
@@ -0,0 +1,22 @@
+/** Carbon Ocean module — tsb analytics library. */
+
+/** Options for Carbon Ocean. */
+export interface CarbonOceanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Carbon Ocean. */
+export interface CarbonOceanResult { values: number[]; converged: boolean; }
+
+/** Compute Carbon Ocean. */
+export function computeCarbonOcean(data: number[], opts: CarbonOceanOptions = {}): CarbonOceanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCarbonOcean };
diff --git a/src/oceanography/chemical.ts b/src/oceanography/chemical.ts
new file mode 100644
index 000000000..d4cf7c166
--- /dev/null
+++ b/src/oceanography/chemical.ts
@@ -0,0 +1,22 @@
+/** Chemical module — tsb analytics library. */
+
+/** Options for Chemical. */
+export interface ChemicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Chemical. */
+export interface ChemicalResult { values: number[]; converged: boolean; }
+
+/** Compute Chemical. */
+export function computeChemical(data: number[], opts: ChemicalOptions = {}): ChemicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeChemical };
diff --git a/src/oceanography/circulation.ts b/src/oceanography/circulation.ts
new file mode 100644
index 000000000..0b253cee1
--- /dev/null
+++ b/src/oceanography/circulation.ts
@@ -0,0 +1,22 @@
+/** Circulation module — tsb analytics library. */
+
+/** Options for Circulation. */
+export interface CirculationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Circulation. */
+export interface CirculationResult { values: number[]; converged: boolean; }
+
+/** Compute Circulation. */
+export function computeCirculation(data: number[], opts: CirculationOptions = {}): CirculationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCirculation };
diff --git a/src/oceanography/coral.ts b/src/oceanography/coral.ts
new file mode 100644
index 000000000..02d47642f
--- /dev/null
+++ b/src/oceanography/coral.ts
@@ -0,0 +1,22 @@
+/** Coral module — tsb analytics library. */
+
+/** Options for Coral. */
+export interface CoralOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coral. */
+export interface CoralResult { values: number[]; converged: boolean; }
+
+/** Compute Coral. */
+export function computeCoral(data: number[], opts: CoralOptions = {}): CoralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCoral };
diff --git a/src/oceanography/cpu.ts b/src/oceanography/cpu.ts
new file mode 100644
index 000000000..8ab60675a
--- /dev/null
+++ b/src/oceanography/cpu.ts
@@ -0,0 +1,15 @@
+/** Oceanography Cpu module — tsb analytics library. */
+export interface Oceanography cpuOptions { tol?: number; maxIter?: number; }
+export interface Oceanography cpuResult { values: number[]; converged: boolean; }
+export function computeOceanography cpu(data: number[], opts: Oceanography cpuOptions = {}): Oceanography cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography cpu };
diff --git a/src/oceanography/dense.ts b/src/oceanography/dense.ts
new file mode 100644
index 000000000..6d2c1d182
--- /dev/null
+++ b/src/oceanography/dense.ts
@@ -0,0 +1,15 @@
+/** Oceanography Dense module — tsb analytics library. */
+export interface Oceanography denseOptions { tol?: number; maxIter?: number; }
+export interface Oceanography denseResult { values: number[]; converged: boolean; }
+export function computeOceanography dense(data: number[], opts: Oceanography denseOptions = {}): Oceanography denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography dense };
diff --git a/src/oceanography/distributed.ts b/src/oceanography/distributed.ts
new file mode 100644
index 000000000..be6dfdc80
--- /dev/null
+++ b/src/oceanography/distributed.ts
@@ -0,0 +1,15 @@
+/** Oceanography Distributed module — tsb analytics library. */
+export interface Oceanography distributedOptions { tol?: number; maxIter?: number; }
+export interface Oceanography distributedResult { values: number[]; converged: boolean; }
+export function computeOceanography distributed(data: number[], opts: Oceanography distributedOptions = {}): Oceanography distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography distributed };
diff --git a/src/oceanography/downwelling.ts b/src/oceanography/downwelling.ts
new file mode 100644
index 000000000..6c62b2dbe
--- /dev/null
+++ b/src/oceanography/downwelling.ts
@@ -0,0 +1,22 @@
+/** Downwelling module — tsb analytics library. */
+
+/** Options for Downwelling. */
+export interface DownwellingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Downwelling. */
+export interface DownwellingResult { values: number[]; converged: boolean; }
+
+/** Compute Downwelling. */
+export function computeDownwelling(data: number[], opts: DownwellingOptions = {}): DownwellingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDownwelling };
diff --git a/src/oceanography/el_nino.ts b/src/oceanography/el_nino.ts
new file mode 100644
index 000000000..e4c9dde88
--- /dev/null
+++ b/src/oceanography/el_nino.ts
@@ -0,0 +1,22 @@
+/** El Nino module — tsb analytics library. */
+
+/** Options for El Nino. */
+export interface ElNinoOptions { tol?: number; maxIter?: number; }
+
+/** Result from El Nino. */
+export interface ElNinoResult { values: number[]; converged: boolean; }
+
+/** Compute El Nino. */
+export function computeElNino(data: number[], opts: ElNinoOptions = {}): ElNinoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeElNino };
diff --git a/src/oceanography/experimental.ts b/src/oceanography/experimental.ts
new file mode 100644
index 000000000..a1071baab
--- /dev/null
+++ b/src/oceanography/experimental.ts
@@ -0,0 +1,15 @@
+/** Oceanography Experimental module — tsb analytics library. */
+export interface Oceanography experimentalOptions { tol?: number; maxIter?: number; }
+export interface Oceanography experimentalResult { values: number[]; converged: boolean; }
+export function computeOceanography experimental(data: number[], opts: Oceanography experimentalOptions = {}): Oceanography experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography experimental };
diff --git a/src/oceanography/fast.ts b/src/oceanography/fast.ts
new file mode 100644
index 000000000..c66404acc
--- /dev/null
+++ b/src/oceanography/fast.ts
@@ -0,0 +1,15 @@
+/** Oceanography Fast module — tsb analytics library. */
+export interface Oceanography fastOptions { tol?: number; maxIter?: number; }
+export interface Oceanography fastResult { values: number[]; converged: boolean; }
+export function computeOceanography fast(data: number[], opts: Oceanography fastOptions = {}): Oceanography fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography fast };
diff --git a/src/oceanography/future.ts b/src/oceanography/future.ts
new file mode 100644
index 000000000..4bd5fb28d
--- /dev/null
+++ b/src/oceanography/future.ts
@@ -0,0 +1,15 @@
+/** Oceanography Future module — tsb analytics library. */
+export interface Oceanography futureOptions { tol?: number; maxIter?: number; }
+export interface Oceanography futureResult { values: number[]; converged: boolean; }
+export function computeOceanography future(data: number[], opts: Oceanography futureOptions = {}): Oceanography futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography future };
diff --git a/src/oceanography/geological.ts b/src/oceanography/geological.ts
new file mode 100644
index 000000000..ca329b2fb
--- /dev/null
+++ b/src/oceanography/geological.ts
@@ -0,0 +1,22 @@
+/** Geological module — tsb analytics library. */
+
+/** Options for Geological. */
+export interface GeologicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Geological. */
+export interface GeologicalResult { values: number[]; converged: boolean; }
+
+/** Compute Geological. */
+export function computeGeological(data: number[], opts: GeologicalOptions = {}): GeologicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGeological };
diff --git a/src/oceanography/gpu.ts b/src/oceanography/gpu.ts
new file mode 100644
index 000000000..87cbd54db
--- /dev/null
+++ b/src/oceanography/gpu.ts
@@ -0,0 +1,15 @@
+/** Oceanography Gpu module — tsb analytics library. */
+export interface Oceanography gpuOptions { tol?: number; maxIter?: number; }
+export interface Oceanography gpuResult { values: number[]; converged: boolean; }
+export function computeOceanography gpu(data: number[], opts: Oceanography gpuOptions = {}): Oceanography gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography gpu };
diff --git a/src/oceanography/gyre.ts b/src/oceanography/gyre.ts
new file mode 100644
index 000000000..47233fe79
--- /dev/null
+++ b/src/oceanography/gyre.ts
@@ -0,0 +1,22 @@
+/** Gyre module — tsb analytics library. */
+
+/** Options for Gyre. */
+export interface GyreOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gyre. */
+export interface GyreResult { values: number[]; converged: boolean; }
+
+/** Compute Gyre. */
+export function computeGyre(data: number[], opts: GyreOptions = {}): GyreResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGyre };
diff --git a/src/oceanography/la_nina.ts b/src/oceanography/la_nina.ts
new file mode 100644
index 000000000..d444c109d
--- /dev/null
+++ b/src/oceanography/la_nina.ts
@@ -0,0 +1,22 @@
+/** La Nina module — tsb analytics library. */
+
+/** Options for La Nina. */
+export interface LaNinaOptions { tol?: number; maxIter?: number; }
+
+/** Result from La Nina. */
+export interface LaNinaResult { values: number[]; converged: boolean; }
+
+/** Compute La Nina. */
+export function computeLaNina(data: number[], opts: LaNinaOptions = {}): LaNinaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLaNina };
diff --git a/src/oceanography/large.ts b/src/oceanography/large.ts
new file mode 100644
index 000000000..ca954e15d
--- /dev/null
+++ b/src/oceanography/large.ts
@@ -0,0 +1,15 @@
+/** Oceanography Large module — tsb analytics library. */
+export interface Oceanography largeOptions { tol?: number; maxIter?: number; }
+export interface Oceanography largeResult { values: number[]; converged: boolean; }
+export function computeOceanography large(data: number[], opts: Oceanography largeOptions = {}): Oceanography largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography large };
diff --git a/src/oceanography/legacy.ts b/src/oceanography/legacy.ts
new file mode 100644
index 000000000..e99636234
--- /dev/null
+++ b/src/oceanography/legacy.ts
@@ -0,0 +1,15 @@
+/** Oceanography Legacy module — tsb analytics library. */
+export interface Oceanography legacyOptions { tol?: number; maxIter?: number; }
+export interface Oceanography legacyResult { values: number[]; converged: boolean; }
+export function computeOceanography legacy(data: number[], opts: Oceanography legacyOptions = {}): Oceanography legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography legacy };
diff --git a/src/oceanography/lite.ts b/src/oceanography/lite.ts
new file mode 100644
index 000000000..3ebc3eca6
--- /dev/null
+++ b/src/oceanography/lite.ts
@@ -0,0 +1,15 @@
+/** Oceanography Lite module — tsb analytics library. */
+export interface Oceanography liteOptions { tol?: number; maxIter?: number; }
+export interface Oceanography liteResult { values: number[]; converged: boolean; }
+export function computeOceanography lite(data: number[], opts: Oceanography liteOptions = {}): Oceanography liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography lite };
diff --git a/src/oceanography/mangrove.ts b/src/oceanography/mangrove.ts
new file mode 100644
index 000000000..b5b92a4e1
--- /dev/null
+++ b/src/oceanography/mangrove.ts
@@ -0,0 +1,22 @@
+/** Mangrove module — tsb analytics library. */
+
+/** Options for Mangrove. */
+export interface MangroveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mangrove. */
+export interface MangroveResult { values: number[]; converged: boolean; }
+
+/** Compute Mangrove. */
+export function computeMangrove(data: number[], opts: MangroveOptions = {}): MangroveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMangrove };
diff --git a/src/oceanography/mini.ts b/src/oceanography/mini.ts
new file mode 100644
index 000000000..c32b8d983
--- /dev/null
+++ b/src/oceanography/mini.ts
@@ -0,0 +1,15 @@
+/** Oceanography Mini module — tsb analytics library. */
+export interface Oceanography miniOptions { tol?: number; maxIter?: number; }
+export interface Oceanography miniResult { values: number[]; converged: boolean; }
+export function computeOceanography mini(data: number[], opts: Oceanography miniOptions = {}): Oceanography miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography mini };
diff --git a/src/oceanography/mixing.ts b/src/oceanography/mixing.ts
new file mode 100644
index 000000000..ca69588bd
--- /dev/null
+++ b/src/oceanography/mixing.ts
@@ -0,0 +1,22 @@
+/** Mixing module — tsb analytics library. */
+
+/** Options for Mixing. */
+export interface MixingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mixing. */
+export interface MixingResult { values: number[]; converged: boolean; }
+
+/** Compute Mixing. */
+export function computeMixing(data: number[], opts: MixingOptions = {}): MixingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMixing };
diff --git a/src/oceanography/next.ts b/src/oceanography/next.ts
new file mode 100644
index 000000000..897a0a292
--- /dev/null
+++ b/src/oceanography/next.ts
@@ -0,0 +1,15 @@
+/** Oceanography Next module — tsb analytics library. */
+export interface Oceanography nextOptions { tol?: number; maxIter?: number; }
+export interface Oceanography nextResult { values: number[]; converged: boolean; }
+export function computeOceanography next(data: number[], opts: Oceanography nextOptions = {}): Oceanography nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography next };
diff --git a/src/oceanography/nutrients.ts b/src/oceanography/nutrients.ts
new file mode 100644
index 000000000..a475cfa1f
--- /dev/null
+++ b/src/oceanography/nutrients.ts
@@ -0,0 +1,22 @@
+/** Nutrients module — tsb analytics library. */
+
+/** Options for Nutrients. */
+export interface NutrientsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nutrients. */
+export interface NutrientsResult { values: number[]; converged: boolean; }
+
+/** Compute Nutrients. */
+export function computeNutrients(data: number[], opts: NutrientsOptions = {}): NutrientsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNutrients };
diff --git a/src/oceanography/online.ts b/src/oceanography/online.ts
new file mode 100644
index 000000000..b4b0560bf
--- /dev/null
+++ b/src/oceanography/online.ts
@@ -0,0 +1,15 @@
+/** Oceanography Online module — tsb analytics library. */
+export interface Oceanography onlineOptions { tol?: number; maxIter?: number; }
+export interface Oceanography onlineResult { values: number[]; converged: boolean; }
+export function computeOceanography online(data: number[], opts: Oceanography onlineOptions = {}): Oceanography onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography online };
diff --git a/src/oceanography/oxygen.ts b/src/oceanography/oxygen.ts
new file mode 100644
index 000000000..7fa18906a
--- /dev/null
+++ b/src/oceanography/oxygen.ts
@@ -0,0 +1,22 @@
+/** Oxygen module — tsb analytics library. */
+
+/** Options for Oxygen. */
+export interface OxygenOptions { tol?: number; maxIter?: number; }
+
+/** Result from Oxygen. */
+export interface OxygenResult { values: number[]; converged: boolean; }
+
+/** Compute Oxygen. */
+export function computeOxygen(data: number[], opts: OxygenOptions = {}): OxygenResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOxygen };
diff --git a/src/oceanography/parallel.ts b/src/oceanography/parallel.ts
new file mode 100644
index 000000000..e2ecb9f50
--- /dev/null
+++ b/src/oceanography/parallel.ts
@@ -0,0 +1,15 @@
+/** Oceanography Parallel module — tsb analytics library. */
+export interface Oceanography parallelOptions { tol?: number; maxIter?: number; }
+export interface Oceanography parallelResult { values: number[]; converged: boolean; }
+export function computeOceanography parallel(data: number[], opts: Oceanography parallelOptions = {}): Oceanography parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography parallel };
diff --git a/src/oceanography/pdo_ocean.ts b/src/oceanography/pdo_ocean.ts
new file mode 100644
index 000000000..23b5238b9
--- /dev/null
+++ b/src/oceanography/pdo_ocean.ts
@@ -0,0 +1,22 @@
+/** Pdo Ocean module — tsb analytics library. */
+
+/** Options for Pdo Ocean. */
+export interface PdoOceanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pdo Ocean. */
+export interface PdoOceanResult { values: number[]; converged: boolean; }
+
+/** Compute Pdo Ocean. */
+export function computePdoOcean(data: number[], opts: PdoOceanOptions = {}): PdoOceanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePdoOcean };
diff --git a/src/oceanography/physical.ts b/src/oceanography/physical.ts
new file mode 100644
index 000000000..211999352
--- /dev/null
+++ b/src/oceanography/physical.ts
@@ -0,0 +1,22 @@
+/** Physical module — tsb analytics library. */
+
+/** Options for Physical. */
+export interface PhysicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Physical. */
+export interface PhysicalResult { values: number[]; converged: boolean; }
+
+/** Compute Physical. */
+export function computePhysical(data: number[], opts: PhysicalOptions = {}): PhysicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhysical };
diff --git a/src/oceanography/plankton.ts b/src/oceanography/plankton.ts
new file mode 100644
index 000000000..53b289de5
--- /dev/null
+++ b/src/oceanography/plankton.ts
@@ -0,0 +1,22 @@
+/** Plankton module — tsb analytics library. */
+
+/** Options for Plankton. */
+export interface PlanktonOptions { tol?: number; maxIter?: number; }
+
+/** Result from Plankton. */
+export interface PlanktonResult { values: number[]; converged: boolean; }
+
+/** Compute Plankton. */
+export function computePlankton(data: number[], opts: PlanktonOptions = {}): PlanktonResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePlankton };
diff --git a/src/oceanography/plus.ts b/src/oceanography/plus.ts
new file mode 100644
index 000000000..9232f664b
--- /dev/null
+++ b/src/oceanography/plus.ts
@@ -0,0 +1,15 @@
+/** Oceanography Plus module — tsb analytics library. */
+export interface Oceanography plusOptions { tol?: number; maxIter?: number; }
+export interface Oceanography plusResult { values: number[]; converged: boolean; }
+export function computeOceanography plus(data: number[], opts: Oceanography plusOptions = {}): Oceanography plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography plus };
diff --git a/src/oceanography/primary_production.ts b/src/oceanography/primary_production.ts
new file mode 100644
index 000000000..d6ef07e73
--- /dev/null
+++ b/src/oceanography/primary_production.ts
@@ -0,0 +1,22 @@
+/** Primary Production module — tsb analytics library. */
+
+/** Options for Primary Production. */
+export interface PrimaryProductionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Primary Production. */
+export interface PrimaryProductionResult { values: number[]; converged: boolean; }
+
+/** Compute Primary Production. */
+export function computePrimaryProduction(data: number[], opts: PrimaryProductionOptions = {}): PrimaryProductionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrimaryProduction };
diff --git a/src/oceanography/pro.ts b/src/oceanography/pro.ts
new file mode 100644
index 000000000..56b9b4686
--- /dev/null
+++ b/src/oceanography/pro.ts
@@ -0,0 +1,15 @@
+/** Oceanography Pro module — tsb analytics library. */
+export interface Oceanography proOptions { tol?: number; maxIter?: number; }
+export interface Oceanography proResult { values: number[]; converged: boolean; }
+export function computeOceanography pro(data: number[], opts: Oceanography proOptions = {}): Oceanography proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography pro };
diff --git a/src/oceanography/robust.ts b/src/oceanography/robust.ts
new file mode 100644
index 000000000..4b080c1d6
--- /dev/null
+++ b/src/oceanography/robust.ts
@@ -0,0 +1,15 @@
+/** Oceanography Robust module — tsb analytics library. */
+export interface Oceanography robustOptions { tol?: number; maxIter?: number; }
+export interface Oceanography robustResult { values: number[]; converged: boolean; }
+export function computeOceanography robust(data: number[], opts: Oceanography robustOptions = {}): Oceanography robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography robust };
diff --git a/src/oceanography/sea_ice.ts b/src/oceanography/sea_ice.ts
new file mode 100644
index 000000000..fd2741836
--- /dev/null
+++ b/src/oceanography/sea_ice.ts
@@ -0,0 +1,22 @@
+/** Sea Ice module — tsb analytics library. */
+
+/** Options for Sea Ice. */
+export interface SeaIceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sea Ice. */
+export interface SeaIceResult { values: number[]; converged: boolean; }
+
+/** Compute Sea Ice. */
+export function computeSeaIce(data: number[], opts: SeaIceOptions = {}): SeaIceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeaIce };
diff --git a/src/oceanography/seagrass.ts b/src/oceanography/seagrass.ts
new file mode 100644
index 000000000..868bb402f
--- /dev/null
+++ b/src/oceanography/seagrass.ts
@@ -0,0 +1,22 @@
+/** Seagrass module — tsb analytics library. */
+
+/** Options for Seagrass. */
+export interface SeagrassOptions { tol?: number; maxIter?: number; }
+
+/** Result from Seagrass. */
+export interface SeagrassResult { values: number[]; converged: boolean; }
+
+/** Compute Seagrass. */
+export function computeSeagrass(data: number[], opts: SeagrassOptions = {}): SeagrassResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSeagrass };
diff --git a/src/oceanography/small.ts b/src/oceanography/small.ts
new file mode 100644
index 000000000..2361762d0
--- /dev/null
+++ b/src/oceanography/small.ts
@@ -0,0 +1,15 @@
+/** Oceanography Small module — tsb analytics library. */
+export interface Oceanography smallOptions { tol?: number; maxIter?: number; }
+export interface Oceanography smallResult { values: number[]; converged: boolean; }
+export function computeOceanography small(data: number[], opts: Oceanography smallOptions = {}): Oceanography smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography small };
diff --git a/src/oceanography/sparse.ts b/src/oceanography/sparse.ts
new file mode 100644
index 000000000..f2a1dc25b
--- /dev/null
+++ b/src/oceanography/sparse.ts
@@ -0,0 +1,15 @@
+/** Oceanography Sparse module — tsb analytics library. */
+export interface Oceanography sparseOptions { tol?: number; maxIter?: number; }
+export interface Oceanography sparseResult { values: number[]; converged: boolean; }
+export function computeOceanography sparse(data: number[], opts: Oceanography sparseOptions = {}): Oceanography sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography sparse };
diff --git a/src/oceanography/stable.ts b/src/oceanography/stable.ts
new file mode 100644
index 000000000..4112bbf49
--- /dev/null
+++ b/src/oceanography/stable.ts
@@ -0,0 +1,15 @@
+/** Oceanography Stable module — tsb analytics library. */
+export interface Oceanography stableOptions { tol?: number; maxIter?: number; }
+export interface Oceanography stableResult { values: number[]; converged: boolean; }
+export function computeOceanography stable(data: number[], opts: Oceanography stableOptions = {}): Oceanography stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography stable };
diff --git a/src/oceanography/streaming.ts b/src/oceanography/streaming.ts
new file mode 100644
index 000000000..5816fc9f3
--- /dev/null
+++ b/src/oceanography/streaming.ts
@@ -0,0 +1,15 @@
+/** Oceanography Streaming module — tsb analytics library. */
+export interface Oceanography streamingOptions { tol?: number; maxIter?: number; }
+export interface Oceanography streamingResult { values: number[]; converged: boolean; }
+export function computeOceanography streaming(data: number[], opts: Oceanography streamingOptions = {}): Oceanography streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography streaming };
diff --git a/src/oceanography/surge.ts b/src/oceanography/surge.ts
new file mode 100644
index 000000000..ecf88dd2e
--- /dev/null
+++ b/src/oceanography/surge.ts
@@ -0,0 +1,22 @@
+/** Surge module — tsb analytics library. */
+
+/** Options for Surge. */
+export interface SurgeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Surge. */
+export interface SurgeResult { values: number[]; converged: boolean; }
+
+/** Compute Surge. */
+export function computeSurge(data: number[], opts: SurgeOptions = {}): SurgeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSurge };
diff --git a/src/oceanography/thermohaline.ts b/src/oceanography/thermohaline.ts
new file mode 100644
index 000000000..0ab4d9c3c
--- /dev/null
+++ b/src/oceanography/thermohaline.ts
@@ -0,0 +1,22 @@
+/** Thermohaline module — tsb analytics library. */
+
+/** Options for Thermohaline. */
+export interface ThermohalineOptions { tol?: number; maxIter?: number; }
+
+/** Result from Thermohaline. */
+export interface ThermohalineResult { values: number[]; converged: boolean; }
+
+/** Compute Thermohaline. */
+export function computeThermohaline(data: number[], opts: ThermohalineOptions = {}): ThermohalineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeThermohaline };
diff --git a/src/oceanography/tide.ts b/src/oceanography/tide.ts
new file mode 100644
index 000000000..f1bd1a494
--- /dev/null
+++ b/src/oceanography/tide.ts
@@ -0,0 +1,22 @@
+/** Tide module — tsb analytics library. */
+
+/** Options for Tide. */
+export interface TideOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tide. */
+export interface TideResult { values: number[]; converged: boolean; }
+
+/** Compute Tide. */
+export function computeTide(data: number[], opts: TideOptions = {}): TideResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTide };
diff --git a/src/oceanography/tsunami.ts b/src/oceanography/tsunami.ts
new file mode 100644
index 000000000..150cf7385
--- /dev/null
+++ b/src/oceanography/tsunami.ts
@@ -0,0 +1,22 @@
+/** Tsunami module — tsb analytics library. */
+
+/** Options for Tsunami. */
+export interface TsunamiOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tsunami. */
+export interface TsunamiResult { values: number[]; converged: boolean; }
+
+/** Compute Tsunami. */
+export function computeTsunami(data: number[], opts: TsunamiOptions = {}): TsunamiResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTsunami };
diff --git a/src/oceanography/turbulence.ts b/src/oceanography/turbulence.ts
new file mode 100644
index 000000000..6e452049f
--- /dev/null
+++ b/src/oceanography/turbulence.ts
@@ -0,0 +1,22 @@
+/** Turbulence module — tsb analytics library. */
+
+/** Options for Turbulence. */
+export interface TurbulenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Turbulence. */
+export interface TurbulenceResult { values: number[]; converged: boolean; }
+
+/** Compute Turbulence. */
+export function computeTurbulence(data: number[], opts: TurbulenceOptions = {}): TurbulenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTurbulence };
diff --git a/src/oceanography/upwelling.ts b/src/oceanography/upwelling.ts
new file mode 100644
index 000000000..b63b44f50
--- /dev/null
+++ b/src/oceanography/upwelling.ts
@@ -0,0 +1,22 @@
+/** Upwelling module — tsb analytics library. */
+
+/** Options for Upwelling. */
+export interface UpwellingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Upwelling. */
+export interface UpwellingResult { values: number[]; converged: boolean; }
+
+/** Compute Upwelling. */
+export function computeUpwelling(data: number[], opts: UpwellingOptions = {}): UpwellingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeUpwelling };
diff --git a/src/oceanography/v2.ts b/src/oceanography/v2.ts
new file mode 100644
index 000000000..4c2479bda
--- /dev/null
+++ b/src/oceanography/v2.ts
@@ -0,0 +1,15 @@
+/** Oceanography V2 module — tsb analytics library. */
+export interface Oceanography v2Options { tol?: number; maxIter?: number; }
+export interface Oceanography v2Result { values: number[]; converged: boolean; }
+export function computeOceanography v2(data: number[], opts: Oceanography v2Options = {}): Oceanography v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography v2 };
diff --git a/src/oceanography/v3.ts b/src/oceanography/v3.ts
new file mode 100644
index 000000000..0c9121389
--- /dev/null
+++ b/src/oceanography/v3.ts
@@ -0,0 +1,15 @@
+/** Oceanography V3 module — tsb analytics library. */
+export interface Oceanography v3Options { tol?: number; maxIter?: number; }
+export interface Oceanography v3Result { values: number[]; converged: boolean; }
+export function computeOceanography v3(data: number[], opts: Oceanography v3Options = {}): Oceanography v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography v3 };
diff --git a/src/oceanography/wasm.ts b/src/oceanography/wasm.ts
new file mode 100644
index 000000000..7a8381fbe
--- /dev/null
+++ b/src/oceanography/wasm.ts
@@ -0,0 +1,15 @@
+/** Oceanography Wasm module — tsb analytics library. */
+export interface Oceanography wasmOptions { tol?: number; maxIter?: number; }
+export interface Oceanography wasmResult { values: number[]; converged: boolean; }
+export function computeOceanography wasm(data: number[], opts: Oceanography wasmOptions = {}): Oceanography wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography wasm };
diff --git a/src/oceanography/wave_ocean.ts b/src/oceanography/wave_ocean.ts
new file mode 100644
index 000000000..a988ccd2c
--- /dev/null
+++ b/src/oceanography/wave_ocean.ts
@@ -0,0 +1,22 @@
+/** Wave Ocean module — tsb analytics library. */
+
+/** Options for Wave Ocean. */
+export interface WaveOceanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Wave Ocean. */
+export interface WaveOceanResult { values: number[]; converged: boolean; }
+
+/** Compute Wave Ocean. */
+export function computeWaveOcean(data: number[], opts: WaveOceanOptions = {}): WaveOceanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWaveOcean };
diff --git a/src/oceanography/xlarge.ts b/src/oceanography/xlarge.ts
new file mode 100644
index 000000000..14550fc2b
--- /dev/null
+++ b/src/oceanography/xlarge.ts
@@ -0,0 +1,15 @@
+/** Oceanography Xlarge module — tsb analytics library. */
+export interface Oceanography xlargeOptions { tol?: number; maxIter?: number; }
+export interface Oceanography xlargeResult { values: number[]; converged: boolean; }
+export function computeOceanography xlarge(data: number[], opts: Oceanography xlargeOptions = {}): Oceanography xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOceanography xlarge };
diff --git a/src/oncology_sci/adaptation.ts b/src/oncology_sci/adaptation.ts
new file mode 100644
index 000000000..ac87db31d
--- /dev/null
+++ b/src/oncology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci adaptation module — tsb analytics library. */
+export interface OncologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeOncologySciAdaptation(data: number[], opts: OncologySciAdaptationOptions = {}): OncologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciAdaptation };
diff --git a/src/oncology_sci/aggregation.ts b/src/oncology_sci/aggregation.ts
new file mode 100644
index 000000000..9e0081dd0
--- /dev/null
+++ b/src/oncology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci aggregation module — tsb analytics library. */
+export interface OncologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeOncologySciAggregation(data: number[], opts: OncologySciAggregationOptions = {}): OncologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciAggregation };
diff --git a/src/oncology_sci/algebra.ts b/src/oncology_sci/algebra.ts
new file mode 100644
index 000000000..4146dcaac
--- /dev/null
+++ b/src/oncology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** oncology_sci algebra module — tsb analytics library. */
+export interface OncologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface OncologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeOncologySciAlgebra(data: number[], opts: OncologySciAlgebraOptions = {}): OncologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciAlgebra };
diff --git a/src/oncology_sci/alignment.ts b/src/oncology_sci/alignment.ts
new file mode 100644
index 000000000..0444ed1ef
--- /dev/null
+++ b/src/oncology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** oncology_sci alignment module — tsb analytics library. */
+export interface OncologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface OncologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeOncologySciAlignment(data: number[], opts: OncologySciAlignmentOptions = {}): OncologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciAlignment };
diff --git a/src/oncology_sci/analysis.ts b/src/oncology_sci/analysis.ts
new file mode 100644
index 000000000..46c4f7d16
--- /dev/null
+++ b/src/oncology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** oncology_sci analysis module — tsb analytics library. */
+export interface OncologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface OncologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeOncologySciAnalysis(data: number[], opts: OncologySciAnalysisOptions = {}): OncologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciAnalysis };
diff --git a/src/oncology_sci/augmentation.ts b/src/oncology_sci/augmentation.ts
new file mode 100644
index 000000000..1c3be1c05
--- /dev/null
+++ b/src/oncology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci augmentation module — tsb analytics library. */
+export interface OncologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeOncologySciAugmentation(data: number[], opts: OncologySciAugmentationOptions = {}): OncologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciAugmentation };
diff --git a/src/oncology_sci/bagging.ts b/src/oncology_sci/bagging.ts
new file mode 100644
index 000000000..ff8c48215
--- /dev/null
+++ b/src/oncology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** oncology_sci bagging module — tsb analytics library. */
+export interface OncologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeOncologySciBagging(data: number[], opts: OncologySciBaggingOptions = {}): OncologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciBagging };
diff --git a/src/oncology_sci/basis.ts b/src/oncology_sci/basis.ts
new file mode 100644
index 000000000..ed8d5d27e
--- /dev/null
+++ b/src/oncology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** oncology_sci basis module — tsb analytics library. */
+export interface OncologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface OncologySciBasisResult { values: number[]; converged: boolean; }
+export function computeOncologySciBasis(data: number[], opts: OncologySciBasisOptions = {}): OncologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciBasis };
diff --git a/src/oncology_sci/benchmarking.ts b/src/oncology_sci/benchmarking.ts
new file mode 100644
index 000000000..59d0a602c
--- /dev/null
+++ b/src/oncology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** oncology_sci benchmarking module — tsb analytics library. */
+export interface OncologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeOncologySciBenchmarking(data: number[], opts: OncologySciBenchmarkingOptions = {}): OncologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciBenchmarking };
diff --git a/src/oncology_sci/blending.ts b/src/oncology_sci/blending.ts
new file mode 100644
index 000000000..c322c8157
--- /dev/null
+++ b/src/oncology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** oncology_sci blending module — tsb analytics library. */
+export interface OncologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeOncologySciBlending(data: number[], opts: OncologySciBlendingOptions = {}): OncologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciBlending };
diff --git a/src/oncology_sci/boosting.ts b/src/oncology_sci/boosting.ts
new file mode 100644
index 000000000..449c1f01f
--- /dev/null
+++ b/src/oncology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** oncology_sci boosting module — tsb analytics library. */
+export interface OncologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeOncologySciBoosting(data: number[], opts: OncologySciBoostingOptions = {}): OncologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciBoosting };
diff --git a/src/oncology_sci/bootstrap.ts b/src/oncology_sci/bootstrap.ts
new file mode 100644
index 000000000..f9367b781
--- /dev/null
+++ b/src/oncology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** oncology_sci bootstrap module — tsb analytics library. */
+export interface OncologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface OncologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeOncologySciBootstrap(data: number[], opts: OncologySciBootstrapOptions = {}): OncologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciBootstrap };
diff --git a/src/oncology_sci/calculus.ts b/src/oncology_sci/calculus.ts
new file mode 100644
index 000000000..0bd7e1a27
--- /dev/null
+++ b/src/oncology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** oncology_sci calculus module — tsb analytics library. */
+export interface OncologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface OncologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeOncologySciCalculus(data: number[], opts: OncologySciCalculusOptions = {}): OncologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciCalculus };
diff --git a/src/oncology_sci/calibration.ts b/src/oncology_sci/calibration.ts
new file mode 100644
index 000000000..b02bcba72
--- /dev/null
+++ b/src/oncology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** oncology_sci calibration module — tsb analytics library. */
+export interface OncologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeOncologySciCalibration(data: number[], opts: OncologySciCalibrationOptions = {}): OncologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciCalibration };
diff --git a/src/oncology_sci/characterization.ts b/src/oncology_sci/characterization.ts
new file mode 100644
index 000000000..fbad31564
--- /dev/null
+++ b/src/oncology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** oncology_sci characterization module — tsb analytics library. */
+export interface OncologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeOncologySciCharacterization(data: number[], opts: OncologySciCharacterizationOptions = {}): OncologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciCharacterization };
diff --git a/src/oncology_sci/classification.ts b/src/oncology_sci/classification.ts
new file mode 100644
index 000000000..4aa8fc7ca
--- /dev/null
+++ b/src/oncology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** oncology_sci classification module — tsb analytics library. */
+export interface OncologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeOncologySciClassification(data: number[], opts: OncologySciClassificationOptions = {}): OncologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciClassification };
diff --git a/src/oncology_sci/clustering.ts b/src/oncology_sci/clustering.ts
new file mode 100644
index 000000000..4d868a8db
--- /dev/null
+++ b/src/oncology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** oncology_sci clustering module — tsb analytics library. */
+export interface OncologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface OncologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeOncologySciClustering(data: number[], opts: OncologySciClusteringOptions = {}): OncologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciClustering };
diff --git a/src/oncology_sci/compression.ts b/src/oncology_sci/compression.ts
new file mode 100644
index 000000000..26675db58
--- /dev/null
+++ b/src/oncology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** oncology_sci compression module — tsb analytics library. */
+export interface OncologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeOncologySciCompression(data: number[], opts: OncologySciCompressionOptions = {}): OncologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciCompression };
diff --git a/src/oncology_sci/continuous.ts b/src/oncology_sci/continuous.ts
new file mode 100644
index 000000000..d2c92ddbc
--- /dev/null
+++ b/src/oncology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** oncology_sci continuous module — tsb analytics library. */
+export interface OncologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface OncologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeOncologySciContinuous(data: number[], opts: OncologySciContinuousOptions = {}): OncologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciContinuous };
diff --git a/src/oncology_sci/control.ts b/src/oncology_sci/control.ts
new file mode 100644
index 000000000..dc6a5415f
--- /dev/null
+++ b/src/oncology_sci/control.ts
@@ -0,0 +1,14 @@
+/** oncology_sci control module — tsb analytics library. */
+export interface OncologySciControlOptions { tol?: number; maxIter?: number; }
+export interface OncologySciControlResult { values: number[]; converged: boolean; }
+export function computeOncologySciControl(data: number[], opts: OncologySciControlOptions = {}): OncologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciControl };
diff --git a/src/oncology_sci/convergence.ts b/src/oncology_sci/convergence.ts
new file mode 100644
index 000000000..91911d65a
--- /dev/null
+++ b/src/oncology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** oncology_sci convergence module — tsb analytics library. */
+export interface OncologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface OncologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeOncologySciConvergence(data: number[], opts: OncologySciConvergenceOptions = {}): OncologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciConvergence };
diff --git a/src/oncology_sci/convex.ts b/src/oncology_sci/convex.ts
new file mode 100644
index 000000000..404e21d9c
--- /dev/null
+++ b/src/oncology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** oncology_sci convex module — tsb analytics library. */
+export interface OncologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface OncologySciConvexResult { values: number[]; converged: boolean; }
+export function computeOncologySciConvex(data: number[], opts: OncologySciConvexOptions = {}): OncologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciConvex };
diff --git a/src/oncology_sci/correlation.ts b/src/oncology_sci/correlation.ts
new file mode 100644
index 000000000..24d784898
--- /dev/null
+++ b/src/oncology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci correlation module — tsb analytics library. */
+export interface OncologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeOncologySciCorrelation(data: number[], opts: OncologySciCorrelationOptions = {}): OncologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciCorrelation };
diff --git a/src/oncology_sci/covariance.ts b/src/oncology_sci/covariance.ts
new file mode 100644
index 000000000..05cc22d47
--- /dev/null
+++ b/src/oncology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** oncology_sci covariance module — tsb analytics library. */
+export interface OncologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface OncologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeOncologySciCovariance(data: number[], opts: OncologySciCovarianceOptions = {}): OncologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciCovariance };
diff --git a/src/oncology_sci/cross_validation.ts b/src/oncology_sci/cross_validation.ts
new file mode 100644
index 000000000..26f5c9d44
--- /dev/null
+++ b/src/oncology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci cross_validation module — tsb analytics library. */
+export interface OncologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeOncologySciCrossValidation(data: number[], opts: OncologySciCrossValidationOptions = {}): OncologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciCrossValidation };
diff --git a/src/oncology_sci/decoding.ts b/src/oncology_sci/decoding.ts
new file mode 100644
index 000000000..38128eaec
--- /dev/null
+++ b/src/oncology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** oncology_sci decoding module — tsb analytics library. */
+export interface OncologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeOncologySciDecoding(data: number[], opts: OncologySciDecodingOptions = {}): OncologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDecoding };
diff --git a/src/oncology_sci/decomposition.ts b/src/oncology_sci/decomposition.ts
new file mode 100644
index 000000000..7a68ec12b
--- /dev/null
+++ b/src/oncology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** oncology_sci decomposition module — tsb analytics library. */
+export interface OncologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeOncologySciDecomposition(data: number[], opts: OncologySciDecompositionOptions = {}): OncologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDecomposition };
diff --git a/src/oncology_sci/detection.ts b/src/oncology_sci/detection.ts
new file mode 100644
index 000000000..4c3767b96
--- /dev/null
+++ b/src/oncology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** oncology_sci detection module — tsb analytics library. */
+export interface OncologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeOncologySciDetection(data: number[], opts: OncologySciDetectionOptions = {}): OncologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDetection };
diff --git a/src/oncology_sci/deterministic.ts b/src/oncology_sci/deterministic.ts
new file mode 100644
index 000000000..9ba473925
--- /dev/null
+++ b/src/oncology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** oncology_sci deterministic module — tsb analytics library. */
+export interface OncologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeOncologySciDeterministic(data: number[], opts: OncologySciDeterministicOptions = {}): OncologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDeterministic };
diff --git a/src/oncology_sci/diagnostics.ts b/src/oncology_sci/diagnostics.ts
new file mode 100644
index 000000000..e73da8063
--- /dev/null
+++ b/src/oncology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** oncology_sci diagnostics module — tsb analytics library. */
+export interface OncologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeOncologySciDiagnostics(data: number[], opts: OncologySciDiagnosticsOptions = {}): OncologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDiagnostics };
diff --git a/src/oncology_sci/differential.ts b/src/oncology_sci/differential.ts
new file mode 100644
index 000000000..a2feb5993
--- /dev/null
+++ b/src/oncology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** oncology_sci differential module — tsb analytics library. */
+export interface OncologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeOncologySciDifferential(data: number[], opts: OncologySciDifferentialOptions = {}): OncologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDifferential };
diff --git a/src/oncology_sci/discrete.ts b/src/oncology_sci/discrete.ts
new file mode 100644
index 000000000..92673d7e8
--- /dev/null
+++ b/src/oncology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** oncology_sci discrete module — tsb analytics library. */
+export interface OncologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeOncologySciDiscrete(data: number[], opts: OncologySciDiscreteOptions = {}): OncologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDiscrete };
diff --git a/src/oncology_sci/distribution.ts b/src/oncology_sci/distribution.ts
new file mode 100644
index 000000000..c9dcc2b4b
--- /dev/null
+++ b/src/oncology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** oncology_sci distribution module — tsb analytics library. */
+export interface OncologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeOncologySciDistribution(data: number[], opts: OncologySciDistributionOptions = {}): OncologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDistribution };
diff --git a/src/oncology_sci/dynamic.ts b/src/oncology_sci/dynamic.ts
new file mode 100644
index 000000000..9a0ce3999
--- /dev/null
+++ b/src/oncology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** oncology_sci dynamic module — tsb analytics library. */
+export interface OncologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface OncologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeOncologySciDynamic(data: number[], opts: OncologySciDynamicOptions = {}): OncologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciDynamic };
diff --git a/src/oncology_sci/embedding.ts b/src/oncology_sci/embedding.ts
new file mode 100644
index 000000000..aa55f479b
--- /dev/null
+++ b/src/oncology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** oncology_sci embedding module — tsb analytics library. */
+export interface OncologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeOncologySciEmbedding(data: number[], opts: OncologySciEmbeddingOptions = {}): OncologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciEmbedding };
diff --git a/src/oncology_sci/encoding.ts b/src/oncology_sci/encoding.ts
new file mode 100644
index 000000000..b976971f2
--- /dev/null
+++ b/src/oncology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** oncology_sci encoding module — tsb analytics library. */
+export interface OncologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeOncologySciEncoding(data: number[], opts: OncologySciEncodingOptions = {}): OncologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciEncoding };
diff --git a/src/oncology_sci/ensemble.ts b/src/oncology_sci/ensemble.ts
new file mode 100644
index 000000000..465bf6b8b
--- /dev/null
+++ b/src/oncology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** oncology_sci ensemble module — tsb analytics library. */
+export interface OncologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface OncologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeOncologySciEnsemble(data: number[], opts: OncologySciEnsembleOptions = {}): OncologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciEnsemble };
diff --git a/src/oncology_sci/estimation.ts b/src/oncology_sci/estimation.ts
new file mode 100644
index 000000000..de7c2678d
--- /dev/null
+++ b/src/oncology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci estimation module — tsb analytics library. */
+export interface OncologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeOncologySciEstimation(data: number[], opts: OncologySciEstimationOptions = {}): OncologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciEstimation };
diff --git a/src/oncology_sci/evaluation.ts b/src/oncology_sci/evaluation.ts
new file mode 100644
index 000000000..25c2a70bd
--- /dev/null
+++ b/src/oncology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci evaluation module — tsb analytics library. */
+export interface OncologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeOncologySciEvaluation(data: number[], opts: OncologySciEvaluationOptions = {}): OncologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciEvaluation };
diff --git a/src/oncology_sci/extrapolation.ts b/src/oncology_sci/extrapolation.ts
new file mode 100644
index 000000000..83c7f0fdb
--- /dev/null
+++ b/src/oncology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci extrapolation module — tsb analytics library. */
+export interface OncologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeOncologySciExtrapolation(data: number[], opts: OncologySciExtrapolationOptions = {}): OncologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciExtrapolation };
diff --git a/src/oncology_sci/features.ts b/src/oncology_sci/features.ts
new file mode 100644
index 000000000..a35445ab6
--- /dev/null
+++ b/src/oncology_sci/features.ts
@@ -0,0 +1,14 @@
+/** oncology_sci features module — tsb analytics library. */
+export interface OncologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface OncologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeOncologySciFeatures(data: number[], opts: OncologySciFeaturesOptions = {}): OncologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciFeatures };
diff --git a/src/oncology_sci/feedback.ts b/src/oncology_sci/feedback.ts
new file mode 100644
index 000000000..ea7c05b79
--- /dev/null
+++ b/src/oncology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** oncology_sci feedback module — tsb analytics library. */
+export interface OncologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface OncologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeOncologySciFeedback(data: number[], opts: OncologySciFeedbackOptions = {}): OncologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciFeedback };
diff --git a/src/oncology_sci/filtering.ts b/src/oncology_sci/filtering.ts
new file mode 100644
index 000000000..333da5447
--- /dev/null
+++ b/src/oncology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** oncology_sci filtering module — tsb analytics library. */
+export interface OncologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface OncologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeOncologySciFiltering(data: number[], opts: OncologySciFilteringOptions = {}): OncologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciFiltering };
diff --git a/src/oncology_sci/fourier.ts b/src/oncology_sci/fourier.ts
new file mode 100644
index 000000000..6f5ca5c45
--- /dev/null
+++ b/src/oncology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** oncology_sci fourier module — tsb analytics library. */
+export interface OncologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface OncologySciFourierResult { values: number[]; converged: boolean; }
+export function computeOncologySciFourier(data: number[], opts: OncologySciFourierOptions = {}): OncologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciFourier };
diff --git a/src/oncology_sci/fusion.ts b/src/oncology_sci/fusion.ts
new file mode 100644
index 000000000..4dfd70a8b
--- /dev/null
+++ b/src/oncology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** oncology_sci fusion module — tsb analytics library. */
+export interface OncologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciFusionResult { values: number[]; converged: boolean; }
+export function computeOncologySciFusion(data: number[], opts: OncologySciFusionOptions = {}): OncologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciFusion };
diff --git a/src/oncology_sci/generation.ts b/src/oncology_sci/generation.ts
new file mode 100644
index 000000000..2b1f2d98f
--- /dev/null
+++ b/src/oncology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci generation module — tsb analytics library. */
+export interface OncologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeOncologySciGeneration(data: number[], opts: OncologySciGenerationOptions = {}): OncologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciGeneration };
diff --git a/src/oncology_sci/geometry.ts b/src/oncology_sci/geometry.ts
new file mode 100644
index 000000000..3a3694b1f
--- /dev/null
+++ b/src/oncology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** oncology_sci geometry module — tsb analytics library. */
+export interface OncologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface OncologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeOncologySciGeometry(data: number[], opts: OncologySciGeometryOptions = {}): OncologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciGeometry };
diff --git a/src/oncology_sci/gradient.ts b/src/oncology_sci/gradient.ts
new file mode 100644
index 000000000..89261c5ea
--- /dev/null
+++ b/src/oncology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** oncology_sci gradient module — tsb analytics library. */
+export interface OncologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface OncologySciGradientResult { values: number[]; converged: boolean; }
+export function computeOncologySciGradient(data: number[], opts: OncologySciGradientOptions = {}): OncologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciGradient };
diff --git a/src/oncology_sci/hessian.ts b/src/oncology_sci/hessian.ts
new file mode 100644
index 000000000..80a77e7a9
--- /dev/null
+++ b/src/oncology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** oncology_sci hessian module — tsb analytics library. */
+export interface OncologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface OncologySciHessianResult { values: number[]; converged: boolean; }
+export function computeOncologySciHessian(data: number[], opts: OncologySciHessianOptions = {}): OncologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciHessian };
diff --git a/src/oncology_sci/hypothesis.ts b/src/oncology_sci/hypothesis.ts
new file mode 100644
index 000000000..90fc9f8d5
--- /dev/null
+++ b/src/oncology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** oncology_sci hypothesis module — tsb analytics library. */
+export interface OncologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface OncologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeOncologySciHypothesis(data: number[], opts: OncologySciHypothesisOptions = {}): OncologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciHypothesis };
diff --git a/src/oncology_sci/inference.ts b/src/oncology_sci/inference.ts
new file mode 100644
index 000000000..4ff6de2d1
--- /dev/null
+++ b/src/oncology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** oncology_sci inference module — tsb analytics library. */
+export interface OncologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface OncologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeOncologySciInference(data: number[], opts: OncologySciInferenceOptions = {}): OncologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciInference };
diff --git a/src/oncology_sci/inference2.ts b/src/oncology_sci/inference2.ts
new file mode 100644
index 000000000..b1d2cda21
--- /dev/null
+++ b/src/oncology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** oncology_sci inference2 module — tsb analytics library. */
+export interface OncologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface OncologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeOncologySciInference(data: number[], opts: OncologySciInferenceOptions = {}): OncologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciInference };
diff --git a/src/oncology_sci/integral.ts b/src/oncology_sci/integral.ts
new file mode 100644
index 000000000..f1e6e573e
--- /dev/null
+++ b/src/oncology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** oncology_sci integral module — tsb analytics library. */
+export interface OncologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface OncologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeOncologySciIntegral(data: number[], opts: OncologySciIntegralOptions = {}): OncologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciIntegral };
diff --git a/src/oncology_sci/integration.ts b/src/oncology_sci/integration.ts
new file mode 100644
index 000000000..0542754ca
--- /dev/null
+++ b/src/oncology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** oncology_sci integration module — tsb analytics library. */
+export interface OncologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeOncologySciIntegration(data: number[], opts: OncologySciIntegrationOptions = {}): OncologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciIntegration };
diff --git a/src/oncology_sci/interpolation.ts b/src/oncology_sci/interpolation.ts
new file mode 100644
index 000000000..df690e96f
--- /dev/null
+++ b/src/oncology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci interpolation module — tsb analytics library. */
+export interface OncologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeOncologySciInterpolation(data: number[], opts: OncologySciInterpolationOptions = {}): OncologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciInterpolation };
diff --git a/src/oncology_sci/jacobian.ts b/src/oncology_sci/jacobian.ts
new file mode 100644
index 000000000..2b8be8df8
--- /dev/null
+++ b/src/oncology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** oncology_sci jacobian module — tsb analytics library. */
+export interface OncologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface OncologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeOncologySciJacobian(data: number[], opts: OncologySciJacobianOptions = {}): OncologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciJacobian };
diff --git a/src/oncology_sci/kernel.ts b/src/oncology_sci/kernel.ts
new file mode 100644
index 000000000..b2250dd4a
--- /dev/null
+++ b/src/oncology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** oncology_sci kernel module — tsb analytics library. */
+export interface OncologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface OncologySciKernelResult { values: number[]; converged: boolean; }
+export function computeOncologySciKernel(data: number[], opts: OncologySciKernelOptions = {}): OncologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciKernel };
diff --git a/src/oncology_sci/laplacian.ts b/src/oncology_sci/laplacian.ts
new file mode 100644
index 000000000..e97046774
--- /dev/null
+++ b/src/oncology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** oncology_sci laplacian module — tsb analytics library. */
+export interface OncologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface OncologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeOncologySciLaplacian(data: number[], opts: OncologySciLaplacianOptions = {}): OncologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciLaplacian };
diff --git a/src/oncology_sci/learning.ts b/src/oncology_sci/learning.ts
new file mode 100644
index 000000000..0837e0674
--- /dev/null
+++ b/src/oncology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** oncology_sci learning module — tsb analytics library. */
+export interface OncologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface OncologySciLearningResult { values: number[]; converged: boolean; }
+export function computeOncologySciLearning(data: number[], opts: OncologySciLearningOptions = {}): OncologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciLearning };
diff --git a/src/oncology_sci/linear.ts b/src/oncology_sci/linear.ts
new file mode 100644
index 000000000..500ae9c14
--- /dev/null
+++ b/src/oncology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** oncology_sci linear module — tsb analytics library. */
+export interface OncologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface OncologySciLinearResult { values: number[]; converged: boolean; }
+export function computeOncologySciLinear(data: number[], opts: OncologySciLinearOptions = {}): OncologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciLinear };
diff --git a/src/oncology_sci/manifold.ts b/src/oncology_sci/manifold.ts
new file mode 100644
index 000000000..b05e25176
--- /dev/null
+++ b/src/oncology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** oncology_sci manifold module — tsb analytics library. */
+export interface OncologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface OncologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeOncologySciManifold(data: number[], opts: OncologySciManifoldOptions = {}): OncologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciManifold };
diff --git a/src/oncology_sci/matching.ts b/src/oncology_sci/matching.ts
new file mode 100644
index 000000000..cef4ab4c9
--- /dev/null
+++ b/src/oncology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** oncology_sci matching module — tsb analytics library. */
+export interface OncologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeOncologySciMatching(data: number[], opts: OncologySciMatchingOptions = {}): OncologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciMatching };
diff --git a/src/oncology_sci/measurement.ts b/src/oncology_sci/measurement.ts
new file mode 100644
index 000000000..792056e5d
--- /dev/null
+++ b/src/oncology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** oncology_sci measurement module — tsb analytics library. */
+export interface OncologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface OncologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeOncologySciMeasurement(data: number[], opts: OncologySciMeasurementOptions = {}): OncologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciMeasurement };
diff --git a/src/oncology_sci/metrics.ts b/src/oncology_sci/metrics.ts
new file mode 100644
index 000000000..d4bc200af
--- /dev/null
+++ b/src/oncology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** oncology_sci metrics module — tsb analytics library. */
+export interface OncologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface OncologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeOncologySciMetrics(data: number[], opts: OncologySciMetricsOptions = {}): OncologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciMetrics };
diff --git a/src/oncology_sci/modeling.ts b/src/oncology_sci/modeling.ts
new file mode 100644
index 000000000..e012ca872
--- /dev/null
+++ b/src/oncology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** oncology_sci modeling module — tsb analytics library. */
+export interface OncologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciModelingResult { values: number[]; converged: boolean; }
+export function computeOncologySciModeling(data: number[], opts: OncologySciModelingOptions = {}): OncologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciModeling };
diff --git a/src/oncology_sci/monitoring.ts b/src/oncology_sci/monitoring.ts
new file mode 100644
index 000000000..1477bf51d
--- /dev/null
+++ b/src/oncology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** oncology_sci monitoring module — tsb analytics library. */
+export interface OncologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface OncologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeOncologySciMonitoring(data: number[], opts: OncologySciMonitoringOptions = {}): OncologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciMonitoring };
diff --git a/src/oncology_sci/nonlinear.ts b/src/oncology_sci/nonlinear.ts
new file mode 100644
index 000000000..c298cec9c
--- /dev/null
+++ b/src/oncology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** oncology_sci nonlinear module — tsb analytics library. */
+export interface OncologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface OncologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeOncologySciNonlinear(data: number[], opts: OncologySciNonlinearOptions = {}): OncologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciNonlinear };
diff --git a/src/oncology_sci/normalization.ts b/src/oncology_sci/normalization.ts
new file mode 100644
index 000000000..bcfca55e8
--- /dev/null
+++ b/src/oncology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** oncology_sci normalization module — tsb analytics library. */
+export interface OncologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeOncologySciNormalization(data: number[], opts: OncologySciNormalizationOptions = {}): OncologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciNormalization };
diff --git a/src/oncology_sci/optimization.ts b/src/oncology_sci/optimization.ts
new file mode 100644
index 000000000..efed5e5df
--- /dev/null
+++ b/src/oncology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** oncology_sci optimization module — tsb analytics library. */
+export interface OncologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeOncologySciOptimization(data: number[], opts: OncologySciOptimizationOptions = {}): OncologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciOptimization };
diff --git a/src/oncology_sci/patterns.ts b/src/oncology_sci/patterns.ts
new file mode 100644
index 000000000..325fc0ecf
--- /dev/null
+++ b/src/oncology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** oncology_sci patterns module — tsb analytics library. */
+export interface OncologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface OncologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeOncologySciPatterns(data: number[], opts: OncologySciPatternsOptions = {}): OncologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciPatterns };
diff --git a/src/oncology_sci/permutation.ts b/src/oncology_sci/permutation.ts
new file mode 100644
index 000000000..32f3d4550
--- /dev/null
+++ b/src/oncology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci permutation module — tsb analytics library. */
+export interface OncologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeOncologySciPermutation(data: number[], opts: OncologySciPermutationOptions = {}): OncologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciPermutation };
diff --git a/src/oncology_sci/prediction.ts b/src/oncology_sci/prediction.ts
new file mode 100644
index 000000000..8e3fd0440
--- /dev/null
+++ b/src/oncology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** oncology_sci prediction module — tsb analytics library. */
+export interface OncologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeOncologySciPrediction(data: number[], opts: OncologySciPredictionOptions = {}): OncologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciPrediction };
diff --git a/src/oncology_sci/processing.ts b/src/oncology_sci/processing.ts
new file mode 100644
index 000000000..a498b1a99
--- /dev/null
+++ b/src/oncology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** oncology_sci processing module — tsb analytics library. */
+export interface OncologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeOncologySciProcessing(data: number[], opts: OncologySciProcessingOptions = {}): OncologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciProcessing };
diff --git a/src/oncology_sci/profiling.ts b/src/oncology_sci/profiling.ts
new file mode 100644
index 000000000..295b282a3
--- /dev/null
+++ b/src/oncology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** oncology_sci profiling module — tsb analytics library. */
+export interface OncologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeOncologySciProfiling(data: number[], opts: OncologySciProfilingOptions = {}): OncologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciProfiling };
diff --git a/src/oncology_sci/projection.ts b/src/oncology_sci/projection.ts
new file mode 100644
index 000000000..59274bf4b
--- /dev/null
+++ b/src/oncology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** oncology_sci projection module — tsb analytics library. */
+export interface OncologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeOncologySciProjection(data: number[], opts: OncologySciProjectionOptions = {}): OncologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciProjection };
diff --git a/src/oncology_sci/ranking.ts b/src/oncology_sci/ranking.ts
new file mode 100644
index 000000000..f8a9b3b7b
--- /dev/null
+++ b/src/oncology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** oncology_sci ranking module — tsb analytics library. */
+export interface OncologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciRankingResult { values: number[]; converged: boolean; }
+export function computeOncologySciRanking(data: number[], opts: OncologySciRankingOptions = {}): OncologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciRanking };
diff --git a/src/oncology_sci/reconstruction.ts b/src/oncology_sci/reconstruction.ts
new file mode 100644
index 000000000..58c875f61
--- /dev/null
+++ b/src/oncology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** oncology_sci reconstruction module — tsb analytics library. */
+export interface OncologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeOncologySciReconstruction(data: number[], opts: OncologySciReconstructionOptions = {}): OncologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciReconstruction };
diff --git a/src/oncology_sci/registration.ts b/src/oncology_sci/registration.ts
new file mode 100644
index 000000000..fb89bd390
--- /dev/null
+++ b/src/oncology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** oncology_sci registration module — tsb analytics library. */
+export interface OncologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeOncologySciRegistration(data: number[], opts: OncologySciRegistrationOptions = {}): OncologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciRegistration };
diff --git a/src/oncology_sci/regression.ts b/src/oncology_sci/regression.ts
new file mode 100644
index 000000000..35e8d5b6d
--- /dev/null
+++ b/src/oncology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** oncology_sci regression module — tsb analytics library. */
+export interface OncologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeOncologySciRegression(data: number[], opts: OncologySciRegressionOptions = {}): OncologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciRegression };
diff --git a/src/oncology_sci/regularization.ts b/src/oncology_sci/regularization.ts
new file mode 100644
index 000000000..32ec521d1
--- /dev/null
+++ b/src/oncology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** oncology_sci regularization module — tsb analytics library. */
+export interface OncologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeOncologySciRegularization(data: number[], opts: OncologySciRegularizationOptions = {}): OncologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciRegularization };
diff --git a/src/oncology_sci/robustness.ts b/src/oncology_sci/robustness.ts
new file mode 100644
index 000000000..126bc3a41
--- /dev/null
+++ b/src/oncology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** oncology_sci robustness module — tsb analytics library. */
+export interface OncologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface OncologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeOncologySciRobustness(data: number[], opts: OncologySciRobustnessOptions = {}): OncologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciRobustness };
diff --git a/src/oncology_sci/sampling.ts b/src/oncology_sci/sampling.ts
new file mode 100644
index 000000000..9f1abc890
--- /dev/null
+++ b/src/oncology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** oncology_sci sampling module — tsb analytics library. */
+export interface OncologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeOncologySciSampling(data: number[], opts: OncologySciSamplingOptions = {}): OncologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciSampling };
diff --git a/src/oncology_sci/sampling2.ts b/src/oncology_sci/sampling2.ts
new file mode 100644
index 000000000..8e7f6c886
--- /dev/null
+++ b/src/oncology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** oncology_sci sampling2 module — tsb analytics library. */
+export interface OncologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeOncologySciSampling(data: number[], opts: OncologySciSamplingOptions = {}): OncologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciSampling };
diff --git a/src/oncology_sci/scaling.ts b/src/oncology_sci/scaling.ts
new file mode 100644
index 000000000..87790e813
--- /dev/null
+++ b/src/oncology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** oncology_sci scaling module — tsb analytics library. */
+export interface OncologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciScalingResult { values: number[]; converged: boolean; }
+export function computeOncologySciScaling(data: number[], opts: OncologySciScalingOptions = {}): OncologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciScaling };
diff --git a/src/oncology_sci/scoring.ts b/src/oncology_sci/scoring.ts
new file mode 100644
index 000000000..4ddf17586
--- /dev/null
+++ b/src/oncology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** oncology_sci scoring module — tsb analytics library. */
+export interface OncologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface OncologySciScoringResult { values: number[]; converged: boolean; }
+export function computeOncologySciScoring(data: number[], opts: OncologySciScoringOptions = {}): OncologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciScoring };
diff --git a/src/oncology_sci/segmentation.ts b/src/oncology_sci/segmentation.ts
new file mode 100644
index 000000000..9196cc0b1
--- /dev/null
+++ b/src/oncology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci segmentation module — tsb analytics library. */
+export interface OncologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeOncologySciSegmentation(data: number[], opts: OncologySciSegmentationOptions = {}): OncologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciSegmentation };
diff --git a/src/oncology_sci/selection.ts b/src/oncology_sci/selection.ts
new file mode 100644
index 000000000..727943ac9
--- /dev/null
+++ b/src/oncology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** oncology_sci selection module — tsb analytics library. */
+export interface OncologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface OncologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeOncologySciSelection(data: number[], opts: OncologySciSelectionOptions = {}): OncologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciSelection };
diff --git a/src/oncology_sci/sensitivity.ts b/src/oncology_sci/sensitivity.ts
new file mode 100644
index 000000000..66d75f760
--- /dev/null
+++ b/src/oncology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** oncology_sci sensitivity module — tsb analytics library. */
+export interface OncologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface OncologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeOncologySciSensitivity(data: number[], opts: OncologySciSensitivityOptions = {}): OncologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciSensitivity };
diff --git a/src/oncology_sci/simulation.ts b/src/oncology_sci/simulation.ts
new file mode 100644
index 000000000..e898d7ca8
--- /dev/null
+++ b/src/oncology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci simulation module — tsb analytics library. */
+export interface OncologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeOncologySciSimulation(data: number[], opts: OncologySciSimulationOptions = {}): OncologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciSimulation };
diff --git a/src/oncology_sci/smoothing.ts b/src/oncology_sci/smoothing.ts
new file mode 100644
index 000000000..8ecd1407a
--- /dev/null
+++ b/src/oncology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** oncology_sci smoothing module — tsb analytics library. */
+export interface OncologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeOncologySciSmoothing(data: number[], opts: OncologySciSmoothingOptions = {}): OncologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciSmoothing };
diff --git a/src/oncology_sci/stability.ts b/src/oncology_sci/stability.ts
new file mode 100644
index 000000000..871662c8c
--- /dev/null
+++ b/src/oncology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** oncology_sci stability module — tsb analytics library. */
+export interface OncologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface OncologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeOncologySciStability(data: number[], opts: OncologySciStabilityOptions = {}): OncologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciStability };
diff --git a/src/oncology_sci/stacking.ts b/src/oncology_sci/stacking.ts
new file mode 100644
index 000000000..9700de2e1
--- /dev/null
+++ b/src/oncology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** oncology_sci stacking module — tsb analytics library. */
+export interface OncologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciStackingResult { values: number[]; converged: boolean; }
+export function computeOncologySciStacking(data: number[], opts: OncologySciStackingOptions = {}): OncologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciStacking };
diff --git a/src/oncology_sci/standardization.ts b/src/oncology_sci/standardization.ts
new file mode 100644
index 000000000..05092d7df
--- /dev/null
+++ b/src/oncology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** oncology_sci standardization module — tsb analytics library. */
+export interface OncologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeOncologySciStandardization(data: number[], opts: OncologySciStandardizationOptions = {}): OncologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciStandardization };
diff --git a/src/oncology_sci/static.ts b/src/oncology_sci/static.ts
new file mode 100644
index 000000000..257e2867a
--- /dev/null
+++ b/src/oncology_sci/static.ts
@@ -0,0 +1,14 @@
+/** oncology_sci static module — tsb analytics library. */
+export interface OncologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface OncologySciStaticResult { values: number[]; converged: boolean; }
+export function computeOncologySciStatic(data: number[], opts: OncologySciStaticOptions = {}): OncologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciStatic };
diff --git a/src/oncology_sci/stochastic.ts b/src/oncology_sci/stochastic.ts
new file mode 100644
index 000000000..cbbd30d0d
--- /dev/null
+++ b/src/oncology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** oncology_sci stochastic module — tsb analytics library. */
+export interface OncologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface OncologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeOncologySciStochastic(data: number[], opts: OncologySciStochasticOptions = {}): OncologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciStochastic };
diff --git a/src/oncology_sci/synthesis.ts b/src/oncology_sci/synthesis.ts
new file mode 100644
index 000000000..ea51843ec
--- /dev/null
+++ b/src/oncology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** oncology_sci synthesis module — tsb analytics library. */
+export interface OncologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface OncologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeOncologySciSynthesis(data: number[], opts: OncologySciSynthesisOptions = {}): OncologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciSynthesis };
diff --git a/src/oncology_sci/topology.ts b/src/oncology_sci/topology.ts
new file mode 100644
index 000000000..a59aec5cb
--- /dev/null
+++ b/src/oncology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** oncology_sci topology module — tsb analytics library. */
+export interface OncologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface OncologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeOncologySciTopology(data: number[], opts: OncologySciTopologyOptions = {}): OncologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciTopology };
diff --git a/src/oncology_sci/tracking.ts b/src/oncology_sci/tracking.ts
new file mode 100644
index 000000000..eadabb3e7
--- /dev/null
+++ b/src/oncology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** oncology_sci tracking module — tsb analytics library. */
+export interface OncologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeOncologySciTracking(data: number[], opts: OncologySciTrackingOptions = {}): OncologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciTracking };
diff --git a/src/oncology_sci/transform.ts b/src/oncology_sci/transform.ts
new file mode 100644
index 000000000..340c850b3
--- /dev/null
+++ b/src/oncology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** oncology_sci transform module — tsb analytics library. */
+export interface OncologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface OncologySciTransformResult { values: number[]; converged: boolean; }
+export function computeOncologySciTransform(data: number[], opts: OncologySciTransformOptions = {}): OncologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciTransform };
diff --git a/src/oncology_sci/uncertainty.ts b/src/oncology_sci/uncertainty.ts
new file mode 100644
index 000000000..97138b72e
--- /dev/null
+++ b/src/oncology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** oncology_sci uncertainty module — tsb analytics library. */
+export interface OncologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface OncologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeOncologySciUncertainty(data: number[], opts: OncologySciUncertaintyOptions = {}): OncologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciUncertainty };
diff --git a/src/oncology_sci/validation.ts b/src/oncology_sci/validation.ts
new file mode 100644
index 000000000..464a9e4ad
--- /dev/null
+++ b/src/oncology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** oncology_sci validation module — tsb analytics library. */
+export interface OncologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciValidationResult { values: number[]; converged: boolean; }
+export function computeOncologySciValidation(data: number[], opts: OncologySciValidationOptions = {}): OncologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciValidation };
diff --git a/src/oncology_sci/verification.ts b/src/oncology_sci/verification.ts
new file mode 100644
index 000000000..0c98a3cd7
--- /dev/null
+++ b/src/oncology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** oncology_sci verification module — tsb analytics library. */
+export interface OncologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeOncologySciVerification(data: number[], opts: OncologySciVerificationOptions = {}): OncologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciVerification };
diff --git a/src/oncology_sci/visualization.ts b/src/oncology_sci/visualization.ts
new file mode 100644
index 000000000..3c68ab4ec
--- /dev/null
+++ b/src/oncology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** oncology_sci visualization module — tsb analytics library. */
+export interface OncologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface OncologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeOncologySciVisualization(data: number[], opts: OncologySciVisualizationOptions = {}): OncologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciVisualization };
diff --git a/src/oncology_sci/voting.ts b/src/oncology_sci/voting.ts
new file mode 100644
index 000000000..63672ea0b
--- /dev/null
+++ b/src/oncology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** oncology_sci voting module — tsb analytics library. */
+export interface OncologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface OncologySciVotingResult { values: number[]; converged: boolean; }
+export function computeOncologySciVoting(data: number[], opts: OncologySciVotingOptions = {}): OncologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciVoting };
diff --git a/src/oncology_sci/wavelet.ts b/src/oncology_sci/wavelet.ts
new file mode 100644
index 000000000..ce8a4fd09
--- /dev/null
+++ b/src/oncology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** oncology_sci wavelet module — tsb analytics library. */
+export interface OncologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface OncologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeOncologySciWavelet(data: number[], opts: OncologySciWaveletOptions = {}): OncologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOncologySciWavelet };
diff --git a/src/operations/acceptance_sampling.ts b/src/operations/acceptance_sampling.ts
new file mode 100644
index 000000000..bfb2deca1
--- /dev/null
+++ b/src/operations/acceptance_sampling.ts
@@ -0,0 +1,22 @@
+/** Acceptance Sampling module — tsb analytics library. */
+
+/** Options for Acceptance Sampling. */
+export interface AcceptanceSamplingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Acceptance Sampling. */
+export interface AcceptanceSamplingResult { values: number[]; converged: boolean; }
+
+/** Compute Acceptance Sampling. */
+export function computeAcceptanceSampling(data: number[], opts: AcceptanceSamplingOptions = {}): AcceptanceSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAcceptanceSampling };
diff --git a/src/operations/advanced.ts b/src/operations/advanced.ts
new file mode 100644
index 000000000..6f3dac7b6
--- /dev/null
+++ b/src/operations/advanced.ts
@@ -0,0 +1,15 @@
+/** Operations Advanced module — tsb analytics library. */
+export interface Operations advancedOptions { tol?: number; maxIter?: number; }
+export interface Operations advancedResult { values: number[]; converged: boolean; }
+export function computeOperations advanced(data: number[], opts: Operations advancedOptions = {}): Operations advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations advanced };
diff --git a/src/operations/base2.ts b/src/operations/base2.ts
new file mode 100644
index 000000000..8bf022530
--- /dev/null
+++ b/src/operations/base2.ts
@@ -0,0 +1,15 @@
+/** Operations Base2 module — tsb analytics library. */
+export interface Operations base2Options { tol?: number; maxIter?: number; }
+export interface Operations base2Result { values: number[]; converged: boolean; }
+export function computeOperations base2(data: number[], opts: Operations base2Options = {}): Operations base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations base2 };
diff --git a/src/operations/batch.ts b/src/operations/batch.ts
new file mode 100644
index 000000000..f89911c49
--- /dev/null
+++ b/src/operations/batch.ts
@@ -0,0 +1,15 @@
+/** Operations Batch module — tsb analytics library. */
+export interface Operations batchOptions { tol?: number; maxIter?: number; }
+export interface Operations batchResult { values: number[]; converged: boolean; }
+export function computeOperations batch(data: number[], opts: Operations batchOptions = {}): Operations batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations batch };
diff --git a/src/operations/beta.ts b/src/operations/beta.ts
new file mode 100644
index 000000000..11e78ec38
--- /dev/null
+++ b/src/operations/beta.ts
@@ -0,0 +1,15 @@
+/** Operations Beta module — tsb analytics library. */
+export interface Operations betaOptions { tol?: number; maxIter?: number; }
+export interface Operations betaResult { values: number[]; converged: boolean; }
+export function computeOperations beta(data: number[], opts: Operations betaOptions = {}): Operations betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations beta };
diff --git a/src/operations/bottleneck.ts b/src/operations/bottleneck.ts
new file mode 100644
index 000000000..8bd1322dd
--- /dev/null
+++ b/src/operations/bottleneck.ts
@@ -0,0 +1,22 @@
+/** Bottleneck module — tsb analytics library. */
+
+/** Options for Bottleneck. */
+export interface BottleneckOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bottleneck. */
+export interface BottleneckResult { values: number[]; converged: boolean; }
+
+/** Compute Bottleneck. */
+export function computeBottleneck(data: number[], opts: BottleneckOptions = {}): BottleneckResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBottleneck };
diff --git a/src/operations/capacity_ops.ts b/src/operations/capacity_ops.ts
new file mode 100644
index 000000000..332e4f8aa
--- /dev/null
+++ b/src/operations/capacity_ops.ts
@@ -0,0 +1,22 @@
+/** Capacity Ops module — tsb analytics library. */
+
+/** Options for Capacity Ops. */
+export interface CapacityOpsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Capacity Ops. */
+export interface CapacityOpsResult { values: number[]; converged: boolean; }
+
+/** Compute Capacity Ops. */
+export function computeCapacityOps(data: number[], opts: CapacityOpsOptions = {}): CapacityOpsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCapacityOps };
diff --git a/src/operations/constraint_ops.ts b/src/operations/constraint_ops.ts
new file mode 100644
index 000000000..7478ad90f
--- /dev/null
+++ b/src/operations/constraint_ops.ts
@@ -0,0 +1,22 @@
+/** Constraint Ops module — tsb analytics library. */
+
+/** Options for Constraint Ops. */
+export interface ConstraintOpsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Constraint Ops. */
+export interface ConstraintOpsResult { values: number[]; converged: boolean; }
+
+/** Compute Constraint Ops. */
+export function computeConstraintOps(data: number[], opts: ConstraintOpsOptions = {}): ConstraintOpsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConstraintOps };
diff --git a/src/operations/control_chart.ts b/src/operations/control_chart.ts
new file mode 100644
index 000000000..646d44926
--- /dev/null
+++ b/src/operations/control_chart.ts
@@ -0,0 +1,22 @@
+/** Control Chart module — tsb analytics library. */
+
+/** Options for Control Chart. */
+export interface ControlChartOptions { tol?: number; maxIter?: number; }
+
+/** Result from Control Chart. */
+export interface ControlChartResult { values: number[]; converged: boolean; }
+
+/** Compute Control Chart. */
+export function computeControlChart(data: number[], opts: ControlChartOptions = {}): ControlChartResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeControlChart };
diff --git a/src/operations/cpu.ts b/src/operations/cpu.ts
new file mode 100644
index 000000000..12e460c15
--- /dev/null
+++ b/src/operations/cpu.ts
@@ -0,0 +1,15 @@
+/** Operations Cpu module — tsb analytics library. */
+export interface Operations cpuOptions { tol?: number; maxIter?: number; }
+export interface Operations cpuResult { values: number[]; converged: boolean; }
+export function computeOperations cpu(data: number[], opts: Operations cpuOptions = {}): Operations cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations cpu };
diff --git a/src/operations/critical_path.ts b/src/operations/critical_path.ts
new file mode 100644
index 000000000..6175a8adf
--- /dev/null
+++ b/src/operations/critical_path.ts
@@ -0,0 +1,22 @@
+/** Critical Path module — tsb analytics library. */
+
+/** Options for Critical Path. */
+export interface CriticalPathOptions { tol?: number; maxIter?: number; }
+
+/** Result from Critical Path. */
+export interface CriticalPathResult { values: number[]; converged: boolean; }
+
+/** Compute Critical Path. */
+export function computeCriticalPath(data: number[], opts: CriticalPathOptions = {}): CriticalPathResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCriticalPath };
diff --git a/src/operations/cycle_time.ts b/src/operations/cycle_time.ts
new file mode 100644
index 000000000..8edd5fb6f
--- /dev/null
+++ b/src/operations/cycle_time.ts
@@ -0,0 +1,22 @@
+/** Cycle Time module — tsb analytics library. */
+
+/** Options for Cycle Time. */
+export interface CycleTimeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cycle Time. */
+export interface CycleTimeResult { values: number[]; converged: boolean; }
+
+/** Compute Cycle Time. */
+export function computeCycleTime(data: number[], opts: CycleTimeOptions = {}): CycleTimeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCycleTime };
diff --git a/src/operations/dense.ts b/src/operations/dense.ts
new file mode 100644
index 000000000..dfd151dda
--- /dev/null
+++ b/src/operations/dense.ts
@@ -0,0 +1,15 @@
+/** Operations Dense module — tsb analytics library. */
+export interface Operations denseOptions { tol?: number; maxIter?: number; }
+export interface Operations denseResult { values: number[]; converged: boolean; }
+export function computeOperations dense(data: number[], opts: Operations denseOptions = {}): Operations denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations dense };
diff --git a/src/operations/design_of_experiments.ts b/src/operations/design_of_experiments.ts
new file mode 100644
index 000000000..e5aaa0721
--- /dev/null
+++ b/src/operations/design_of_experiments.ts
@@ -0,0 +1,22 @@
+/** Design Of Experiments module — tsb analytics library. */
+
+/** Options for Design Of Experiments. */
+export interface DesignOfExperimentsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Design Of Experiments. */
+export interface DesignOfExperimentsResult { values: number[]; converged: boolean; }
+
+/** Compute Design Of Experiments. */
+export function computeDesignOfExperiments(data: number[], opts: DesignOfExperimentsOptions = {}): DesignOfExperimentsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDesignOfExperiments };
diff --git a/src/operations/distributed.ts b/src/operations/distributed.ts
new file mode 100644
index 000000000..0674f7c75
--- /dev/null
+++ b/src/operations/distributed.ts
@@ -0,0 +1,15 @@
+/** Operations Distributed module — tsb analytics library. */
+export interface Operations distributedOptions { tol?: number; maxIter?: number; }
+export interface Operations distributedResult { values: number[]; converged: boolean; }
+export function computeOperations distributed(data: number[], opts: Operations distributedOptions = {}): Operations distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations distributed };
diff --git a/src/operations/experimental.ts b/src/operations/experimental.ts
new file mode 100644
index 000000000..49b0fad8a
--- /dev/null
+++ b/src/operations/experimental.ts
@@ -0,0 +1,15 @@
+/** Operations Experimental module — tsb analytics library. */
+export interface Operations experimentalOptions { tol?: number; maxIter?: number; }
+export interface Operations experimentalResult { values: number[]; converged: boolean; }
+export function computeOperations experimental(data: number[], opts: Operations experimentalOptions = {}): Operations experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations experimental };
diff --git a/src/operations/failure_mode.ts b/src/operations/failure_mode.ts
new file mode 100644
index 000000000..69c237636
--- /dev/null
+++ b/src/operations/failure_mode.ts
@@ -0,0 +1,22 @@
+/** Failure Mode module — tsb analytics library. */
+
+/** Options for Failure Mode. */
+export interface FailureModeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Failure Mode. */
+export interface FailureModeResult { values: number[]; converged: boolean; }
+
+/** Compute Failure Mode. */
+export function computeFailureMode(data: number[], opts: FailureModeOptions = {}): FailureModeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFailureMode };
diff --git a/src/operations/fast.ts b/src/operations/fast.ts
new file mode 100644
index 000000000..02a646bb9
--- /dev/null
+++ b/src/operations/fast.ts
@@ -0,0 +1,15 @@
+/** Operations Fast module — tsb analytics library. */
+export interface Operations fastOptions { tol?: number; maxIter?: number; }
+export interface Operations fastResult { values: number[]; converged: boolean; }
+export function computeOperations fast(data: number[], opts: Operations fastOptions = {}): Operations fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations fast };
diff --git a/src/operations/future.ts b/src/operations/future.ts
new file mode 100644
index 000000000..19adb0f92
--- /dev/null
+++ b/src/operations/future.ts
@@ -0,0 +1,15 @@
+/** Operations Future module — tsb analytics library. */
+export interface Operations futureOptions { tol?: number; maxIter?: number; }
+export interface Operations futureResult { values: number[]; converged: boolean; }
+export function computeOperations future(data: number[], opts: Operations futureOptions = {}): Operations futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations future };
diff --git a/src/operations/gantt.ts b/src/operations/gantt.ts
new file mode 100644
index 000000000..b5c4cf662
--- /dev/null
+++ b/src/operations/gantt.ts
@@ -0,0 +1,22 @@
+/** Gantt module — tsb analytics library. */
+
+/** Options for Gantt. */
+export interface GanttOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gantt. */
+export interface GanttResult { values: number[]; converged: boolean; }
+
+/** Compute Gantt. */
+export function computeGantt(data: number[], opts: GanttOptions = {}): GanttResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGantt };
diff --git a/src/operations/gpu.ts b/src/operations/gpu.ts
new file mode 100644
index 000000000..00436237b
--- /dev/null
+++ b/src/operations/gpu.ts
@@ -0,0 +1,15 @@
+/** Operations Gpu module — tsb analytics library. */
+export interface Operations gpuOptions { tol?: number; maxIter?: number; }
+export interface Operations gpuResult { values: number[]; converged: boolean; }
+export function computeOperations gpu(data: number[], opts: Operations gpuOptions = {}): Operations gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations gpu };
diff --git a/src/operations/kanban.ts b/src/operations/kanban.ts
new file mode 100644
index 000000000..47e6e352d
--- /dev/null
+++ b/src/operations/kanban.ts
@@ -0,0 +1,22 @@
+/** Kanban module — tsb analytics library. */
+
+/** Options for Kanban. */
+export interface KanbanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Kanban. */
+export interface KanbanResult { values: number[]; converged: boolean; }
+
+/** Compute Kanban. */
+export function computeKanban(data: number[], opts: KanbanOptions = {}): KanbanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKanban };
diff --git a/src/operations/large.ts b/src/operations/large.ts
new file mode 100644
index 000000000..b357d0d7a
--- /dev/null
+++ b/src/operations/large.ts
@@ -0,0 +1,15 @@
+/** Operations Large module — tsb analytics library. */
+export interface Operations largeOptions { tol?: number; maxIter?: number; }
+export interface Operations largeResult { values: number[]; converged: boolean; }
+export function computeOperations large(data: number[], opts: Operations largeOptions = {}): Operations largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations large };
diff --git a/src/operations/lead_time.ts b/src/operations/lead_time.ts
new file mode 100644
index 000000000..a6214b56e
--- /dev/null
+++ b/src/operations/lead_time.ts
@@ -0,0 +1,22 @@
+/** Lead Time module — tsb analytics library. */
+
+/** Options for Lead Time. */
+export interface LeadTimeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lead Time. */
+export interface LeadTimeResult { values: number[]; converged: boolean; }
+
+/** Compute Lead Time. */
+export function computeLeadTime(data: number[], opts: LeadTimeOptions = {}): LeadTimeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLeadTime };
diff --git a/src/operations/lean.ts b/src/operations/lean.ts
new file mode 100644
index 000000000..106c5d002
--- /dev/null
+++ b/src/operations/lean.ts
@@ -0,0 +1,22 @@
+/** Lean module — tsb analytics library. */
+
+/** Options for Lean. */
+export interface LeanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lean. */
+export interface LeanResult { values: number[]; converged: boolean; }
+
+/** Compute Lean. */
+export function computeLean(data: number[], opts: LeanOptions = {}): LeanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLean };
diff --git a/src/operations/legacy.ts b/src/operations/legacy.ts
new file mode 100644
index 000000000..619403713
--- /dev/null
+++ b/src/operations/legacy.ts
@@ -0,0 +1,15 @@
+/** Operations Legacy module — tsb analytics library. */
+export interface Operations legacyOptions { tol?: number; maxIter?: number; }
+export interface Operations legacyResult { values: number[]; converged: boolean; }
+export function computeOperations legacy(data: number[], opts: Operations legacyOptions = {}): Operations legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations legacy };
diff --git a/src/operations/lite.ts b/src/operations/lite.ts
new file mode 100644
index 000000000..8dda8c9e7
--- /dev/null
+++ b/src/operations/lite.ts
@@ -0,0 +1,15 @@
+/** Operations Lite module — tsb analytics library. */
+export interface Operations liteOptions { tol?: number; maxIter?: number; }
+export interface Operations liteResult { values: number[]; converged: boolean; }
+export function computeOperations lite(data: number[], opts: Operations liteOptions = {}): Operations liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations lite };
diff --git a/src/operations/maintenance.ts b/src/operations/maintenance.ts
new file mode 100644
index 000000000..59c7c3a1c
--- /dev/null
+++ b/src/operations/maintenance.ts
@@ -0,0 +1,22 @@
+/** Maintenance module — tsb analytics library. */
+
+/** Options for Maintenance. */
+export interface MaintenanceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Maintenance. */
+export interface MaintenanceResult { values: number[]; converged: boolean; }
+
+/** Compute Maintenance. */
+export function computeMaintenance(data: number[], opts: MaintenanceOptions = {}): MaintenanceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMaintenance };
diff --git a/src/operations/mini.ts b/src/operations/mini.ts
new file mode 100644
index 000000000..700d0362e
--- /dev/null
+++ b/src/operations/mini.ts
@@ -0,0 +1,15 @@
+/** Operations Mini module — tsb analytics library. */
+export interface Operations miniOptions { tol?: number; maxIter?: number; }
+export interface Operations miniResult { values: number[]; converged: boolean; }
+export function computeOperations mini(data: number[], opts: Operations miniOptions = {}): Operations miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations mini };
diff --git a/src/operations/next.ts b/src/operations/next.ts
new file mode 100644
index 000000000..6456d47ed
--- /dev/null
+++ b/src/operations/next.ts
@@ -0,0 +1,15 @@
+/** Operations Next module — tsb analytics library. */
+export interface Operations nextOptions { tol?: number; maxIter?: number; }
+export interface Operations nextResult { values: number[]; converged: boolean; }
+export function computeOperations next(data: number[], opts: Operations nextOptions = {}): Operations nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations next };
diff --git a/src/operations/online.ts b/src/operations/online.ts
new file mode 100644
index 000000000..428e773bd
--- /dev/null
+++ b/src/operations/online.ts
@@ -0,0 +1,15 @@
+/** Operations Online module — tsb analytics library. */
+export interface Operations onlineOptions { tol?: number; maxIter?: number; }
+export interface Operations onlineResult { values: number[]; converged: boolean; }
+export function computeOperations online(data: number[], opts: Operations onlineOptions = {}): Operations onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations online };
diff --git a/src/operations/parallel.ts b/src/operations/parallel.ts
new file mode 100644
index 000000000..ca32c4e9e
--- /dev/null
+++ b/src/operations/parallel.ts
@@ -0,0 +1,15 @@
+/** Operations Parallel module — tsb analytics library. */
+export interface Operations parallelOptions { tol?: number; maxIter?: number; }
+export interface Operations parallelResult { values: number[]; converged: boolean; }
+export function computeOperations parallel(data: number[], opts: Operations parallelOptions = {}): Operations parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations parallel };
diff --git a/src/operations/pert.ts b/src/operations/pert.ts
new file mode 100644
index 000000000..a8afb597b
--- /dev/null
+++ b/src/operations/pert.ts
@@ -0,0 +1,22 @@
+/** Pert module — tsb analytics library. */
+
+/** Options for Pert. */
+export interface PertOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pert. */
+export interface PertResult { values: number[]; converged: boolean; }
+
+/** Compute Pert. */
+export function computePert(data: number[], opts: PertOptions = {}): PertResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePert };
diff --git a/src/operations/plus.ts b/src/operations/plus.ts
new file mode 100644
index 000000000..b38dd4d41
--- /dev/null
+++ b/src/operations/plus.ts
@@ -0,0 +1,15 @@
+/** Operations Plus module — tsb analytics library. */
+export interface Operations plusOptions { tol?: number; maxIter?: number; }
+export interface Operations plusResult { values: number[]; converged: boolean; }
+export function computeOperations plus(data: number[], opts: Operations plusOptions = {}): Operations plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations plus };
diff --git a/src/operations/pro.ts b/src/operations/pro.ts
new file mode 100644
index 000000000..46c742cf6
--- /dev/null
+++ b/src/operations/pro.ts
@@ -0,0 +1,15 @@
+/** Operations Pro module — tsb analytics library. */
+export interface Operations proOptions { tol?: number; maxIter?: number; }
+export interface Operations proResult { values: number[]; converged: boolean; }
+export function computeOperations pro(data: number[], opts: Operations proOptions = {}): Operations proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations pro };
diff --git a/src/operations/project.ts b/src/operations/project.ts
new file mode 100644
index 000000000..dffd6f74b
--- /dev/null
+++ b/src/operations/project.ts
@@ -0,0 +1,22 @@
+/** Project module — tsb analytics library. */
+
+/** Options for Project. */
+export interface ProjectOptions { tol?: number; maxIter?: number; }
+
+/** Result from Project. */
+export interface ProjectResult { values: number[]; converged: boolean; }
+
+/** Compute Project. */
+export function computeProject(data: number[], opts: ProjectOptions = {}): ProjectResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProject };
diff --git a/src/operations/quality_function.ts b/src/operations/quality_function.ts
new file mode 100644
index 000000000..5888b8d9f
--- /dev/null
+++ b/src/operations/quality_function.ts
@@ -0,0 +1,22 @@
+/** Quality Function module — tsb analytics library. */
+
+/** Options for Quality Function. */
+export interface QualityFunctionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quality Function. */
+export interface QualityFunctionResult { values: number[]; converged: boolean; }
+
+/** Compute Quality Function. */
+export function computeQualityFunction(data: number[], opts: QualityFunctionOptions = {}): QualityFunctionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQualityFunction };
diff --git a/src/operations/queuing.ts b/src/operations/queuing.ts
new file mode 100644
index 000000000..870f0c636
--- /dev/null
+++ b/src/operations/queuing.ts
@@ -0,0 +1,22 @@
+/** Queuing module — tsb analytics library. */
+
+/** Options for Queuing. */
+export interface QueuingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Queuing. */
+export interface QueuingResult { values: number[]; converged: boolean; }
+
+/** Compute Queuing. */
+export function computeQueuing(data: number[], opts: QueuingOptions = {}): QueuingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQueuing };
diff --git a/src/operations/reliability_ops.ts b/src/operations/reliability_ops.ts
new file mode 100644
index 000000000..dc1241e87
--- /dev/null
+++ b/src/operations/reliability_ops.ts
@@ -0,0 +1,22 @@
+/** Reliability Ops module — tsb analytics library. */
+
+/** Options for Reliability Ops. */
+export interface ReliabilityOpsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reliability Ops. */
+export interface ReliabilityOpsResult { values: number[]; converged: boolean; }
+
+/** Compute Reliability Ops. */
+export function computeReliabilityOps(data: number[], opts: ReliabilityOpsOptions = {}): ReliabilityOpsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReliabilityOps };
diff --git a/src/operations/resource.ts b/src/operations/resource.ts
new file mode 100644
index 000000000..8a495f763
--- /dev/null
+++ b/src/operations/resource.ts
@@ -0,0 +1,22 @@
+/** Resource module — tsb analytics library. */
+
+/** Options for Resource. */
+export interface ResourceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Resource. */
+export interface ResourceResult { values: number[]; converged: boolean; }
+
+/** Compute Resource. */
+export function computeResource(data: number[], opts: ResourceOptions = {}): ResourceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeResource };
diff --git a/src/operations/response_surface.ts b/src/operations/response_surface.ts
new file mode 100644
index 000000000..f6f779f38
--- /dev/null
+++ b/src/operations/response_surface.ts
@@ -0,0 +1,22 @@
+/** Response Surface module — tsb analytics library. */
+
+/** Options for Response Surface. */
+export interface ResponseSurfaceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Response Surface. */
+export interface ResponseSurfaceResult { values: number[]; converged: boolean; }
+
+/** Compute Response Surface. */
+export function computeResponseSurface(data: number[], opts: ResponseSurfaceOptions = {}): ResponseSurfaceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeResponseSurface };
diff --git a/src/operations/robust.ts b/src/operations/robust.ts
new file mode 100644
index 000000000..00d96fc2b
--- /dev/null
+++ b/src/operations/robust.ts
@@ -0,0 +1,15 @@
+/** Operations Robust module — tsb analytics library. */
+export interface Operations robustOptions { tol?: number; maxIter?: number; }
+export interface Operations robustResult { values: number[]; converged: boolean; }
+export function computeOperations robust(data: number[], opts: Operations robustOptions = {}): Operations robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations robust };
diff --git a/src/operations/robust_design.ts b/src/operations/robust_design.ts
new file mode 100644
index 000000000..5f1114f04
--- /dev/null
+++ b/src/operations/robust_design.ts
@@ -0,0 +1,22 @@
+/** Robust Design module — tsb analytics library. */
+
+/** Options for Robust Design. */
+export interface RobustDesignOptions { tol?: number; maxIter?: number; }
+
+/** Result from Robust Design. */
+export interface RobustDesignResult { values: number[]; converged: boolean; }
+
+/** Compute Robust Design. */
+export function computeRobustDesign(data: number[], opts: RobustDesignOptions = {}): RobustDesignResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRobustDesign };
diff --git a/src/operations/root_cause.ts b/src/operations/root_cause.ts
new file mode 100644
index 000000000..8b33a8d3a
--- /dev/null
+++ b/src/operations/root_cause.ts
@@ -0,0 +1,22 @@
+/** Root Cause module — tsb analytics library. */
+
+/** Options for Root Cause. */
+export interface RootCauseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Root Cause. */
+export interface RootCauseResult { values: number[]; converged: boolean; }
+
+/** Compute Root Cause. */
+export function computeRootCause(data: number[], opts: RootCauseOptions = {}): RootCauseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRootCause };
diff --git a/src/operations/scheduling_ops.ts b/src/operations/scheduling_ops.ts
new file mode 100644
index 000000000..fd798916b
--- /dev/null
+++ b/src/operations/scheduling_ops.ts
@@ -0,0 +1,22 @@
+/** Scheduling Ops module — tsb analytics library. */
+
+/** Options for Scheduling Ops. */
+export interface SchedulingOpsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Scheduling Ops. */
+export interface SchedulingOpsResult { values: number[]; converged: boolean; }
+
+/** Compute Scheduling Ops. */
+export function computeSchedulingOps(data: number[], opts: SchedulingOpsOptions = {}): SchedulingOpsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSchedulingOps };
diff --git a/src/operations/simulation_ops.ts b/src/operations/simulation_ops.ts
new file mode 100644
index 000000000..5223ed71b
--- /dev/null
+++ b/src/operations/simulation_ops.ts
@@ -0,0 +1,22 @@
+/** Simulation Ops module — tsb analytics library. */
+
+/** Options for Simulation Ops. */
+export interface SimulationOpsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Simulation Ops. */
+export interface SimulationOpsResult { values: number[]; converged: boolean; }
+
+/** Compute Simulation Ops. */
+export function computeSimulationOps(data: number[], opts: SimulationOpsOptions = {}): SimulationOpsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSimulationOps };
diff --git a/src/operations/six_sigma.ts b/src/operations/six_sigma.ts
new file mode 100644
index 000000000..b7190dcf9
--- /dev/null
+++ b/src/operations/six_sigma.ts
@@ -0,0 +1,22 @@
+/** Six Sigma module — tsb analytics library. */
+
+/** Options for Six Sigma. */
+export interface SixSigmaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Six Sigma. */
+export interface SixSigmaResult { values: number[]; converged: boolean; }
+
+/** Compute Six Sigma. */
+export function computeSixSigma(data: number[], opts: SixSigmaOptions = {}): SixSigmaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSixSigma };
diff --git a/src/operations/small.ts b/src/operations/small.ts
new file mode 100644
index 000000000..6a99607cb
--- /dev/null
+++ b/src/operations/small.ts
@@ -0,0 +1,15 @@
+/** Operations Small module — tsb analytics library. */
+export interface Operations smallOptions { tol?: number; maxIter?: number; }
+export interface Operations smallResult { values: number[]; converged: boolean; }
+export function computeOperations small(data: number[], opts: Operations smallOptions = {}): Operations smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations small };
diff --git a/src/operations/sparse.ts b/src/operations/sparse.ts
new file mode 100644
index 000000000..7cd145eb3
--- /dev/null
+++ b/src/operations/sparse.ts
@@ -0,0 +1,15 @@
+/** Operations Sparse module — tsb analytics library. */
+export interface Operations sparseOptions { tol?: number; maxIter?: number; }
+export interface Operations sparseResult { values: number[]; converged: boolean; }
+export function computeOperations sparse(data: number[], opts: Operations sparseOptions = {}): Operations sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations sparse };
diff --git a/src/operations/stable.ts b/src/operations/stable.ts
new file mode 100644
index 000000000..1ed7a7e01
--- /dev/null
+++ b/src/operations/stable.ts
@@ -0,0 +1,15 @@
+/** Operations Stable module — tsb analytics library. */
+export interface Operations stableOptions { tol?: number; maxIter?: number; }
+export interface Operations stableResult { values: number[]; converged: boolean; }
+export function computeOperations stable(data: number[], opts: Operations stableOptions = {}): Operations stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations stable };
diff --git a/src/operations/statistical_process.ts b/src/operations/statistical_process.ts
new file mode 100644
index 000000000..1f9729427
--- /dev/null
+++ b/src/operations/statistical_process.ts
@@ -0,0 +1,22 @@
+/** Statistical Process module — tsb analytics library. */
+
+/** Options for Statistical Process. */
+export interface StatisticalProcessOptions { tol?: number; maxIter?: number; }
+
+/** Result from Statistical Process. */
+export interface StatisticalProcessResult { values: number[]; converged: boolean; }
+
+/** Compute Statistical Process. */
+export function computeStatisticalProcess(data: number[], opts: StatisticalProcessOptions = {}): StatisticalProcessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStatisticalProcess };
diff --git a/src/operations/streaming.ts b/src/operations/streaming.ts
new file mode 100644
index 000000000..98c548218
--- /dev/null
+++ b/src/operations/streaming.ts
@@ -0,0 +1,15 @@
+/** Operations Streaming module — tsb analytics library. */
+export interface Operations streamingOptions { tol?: number; maxIter?: number; }
+export interface Operations streamingResult { values: number[]; converged: boolean; }
+export function computeOperations streaming(data: number[], opts: Operations streamingOptions = {}): Operations streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations streaming };
diff --git a/src/operations/throughput.ts b/src/operations/throughput.ts
new file mode 100644
index 000000000..842876160
--- /dev/null
+++ b/src/operations/throughput.ts
@@ -0,0 +1,22 @@
+/** Throughput module — tsb analytics library. */
+
+/** Options for Throughput. */
+export interface ThroughputOptions { tol?: number; maxIter?: number; }
+
+/** Result from Throughput. */
+export interface ThroughputResult { values: number[]; converged: boolean; }
+
+/** Compute Throughput. */
+export function computeThroughput(data: number[], opts: ThroughputOptions = {}): ThroughputResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeThroughput };
diff --git a/src/operations/toc.ts b/src/operations/toc.ts
new file mode 100644
index 000000000..06a960225
--- /dev/null
+++ b/src/operations/toc.ts
@@ -0,0 +1,22 @@
+/** Toc module — tsb analytics library. */
+
+/** Options for Toc. */
+export interface TocOptions { tol?: number; maxIter?: number; }
+
+/** Result from Toc. */
+export interface TocResult { values: number[]; converged: boolean; }
+
+/** Compute Toc. */
+export function computeToc(data: number[], opts: TocOptions = {}): TocResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeToc };
diff --git a/src/operations/v2.ts b/src/operations/v2.ts
new file mode 100644
index 000000000..0038efc85
--- /dev/null
+++ b/src/operations/v2.ts
@@ -0,0 +1,15 @@
+/** Operations V2 module — tsb analytics library. */
+export interface Operations v2Options { tol?: number; maxIter?: number; }
+export interface Operations v2Result { values: number[]; converged: boolean; }
+export function computeOperations v2(data: number[], opts: Operations v2Options = {}): Operations v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations v2 };
diff --git a/src/operations/v3.ts b/src/operations/v3.ts
new file mode 100644
index 000000000..0fdeaa8c7
--- /dev/null
+++ b/src/operations/v3.ts
@@ -0,0 +1,15 @@
+/** Operations V3 module — tsb analytics library. */
+export interface Operations v3Options { tol?: number; maxIter?: number; }
+export interface Operations v3Result { values: number[]; converged: boolean; }
+export function computeOperations v3(data: number[], opts: Operations v3Options = {}): Operations v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations v3 };
diff --git a/src/operations/wasm.ts b/src/operations/wasm.ts
new file mode 100644
index 000000000..985d45a8c
--- /dev/null
+++ b/src/operations/wasm.ts
@@ -0,0 +1,15 @@
+/** Operations Wasm module — tsb analytics library. */
+export interface Operations wasmOptions { tol?: number; maxIter?: number; }
+export interface Operations wasmResult { values: number[]; converged: boolean; }
+export function computeOperations wasm(data: number[], opts: Operations wasmOptions = {}): Operations wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations wasm };
diff --git a/src/operations/work_in_progress.ts b/src/operations/work_in_progress.ts
new file mode 100644
index 000000000..deae339fb
--- /dev/null
+++ b/src/operations/work_in_progress.ts
@@ -0,0 +1,22 @@
+/** Work In Progress module — tsb analytics library. */
+
+/** Options for Work In Progress. */
+export interface WorkInProgressOptions { tol?: number; maxIter?: number; }
+
+/** Result from Work In Progress. */
+export interface WorkInProgressResult { values: number[]; converged: boolean; }
+
+/** Compute Work In Progress. */
+export function computeWorkInProgress(data: number[], opts: WorkInProgressOptions = {}): WorkInProgressResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWorkInProgress };
diff --git a/src/operations/xlarge.ts b/src/operations/xlarge.ts
new file mode 100644
index 000000000..3fba55776
--- /dev/null
+++ b/src/operations/xlarge.ts
@@ -0,0 +1,15 @@
+/** Operations Xlarge module — tsb analytics library. */
+export interface Operations xlargeOptions { tol?: number; maxIter?: number; }
+export interface Operations xlargeResult { values: number[]; converged: boolean; }
+export function computeOperations xlarge(data: number[], opts: Operations xlargeOptions = {}): Operations xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOperations xlarge };
diff --git a/src/ophthalmology_sci/adaptation.ts b/src/ophthalmology_sci/adaptation.ts
new file mode 100644
index 000000000..b4615c674
--- /dev/null
+++ b/src/ophthalmology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci adaptation module — tsb analytics library. */
+export interface OphthalmologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciAdaptation(data: number[], opts: OphthalmologySciAdaptationOptions = {}): OphthalmologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciAdaptation };
diff --git a/src/ophthalmology_sci/aggregation.ts b/src/ophthalmology_sci/aggregation.ts
new file mode 100644
index 000000000..c9a44f416
--- /dev/null
+++ b/src/ophthalmology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci aggregation module — tsb analytics library. */
+export interface OphthalmologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciAggregation(data: number[], opts: OphthalmologySciAggregationOptions = {}): OphthalmologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciAggregation };
diff --git a/src/ophthalmology_sci/algebra.ts b/src/ophthalmology_sci/algebra.ts
new file mode 100644
index 000000000..de1120497
--- /dev/null
+++ b/src/ophthalmology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci algebra module — tsb analytics library. */
+export interface OphthalmologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciAlgebra(data: number[], opts: OphthalmologySciAlgebraOptions = {}): OphthalmologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciAlgebra };
diff --git a/src/ophthalmology_sci/alignment.ts b/src/ophthalmology_sci/alignment.ts
new file mode 100644
index 000000000..7a988aa2e
--- /dev/null
+++ b/src/ophthalmology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci alignment module — tsb analytics library. */
+export interface OphthalmologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciAlignment(data: number[], opts: OphthalmologySciAlignmentOptions = {}): OphthalmologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciAlignment };
diff --git a/src/ophthalmology_sci/analysis.ts b/src/ophthalmology_sci/analysis.ts
new file mode 100644
index 000000000..f7d180307
--- /dev/null
+++ b/src/ophthalmology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci analysis module — tsb analytics library. */
+export interface OphthalmologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciAnalysis(data: number[], opts: OphthalmologySciAnalysisOptions = {}): OphthalmologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciAnalysis };
diff --git a/src/ophthalmology_sci/augmentation.ts b/src/ophthalmology_sci/augmentation.ts
new file mode 100644
index 000000000..0a14309d9
--- /dev/null
+++ b/src/ophthalmology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci augmentation module — tsb analytics library. */
+export interface OphthalmologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciAugmentation(data: number[], opts: OphthalmologySciAugmentationOptions = {}): OphthalmologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciAugmentation };
diff --git a/src/ophthalmology_sci/bagging.ts b/src/ophthalmology_sci/bagging.ts
new file mode 100644
index 000000000..23064e10a
--- /dev/null
+++ b/src/ophthalmology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci bagging module — tsb analytics library. */
+export interface OphthalmologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciBagging(data: number[], opts: OphthalmologySciBaggingOptions = {}): OphthalmologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciBagging };
diff --git a/src/ophthalmology_sci/basis.ts b/src/ophthalmology_sci/basis.ts
new file mode 100644
index 000000000..f8a5d10ee
--- /dev/null
+++ b/src/ophthalmology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci basis module — tsb analytics library. */
+export interface OphthalmologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciBasisResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciBasis(data: number[], opts: OphthalmologySciBasisOptions = {}): OphthalmologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciBasis };
diff --git a/src/ophthalmology_sci/benchmarking.ts b/src/ophthalmology_sci/benchmarking.ts
new file mode 100644
index 000000000..0947dfca3
--- /dev/null
+++ b/src/ophthalmology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci benchmarking module — tsb analytics library. */
+export interface OphthalmologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciBenchmarking(data: number[], opts: OphthalmologySciBenchmarkingOptions = {}): OphthalmologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciBenchmarking };
diff --git a/src/ophthalmology_sci/blending.ts b/src/ophthalmology_sci/blending.ts
new file mode 100644
index 000000000..c452c4960
--- /dev/null
+++ b/src/ophthalmology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci blending module — tsb analytics library. */
+export interface OphthalmologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciBlending(data: number[], opts: OphthalmologySciBlendingOptions = {}): OphthalmologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciBlending };
diff --git a/src/ophthalmology_sci/boosting.ts b/src/ophthalmology_sci/boosting.ts
new file mode 100644
index 000000000..00541e416
--- /dev/null
+++ b/src/ophthalmology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci boosting module — tsb analytics library. */
+export interface OphthalmologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciBoosting(data: number[], opts: OphthalmologySciBoostingOptions = {}): OphthalmologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciBoosting };
diff --git a/src/ophthalmology_sci/bootstrap.ts b/src/ophthalmology_sci/bootstrap.ts
new file mode 100644
index 000000000..cf4866062
--- /dev/null
+++ b/src/ophthalmology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci bootstrap module — tsb analytics library. */
+export interface OphthalmologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciBootstrap(data: number[], opts: OphthalmologySciBootstrapOptions = {}): OphthalmologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciBootstrap };
diff --git a/src/ophthalmology_sci/calculus.ts b/src/ophthalmology_sci/calculus.ts
new file mode 100644
index 000000000..79f151206
--- /dev/null
+++ b/src/ophthalmology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci calculus module — tsb analytics library. */
+export interface OphthalmologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciCalculus(data: number[], opts: OphthalmologySciCalculusOptions = {}): OphthalmologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciCalculus };
diff --git a/src/ophthalmology_sci/calibration.ts b/src/ophthalmology_sci/calibration.ts
new file mode 100644
index 000000000..78220ebad
--- /dev/null
+++ b/src/ophthalmology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci calibration module — tsb analytics library. */
+export interface OphthalmologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciCalibration(data: number[], opts: OphthalmologySciCalibrationOptions = {}): OphthalmologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciCalibration };
diff --git a/src/ophthalmology_sci/characterization.ts b/src/ophthalmology_sci/characterization.ts
new file mode 100644
index 000000000..5de48d0bb
--- /dev/null
+++ b/src/ophthalmology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci characterization module — tsb analytics library. */
+export interface OphthalmologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciCharacterization(data: number[], opts: OphthalmologySciCharacterizationOptions = {}): OphthalmologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciCharacterization };
diff --git a/src/ophthalmology_sci/classification.ts b/src/ophthalmology_sci/classification.ts
new file mode 100644
index 000000000..c8ff8089a
--- /dev/null
+++ b/src/ophthalmology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci classification module — tsb analytics library. */
+export interface OphthalmologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciClassification(data: number[], opts: OphthalmologySciClassificationOptions = {}): OphthalmologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciClassification };
diff --git a/src/ophthalmology_sci/clustering.ts b/src/ophthalmology_sci/clustering.ts
new file mode 100644
index 000000000..a106faf61
--- /dev/null
+++ b/src/ophthalmology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci clustering module — tsb analytics library. */
+export interface OphthalmologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciClustering(data: number[], opts: OphthalmologySciClusteringOptions = {}): OphthalmologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciClustering };
diff --git a/src/ophthalmology_sci/compression.ts b/src/ophthalmology_sci/compression.ts
new file mode 100644
index 000000000..bbf0b41ee
--- /dev/null
+++ b/src/ophthalmology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci compression module — tsb analytics library. */
+export interface OphthalmologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciCompression(data: number[], opts: OphthalmologySciCompressionOptions = {}): OphthalmologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciCompression };
diff --git a/src/ophthalmology_sci/continuous.ts b/src/ophthalmology_sci/continuous.ts
new file mode 100644
index 000000000..e4791eeb6
--- /dev/null
+++ b/src/ophthalmology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci continuous module — tsb analytics library. */
+export interface OphthalmologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciContinuous(data: number[], opts: OphthalmologySciContinuousOptions = {}): OphthalmologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciContinuous };
diff --git a/src/ophthalmology_sci/control.ts b/src/ophthalmology_sci/control.ts
new file mode 100644
index 000000000..0278d2625
--- /dev/null
+++ b/src/ophthalmology_sci/control.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci control module — tsb analytics library. */
+export interface OphthalmologySciControlOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciControlResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciControl(data: number[], opts: OphthalmologySciControlOptions = {}): OphthalmologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciControl };
diff --git a/src/ophthalmology_sci/convergence.ts b/src/ophthalmology_sci/convergence.ts
new file mode 100644
index 000000000..a31d8a84f
--- /dev/null
+++ b/src/ophthalmology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci convergence module — tsb analytics library. */
+export interface OphthalmologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciConvergence(data: number[], opts: OphthalmologySciConvergenceOptions = {}): OphthalmologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciConvergence };
diff --git a/src/ophthalmology_sci/convex.ts b/src/ophthalmology_sci/convex.ts
new file mode 100644
index 000000000..e126c8392
--- /dev/null
+++ b/src/ophthalmology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci convex module — tsb analytics library. */
+export interface OphthalmologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciConvexResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciConvex(data: number[], opts: OphthalmologySciConvexOptions = {}): OphthalmologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciConvex };
diff --git a/src/ophthalmology_sci/correlation.ts b/src/ophthalmology_sci/correlation.ts
new file mode 100644
index 000000000..0c5bd4618
--- /dev/null
+++ b/src/ophthalmology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci correlation module — tsb analytics library. */
+export interface OphthalmologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciCorrelation(data: number[], opts: OphthalmologySciCorrelationOptions = {}): OphthalmologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciCorrelation };
diff --git a/src/ophthalmology_sci/covariance.ts b/src/ophthalmology_sci/covariance.ts
new file mode 100644
index 000000000..a86c8a203
--- /dev/null
+++ b/src/ophthalmology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci covariance module — tsb analytics library. */
+export interface OphthalmologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciCovariance(data: number[], opts: OphthalmologySciCovarianceOptions = {}): OphthalmologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciCovariance };
diff --git a/src/ophthalmology_sci/cross_validation.ts b/src/ophthalmology_sci/cross_validation.ts
new file mode 100644
index 000000000..d34b6002b
--- /dev/null
+++ b/src/ophthalmology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci cross_validation module — tsb analytics library. */
+export interface OphthalmologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciCrossValidation(data: number[], opts: OphthalmologySciCrossValidationOptions = {}): OphthalmologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciCrossValidation };
diff --git a/src/ophthalmology_sci/decoding.ts b/src/ophthalmology_sci/decoding.ts
new file mode 100644
index 000000000..bb5fb2215
--- /dev/null
+++ b/src/ophthalmology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci decoding module — tsb analytics library. */
+export interface OphthalmologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDecoding(data: number[], opts: OphthalmologySciDecodingOptions = {}): OphthalmologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDecoding };
diff --git a/src/ophthalmology_sci/decomposition.ts b/src/ophthalmology_sci/decomposition.ts
new file mode 100644
index 000000000..a1372f195
--- /dev/null
+++ b/src/ophthalmology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci decomposition module — tsb analytics library. */
+export interface OphthalmologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDecomposition(data: number[], opts: OphthalmologySciDecompositionOptions = {}): OphthalmologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDecomposition };
diff --git a/src/ophthalmology_sci/detection.ts b/src/ophthalmology_sci/detection.ts
new file mode 100644
index 000000000..8b5d00705
--- /dev/null
+++ b/src/ophthalmology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci detection module — tsb analytics library. */
+export interface OphthalmologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDetection(data: number[], opts: OphthalmologySciDetectionOptions = {}): OphthalmologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDetection };
diff --git a/src/ophthalmology_sci/deterministic.ts b/src/ophthalmology_sci/deterministic.ts
new file mode 100644
index 000000000..3be710a62
--- /dev/null
+++ b/src/ophthalmology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci deterministic module — tsb analytics library. */
+export interface OphthalmologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDeterministic(data: number[], opts: OphthalmologySciDeterministicOptions = {}): OphthalmologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDeterministic };
diff --git a/src/ophthalmology_sci/diagnostics.ts b/src/ophthalmology_sci/diagnostics.ts
new file mode 100644
index 000000000..ab5b3b9b0
--- /dev/null
+++ b/src/ophthalmology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci diagnostics module — tsb analytics library. */
+export interface OphthalmologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDiagnostics(data: number[], opts: OphthalmologySciDiagnosticsOptions = {}): OphthalmologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDiagnostics };
diff --git a/src/ophthalmology_sci/differential.ts b/src/ophthalmology_sci/differential.ts
new file mode 100644
index 000000000..26a7a0786
--- /dev/null
+++ b/src/ophthalmology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci differential module — tsb analytics library. */
+export interface OphthalmologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDifferential(data: number[], opts: OphthalmologySciDifferentialOptions = {}): OphthalmologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDifferential };
diff --git a/src/ophthalmology_sci/discrete.ts b/src/ophthalmology_sci/discrete.ts
new file mode 100644
index 000000000..b55d5d1be
--- /dev/null
+++ b/src/ophthalmology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci discrete module — tsb analytics library. */
+export interface OphthalmologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDiscrete(data: number[], opts: OphthalmologySciDiscreteOptions = {}): OphthalmologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDiscrete };
diff --git a/src/ophthalmology_sci/distribution.ts b/src/ophthalmology_sci/distribution.ts
new file mode 100644
index 000000000..a94800fa1
--- /dev/null
+++ b/src/ophthalmology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci distribution module — tsb analytics library. */
+export interface OphthalmologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDistribution(data: number[], opts: OphthalmologySciDistributionOptions = {}): OphthalmologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDistribution };
diff --git a/src/ophthalmology_sci/dynamic.ts b/src/ophthalmology_sci/dynamic.ts
new file mode 100644
index 000000000..550a0928f
--- /dev/null
+++ b/src/ophthalmology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci dynamic module — tsb analytics library. */
+export interface OphthalmologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciDynamic(data: number[], opts: OphthalmologySciDynamicOptions = {}): OphthalmologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciDynamic };
diff --git a/src/ophthalmology_sci/embedding.ts b/src/ophthalmology_sci/embedding.ts
new file mode 100644
index 000000000..a751dbcd9
--- /dev/null
+++ b/src/ophthalmology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci embedding module — tsb analytics library. */
+export interface OphthalmologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciEmbedding(data: number[], opts: OphthalmologySciEmbeddingOptions = {}): OphthalmologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciEmbedding };
diff --git a/src/ophthalmology_sci/encoding.ts b/src/ophthalmology_sci/encoding.ts
new file mode 100644
index 000000000..7045a4a9f
--- /dev/null
+++ b/src/ophthalmology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci encoding module — tsb analytics library. */
+export interface OphthalmologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciEncoding(data: number[], opts: OphthalmologySciEncodingOptions = {}): OphthalmologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciEncoding };
diff --git a/src/ophthalmology_sci/ensemble.ts b/src/ophthalmology_sci/ensemble.ts
new file mode 100644
index 000000000..43e3a33ae
--- /dev/null
+++ b/src/ophthalmology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci ensemble module — tsb analytics library. */
+export interface OphthalmologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciEnsemble(data: number[], opts: OphthalmologySciEnsembleOptions = {}): OphthalmologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciEnsemble };
diff --git a/src/ophthalmology_sci/estimation.ts b/src/ophthalmology_sci/estimation.ts
new file mode 100644
index 000000000..86e7c406a
--- /dev/null
+++ b/src/ophthalmology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci estimation module — tsb analytics library. */
+export interface OphthalmologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciEstimation(data: number[], opts: OphthalmologySciEstimationOptions = {}): OphthalmologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciEstimation };
diff --git a/src/ophthalmology_sci/evaluation.ts b/src/ophthalmology_sci/evaluation.ts
new file mode 100644
index 000000000..15912cf21
--- /dev/null
+++ b/src/ophthalmology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci evaluation module — tsb analytics library. */
+export interface OphthalmologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciEvaluation(data: number[], opts: OphthalmologySciEvaluationOptions = {}): OphthalmologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciEvaluation };
diff --git a/src/ophthalmology_sci/extrapolation.ts b/src/ophthalmology_sci/extrapolation.ts
new file mode 100644
index 000000000..a65b82832
--- /dev/null
+++ b/src/ophthalmology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci extrapolation module — tsb analytics library. */
+export interface OphthalmologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciExtrapolation(data: number[], opts: OphthalmologySciExtrapolationOptions = {}): OphthalmologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciExtrapolation };
diff --git a/src/ophthalmology_sci/features.ts b/src/ophthalmology_sci/features.ts
new file mode 100644
index 000000000..145bf1de7
--- /dev/null
+++ b/src/ophthalmology_sci/features.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci features module — tsb analytics library. */
+export interface OphthalmologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciFeatures(data: number[], opts: OphthalmologySciFeaturesOptions = {}): OphthalmologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciFeatures };
diff --git a/src/ophthalmology_sci/feedback.ts b/src/ophthalmology_sci/feedback.ts
new file mode 100644
index 000000000..c5de5f37a
--- /dev/null
+++ b/src/ophthalmology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci feedback module — tsb analytics library. */
+export interface OphthalmologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciFeedback(data: number[], opts: OphthalmologySciFeedbackOptions = {}): OphthalmologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciFeedback };
diff --git a/src/ophthalmology_sci/filtering.ts b/src/ophthalmology_sci/filtering.ts
new file mode 100644
index 000000000..53e8701d6
--- /dev/null
+++ b/src/ophthalmology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci filtering module — tsb analytics library. */
+export interface OphthalmologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciFiltering(data: number[], opts: OphthalmologySciFilteringOptions = {}): OphthalmologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciFiltering };
diff --git a/src/ophthalmology_sci/fourier.ts b/src/ophthalmology_sci/fourier.ts
new file mode 100644
index 000000000..5b5a5b4b6
--- /dev/null
+++ b/src/ophthalmology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci fourier module — tsb analytics library. */
+export interface OphthalmologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciFourierResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciFourier(data: number[], opts: OphthalmologySciFourierOptions = {}): OphthalmologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciFourier };
diff --git a/src/ophthalmology_sci/fusion.ts b/src/ophthalmology_sci/fusion.ts
new file mode 100644
index 000000000..d11af4575
--- /dev/null
+++ b/src/ophthalmology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci fusion module — tsb analytics library. */
+export interface OphthalmologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciFusionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciFusion(data: number[], opts: OphthalmologySciFusionOptions = {}): OphthalmologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciFusion };
diff --git a/src/ophthalmology_sci/generation.ts b/src/ophthalmology_sci/generation.ts
new file mode 100644
index 000000000..7c7f2b6b8
--- /dev/null
+++ b/src/ophthalmology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci generation module — tsb analytics library. */
+export interface OphthalmologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciGeneration(data: number[], opts: OphthalmologySciGenerationOptions = {}): OphthalmologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciGeneration };
diff --git a/src/ophthalmology_sci/geometry.ts b/src/ophthalmology_sci/geometry.ts
new file mode 100644
index 000000000..876edc1e7
--- /dev/null
+++ b/src/ophthalmology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci geometry module — tsb analytics library. */
+export interface OphthalmologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciGeometry(data: number[], opts: OphthalmologySciGeometryOptions = {}): OphthalmologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciGeometry };
diff --git a/src/ophthalmology_sci/gradient.ts b/src/ophthalmology_sci/gradient.ts
new file mode 100644
index 000000000..1774638d6
--- /dev/null
+++ b/src/ophthalmology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci gradient module — tsb analytics library. */
+export interface OphthalmologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciGradientResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciGradient(data: number[], opts: OphthalmologySciGradientOptions = {}): OphthalmologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciGradient };
diff --git a/src/ophthalmology_sci/hessian.ts b/src/ophthalmology_sci/hessian.ts
new file mode 100644
index 000000000..26dda96f7
--- /dev/null
+++ b/src/ophthalmology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci hessian module — tsb analytics library. */
+export interface OphthalmologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciHessianResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciHessian(data: number[], opts: OphthalmologySciHessianOptions = {}): OphthalmologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciHessian };
diff --git a/src/ophthalmology_sci/hypothesis.ts b/src/ophthalmology_sci/hypothesis.ts
new file mode 100644
index 000000000..f60b09ebf
--- /dev/null
+++ b/src/ophthalmology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci hypothesis module — tsb analytics library. */
+export interface OphthalmologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciHypothesis(data: number[], opts: OphthalmologySciHypothesisOptions = {}): OphthalmologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciHypothesis };
diff --git a/src/ophthalmology_sci/inference.ts b/src/ophthalmology_sci/inference.ts
new file mode 100644
index 000000000..1ce110755
--- /dev/null
+++ b/src/ophthalmology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci inference module — tsb analytics library. */
+export interface OphthalmologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciInference(data: number[], opts: OphthalmologySciInferenceOptions = {}): OphthalmologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciInference };
diff --git a/src/ophthalmology_sci/inference2.ts b/src/ophthalmology_sci/inference2.ts
new file mode 100644
index 000000000..996f698a9
--- /dev/null
+++ b/src/ophthalmology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci inference2 module — tsb analytics library. */
+export interface OphthalmologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciInference(data: number[], opts: OphthalmologySciInferenceOptions = {}): OphthalmologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciInference };
diff --git a/src/ophthalmology_sci/integral.ts b/src/ophthalmology_sci/integral.ts
new file mode 100644
index 000000000..7e682f0e2
--- /dev/null
+++ b/src/ophthalmology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci integral module — tsb analytics library. */
+export interface OphthalmologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciIntegral(data: number[], opts: OphthalmologySciIntegralOptions = {}): OphthalmologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciIntegral };
diff --git a/src/ophthalmology_sci/integration.ts b/src/ophthalmology_sci/integration.ts
new file mode 100644
index 000000000..b8816d5d5
--- /dev/null
+++ b/src/ophthalmology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci integration module — tsb analytics library. */
+export interface OphthalmologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciIntegration(data: number[], opts: OphthalmologySciIntegrationOptions = {}): OphthalmologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciIntegration };
diff --git a/src/ophthalmology_sci/interpolation.ts b/src/ophthalmology_sci/interpolation.ts
new file mode 100644
index 000000000..1d359cf20
--- /dev/null
+++ b/src/ophthalmology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci interpolation module — tsb analytics library. */
+export interface OphthalmologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciInterpolation(data: number[], opts: OphthalmologySciInterpolationOptions = {}): OphthalmologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciInterpolation };
diff --git a/src/ophthalmology_sci/jacobian.ts b/src/ophthalmology_sci/jacobian.ts
new file mode 100644
index 000000000..bfd3a88bb
--- /dev/null
+++ b/src/ophthalmology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci jacobian module — tsb analytics library. */
+export interface OphthalmologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciJacobian(data: number[], opts: OphthalmologySciJacobianOptions = {}): OphthalmologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciJacobian };
diff --git a/src/ophthalmology_sci/kernel.ts b/src/ophthalmology_sci/kernel.ts
new file mode 100644
index 000000000..9c40e2d45
--- /dev/null
+++ b/src/ophthalmology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci kernel module — tsb analytics library. */
+export interface OphthalmologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciKernelResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciKernel(data: number[], opts: OphthalmologySciKernelOptions = {}): OphthalmologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciKernel };
diff --git a/src/ophthalmology_sci/laplacian.ts b/src/ophthalmology_sci/laplacian.ts
new file mode 100644
index 000000000..2e94953a8
--- /dev/null
+++ b/src/ophthalmology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci laplacian module — tsb analytics library. */
+export interface OphthalmologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciLaplacian(data: number[], opts: OphthalmologySciLaplacianOptions = {}): OphthalmologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciLaplacian };
diff --git a/src/ophthalmology_sci/learning.ts b/src/ophthalmology_sci/learning.ts
new file mode 100644
index 000000000..1cdd52b38
--- /dev/null
+++ b/src/ophthalmology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci learning module — tsb analytics library. */
+export interface OphthalmologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciLearningResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciLearning(data: number[], opts: OphthalmologySciLearningOptions = {}): OphthalmologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciLearning };
diff --git a/src/ophthalmology_sci/linear.ts b/src/ophthalmology_sci/linear.ts
new file mode 100644
index 000000000..e3198dadd
--- /dev/null
+++ b/src/ophthalmology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci linear module — tsb analytics library. */
+export interface OphthalmologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciLinearResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciLinear(data: number[], opts: OphthalmologySciLinearOptions = {}): OphthalmologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciLinear };
diff --git a/src/ophthalmology_sci/manifold.ts b/src/ophthalmology_sci/manifold.ts
new file mode 100644
index 000000000..e252ad76f
--- /dev/null
+++ b/src/ophthalmology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci manifold module — tsb analytics library. */
+export interface OphthalmologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciManifold(data: number[], opts: OphthalmologySciManifoldOptions = {}): OphthalmologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciManifold };
diff --git a/src/ophthalmology_sci/matching.ts b/src/ophthalmology_sci/matching.ts
new file mode 100644
index 000000000..e7f0baab1
--- /dev/null
+++ b/src/ophthalmology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci matching module — tsb analytics library. */
+export interface OphthalmologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciMatching(data: number[], opts: OphthalmologySciMatchingOptions = {}): OphthalmologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciMatching };
diff --git a/src/ophthalmology_sci/measurement.ts b/src/ophthalmology_sci/measurement.ts
new file mode 100644
index 000000000..ea9093a80
--- /dev/null
+++ b/src/ophthalmology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci measurement module — tsb analytics library. */
+export interface OphthalmologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciMeasurement(data: number[], opts: OphthalmologySciMeasurementOptions = {}): OphthalmologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciMeasurement };
diff --git a/src/ophthalmology_sci/metrics.ts b/src/ophthalmology_sci/metrics.ts
new file mode 100644
index 000000000..bea4ac0a4
--- /dev/null
+++ b/src/ophthalmology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci metrics module — tsb analytics library. */
+export interface OphthalmologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciMetrics(data: number[], opts: OphthalmologySciMetricsOptions = {}): OphthalmologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciMetrics };
diff --git a/src/ophthalmology_sci/modeling.ts b/src/ophthalmology_sci/modeling.ts
new file mode 100644
index 000000000..607de1693
--- /dev/null
+++ b/src/ophthalmology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci modeling module — tsb analytics library. */
+export interface OphthalmologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciModelingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciModeling(data: number[], opts: OphthalmologySciModelingOptions = {}): OphthalmologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciModeling };
diff --git a/src/ophthalmology_sci/monitoring.ts b/src/ophthalmology_sci/monitoring.ts
new file mode 100644
index 000000000..8012f6dc6
--- /dev/null
+++ b/src/ophthalmology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci monitoring module — tsb analytics library. */
+export interface OphthalmologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciMonitoring(data: number[], opts: OphthalmologySciMonitoringOptions = {}): OphthalmologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciMonitoring };
diff --git a/src/ophthalmology_sci/nonlinear.ts b/src/ophthalmology_sci/nonlinear.ts
new file mode 100644
index 000000000..22b653a71
--- /dev/null
+++ b/src/ophthalmology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci nonlinear module — tsb analytics library. */
+export interface OphthalmologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciNonlinear(data: number[], opts: OphthalmologySciNonlinearOptions = {}): OphthalmologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciNonlinear };
diff --git a/src/ophthalmology_sci/normalization.ts b/src/ophthalmology_sci/normalization.ts
new file mode 100644
index 000000000..a4b3e7660
--- /dev/null
+++ b/src/ophthalmology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci normalization module — tsb analytics library. */
+export interface OphthalmologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciNormalization(data: number[], opts: OphthalmologySciNormalizationOptions = {}): OphthalmologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciNormalization };
diff --git a/src/ophthalmology_sci/optimization.ts b/src/ophthalmology_sci/optimization.ts
new file mode 100644
index 000000000..151ecaddf
--- /dev/null
+++ b/src/ophthalmology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci optimization module — tsb analytics library. */
+export interface OphthalmologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciOptimization(data: number[], opts: OphthalmologySciOptimizationOptions = {}): OphthalmologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciOptimization };
diff --git a/src/ophthalmology_sci/patterns.ts b/src/ophthalmology_sci/patterns.ts
new file mode 100644
index 000000000..2ea64fad6
--- /dev/null
+++ b/src/ophthalmology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci patterns module — tsb analytics library. */
+export interface OphthalmologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciPatterns(data: number[], opts: OphthalmologySciPatternsOptions = {}): OphthalmologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciPatterns };
diff --git a/src/ophthalmology_sci/permutation.ts b/src/ophthalmology_sci/permutation.ts
new file mode 100644
index 000000000..c4898e084
--- /dev/null
+++ b/src/ophthalmology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci permutation module — tsb analytics library. */
+export interface OphthalmologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciPermutation(data: number[], opts: OphthalmologySciPermutationOptions = {}): OphthalmologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciPermutation };
diff --git a/src/ophthalmology_sci/prediction.ts b/src/ophthalmology_sci/prediction.ts
new file mode 100644
index 000000000..3277d17af
--- /dev/null
+++ b/src/ophthalmology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci prediction module — tsb analytics library. */
+export interface OphthalmologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciPrediction(data: number[], opts: OphthalmologySciPredictionOptions = {}): OphthalmologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciPrediction };
diff --git a/src/ophthalmology_sci/processing.ts b/src/ophthalmology_sci/processing.ts
new file mode 100644
index 000000000..b4897aaef
--- /dev/null
+++ b/src/ophthalmology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci processing module — tsb analytics library. */
+export interface OphthalmologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciProcessing(data: number[], opts: OphthalmologySciProcessingOptions = {}): OphthalmologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciProcessing };
diff --git a/src/ophthalmology_sci/profiling.ts b/src/ophthalmology_sci/profiling.ts
new file mode 100644
index 000000000..e5c12fcd8
--- /dev/null
+++ b/src/ophthalmology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci profiling module — tsb analytics library. */
+export interface OphthalmologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciProfiling(data: number[], opts: OphthalmologySciProfilingOptions = {}): OphthalmologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciProfiling };
diff --git a/src/ophthalmology_sci/projection.ts b/src/ophthalmology_sci/projection.ts
new file mode 100644
index 000000000..8a748321b
--- /dev/null
+++ b/src/ophthalmology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci projection module — tsb analytics library. */
+export interface OphthalmologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciProjection(data: number[], opts: OphthalmologySciProjectionOptions = {}): OphthalmologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciProjection };
diff --git a/src/ophthalmology_sci/ranking.ts b/src/ophthalmology_sci/ranking.ts
new file mode 100644
index 000000000..9eec5d29a
--- /dev/null
+++ b/src/ophthalmology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci ranking module — tsb analytics library. */
+export interface OphthalmologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciRankingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciRanking(data: number[], opts: OphthalmologySciRankingOptions = {}): OphthalmologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciRanking };
diff --git a/src/ophthalmology_sci/reconstruction.ts b/src/ophthalmology_sci/reconstruction.ts
new file mode 100644
index 000000000..4ded0278b
--- /dev/null
+++ b/src/ophthalmology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci reconstruction module — tsb analytics library. */
+export interface OphthalmologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciReconstruction(data: number[], opts: OphthalmologySciReconstructionOptions = {}): OphthalmologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciReconstruction };
diff --git a/src/ophthalmology_sci/registration.ts b/src/ophthalmology_sci/registration.ts
new file mode 100644
index 000000000..ef7a9dcbb
--- /dev/null
+++ b/src/ophthalmology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci registration module — tsb analytics library. */
+export interface OphthalmologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciRegistration(data: number[], opts: OphthalmologySciRegistrationOptions = {}): OphthalmologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciRegistration };
diff --git a/src/ophthalmology_sci/regression.ts b/src/ophthalmology_sci/regression.ts
new file mode 100644
index 000000000..6f4a3b9fb
--- /dev/null
+++ b/src/ophthalmology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci regression module — tsb analytics library. */
+export interface OphthalmologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciRegression(data: number[], opts: OphthalmologySciRegressionOptions = {}): OphthalmologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciRegression };
diff --git a/src/ophthalmology_sci/regularization.ts b/src/ophthalmology_sci/regularization.ts
new file mode 100644
index 000000000..5e1e0390a
--- /dev/null
+++ b/src/ophthalmology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci regularization module — tsb analytics library. */
+export interface OphthalmologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciRegularization(data: number[], opts: OphthalmologySciRegularizationOptions = {}): OphthalmologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciRegularization };
diff --git a/src/ophthalmology_sci/robustness.ts b/src/ophthalmology_sci/robustness.ts
new file mode 100644
index 000000000..1ec82f2d5
--- /dev/null
+++ b/src/ophthalmology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci robustness module — tsb analytics library. */
+export interface OphthalmologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciRobustness(data: number[], opts: OphthalmologySciRobustnessOptions = {}): OphthalmologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciRobustness };
diff --git a/src/ophthalmology_sci/sampling.ts b/src/ophthalmology_sci/sampling.ts
new file mode 100644
index 000000000..a1150265b
--- /dev/null
+++ b/src/ophthalmology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci sampling module — tsb analytics library. */
+export interface OphthalmologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciSampling(data: number[], opts: OphthalmologySciSamplingOptions = {}): OphthalmologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciSampling };
diff --git a/src/ophthalmology_sci/sampling2.ts b/src/ophthalmology_sci/sampling2.ts
new file mode 100644
index 000000000..ce2008736
--- /dev/null
+++ b/src/ophthalmology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci sampling2 module — tsb analytics library. */
+export interface OphthalmologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciSampling(data: number[], opts: OphthalmologySciSamplingOptions = {}): OphthalmologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciSampling };
diff --git a/src/ophthalmology_sci/scaling.ts b/src/ophthalmology_sci/scaling.ts
new file mode 100644
index 000000000..e370767c6
--- /dev/null
+++ b/src/ophthalmology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci scaling module — tsb analytics library. */
+export interface OphthalmologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciScalingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciScaling(data: number[], opts: OphthalmologySciScalingOptions = {}): OphthalmologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciScaling };
diff --git a/src/ophthalmology_sci/scoring.ts b/src/ophthalmology_sci/scoring.ts
new file mode 100644
index 000000000..41772feb6
--- /dev/null
+++ b/src/ophthalmology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci scoring module — tsb analytics library. */
+export interface OphthalmologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciScoringResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciScoring(data: number[], opts: OphthalmologySciScoringOptions = {}): OphthalmologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciScoring };
diff --git a/src/ophthalmology_sci/segmentation.ts b/src/ophthalmology_sci/segmentation.ts
new file mode 100644
index 000000000..957d22204
--- /dev/null
+++ b/src/ophthalmology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci segmentation module — tsb analytics library. */
+export interface OphthalmologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciSegmentation(data: number[], opts: OphthalmologySciSegmentationOptions = {}): OphthalmologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciSegmentation };
diff --git a/src/ophthalmology_sci/selection.ts b/src/ophthalmology_sci/selection.ts
new file mode 100644
index 000000000..406ca97a9
--- /dev/null
+++ b/src/ophthalmology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci selection module — tsb analytics library. */
+export interface OphthalmologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciSelection(data: number[], opts: OphthalmologySciSelectionOptions = {}): OphthalmologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciSelection };
diff --git a/src/ophthalmology_sci/sensitivity.ts b/src/ophthalmology_sci/sensitivity.ts
new file mode 100644
index 000000000..f744b49f5
--- /dev/null
+++ b/src/ophthalmology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci sensitivity module — tsb analytics library. */
+export interface OphthalmologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciSensitivity(data: number[], opts: OphthalmologySciSensitivityOptions = {}): OphthalmologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciSensitivity };
diff --git a/src/ophthalmology_sci/simulation.ts b/src/ophthalmology_sci/simulation.ts
new file mode 100644
index 000000000..f05ad4c35
--- /dev/null
+++ b/src/ophthalmology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci simulation module — tsb analytics library. */
+export interface OphthalmologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciSimulation(data: number[], opts: OphthalmologySciSimulationOptions = {}): OphthalmologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciSimulation };
diff --git a/src/ophthalmology_sci/smoothing.ts b/src/ophthalmology_sci/smoothing.ts
new file mode 100644
index 000000000..63d82f563
--- /dev/null
+++ b/src/ophthalmology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci smoothing module — tsb analytics library. */
+export interface OphthalmologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciSmoothing(data: number[], opts: OphthalmologySciSmoothingOptions = {}): OphthalmologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciSmoothing };
diff --git a/src/ophthalmology_sci/stability.ts b/src/ophthalmology_sci/stability.ts
new file mode 100644
index 000000000..b00510d35
--- /dev/null
+++ b/src/ophthalmology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci stability module — tsb analytics library. */
+export interface OphthalmologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciStability(data: number[], opts: OphthalmologySciStabilityOptions = {}): OphthalmologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciStability };
diff --git a/src/ophthalmology_sci/stacking.ts b/src/ophthalmology_sci/stacking.ts
new file mode 100644
index 000000000..d1c2b7b31
--- /dev/null
+++ b/src/ophthalmology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci stacking module — tsb analytics library. */
+export interface OphthalmologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciStackingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciStacking(data: number[], opts: OphthalmologySciStackingOptions = {}): OphthalmologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciStacking };
diff --git a/src/ophthalmology_sci/standardization.ts b/src/ophthalmology_sci/standardization.ts
new file mode 100644
index 000000000..9eb17e281
--- /dev/null
+++ b/src/ophthalmology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci standardization module — tsb analytics library. */
+export interface OphthalmologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciStandardization(data: number[], opts: OphthalmologySciStandardizationOptions = {}): OphthalmologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciStandardization };
diff --git a/src/ophthalmology_sci/static.ts b/src/ophthalmology_sci/static.ts
new file mode 100644
index 000000000..26f5f27ff
--- /dev/null
+++ b/src/ophthalmology_sci/static.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci static module — tsb analytics library. */
+export interface OphthalmologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciStaticResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciStatic(data: number[], opts: OphthalmologySciStaticOptions = {}): OphthalmologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciStatic };
diff --git a/src/ophthalmology_sci/stochastic.ts b/src/ophthalmology_sci/stochastic.ts
new file mode 100644
index 000000000..eb70d50f9
--- /dev/null
+++ b/src/ophthalmology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci stochastic module — tsb analytics library. */
+export interface OphthalmologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciStochastic(data: number[], opts: OphthalmologySciStochasticOptions = {}): OphthalmologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciStochastic };
diff --git a/src/ophthalmology_sci/synthesis.ts b/src/ophthalmology_sci/synthesis.ts
new file mode 100644
index 000000000..2c6e1643d
--- /dev/null
+++ b/src/ophthalmology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci synthesis module — tsb analytics library. */
+export interface OphthalmologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciSynthesis(data: number[], opts: OphthalmologySciSynthesisOptions = {}): OphthalmologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciSynthesis };
diff --git a/src/ophthalmology_sci/topology.ts b/src/ophthalmology_sci/topology.ts
new file mode 100644
index 000000000..6a81cd971
--- /dev/null
+++ b/src/ophthalmology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci topology module — tsb analytics library. */
+export interface OphthalmologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciTopology(data: number[], opts: OphthalmologySciTopologyOptions = {}): OphthalmologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciTopology };
diff --git a/src/ophthalmology_sci/tracking.ts b/src/ophthalmology_sci/tracking.ts
new file mode 100644
index 000000000..41a08efe3
--- /dev/null
+++ b/src/ophthalmology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci tracking module — tsb analytics library. */
+export interface OphthalmologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciTracking(data: number[], opts: OphthalmologySciTrackingOptions = {}): OphthalmologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciTracking };
diff --git a/src/ophthalmology_sci/transform.ts b/src/ophthalmology_sci/transform.ts
new file mode 100644
index 000000000..7e9a4dbcd
--- /dev/null
+++ b/src/ophthalmology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci transform module — tsb analytics library. */
+export interface OphthalmologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciTransformResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciTransform(data: number[], opts: OphthalmologySciTransformOptions = {}): OphthalmologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciTransform };
diff --git a/src/ophthalmology_sci/uncertainty.ts b/src/ophthalmology_sci/uncertainty.ts
new file mode 100644
index 000000000..cbda0b4cc
--- /dev/null
+++ b/src/ophthalmology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci uncertainty module — tsb analytics library. */
+export interface OphthalmologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciUncertainty(data: number[], opts: OphthalmologySciUncertaintyOptions = {}): OphthalmologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciUncertainty };
diff --git a/src/ophthalmology_sci/validation.ts b/src/ophthalmology_sci/validation.ts
new file mode 100644
index 000000000..10da6a70c
--- /dev/null
+++ b/src/ophthalmology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci validation module — tsb analytics library. */
+export interface OphthalmologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciValidationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciValidation(data: number[], opts: OphthalmologySciValidationOptions = {}): OphthalmologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciValidation };
diff --git a/src/ophthalmology_sci/verification.ts b/src/ophthalmology_sci/verification.ts
new file mode 100644
index 000000000..9a65fe085
--- /dev/null
+++ b/src/ophthalmology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci verification module — tsb analytics library. */
+export interface OphthalmologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciVerification(data: number[], opts: OphthalmologySciVerificationOptions = {}): OphthalmologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciVerification };
diff --git a/src/ophthalmology_sci/visualization.ts b/src/ophthalmology_sci/visualization.ts
new file mode 100644
index 000000000..915fa6496
--- /dev/null
+++ b/src/ophthalmology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci visualization module — tsb analytics library. */
+export interface OphthalmologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciVisualization(data: number[], opts: OphthalmologySciVisualizationOptions = {}): OphthalmologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciVisualization };
diff --git a/src/ophthalmology_sci/voting.ts b/src/ophthalmology_sci/voting.ts
new file mode 100644
index 000000000..550f8563e
--- /dev/null
+++ b/src/ophthalmology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci voting module — tsb analytics library. */
+export interface OphthalmologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciVotingResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciVoting(data: number[], opts: OphthalmologySciVotingOptions = {}): OphthalmologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciVoting };
diff --git a/src/ophthalmology_sci/wavelet.ts b/src/ophthalmology_sci/wavelet.ts
new file mode 100644
index 000000000..fa4341402
--- /dev/null
+++ b/src/ophthalmology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** ophthalmology_sci wavelet module — tsb analytics library. */
+export interface OphthalmologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface OphthalmologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeOphthalmologySciWavelet(data: number[], opts: OphthalmologySciWaveletOptions = {}): OphthalmologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOphthalmologySciWavelet };
diff --git a/src/optimization/active_set.ts b/src/optimization/active_set.ts
new file mode 100644
index 000000000..d06a74845
--- /dev/null
+++ b/src/optimization/active_set.ts
@@ -0,0 +1,22 @@
+/** Active Set module — tsb analytics library. */
+
+/** Options for Active Set. */
+export interface ActiveSetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Active Set. */
+export interface ActiveSetResult { values: number[]; converged: boolean; }
+
+/** Compute Active Set. */
+export function computeActiveSet(data: number[], opts: ActiveSetOptions = {}): ActiveSetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeActiveSet };
diff --git a/src/optimization/adam.ts b/src/optimization/adam.ts
new file mode 100644
index 000000000..b00c9b0e1
--- /dev/null
+++ b/src/optimization/adam.ts
@@ -0,0 +1,22 @@
+/** Adam module — tsb analytics library. */
+
+/** Options for Adam. */
+export interface AdamOptions { tol?: number; maxIter?: number; }
+
+/** Result from Adam. */
+export interface AdamResult { values: number[]; converged: boolean; }
+
+/** Compute Adam. */
+export function computeAdam(data: number[], opts: AdamOptions = {}): AdamResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAdam };
diff --git a/src/optimization/admm.ts b/src/optimization/admm.ts
new file mode 100644
index 000000000..1d135da15
--- /dev/null
+++ b/src/optimization/admm.ts
@@ -0,0 +1,22 @@
+/** Admm module — tsb analytics library. */
+
+/** Options for Admm. */
+export interface AdmmOptions { tol?: number; maxIter?: number; }
+
+/** Result from Admm. */
+export interface AdmmResult { values: number[]; converged: boolean; }
+
+/** Compute Admm. */
+export function computeAdmm(data: number[], opts: AdmmOptions = {}): AdmmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAdmm };
diff --git a/src/optimization/advanced.ts b/src/optimization/advanced.ts
new file mode 100644
index 000000000..8cc7f5b5e
--- /dev/null
+++ b/src/optimization/advanced.ts
@@ -0,0 +1,15 @@
+/** Optimization Advanced module — tsb analytics library. */
+export interface Optimization advancedOptions { tol?: number; maxIter?: number; }
+export interface Optimization advancedResult { values: number[]; converged: boolean; }
+export function computeOptimization advanced(data: number[], opts: Optimization advancedOptions = {}): Optimization advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization advanced };
diff --git a/src/optimization/base2.ts b/src/optimization/base2.ts
new file mode 100644
index 000000000..59b518a61
--- /dev/null
+++ b/src/optimization/base2.ts
@@ -0,0 +1,15 @@
+/** Optimization Base2 module — tsb analytics library. */
+export interface Optimization base2Options { tol?: number; maxIter?: number; }
+export interface Optimization base2Result { values: number[]; converged: boolean; }
+export function computeOptimization base2(data: number[], opts: Optimization base2Options = {}): Optimization base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization base2 };
diff --git a/src/optimization/batch.ts b/src/optimization/batch.ts
new file mode 100644
index 000000000..80b486330
--- /dev/null
+++ b/src/optimization/batch.ts
@@ -0,0 +1,15 @@
+/** Optimization Batch module — tsb analytics library. */
+export interface Optimization batchOptions { tol?: number; maxIter?: number; }
+export interface Optimization batchResult { values: number[]; converged: boolean; }
+export function computeOptimization batch(data: number[], opts: Optimization batchOptions = {}): Optimization batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization batch };
diff --git a/src/optimization/bellman.ts b/src/optimization/bellman.ts
new file mode 100644
index 000000000..ac74ee665
--- /dev/null
+++ b/src/optimization/bellman.ts
@@ -0,0 +1,22 @@
+/** Bellman module — tsb analytics library. */
+
+/** Options for Bellman. */
+export interface BellmanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bellman. */
+export interface BellmanResult { values: number[]; converged: boolean; }
+
+/** Compute Bellman. */
+export function computeBellman(data: number[], opts: BellmanOptions = {}): BellmanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBellman };
diff --git a/src/optimization/beta.ts b/src/optimization/beta.ts
new file mode 100644
index 000000000..d26dca791
--- /dev/null
+++ b/src/optimization/beta.ts
@@ -0,0 +1,15 @@
+/** Optimization Beta module — tsb analytics library. */
+export interface Optimization betaOptions { tol?: number; maxIter?: number; }
+export interface Optimization betaResult { values: number[]; converged: boolean; }
+export function computeOptimization beta(data: number[], opts: Optimization betaOptions = {}): Optimization betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization beta };
diff --git a/src/optimization/bfgs.ts b/src/optimization/bfgs.ts
new file mode 100644
index 000000000..ab5c727ce
--- /dev/null
+++ b/src/optimization/bfgs.ts
@@ -0,0 +1,22 @@
+/** Bfgs module — tsb analytics library. */
+
+/** Options for Bfgs. */
+export interface BfgsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bfgs. */
+export interface BfgsResult { values: number[]; converged: boolean; }
+
+/** Compute Bfgs. */
+export function computeBfgs(data: number[], opts: BfgsOptions = {}): BfgsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBfgs };
diff --git a/src/optimization/branch_bound.ts b/src/optimization/branch_bound.ts
new file mode 100644
index 000000000..fea702635
--- /dev/null
+++ b/src/optimization/branch_bound.ts
@@ -0,0 +1,22 @@
+/** Branch Bound module — tsb analytics library. */
+
+/** Options for Branch Bound. */
+export interface BranchBoundOptions { tol?: number; maxIter?: number; }
+
+/** Result from Branch Bound. */
+export interface BranchBoundResult { values: number[]; converged: boolean; }
+
+/** Compute Branch Bound. */
+export function computeBranchBound(data: number[], opts: BranchBoundOptions = {}): BranchBoundResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBranchBound };
diff --git a/src/optimization/cg.ts b/src/optimization/cg.ts
new file mode 100644
index 000000000..2be02ca04
--- /dev/null
+++ b/src/optimization/cg.ts
@@ -0,0 +1,22 @@
+/** Cg module — tsb analytics library. */
+
+/** Options for Cg. */
+export interface CgOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cg. */
+export interface CgResult { values: number[]; converged: boolean; }
+
+/** Compute Cg. */
+export function computeCg(data: number[], opts: CgOptions = {}): CgResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCg };
diff --git a/src/optimization/coordinate_descent.ts b/src/optimization/coordinate_descent.ts
new file mode 100644
index 000000000..6425b76c3
--- /dev/null
+++ b/src/optimization/coordinate_descent.ts
@@ -0,0 +1,22 @@
+/** Coordinate Descent module — tsb analytics library. */
+
+/** Options for Coordinate Descent. */
+export interface CoordinateDescentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coordinate Descent. */
+export interface CoordinateDescentResult { values: number[]; converged: boolean; }
+
+/** Compute Coordinate Descent. */
+export function computeCoordinateDescent(data: number[], opts: CoordinateDescentOptions = {}): CoordinateDescentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCoordinateDescent };
diff --git a/src/optimization/cpu.ts b/src/optimization/cpu.ts
new file mode 100644
index 000000000..61d7e40eb
--- /dev/null
+++ b/src/optimization/cpu.ts
@@ -0,0 +1,15 @@
+/** Optimization Cpu module — tsb analytics library. */
+export interface Optimization cpuOptions { tol?: number; maxIter?: number; }
+export interface Optimization cpuResult { values: number[]; converged: boolean; }
+export function computeOptimization cpu(data: number[], opts: Optimization cpuOptions = {}): Optimization cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization cpu };
diff --git a/src/optimization/cutting_plane.ts b/src/optimization/cutting_plane.ts
new file mode 100644
index 000000000..02731d3a0
--- /dev/null
+++ b/src/optimization/cutting_plane.ts
@@ -0,0 +1,22 @@
+/** Cutting Plane module — tsb analytics library. */
+
+/** Options for Cutting Plane. */
+export interface CuttingPlaneOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cutting Plane. */
+export interface CuttingPlaneResult { values: number[]; converged: boolean; }
+
+/** Compute Cutting Plane. */
+export function computeCuttingPlane(data: number[], opts: CuttingPlaneOptions = {}): CuttingPlaneResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCuttingPlane };
diff --git a/src/optimization/dense.ts b/src/optimization/dense.ts
new file mode 100644
index 000000000..7daa05b11
--- /dev/null
+++ b/src/optimization/dense.ts
@@ -0,0 +1,15 @@
+/** Optimization Dense module — tsb analytics library. */
+export interface Optimization denseOptions { tol?: number; maxIter?: number; }
+export interface Optimization denseResult { values: number[]; converged: boolean; }
+export function computeOptimization dense(data: number[], opts: Optimization denseOptions = {}): Optimization denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization dense };
diff --git a/src/optimization/distributed.ts b/src/optimization/distributed.ts
new file mode 100644
index 000000000..c05197f48
--- /dev/null
+++ b/src/optimization/distributed.ts
@@ -0,0 +1,15 @@
+/** Optimization Distributed module — tsb analytics library. */
+export interface Optimization distributedOptions { tol?: number; maxIter?: number; }
+export interface Optimization distributedResult { values: number[]; converged: boolean; }
+export function computeOptimization distributed(data: number[], opts: Optimization distributedOptions = {}): Optimization distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization distributed };
diff --git a/src/optimization/dual.ts b/src/optimization/dual.ts
new file mode 100644
index 000000000..9b37f323f
--- /dev/null
+++ b/src/optimization/dual.ts
@@ -0,0 +1,22 @@
+/** Dual module — tsb analytics library. */
+
+/** Options for Dual. */
+export interface DualOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dual. */
+export interface DualResult { values: number[]; converged: boolean; }
+
+/** Compute Dual. */
+export function computeDual(data: number[], opts: DualOptions = {}): DualResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDual };
diff --git a/src/optimization/dynamic_prog.ts b/src/optimization/dynamic_prog.ts
new file mode 100644
index 000000000..7d2c58fd1
--- /dev/null
+++ b/src/optimization/dynamic_prog.ts
@@ -0,0 +1,22 @@
+/** Dynamic Prog module — tsb analytics library. */
+
+/** Options for Dynamic Prog. */
+export interface DynamicProgOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dynamic Prog. */
+export interface DynamicProgResult { values: number[]; converged: boolean; }
+
+/** Compute Dynamic Prog. */
+export function computeDynamicProg(data: number[], opts: DynamicProgOptions = {}): DynamicProgResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDynamicProg };
diff --git a/src/optimization/experimental.ts b/src/optimization/experimental.ts
new file mode 100644
index 000000000..8e82eac11
--- /dev/null
+++ b/src/optimization/experimental.ts
@@ -0,0 +1,15 @@
+/** Optimization Experimental module — tsb analytics library. */
+export interface Optimization experimentalOptions { tol?: number; maxIter?: number; }
+export interface Optimization experimentalResult { values: number[]; converged: boolean; }
+export function computeOptimization experimental(data: number[], opts: Optimization experimentalOptions = {}): Optimization experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization experimental };
diff --git a/src/optimization/fast.ts b/src/optimization/fast.ts
new file mode 100644
index 000000000..f7e04374c
--- /dev/null
+++ b/src/optimization/fast.ts
@@ -0,0 +1,15 @@
+/** Optimization Fast module — tsb analytics library. */
+export interface Optimization fastOptions { tol?: number; maxIter?: number; }
+export interface Optimization fastResult { values: number[]; converged: boolean; }
+export function computeOptimization fast(data: number[], opts: Optimization fastOptions = {}): Optimization fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization fast };
diff --git a/src/optimization/frank_wolfe.ts b/src/optimization/frank_wolfe.ts
new file mode 100644
index 000000000..ab46cd5ab
--- /dev/null
+++ b/src/optimization/frank_wolfe.ts
@@ -0,0 +1,22 @@
+/** Frank Wolfe module — tsb analytics library. */
+
+/** Options for Frank Wolfe. */
+export interface FrankWolfeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Frank Wolfe. */
+export interface FrankWolfeResult { values: number[]; converged: boolean; }
+
+/** Compute Frank Wolfe. */
+export function computeFrankWolfe(data: number[], opts: FrankWolfeOptions = {}): FrankWolfeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFrankWolfe };
diff --git a/src/optimization/future.ts b/src/optimization/future.ts
new file mode 100644
index 000000000..d6ef2378e
--- /dev/null
+++ b/src/optimization/future.ts
@@ -0,0 +1,15 @@
+/** Optimization Future module — tsb analytics library. */
+export interface Optimization futureOptions { tol?: number; maxIter?: number; }
+export interface Optimization futureResult { values: number[]; converged: boolean; }
+export function computeOptimization future(data: number[], opts: Optimization futureOptions = {}): Optimization futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization future };
diff --git a/src/optimization/genetic.ts b/src/optimization/genetic.ts
new file mode 100644
index 000000000..e9151d70b
--- /dev/null
+++ b/src/optimization/genetic.ts
@@ -0,0 +1,22 @@
+/** Genetic module — tsb analytics library. */
+
+/** Options for Genetic. */
+export interface GeneticOptions { tol?: number; maxIter?: number; }
+
+/** Result from Genetic. */
+export interface GeneticResult { values: number[]; converged: boolean; }
+
+/** Compute Genetic. */
+export function computeGenetic(data: number[], opts: GeneticOptions = {}): GeneticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGenetic };
diff --git a/src/optimization/gpu.ts b/src/optimization/gpu.ts
new file mode 100644
index 000000000..0a5154359
--- /dev/null
+++ b/src/optimization/gpu.ts
@@ -0,0 +1,15 @@
+/** Optimization Gpu module — tsb analytics library. */
+export interface Optimization gpuOptions { tol?: number; maxIter?: number; }
+export interface Optimization gpuResult { values: number[]; converged: boolean; }
+export function computeOptimization gpu(data: number[], opts: Optimization gpuOptions = {}): Optimization gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization gpu };
diff --git a/src/optimization/gradient_descent.ts b/src/optimization/gradient_descent.ts
new file mode 100644
index 000000000..1e32ce269
--- /dev/null
+++ b/src/optimization/gradient_descent.ts
@@ -0,0 +1,22 @@
+/** Gradient Descent module — tsb analytics library. */
+
+/** Options for Gradient Descent. */
+export interface GradientDescentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gradient Descent. */
+export interface GradientDescentResult { values: number[]; converged: boolean; }
+
+/** Compute Gradient Descent. */
+export function computeGradientDescent(data: number[], opts: GradientDescentOptions = {}): GradientDescentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGradientDescent };
diff --git a/src/optimization/integer_prog.ts b/src/optimization/integer_prog.ts
new file mode 100644
index 000000000..08dad85ef
--- /dev/null
+++ b/src/optimization/integer_prog.ts
@@ -0,0 +1,22 @@
+/** Integer Prog module — tsb analytics library. */
+
+/** Options for Integer Prog. */
+export interface IntegerProgOptions { tol?: number; maxIter?: number; }
+
+/** Result from Integer Prog. */
+export interface IntegerProgResult { values: number[]; converged: boolean; }
+
+/** Compute Integer Prog. */
+export function computeIntegerProg(data: number[], opts: IntegerProgOptions = {}): IntegerProgResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIntegerProg };
diff --git a/src/optimization/interior_point.ts b/src/optimization/interior_point.ts
new file mode 100644
index 000000000..96e015f02
--- /dev/null
+++ b/src/optimization/interior_point.ts
@@ -0,0 +1,22 @@
+/** Interior Point module — tsb analytics library. */
+
+/** Options for Interior Point. */
+export interface InteriorPointOptions { tol?: number; maxIter?: number; }
+
+/** Result from Interior Point. */
+export interface InteriorPointResult { values: number[]; converged: boolean; }
+
+/** Compute Interior Point. */
+export function computeInteriorPoint(data: number[], opts: InteriorPointOptions = {}): InteriorPointResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInteriorPoint };
diff --git a/src/optimization/kkt.ts b/src/optimization/kkt.ts
new file mode 100644
index 000000000..7bf66b7b6
--- /dev/null
+++ b/src/optimization/kkt.ts
@@ -0,0 +1,22 @@
+/** Kkt module — tsb analytics library. */
+
+/** Options for Kkt. */
+export interface KktOptions { tol?: number; maxIter?: number; }
+
+/** Result from Kkt. */
+export interface KktResult { values: number[]; converged: boolean; }
+
+/** Compute Kkt. */
+export function computeKkt(data: number[], opts: KktOptions = {}): KktResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKkt };
diff --git a/src/optimization/lagrangian.ts b/src/optimization/lagrangian.ts
new file mode 100644
index 000000000..7d54b14a5
--- /dev/null
+++ b/src/optimization/lagrangian.ts
@@ -0,0 +1,22 @@
+/** Lagrangian module — tsb analytics library. */
+
+/** Options for Lagrangian. */
+export interface LagrangianOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lagrangian. */
+export interface LagrangianResult { values: number[]; converged: boolean; }
+
+/** Compute Lagrangian. */
+export function computeLagrangian(data: number[], opts: LagrangianOptions = {}): LagrangianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLagrangian };
diff --git a/src/optimization/large.ts b/src/optimization/large.ts
new file mode 100644
index 000000000..1a223c1ee
--- /dev/null
+++ b/src/optimization/large.ts
@@ -0,0 +1,15 @@
+/** Optimization Large module — tsb analytics library. */
+export interface Optimization largeOptions { tol?: number; maxIter?: number; }
+export interface Optimization largeResult { values: number[]; converged: boolean; }
+export function computeOptimization large(data: number[], opts: Optimization largeOptions = {}): Optimization largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization large };
diff --git a/src/optimization/lbfgs.ts b/src/optimization/lbfgs.ts
new file mode 100644
index 000000000..9eb488eab
--- /dev/null
+++ b/src/optimization/lbfgs.ts
@@ -0,0 +1,22 @@
+/** Lbfgs module — tsb analytics library. */
+
+/** Options for Lbfgs. */
+export interface LbfgsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lbfgs. */
+export interface LbfgsResult { values: number[]; converged: boolean; }
+
+/** Compute Lbfgs. */
+export function computeLbfgs(data: number[], opts: LbfgsOptions = {}): LbfgsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLbfgs };
diff --git a/src/optimization/legacy.ts b/src/optimization/legacy.ts
new file mode 100644
index 000000000..5e4952db4
--- /dev/null
+++ b/src/optimization/legacy.ts
@@ -0,0 +1,15 @@
+/** Optimization Legacy module — tsb analytics library. */
+export interface Optimization legacyOptions { tol?: number; maxIter?: number; }
+export interface Optimization legacyResult { values: number[]; converged: boolean; }
+export function computeOptimization legacy(data: number[], opts: Optimization legacyOptions = {}): Optimization legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization legacy };
diff --git a/src/optimization/linear_prog.ts b/src/optimization/linear_prog.ts
new file mode 100644
index 000000000..d0aedf6e7
--- /dev/null
+++ b/src/optimization/linear_prog.ts
@@ -0,0 +1,22 @@
+/** Linear Prog module — tsb analytics library. */
+
+/** Options for Linear Prog. */
+export interface LinearProgOptions { tol?: number; maxIter?: number; }
+
+/** Result from Linear Prog. */
+export interface LinearProgResult { values: number[]; converged: boolean; }
+
+/** Compute Linear Prog. */
+export function computeLinearProg(data: number[], opts: LinearProgOptions = {}): LinearProgResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLinearProg };
diff --git a/src/optimization/lite.ts b/src/optimization/lite.ts
new file mode 100644
index 000000000..4b0d939c8
--- /dev/null
+++ b/src/optimization/lite.ts
@@ -0,0 +1,15 @@
+/** Optimization Lite module — tsb analytics library. */
+export interface Optimization liteOptions { tol?: number; maxIter?: number; }
+export interface Optimization liteResult { values: number[]; converged: boolean; }
+export function computeOptimization lite(data: number[], opts: Optimization liteOptions = {}): Optimization liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization lite };
diff --git a/src/optimization/mini.ts b/src/optimization/mini.ts
new file mode 100644
index 000000000..dad862b05
--- /dev/null
+++ b/src/optimization/mini.ts
@@ -0,0 +1,15 @@
+/** Optimization Mini module — tsb analytics library. */
+export interface Optimization miniOptions { tol?: number; maxIter?: number; }
+export interface Optimization miniResult { values: number[]; converged: boolean; }
+export function computeOptimization mini(data: number[], opts: Optimization miniOptions = {}): Optimization miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization mini };
diff --git a/src/optimization/mirror_descent.ts b/src/optimization/mirror_descent.ts
new file mode 100644
index 000000000..a65617aa0
--- /dev/null
+++ b/src/optimization/mirror_descent.ts
@@ -0,0 +1,22 @@
+/** Mirror Descent module — tsb analytics library. */
+
+/** Options for Mirror Descent. */
+export interface MirrorDescentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mirror Descent. */
+export interface MirrorDescentResult { values: number[]; converged: boolean; }
+
+/** Compute Mirror Descent. */
+export function computeMirrorDescent(data: number[], opts: MirrorDescentOptions = {}): MirrorDescentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMirrorDescent };
diff --git a/src/optimization/nelder_mead.ts b/src/optimization/nelder_mead.ts
new file mode 100644
index 000000000..6340fa8f5
--- /dev/null
+++ b/src/optimization/nelder_mead.ts
@@ -0,0 +1,22 @@
+/** Nelder Mead module — tsb analytics library. */
+
+/** Options for Nelder Mead. */
+export interface NelderMeadOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nelder Mead. */
+export interface NelderMeadResult { values: number[]; converged: boolean; }
+
+/** Compute Nelder Mead. */
+export function computeNelderMead(data: number[], opts: NelderMeadOptions = {}): NelderMeadResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNelderMead };
diff --git a/src/optimization/next.ts b/src/optimization/next.ts
new file mode 100644
index 000000000..c228b1a99
--- /dev/null
+++ b/src/optimization/next.ts
@@ -0,0 +1,15 @@
+/** Optimization Next module — tsb analytics library. */
+export interface Optimization nextOptions { tol?: number; maxIter?: number; }
+export interface Optimization nextResult { values: number[]; converged: boolean; }
+export function computeOptimization next(data: number[], opts: Optimization nextOptions = {}): Optimization nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization next };
diff --git a/src/optimization/nonlinear_prog.ts b/src/optimization/nonlinear_prog.ts
new file mode 100644
index 000000000..dfe816659
--- /dev/null
+++ b/src/optimization/nonlinear_prog.ts
@@ -0,0 +1,22 @@
+/** Nonlinear Prog module — tsb analytics library. */
+
+/** Options for Nonlinear Prog. */
+export interface NonlinearProgOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nonlinear Prog. */
+export interface NonlinearProgResult { values: number[]; converged: boolean; }
+
+/** Compute Nonlinear Prog. */
+export function computeNonlinearProg(data: number[], opts: NonlinearProgOptions = {}): NonlinearProgResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNonlinearProg };
diff --git a/src/optimization/online.ts b/src/optimization/online.ts
new file mode 100644
index 000000000..2e4a402cd
--- /dev/null
+++ b/src/optimization/online.ts
@@ -0,0 +1,15 @@
+/** Optimization Online module — tsb analytics library. */
+export interface Optimization onlineOptions { tol?: number; maxIter?: number; }
+export interface Optimization onlineResult { values: number[]; converged: boolean; }
+export function computeOptimization online(data: number[], opts: Optimization onlineOptions = {}): Optimization onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization online };
diff --git a/src/optimization/parallel.ts b/src/optimization/parallel.ts
new file mode 100644
index 000000000..36443d92e
--- /dev/null
+++ b/src/optimization/parallel.ts
@@ -0,0 +1,15 @@
+/** Optimization Parallel module — tsb analytics library. */
+export interface Optimization parallelOptions { tol?: number; maxIter?: number; }
+export interface Optimization parallelResult { values: number[]; converged: boolean; }
+export function computeOptimization parallel(data: number[], opts: Optimization parallelOptions = {}): Optimization parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization parallel };
diff --git a/src/optimization/plus.ts b/src/optimization/plus.ts
new file mode 100644
index 000000000..690f2721d
--- /dev/null
+++ b/src/optimization/plus.ts
@@ -0,0 +1,15 @@
+/** Optimization Plus module — tsb analytics library. */
+export interface Optimization plusOptions { tol?: number; maxIter?: number; }
+export interface Optimization plusResult { values: number[]; converged: boolean; }
+export function computeOptimization plus(data: number[], opts: Optimization plusOptions = {}): Optimization plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization plus };
diff --git a/src/optimization/policy_gradient.ts b/src/optimization/policy_gradient.ts
new file mode 100644
index 000000000..a8ce6410e
--- /dev/null
+++ b/src/optimization/policy_gradient.ts
@@ -0,0 +1,22 @@
+/** Policy Gradient module — tsb analytics library. */
+
+/** Options for Policy Gradient. */
+export interface PolicyGradientOptions { tol?: number; maxIter?: number; }
+
+/** Result from Policy Gradient. */
+export interface PolicyGradientResult { values: number[]; converged: boolean; }
+
+/** Compute Policy Gradient. */
+export function computePolicyGradient(data: number[], opts: PolicyGradientOptions = {}): PolicyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePolicyGradient };
diff --git a/src/optimization/pro.ts b/src/optimization/pro.ts
new file mode 100644
index 000000000..ac4adae6f
--- /dev/null
+++ b/src/optimization/pro.ts
@@ -0,0 +1,15 @@
+/** Optimization Pro module — tsb analytics library. */
+export interface Optimization proOptions { tol?: number; maxIter?: number; }
+export interface Optimization proResult { values: number[]; converged: boolean; }
+export function computeOptimization pro(data: number[], opts: Optimization proOptions = {}): Optimization proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization pro };
diff --git a/src/optimization/proximal.ts b/src/optimization/proximal.ts
new file mode 100644
index 000000000..57e92ce1e
--- /dev/null
+++ b/src/optimization/proximal.ts
@@ -0,0 +1,22 @@
+/** Proximal module — tsb analytics library. */
+
+/** Options for Proximal. */
+export interface ProximalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Proximal. */
+export interface ProximalResult { values: number[]; converged: boolean; }
+
+/** Compute Proximal. */
+export function computeProximal(data: number[], opts: ProximalOptions = {}): ProximalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProximal };
diff --git a/src/optimization/pso.ts b/src/optimization/pso.ts
new file mode 100644
index 000000000..7515d236a
--- /dev/null
+++ b/src/optimization/pso.ts
@@ -0,0 +1,22 @@
+/** Pso module — tsb analytics library. */
+
+/** Options for Pso. */
+export interface PsoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pso. */
+export interface PsoResult { values: number[]; converged: boolean; }
+
+/** Compute Pso. */
+export function computePso(data: number[], opts: PsoOptions = {}): PsoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePso };
diff --git a/src/optimization/quadratic_prog.ts b/src/optimization/quadratic_prog.ts
new file mode 100644
index 000000000..f9b4040ec
--- /dev/null
+++ b/src/optimization/quadratic_prog.ts
@@ -0,0 +1,22 @@
+/** Quadratic Prog module — tsb analytics library. */
+
+/** Options for Quadratic Prog. */
+export interface QuadraticProgOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quadratic Prog. */
+export interface QuadraticProgResult { values: number[]; converged: boolean; }
+
+/** Compute Quadratic Prog. */
+export function computeQuadraticProg(data: number[], opts: QuadraticProgOptions = {}): QuadraticProgResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQuadraticProg };
diff --git a/src/optimization/robust.ts b/src/optimization/robust.ts
new file mode 100644
index 000000000..ece40585e
--- /dev/null
+++ b/src/optimization/robust.ts
@@ -0,0 +1,15 @@
+/** Optimization Robust module — tsb analytics library. */
+export interface Optimization robustOptions { tol?: number; maxIter?: number; }
+export interface Optimization robustResult { values: number[]; converged: boolean; }
+export function computeOptimization robust(data: number[], opts: Optimization robustOptions = {}): Optimization robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization robust };
diff --git a/src/optimization/sa.ts b/src/optimization/sa.ts
new file mode 100644
index 000000000..08fbdf2bf
--- /dev/null
+++ b/src/optimization/sa.ts
@@ -0,0 +1,22 @@
+/** Sa module — tsb analytics library. */
+
+/** Options for Sa. */
+export interface SaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sa. */
+export interface SaResult { values: number[]; converged: boolean; }
+
+/** Compute Sa. */
+export function computeSa(data: number[], opts: SaOptions = {}): SaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSa };
diff --git a/src/optimization/small.ts b/src/optimization/small.ts
new file mode 100644
index 000000000..879dd7c65
--- /dev/null
+++ b/src/optimization/small.ts
@@ -0,0 +1,15 @@
+/** Optimization Small module — tsb analytics library. */
+export interface Optimization smallOptions { tol?: number; maxIter?: number; }
+export interface Optimization smallResult { values: number[]; converged: boolean; }
+export function computeOptimization small(data: number[], opts: Optimization smallOptions = {}): Optimization smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization small };
diff --git a/src/optimization/sparse.ts b/src/optimization/sparse.ts
new file mode 100644
index 000000000..770267986
--- /dev/null
+++ b/src/optimization/sparse.ts
@@ -0,0 +1,15 @@
+/** Optimization Sparse module — tsb analytics library. */
+export interface Optimization sparseOptions { tol?: number; maxIter?: number; }
+export interface Optimization sparseResult { values: number[]; converged: boolean; }
+export function computeOptimization sparse(data: number[], opts: Optimization sparseOptions = {}): Optimization sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization sparse };
diff --git a/src/optimization/stable.ts b/src/optimization/stable.ts
new file mode 100644
index 000000000..9f22d2ac4
--- /dev/null
+++ b/src/optimization/stable.ts
@@ -0,0 +1,15 @@
+/** Optimization Stable module — tsb analytics library. */
+export interface Optimization stableOptions { tol?: number; maxIter?: number; }
+export interface Optimization stableResult { values: number[]; converged: boolean; }
+export function computeOptimization stable(data: number[], opts: Optimization stableOptions = {}): Optimization stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization stable };
diff --git a/src/optimization/stochastic_opt.ts b/src/optimization/stochastic_opt.ts
new file mode 100644
index 000000000..43b9b97e8
--- /dev/null
+++ b/src/optimization/stochastic_opt.ts
@@ -0,0 +1,22 @@
+/** Stochastic Opt module — tsb analytics library. */
+
+/** Options for Stochastic Opt. */
+export interface StochasticOptOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stochastic Opt. */
+export interface StochasticOptResult { values: number[]; converged: boolean; }
+
+/** Compute Stochastic Opt. */
+export function computeStochasticOpt(data: number[], opts: StochasticOptOptions = {}): StochasticOptResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStochasticOpt };
diff --git a/src/optimization/streaming.ts b/src/optimization/streaming.ts
new file mode 100644
index 000000000..281dc22b1
--- /dev/null
+++ b/src/optimization/streaming.ts
@@ -0,0 +1,15 @@
+/** Optimization Streaming module — tsb analytics library. */
+export interface Optimization streamingOptions { tol?: number; maxIter?: number; }
+export interface Optimization streamingResult { values: number[]; converged: boolean; }
+export function computeOptimization streaming(data: number[], opts: Optimization streamingOptions = {}): Optimization streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization streaming };
diff --git a/src/optimization/trust_region.ts b/src/optimization/trust_region.ts
new file mode 100644
index 000000000..5268ed944
--- /dev/null
+++ b/src/optimization/trust_region.ts
@@ -0,0 +1,22 @@
+/** Trust Region module — tsb analytics library. */
+
+/** Options for Trust Region. */
+export interface TrustRegionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Trust Region. */
+export interface TrustRegionResult { values: number[]; converged: boolean; }
+
+/** Compute Trust Region. */
+export function computeTrustRegion(data: number[], opts: TrustRegionOptions = {}): TrustRegionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTrustRegion };
diff --git a/src/optimization/v2.ts b/src/optimization/v2.ts
new file mode 100644
index 000000000..d5731766f
--- /dev/null
+++ b/src/optimization/v2.ts
@@ -0,0 +1,15 @@
+/** Optimization V2 module — tsb analytics library. */
+export interface Optimization v2Options { tol?: number; maxIter?: number; }
+export interface Optimization v2Result { values: number[]; converged: boolean; }
+export function computeOptimization v2(data: number[], opts: Optimization v2Options = {}): Optimization v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization v2 };
diff --git a/src/optimization/v3.ts b/src/optimization/v3.ts
new file mode 100644
index 000000000..02feb62ed
--- /dev/null
+++ b/src/optimization/v3.ts
@@ -0,0 +1,15 @@
+/** Optimization V3 module — tsb analytics library. */
+export interface Optimization v3Options { tol?: number; maxIter?: number; }
+export interface Optimization v3Result { values: number[]; converged: boolean; }
+export function computeOptimization v3(data: number[], opts: Optimization v3Options = {}): Optimization v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization v3 };
diff --git a/src/optimization/wasm.ts b/src/optimization/wasm.ts
new file mode 100644
index 000000000..d1feca8b3
--- /dev/null
+++ b/src/optimization/wasm.ts
@@ -0,0 +1,15 @@
+/** Optimization Wasm module — tsb analytics library. */
+export interface Optimization wasmOptions { tol?: number; maxIter?: number; }
+export interface Optimization wasmResult { values: number[]; converged: boolean; }
+export function computeOptimization wasm(data: number[], opts: Optimization wasmOptions = {}): Optimization wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization wasm };
diff --git a/src/optimization/xlarge.ts b/src/optimization/xlarge.ts
new file mode 100644
index 000000000..2fba96da1
--- /dev/null
+++ b/src/optimization/xlarge.ts
@@ -0,0 +1,15 @@
+/** Optimization Xlarge module — tsb analytics library. */
+export interface Optimization xlargeOptions { tol?: number; maxIter?: number; }
+export interface Optimization xlargeResult { values: number[]; converged: boolean; }
+export function computeOptimization xlarge(data: number[], opts: Optimization xlargeOptions = {}): Optimization xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOptimization xlarge };
diff --git a/src/orthopedics_sci/adaptation.ts b/src/orthopedics_sci/adaptation.ts
new file mode 100644
index 000000000..785d02b00
--- /dev/null
+++ b/src/orthopedics_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci adaptation module — tsb analytics library. */
+export interface OrthopedicsSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciAdaptation(data: number[], opts: OrthopedicsSciAdaptationOptions = {}): OrthopedicsSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciAdaptation };
diff --git a/src/orthopedics_sci/aggregation.ts b/src/orthopedics_sci/aggregation.ts
new file mode 100644
index 000000000..4b16b05f0
--- /dev/null
+++ b/src/orthopedics_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci aggregation module — tsb analytics library. */
+export interface OrthopedicsSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciAggregationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciAggregation(data: number[], opts: OrthopedicsSciAggregationOptions = {}): OrthopedicsSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciAggregation };
diff --git a/src/orthopedics_sci/algebra.ts b/src/orthopedics_sci/algebra.ts
new file mode 100644
index 000000000..3effea001
--- /dev/null
+++ b/src/orthopedics_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci algebra module — tsb analytics library. */
+export interface OrthopedicsSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciAlgebra(data: number[], opts: OrthopedicsSciAlgebraOptions = {}): OrthopedicsSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciAlgebra };
diff --git a/src/orthopedics_sci/alignment.ts b/src/orthopedics_sci/alignment.ts
new file mode 100644
index 000000000..5fb7f5ebc
--- /dev/null
+++ b/src/orthopedics_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci alignment module — tsb analytics library. */
+export interface OrthopedicsSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciAlignment(data: number[], opts: OrthopedicsSciAlignmentOptions = {}): OrthopedicsSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciAlignment };
diff --git a/src/orthopedics_sci/analysis.ts b/src/orthopedics_sci/analysis.ts
new file mode 100644
index 000000000..7c0bbe2e6
--- /dev/null
+++ b/src/orthopedics_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci analysis module — tsb analytics library. */
+export interface OrthopedicsSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciAnalysis(data: number[], opts: OrthopedicsSciAnalysisOptions = {}): OrthopedicsSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciAnalysis };
diff --git a/src/orthopedics_sci/augmentation.ts b/src/orthopedics_sci/augmentation.ts
new file mode 100644
index 000000000..286eda968
--- /dev/null
+++ b/src/orthopedics_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci augmentation module — tsb analytics library. */
+export interface OrthopedicsSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciAugmentation(data: number[], opts: OrthopedicsSciAugmentationOptions = {}): OrthopedicsSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciAugmentation };
diff --git a/src/orthopedics_sci/bagging.ts b/src/orthopedics_sci/bagging.ts
new file mode 100644
index 000000000..7cfec7485
--- /dev/null
+++ b/src/orthopedics_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci bagging module — tsb analytics library. */
+export interface OrthopedicsSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciBaggingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciBagging(data: number[], opts: OrthopedicsSciBaggingOptions = {}): OrthopedicsSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciBagging };
diff --git a/src/orthopedics_sci/basis.ts b/src/orthopedics_sci/basis.ts
new file mode 100644
index 000000000..9e7746bb7
--- /dev/null
+++ b/src/orthopedics_sci/basis.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci basis module — tsb analytics library. */
+export interface OrthopedicsSciBasisOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciBasisResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciBasis(data: number[], opts: OrthopedicsSciBasisOptions = {}): OrthopedicsSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciBasis };
diff --git a/src/orthopedics_sci/benchmarking.ts b/src/orthopedics_sci/benchmarking.ts
new file mode 100644
index 000000000..1b4e7e052
--- /dev/null
+++ b/src/orthopedics_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci benchmarking module — tsb analytics library. */
+export interface OrthopedicsSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciBenchmarking(data: number[], opts: OrthopedicsSciBenchmarkingOptions = {}): OrthopedicsSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciBenchmarking };
diff --git a/src/orthopedics_sci/blending.ts b/src/orthopedics_sci/blending.ts
new file mode 100644
index 000000000..f19e8b6d6
--- /dev/null
+++ b/src/orthopedics_sci/blending.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci blending module — tsb analytics library. */
+export interface OrthopedicsSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciBlendingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciBlending(data: number[], opts: OrthopedicsSciBlendingOptions = {}): OrthopedicsSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciBlending };
diff --git a/src/orthopedics_sci/boosting.ts b/src/orthopedics_sci/boosting.ts
new file mode 100644
index 000000000..196e6239c
--- /dev/null
+++ b/src/orthopedics_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci boosting module — tsb analytics library. */
+export interface OrthopedicsSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciBoostingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciBoosting(data: number[], opts: OrthopedicsSciBoostingOptions = {}): OrthopedicsSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciBoosting };
diff --git a/src/orthopedics_sci/bootstrap.ts b/src/orthopedics_sci/bootstrap.ts
new file mode 100644
index 000000000..5dd92d023
--- /dev/null
+++ b/src/orthopedics_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci bootstrap module — tsb analytics library. */
+export interface OrthopedicsSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciBootstrap(data: number[], opts: OrthopedicsSciBootstrapOptions = {}): OrthopedicsSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciBootstrap };
diff --git a/src/orthopedics_sci/calculus.ts b/src/orthopedics_sci/calculus.ts
new file mode 100644
index 000000000..d8b67cd89
--- /dev/null
+++ b/src/orthopedics_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci calculus module — tsb analytics library. */
+export interface OrthopedicsSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciCalculusResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciCalculus(data: number[], opts: OrthopedicsSciCalculusOptions = {}): OrthopedicsSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciCalculus };
diff --git a/src/orthopedics_sci/calibration.ts b/src/orthopedics_sci/calibration.ts
new file mode 100644
index 000000000..0a7f1ac05
--- /dev/null
+++ b/src/orthopedics_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci calibration module — tsb analytics library. */
+export interface OrthopedicsSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciCalibration(data: number[], opts: OrthopedicsSciCalibrationOptions = {}): OrthopedicsSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciCalibration };
diff --git a/src/orthopedics_sci/characterization.ts b/src/orthopedics_sci/characterization.ts
new file mode 100644
index 000000000..7f9c6cbe2
--- /dev/null
+++ b/src/orthopedics_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci characterization module — tsb analytics library. */
+export interface OrthopedicsSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciCharacterization(data: number[], opts: OrthopedicsSciCharacterizationOptions = {}): OrthopedicsSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciCharacterization };
diff --git a/src/orthopedics_sci/classification.ts b/src/orthopedics_sci/classification.ts
new file mode 100644
index 000000000..395a5b913
--- /dev/null
+++ b/src/orthopedics_sci/classification.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci classification module — tsb analytics library. */
+export interface OrthopedicsSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciClassificationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciClassification(data: number[], opts: OrthopedicsSciClassificationOptions = {}): OrthopedicsSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciClassification };
diff --git a/src/orthopedics_sci/clustering.ts b/src/orthopedics_sci/clustering.ts
new file mode 100644
index 000000000..47dd140e9
--- /dev/null
+++ b/src/orthopedics_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci clustering module — tsb analytics library. */
+export interface OrthopedicsSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciClusteringResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciClustering(data: number[], opts: OrthopedicsSciClusteringOptions = {}): OrthopedicsSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciClustering };
diff --git a/src/orthopedics_sci/compression.ts b/src/orthopedics_sci/compression.ts
new file mode 100644
index 000000000..7224e89d1
--- /dev/null
+++ b/src/orthopedics_sci/compression.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci compression module — tsb analytics library. */
+export interface OrthopedicsSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciCompressionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciCompression(data: number[], opts: OrthopedicsSciCompressionOptions = {}): OrthopedicsSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciCompression };
diff --git a/src/orthopedics_sci/continuous.ts b/src/orthopedics_sci/continuous.ts
new file mode 100644
index 000000000..b9b549010
--- /dev/null
+++ b/src/orthopedics_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci continuous module — tsb analytics library. */
+export interface OrthopedicsSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciContinuousResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciContinuous(data: number[], opts: OrthopedicsSciContinuousOptions = {}): OrthopedicsSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciContinuous };
diff --git a/src/orthopedics_sci/control.ts b/src/orthopedics_sci/control.ts
new file mode 100644
index 000000000..c5ef8483a
--- /dev/null
+++ b/src/orthopedics_sci/control.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci control module — tsb analytics library. */
+export interface OrthopedicsSciControlOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciControlResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciControl(data: number[], opts: OrthopedicsSciControlOptions = {}): OrthopedicsSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciControl };
diff --git a/src/orthopedics_sci/convergence.ts b/src/orthopedics_sci/convergence.ts
new file mode 100644
index 000000000..9ca1110e2
--- /dev/null
+++ b/src/orthopedics_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci convergence module — tsb analytics library. */
+export interface OrthopedicsSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciConvergence(data: number[], opts: OrthopedicsSciConvergenceOptions = {}): OrthopedicsSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciConvergence };
diff --git a/src/orthopedics_sci/convex.ts b/src/orthopedics_sci/convex.ts
new file mode 100644
index 000000000..bb5097c35
--- /dev/null
+++ b/src/orthopedics_sci/convex.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci convex module — tsb analytics library. */
+export interface OrthopedicsSciConvexOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciConvexResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciConvex(data: number[], opts: OrthopedicsSciConvexOptions = {}): OrthopedicsSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciConvex };
diff --git a/src/orthopedics_sci/correlation.ts b/src/orthopedics_sci/correlation.ts
new file mode 100644
index 000000000..be2568f37
--- /dev/null
+++ b/src/orthopedics_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci correlation module — tsb analytics library. */
+export interface OrthopedicsSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciCorrelation(data: number[], opts: OrthopedicsSciCorrelationOptions = {}): OrthopedicsSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciCorrelation };
diff --git a/src/orthopedics_sci/covariance.ts b/src/orthopedics_sci/covariance.ts
new file mode 100644
index 000000000..ca44ef019
--- /dev/null
+++ b/src/orthopedics_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci covariance module — tsb analytics library. */
+export interface OrthopedicsSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciCovariance(data: number[], opts: OrthopedicsSciCovarianceOptions = {}): OrthopedicsSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciCovariance };
diff --git a/src/orthopedics_sci/cross_validation.ts b/src/orthopedics_sci/cross_validation.ts
new file mode 100644
index 000000000..9eaa5128b
--- /dev/null
+++ b/src/orthopedics_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci cross_validation module — tsb analytics library. */
+export interface OrthopedicsSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciCrossValidation(data: number[], opts: OrthopedicsSciCrossValidationOptions = {}): OrthopedicsSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciCrossValidation };
diff --git a/src/orthopedics_sci/decoding.ts b/src/orthopedics_sci/decoding.ts
new file mode 100644
index 000000000..cb53c64f7
--- /dev/null
+++ b/src/orthopedics_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci decoding module — tsb analytics library. */
+export interface OrthopedicsSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDecodingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDecoding(data: number[], opts: OrthopedicsSciDecodingOptions = {}): OrthopedicsSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDecoding };
diff --git a/src/orthopedics_sci/decomposition.ts b/src/orthopedics_sci/decomposition.ts
new file mode 100644
index 000000000..0e0c55979
--- /dev/null
+++ b/src/orthopedics_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci decomposition module — tsb analytics library. */
+export interface OrthopedicsSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDecomposition(data: number[], opts: OrthopedicsSciDecompositionOptions = {}): OrthopedicsSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDecomposition };
diff --git a/src/orthopedics_sci/detection.ts b/src/orthopedics_sci/detection.ts
new file mode 100644
index 000000000..0eee73ee9
--- /dev/null
+++ b/src/orthopedics_sci/detection.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci detection module — tsb analytics library. */
+export interface OrthopedicsSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDetectionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDetection(data: number[], opts: OrthopedicsSciDetectionOptions = {}): OrthopedicsSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDetection };
diff --git a/src/orthopedics_sci/deterministic.ts b/src/orthopedics_sci/deterministic.ts
new file mode 100644
index 000000000..521d3c286
--- /dev/null
+++ b/src/orthopedics_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci deterministic module — tsb analytics library. */
+export interface OrthopedicsSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDeterministic(data: number[], opts: OrthopedicsSciDeterministicOptions = {}): OrthopedicsSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDeterministic };
diff --git a/src/orthopedics_sci/diagnostics.ts b/src/orthopedics_sci/diagnostics.ts
new file mode 100644
index 000000000..79f36ebce
--- /dev/null
+++ b/src/orthopedics_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci diagnostics module — tsb analytics library. */
+export interface OrthopedicsSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDiagnostics(data: number[], opts: OrthopedicsSciDiagnosticsOptions = {}): OrthopedicsSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDiagnostics };
diff --git a/src/orthopedics_sci/differential.ts b/src/orthopedics_sci/differential.ts
new file mode 100644
index 000000000..b4cb897e2
--- /dev/null
+++ b/src/orthopedics_sci/differential.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci differential module — tsb analytics library. */
+export interface OrthopedicsSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDifferential(data: number[], opts: OrthopedicsSciDifferentialOptions = {}): OrthopedicsSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDifferential };
diff --git a/src/orthopedics_sci/discrete.ts b/src/orthopedics_sci/discrete.ts
new file mode 100644
index 000000000..029b4696f
--- /dev/null
+++ b/src/orthopedics_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci discrete module — tsb analytics library. */
+export interface OrthopedicsSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDiscrete(data: number[], opts: OrthopedicsSciDiscreteOptions = {}): OrthopedicsSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDiscrete };
diff --git a/src/orthopedics_sci/distribution.ts b/src/orthopedics_sci/distribution.ts
new file mode 100644
index 000000000..a4ac17df7
--- /dev/null
+++ b/src/orthopedics_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci distribution module — tsb analytics library. */
+export interface OrthopedicsSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDistributionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDistribution(data: number[], opts: OrthopedicsSciDistributionOptions = {}): OrthopedicsSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDistribution };
diff --git a/src/orthopedics_sci/dynamic.ts b/src/orthopedics_sci/dynamic.ts
new file mode 100644
index 000000000..bfb6f6f82
--- /dev/null
+++ b/src/orthopedics_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci dynamic module — tsb analytics library. */
+export interface OrthopedicsSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciDynamicResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciDynamic(data: number[], opts: OrthopedicsSciDynamicOptions = {}): OrthopedicsSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciDynamic };
diff --git a/src/orthopedics_sci/embedding.ts b/src/orthopedics_sci/embedding.ts
new file mode 100644
index 000000000..c1afc726f
--- /dev/null
+++ b/src/orthopedics_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci embedding module — tsb analytics library. */
+export interface OrthopedicsSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciEmbedding(data: number[], opts: OrthopedicsSciEmbeddingOptions = {}): OrthopedicsSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciEmbedding };
diff --git a/src/orthopedics_sci/encoding.ts b/src/orthopedics_sci/encoding.ts
new file mode 100644
index 000000000..84aad62ed
--- /dev/null
+++ b/src/orthopedics_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci encoding module — tsb analytics library. */
+export interface OrthopedicsSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciEncodingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciEncoding(data: number[], opts: OrthopedicsSciEncodingOptions = {}): OrthopedicsSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciEncoding };
diff --git a/src/orthopedics_sci/ensemble.ts b/src/orthopedics_sci/ensemble.ts
new file mode 100644
index 000000000..a42d3ee6f
--- /dev/null
+++ b/src/orthopedics_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci ensemble module — tsb analytics library. */
+export interface OrthopedicsSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciEnsemble(data: number[], opts: OrthopedicsSciEnsembleOptions = {}): OrthopedicsSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciEnsemble };
diff --git a/src/orthopedics_sci/estimation.ts b/src/orthopedics_sci/estimation.ts
new file mode 100644
index 000000000..7ff6c653e
--- /dev/null
+++ b/src/orthopedics_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci estimation module — tsb analytics library. */
+export interface OrthopedicsSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciEstimationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciEstimation(data: number[], opts: OrthopedicsSciEstimationOptions = {}): OrthopedicsSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciEstimation };
diff --git a/src/orthopedics_sci/evaluation.ts b/src/orthopedics_sci/evaluation.ts
new file mode 100644
index 000000000..adc18d4ee
--- /dev/null
+++ b/src/orthopedics_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci evaluation module — tsb analytics library. */
+export interface OrthopedicsSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciEvaluation(data: number[], opts: OrthopedicsSciEvaluationOptions = {}): OrthopedicsSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciEvaluation };
diff --git a/src/orthopedics_sci/extrapolation.ts b/src/orthopedics_sci/extrapolation.ts
new file mode 100644
index 000000000..c537bbe63
--- /dev/null
+++ b/src/orthopedics_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci extrapolation module — tsb analytics library. */
+export interface OrthopedicsSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciExtrapolation(data: number[], opts: OrthopedicsSciExtrapolationOptions = {}): OrthopedicsSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciExtrapolation };
diff --git a/src/orthopedics_sci/features.ts b/src/orthopedics_sci/features.ts
new file mode 100644
index 000000000..b2aaa2195
--- /dev/null
+++ b/src/orthopedics_sci/features.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci features module — tsb analytics library. */
+export interface OrthopedicsSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciFeatures(data: number[], opts: OrthopedicsSciFeaturesOptions = {}): OrthopedicsSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciFeatures };
diff --git a/src/orthopedics_sci/feedback.ts b/src/orthopedics_sci/feedback.ts
new file mode 100644
index 000000000..07397bb87
--- /dev/null
+++ b/src/orthopedics_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci feedback module — tsb analytics library. */
+export interface OrthopedicsSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciFeedback(data: number[], opts: OrthopedicsSciFeedbackOptions = {}): OrthopedicsSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciFeedback };
diff --git a/src/orthopedics_sci/filtering.ts b/src/orthopedics_sci/filtering.ts
new file mode 100644
index 000000000..58c8d4c72
--- /dev/null
+++ b/src/orthopedics_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci filtering module — tsb analytics library. */
+export interface OrthopedicsSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciFilteringResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciFiltering(data: number[], opts: OrthopedicsSciFilteringOptions = {}): OrthopedicsSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciFiltering };
diff --git a/src/orthopedics_sci/fourier.ts b/src/orthopedics_sci/fourier.ts
new file mode 100644
index 000000000..f7dd5c95c
--- /dev/null
+++ b/src/orthopedics_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci fourier module — tsb analytics library. */
+export interface OrthopedicsSciFourierOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciFourierResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciFourier(data: number[], opts: OrthopedicsSciFourierOptions = {}): OrthopedicsSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciFourier };
diff --git a/src/orthopedics_sci/fusion.ts b/src/orthopedics_sci/fusion.ts
new file mode 100644
index 000000000..b0020b391
--- /dev/null
+++ b/src/orthopedics_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci fusion module — tsb analytics library. */
+export interface OrthopedicsSciFusionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciFusionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciFusion(data: number[], opts: OrthopedicsSciFusionOptions = {}): OrthopedicsSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciFusion };
diff --git a/src/orthopedics_sci/generation.ts b/src/orthopedics_sci/generation.ts
new file mode 100644
index 000000000..770ebdfd8
--- /dev/null
+++ b/src/orthopedics_sci/generation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci generation module — tsb analytics library. */
+export interface OrthopedicsSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciGenerationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciGeneration(data: number[], opts: OrthopedicsSciGenerationOptions = {}): OrthopedicsSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciGeneration };
diff --git a/src/orthopedics_sci/geometry.ts b/src/orthopedics_sci/geometry.ts
new file mode 100644
index 000000000..65461b16d
--- /dev/null
+++ b/src/orthopedics_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci geometry module — tsb analytics library. */
+export interface OrthopedicsSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciGeometryResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciGeometry(data: number[], opts: OrthopedicsSciGeometryOptions = {}): OrthopedicsSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciGeometry };
diff --git a/src/orthopedics_sci/gradient.ts b/src/orthopedics_sci/gradient.ts
new file mode 100644
index 000000000..f27f40258
--- /dev/null
+++ b/src/orthopedics_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci gradient module — tsb analytics library. */
+export interface OrthopedicsSciGradientOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciGradientResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciGradient(data: number[], opts: OrthopedicsSciGradientOptions = {}): OrthopedicsSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciGradient };
diff --git a/src/orthopedics_sci/hessian.ts b/src/orthopedics_sci/hessian.ts
new file mode 100644
index 000000000..e4a65082f
--- /dev/null
+++ b/src/orthopedics_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci hessian module — tsb analytics library. */
+export interface OrthopedicsSciHessianOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciHessianResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciHessian(data: number[], opts: OrthopedicsSciHessianOptions = {}): OrthopedicsSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciHessian };
diff --git a/src/orthopedics_sci/hypothesis.ts b/src/orthopedics_sci/hypothesis.ts
new file mode 100644
index 000000000..007f0c0a8
--- /dev/null
+++ b/src/orthopedics_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci hypothesis module — tsb analytics library. */
+export interface OrthopedicsSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciHypothesis(data: number[], opts: OrthopedicsSciHypothesisOptions = {}): OrthopedicsSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciHypothesis };
diff --git a/src/orthopedics_sci/inference.ts b/src/orthopedics_sci/inference.ts
new file mode 100644
index 000000000..24d1e9c56
--- /dev/null
+++ b/src/orthopedics_sci/inference.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci inference module — tsb analytics library. */
+export interface OrthopedicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciInference(data: number[], opts: OrthopedicsSciInferenceOptions = {}): OrthopedicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciInference };
diff --git a/src/orthopedics_sci/inference2.ts b/src/orthopedics_sci/inference2.ts
new file mode 100644
index 000000000..37c918c8e
--- /dev/null
+++ b/src/orthopedics_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci inference2 module — tsb analytics library. */
+export interface OrthopedicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciInference(data: number[], opts: OrthopedicsSciInferenceOptions = {}): OrthopedicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciInference };
diff --git a/src/orthopedics_sci/integral.ts b/src/orthopedics_sci/integral.ts
new file mode 100644
index 000000000..c3731104f
--- /dev/null
+++ b/src/orthopedics_sci/integral.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci integral module — tsb analytics library. */
+export interface OrthopedicsSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciIntegralResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciIntegral(data: number[], opts: OrthopedicsSciIntegralOptions = {}): OrthopedicsSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciIntegral };
diff --git a/src/orthopedics_sci/integration.ts b/src/orthopedics_sci/integration.ts
new file mode 100644
index 000000000..758159634
--- /dev/null
+++ b/src/orthopedics_sci/integration.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci integration module — tsb analytics library. */
+export interface OrthopedicsSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciIntegration(data: number[], opts: OrthopedicsSciIntegrationOptions = {}): OrthopedicsSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciIntegration };
diff --git a/src/orthopedics_sci/interpolation.ts b/src/orthopedics_sci/interpolation.ts
new file mode 100644
index 000000000..95223d012
--- /dev/null
+++ b/src/orthopedics_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci interpolation module — tsb analytics library. */
+export interface OrthopedicsSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciInterpolation(data: number[], opts: OrthopedicsSciInterpolationOptions = {}): OrthopedicsSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciInterpolation };
diff --git a/src/orthopedics_sci/jacobian.ts b/src/orthopedics_sci/jacobian.ts
new file mode 100644
index 000000000..ff2de9054
--- /dev/null
+++ b/src/orthopedics_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci jacobian module — tsb analytics library. */
+export interface OrthopedicsSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciJacobianResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciJacobian(data: number[], opts: OrthopedicsSciJacobianOptions = {}): OrthopedicsSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciJacobian };
diff --git a/src/orthopedics_sci/kernel.ts b/src/orthopedics_sci/kernel.ts
new file mode 100644
index 000000000..9394ce854
--- /dev/null
+++ b/src/orthopedics_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci kernel module — tsb analytics library. */
+export interface OrthopedicsSciKernelOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciKernelResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciKernel(data: number[], opts: OrthopedicsSciKernelOptions = {}): OrthopedicsSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciKernel };
diff --git a/src/orthopedics_sci/laplacian.ts b/src/orthopedics_sci/laplacian.ts
new file mode 100644
index 000000000..28883e65f
--- /dev/null
+++ b/src/orthopedics_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci laplacian module — tsb analytics library. */
+export interface OrthopedicsSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciLaplacian(data: number[], opts: OrthopedicsSciLaplacianOptions = {}): OrthopedicsSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciLaplacian };
diff --git a/src/orthopedics_sci/learning.ts b/src/orthopedics_sci/learning.ts
new file mode 100644
index 000000000..f5a6adca1
--- /dev/null
+++ b/src/orthopedics_sci/learning.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci learning module — tsb analytics library. */
+export interface OrthopedicsSciLearningOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciLearningResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciLearning(data: number[], opts: OrthopedicsSciLearningOptions = {}): OrthopedicsSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciLearning };
diff --git a/src/orthopedics_sci/linear.ts b/src/orthopedics_sci/linear.ts
new file mode 100644
index 000000000..a413564db
--- /dev/null
+++ b/src/orthopedics_sci/linear.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci linear module — tsb analytics library. */
+export interface OrthopedicsSciLinearOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciLinearResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciLinear(data: number[], opts: OrthopedicsSciLinearOptions = {}): OrthopedicsSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciLinear };
diff --git a/src/orthopedics_sci/manifold.ts b/src/orthopedics_sci/manifold.ts
new file mode 100644
index 000000000..186fb6f55
--- /dev/null
+++ b/src/orthopedics_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci manifold module — tsb analytics library. */
+export interface OrthopedicsSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciManifoldResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciManifold(data: number[], opts: OrthopedicsSciManifoldOptions = {}): OrthopedicsSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciManifold };
diff --git a/src/orthopedics_sci/matching.ts b/src/orthopedics_sci/matching.ts
new file mode 100644
index 000000000..dd432b256
--- /dev/null
+++ b/src/orthopedics_sci/matching.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci matching module — tsb analytics library. */
+export interface OrthopedicsSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciMatchingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciMatching(data: number[], opts: OrthopedicsSciMatchingOptions = {}): OrthopedicsSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciMatching };
diff --git a/src/orthopedics_sci/measurement.ts b/src/orthopedics_sci/measurement.ts
new file mode 100644
index 000000000..75cf0c1a7
--- /dev/null
+++ b/src/orthopedics_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci measurement module — tsb analytics library. */
+export interface OrthopedicsSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciMeasurement(data: number[], opts: OrthopedicsSciMeasurementOptions = {}): OrthopedicsSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciMeasurement };
diff --git a/src/orthopedics_sci/metrics.ts b/src/orthopedics_sci/metrics.ts
new file mode 100644
index 000000000..2f71b9717
--- /dev/null
+++ b/src/orthopedics_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci metrics module — tsb analytics library. */
+export interface OrthopedicsSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciMetricsResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciMetrics(data: number[], opts: OrthopedicsSciMetricsOptions = {}): OrthopedicsSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciMetrics };
diff --git a/src/orthopedics_sci/modeling.ts b/src/orthopedics_sci/modeling.ts
new file mode 100644
index 000000000..7b9a134cd
--- /dev/null
+++ b/src/orthopedics_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci modeling module — tsb analytics library. */
+export interface OrthopedicsSciModelingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciModelingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciModeling(data: number[], opts: OrthopedicsSciModelingOptions = {}): OrthopedicsSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciModeling };
diff --git a/src/orthopedics_sci/monitoring.ts b/src/orthopedics_sci/monitoring.ts
new file mode 100644
index 000000000..6de82d6c9
--- /dev/null
+++ b/src/orthopedics_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci monitoring module — tsb analytics library. */
+export interface OrthopedicsSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciMonitoring(data: number[], opts: OrthopedicsSciMonitoringOptions = {}): OrthopedicsSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciMonitoring };
diff --git a/src/orthopedics_sci/nonlinear.ts b/src/orthopedics_sci/nonlinear.ts
new file mode 100644
index 000000000..9bd9d71e6
--- /dev/null
+++ b/src/orthopedics_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci nonlinear module — tsb analytics library. */
+export interface OrthopedicsSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciNonlinear(data: number[], opts: OrthopedicsSciNonlinearOptions = {}): OrthopedicsSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciNonlinear };
diff --git a/src/orthopedics_sci/normalization.ts b/src/orthopedics_sci/normalization.ts
new file mode 100644
index 000000000..32dcdac15
--- /dev/null
+++ b/src/orthopedics_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci normalization module — tsb analytics library. */
+export interface OrthopedicsSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciNormalization(data: number[], opts: OrthopedicsSciNormalizationOptions = {}): OrthopedicsSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciNormalization };
diff --git a/src/orthopedics_sci/optimization.ts b/src/orthopedics_sci/optimization.ts
new file mode 100644
index 000000000..938f543a0
--- /dev/null
+++ b/src/orthopedics_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci optimization module — tsb analytics library. */
+export interface OrthopedicsSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciOptimization(data: number[], opts: OrthopedicsSciOptimizationOptions = {}): OrthopedicsSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciOptimization };
diff --git a/src/orthopedics_sci/patterns.ts b/src/orthopedics_sci/patterns.ts
new file mode 100644
index 000000000..1ced40adc
--- /dev/null
+++ b/src/orthopedics_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci patterns module — tsb analytics library. */
+export interface OrthopedicsSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciPatternsResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciPatterns(data: number[], opts: OrthopedicsSciPatternsOptions = {}): OrthopedicsSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciPatterns };
diff --git a/src/orthopedics_sci/permutation.ts b/src/orthopedics_sci/permutation.ts
new file mode 100644
index 000000000..0e1139a4c
--- /dev/null
+++ b/src/orthopedics_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci permutation module — tsb analytics library. */
+export interface OrthopedicsSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciPermutationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciPermutation(data: number[], opts: OrthopedicsSciPermutationOptions = {}): OrthopedicsSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciPermutation };
diff --git a/src/orthopedics_sci/prediction.ts b/src/orthopedics_sci/prediction.ts
new file mode 100644
index 000000000..7ec21b328
--- /dev/null
+++ b/src/orthopedics_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci prediction module — tsb analytics library. */
+export interface OrthopedicsSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciPredictionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciPrediction(data: number[], opts: OrthopedicsSciPredictionOptions = {}): OrthopedicsSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciPrediction };
diff --git a/src/orthopedics_sci/processing.ts b/src/orthopedics_sci/processing.ts
new file mode 100644
index 000000000..8b294ce2d
--- /dev/null
+++ b/src/orthopedics_sci/processing.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci processing module — tsb analytics library. */
+export interface OrthopedicsSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciProcessingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciProcessing(data: number[], opts: OrthopedicsSciProcessingOptions = {}): OrthopedicsSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciProcessing };
diff --git a/src/orthopedics_sci/profiling.ts b/src/orthopedics_sci/profiling.ts
new file mode 100644
index 000000000..b0eb82a72
--- /dev/null
+++ b/src/orthopedics_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci profiling module — tsb analytics library. */
+export interface OrthopedicsSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciProfilingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciProfiling(data: number[], opts: OrthopedicsSciProfilingOptions = {}): OrthopedicsSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciProfiling };
diff --git a/src/orthopedics_sci/projection.ts b/src/orthopedics_sci/projection.ts
new file mode 100644
index 000000000..b197529e6
--- /dev/null
+++ b/src/orthopedics_sci/projection.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci projection module — tsb analytics library. */
+export interface OrthopedicsSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciProjectionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciProjection(data: number[], opts: OrthopedicsSciProjectionOptions = {}): OrthopedicsSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciProjection };
diff --git a/src/orthopedics_sci/ranking.ts b/src/orthopedics_sci/ranking.ts
new file mode 100644
index 000000000..51307c36c
--- /dev/null
+++ b/src/orthopedics_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci ranking module — tsb analytics library. */
+export interface OrthopedicsSciRankingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciRankingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciRanking(data: number[], opts: OrthopedicsSciRankingOptions = {}): OrthopedicsSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciRanking };
diff --git a/src/orthopedics_sci/reconstruction.ts b/src/orthopedics_sci/reconstruction.ts
new file mode 100644
index 000000000..54660e105
--- /dev/null
+++ b/src/orthopedics_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci reconstruction module — tsb analytics library. */
+export interface OrthopedicsSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciReconstruction(data: number[], opts: OrthopedicsSciReconstructionOptions = {}): OrthopedicsSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciReconstruction };
diff --git a/src/orthopedics_sci/registration.ts b/src/orthopedics_sci/registration.ts
new file mode 100644
index 000000000..c50274d4e
--- /dev/null
+++ b/src/orthopedics_sci/registration.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci registration module — tsb analytics library. */
+export interface OrthopedicsSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciRegistration(data: number[], opts: OrthopedicsSciRegistrationOptions = {}): OrthopedicsSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciRegistration };
diff --git a/src/orthopedics_sci/regression.ts b/src/orthopedics_sci/regression.ts
new file mode 100644
index 000000000..0b9236d09
--- /dev/null
+++ b/src/orthopedics_sci/regression.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci regression module — tsb analytics library. */
+export interface OrthopedicsSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciRegressionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciRegression(data: number[], opts: OrthopedicsSciRegressionOptions = {}): OrthopedicsSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciRegression };
diff --git a/src/orthopedics_sci/regularization.ts b/src/orthopedics_sci/regularization.ts
new file mode 100644
index 000000000..81ac61cbb
--- /dev/null
+++ b/src/orthopedics_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci regularization module — tsb analytics library. */
+export interface OrthopedicsSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciRegularization(data: number[], opts: OrthopedicsSciRegularizationOptions = {}): OrthopedicsSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciRegularization };
diff --git a/src/orthopedics_sci/robustness.ts b/src/orthopedics_sci/robustness.ts
new file mode 100644
index 000000000..d83334434
--- /dev/null
+++ b/src/orthopedics_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci robustness module — tsb analytics library. */
+export interface OrthopedicsSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciRobustness(data: number[], opts: OrthopedicsSciRobustnessOptions = {}): OrthopedicsSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciRobustness };
diff --git a/src/orthopedics_sci/sampling.ts b/src/orthopedics_sci/sampling.ts
new file mode 100644
index 000000000..dd98a8ea7
--- /dev/null
+++ b/src/orthopedics_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci sampling module — tsb analytics library. */
+export interface OrthopedicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciSampling(data: number[], opts: OrthopedicsSciSamplingOptions = {}): OrthopedicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciSampling };
diff --git a/src/orthopedics_sci/sampling2.ts b/src/orthopedics_sci/sampling2.ts
new file mode 100644
index 000000000..4600d30f1
--- /dev/null
+++ b/src/orthopedics_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci sampling2 module — tsb analytics library. */
+export interface OrthopedicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciSampling(data: number[], opts: OrthopedicsSciSamplingOptions = {}): OrthopedicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciSampling };
diff --git a/src/orthopedics_sci/scaling.ts b/src/orthopedics_sci/scaling.ts
new file mode 100644
index 000000000..68fd383a1
--- /dev/null
+++ b/src/orthopedics_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci scaling module — tsb analytics library. */
+export interface OrthopedicsSciScalingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciScalingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciScaling(data: number[], opts: OrthopedicsSciScalingOptions = {}): OrthopedicsSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciScaling };
diff --git a/src/orthopedics_sci/scoring.ts b/src/orthopedics_sci/scoring.ts
new file mode 100644
index 000000000..54bca77a8
--- /dev/null
+++ b/src/orthopedics_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci scoring module — tsb analytics library. */
+export interface OrthopedicsSciScoringOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciScoringResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciScoring(data: number[], opts: OrthopedicsSciScoringOptions = {}): OrthopedicsSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciScoring };
diff --git a/src/orthopedics_sci/segmentation.ts b/src/orthopedics_sci/segmentation.ts
new file mode 100644
index 000000000..8a653f92b
--- /dev/null
+++ b/src/orthopedics_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci segmentation module — tsb analytics library. */
+export interface OrthopedicsSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciSegmentation(data: number[], opts: OrthopedicsSciSegmentationOptions = {}): OrthopedicsSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciSegmentation };
diff --git a/src/orthopedics_sci/selection.ts b/src/orthopedics_sci/selection.ts
new file mode 100644
index 000000000..c2569b0c4
--- /dev/null
+++ b/src/orthopedics_sci/selection.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci selection module — tsb analytics library. */
+export interface OrthopedicsSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciSelectionResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciSelection(data: number[], opts: OrthopedicsSciSelectionOptions = {}): OrthopedicsSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciSelection };
diff --git a/src/orthopedics_sci/sensitivity.ts b/src/orthopedics_sci/sensitivity.ts
new file mode 100644
index 000000000..a464019ae
--- /dev/null
+++ b/src/orthopedics_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci sensitivity module — tsb analytics library. */
+export interface OrthopedicsSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciSensitivity(data: number[], opts: OrthopedicsSciSensitivityOptions = {}): OrthopedicsSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciSensitivity };
diff --git a/src/orthopedics_sci/simulation.ts b/src/orthopedics_sci/simulation.ts
new file mode 100644
index 000000000..3692fc8f8
--- /dev/null
+++ b/src/orthopedics_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci simulation module — tsb analytics library. */
+export interface OrthopedicsSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciSimulationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciSimulation(data: number[], opts: OrthopedicsSciSimulationOptions = {}): OrthopedicsSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciSimulation };
diff --git a/src/orthopedics_sci/smoothing.ts b/src/orthopedics_sci/smoothing.ts
new file mode 100644
index 000000000..7319885f7
--- /dev/null
+++ b/src/orthopedics_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci smoothing module — tsb analytics library. */
+export interface OrthopedicsSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciSmoothing(data: number[], opts: OrthopedicsSciSmoothingOptions = {}): OrthopedicsSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciSmoothing };
diff --git a/src/orthopedics_sci/stability.ts b/src/orthopedics_sci/stability.ts
new file mode 100644
index 000000000..ea3356da6
--- /dev/null
+++ b/src/orthopedics_sci/stability.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci stability module — tsb analytics library. */
+export interface OrthopedicsSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciStabilityResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciStability(data: number[], opts: OrthopedicsSciStabilityOptions = {}): OrthopedicsSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciStability };
diff --git a/src/orthopedics_sci/stacking.ts b/src/orthopedics_sci/stacking.ts
new file mode 100644
index 000000000..6c097ca87
--- /dev/null
+++ b/src/orthopedics_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci stacking module — tsb analytics library. */
+export interface OrthopedicsSciStackingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciStackingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciStacking(data: number[], opts: OrthopedicsSciStackingOptions = {}): OrthopedicsSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciStacking };
diff --git a/src/orthopedics_sci/standardization.ts b/src/orthopedics_sci/standardization.ts
new file mode 100644
index 000000000..b8c048dcd
--- /dev/null
+++ b/src/orthopedics_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci standardization module — tsb analytics library. */
+export interface OrthopedicsSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciStandardization(data: number[], opts: OrthopedicsSciStandardizationOptions = {}): OrthopedicsSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciStandardization };
diff --git a/src/orthopedics_sci/static.ts b/src/orthopedics_sci/static.ts
new file mode 100644
index 000000000..9ee03fee5
--- /dev/null
+++ b/src/orthopedics_sci/static.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci static module — tsb analytics library. */
+export interface OrthopedicsSciStaticOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciStaticResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciStatic(data: number[], opts: OrthopedicsSciStaticOptions = {}): OrthopedicsSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciStatic };
diff --git a/src/orthopedics_sci/stochastic.ts b/src/orthopedics_sci/stochastic.ts
new file mode 100644
index 000000000..53dd56ca7
--- /dev/null
+++ b/src/orthopedics_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci stochastic module — tsb analytics library. */
+export interface OrthopedicsSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciStochasticResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciStochastic(data: number[], opts: OrthopedicsSciStochasticOptions = {}): OrthopedicsSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciStochastic };
diff --git a/src/orthopedics_sci/synthesis.ts b/src/orthopedics_sci/synthesis.ts
new file mode 100644
index 000000000..1316bbfe8
--- /dev/null
+++ b/src/orthopedics_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci synthesis module — tsb analytics library. */
+export interface OrthopedicsSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciSynthesis(data: number[], opts: OrthopedicsSciSynthesisOptions = {}): OrthopedicsSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciSynthesis };
diff --git a/src/orthopedics_sci/topology.ts b/src/orthopedics_sci/topology.ts
new file mode 100644
index 000000000..3bf2d117d
--- /dev/null
+++ b/src/orthopedics_sci/topology.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci topology module — tsb analytics library. */
+export interface OrthopedicsSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciTopologyResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciTopology(data: number[], opts: OrthopedicsSciTopologyOptions = {}): OrthopedicsSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciTopology };
diff --git a/src/orthopedics_sci/tracking.ts b/src/orthopedics_sci/tracking.ts
new file mode 100644
index 000000000..6bcb7a246
--- /dev/null
+++ b/src/orthopedics_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci tracking module — tsb analytics library. */
+export interface OrthopedicsSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciTrackingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciTracking(data: number[], opts: OrthopedicsSciTrackingOptions = {}): OrthopedicsSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciTracking };
diff --git a/src/orthopedics_sci/transform.ts b/src/orthopedics_sci/transform.ts
new file mode 100644
index 000000000..89a1e7d7d
--- /dev/null
+++ b/src/orthopedics_sci/transform.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci transform module — tsb analytics library. */
+export interface OrthopedicsSciTransformOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciTransformResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciTransform(data: number[], opts: OrthopedicsSciTransformOptions = {}): OrthopedicsSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciTransform };
diff --git a/src/orthopedics_sci/uncertainty.ts b/src/orthopedics_sci/uncertainty.ts
new file mode 100644
index 000000000..984787276
--- /dev/null
+++ b/src/orthopedics_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci uncertainty module — tsb analytics library. */
+export interface OrthopedicsSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciUncertainty(data: number[], opts: OrthopedicsSciUncertaintyOptions = {}): OrthopedicsSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciUncertainty };
diff --git a/src/orthopedics_sci/validation.ts b/src/orthopedics_sci/validation.ts
new file mode 100644
index 000000000..3360bb380
--- /dev/null
+++ b/src/orthopedics_sci/validation.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci validation module — tsb analytics library. */
+export interface OrthopedicsSciValidationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciValidationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciValidation(data: number[], opts: OrthopedicsSciValidationOptions = {}): OrthopedicsSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciValidation };
diff --git a/src/orthopedics_sci/verification.ts b/src/orthopedics_sci/verification.ts
new file mode 100644
index 000000000..7dd329691
--- /dev/null
+++ b/src/orthopedics_sci/verification.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci verification module — tsb analytics library. */
+export interface OrthopedicsSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciVerificationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciVerification(data: number[], opts: OrthopedicsSciVerificationOptions = {}): OrthopedicsSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciVerification };
diff --git a/src/orthopedics_sci/visualization.ts b/src/orthopedics_sci/visualization.ts
new file mode 100644
index 000000000..a0e58c5bd
--- /dev/null
+++ b/src/orthopedics_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci visualization module — tsb analytics library. */
+export interface OrthopedicsSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciVisualization(data: number[], opts: OrthopedicsSciVisualizationOptions = {}): OrthopedicsSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciVisualization };
diff --git a/src/orthopedics_sci/voting.ts b/src/orthopedics_sci/voting.ts
new file mode 100644
index 000000000..5a8c29a92
--- /dev/null
+++ b/src/orthopedics_sci/voting.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci voting module — tsb analytics library. */
+export interface OrthopedicsSciVotingOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciVotingResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciVoting(data: number[], opts: OrthopedicsSciVotingOptions = {}): OrthopedicsSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciVoting };
diff --git a/src/orthopedics_sci/wavelet.ts b/src/orthopedics_sci/wavelet.ts
new file mode 100644
index 000000000..8061bf507
--- /dev/null
+++ b/src/orthopedics_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** orthopedics_sci wavelet module — tsb analytics library. */
+export interface OrthopedicsSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface OrthopedicsSciWaveletResult { values: number[]; converged: boolean; }
+export function computeOrthopedicsSciWavelet(data: number[], opts: OrthopedicsSciWaveletOptions = {}): OrthopedicsSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeOrthopedicsSciWavelet };
diff --git a/src/paleoclimatology/adaptation.ts b/src/paleoclimatology/adaptation.ts
new file mode 100644
index 000000000..c676cb475
--- /dev/null
+++ b/src/paleoclimatology/adaptation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology adaptation module — tsb analytics library. */
+export interface PaleoclimatologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyAdaptationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyAdaptation(data: number[], opts: PaleoclimatologyAdaptationOptions = {}): PaleoclimatologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyAdaptation };
diff --git a/src/paleoclimatology/aggregation.ts b/src/paleoclimatology/aggregation.ts
new file mode 100644
index 000000000..c95529b98
--- /dev/null
+++ b/src/paleoclimatology/aggregation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology aggregation module — tsb analytics library. */
+export interface PaleoclimatologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyAggregationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyAggregation(data: number[], opts: PaleoclimatologyAggregationOptions = {}): PaleoclimatologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyAggregation };
diff --git a/src/paleoclimatology/algebra.ts b/src/paleoclimatology/algebra.ts
new file mode 100644
index 000000000..72c3dda03
--- /dev/null
+++ b/src/paleoclimatology/algebra.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology algebra module — tsb analytics library. */
+export interface PaleoclimatologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyAlgebraResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyAlgebra(data: number[], opts: PaleoclimatologyAlgebraOptions = {}): PaleoclimatologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyAlgebra };
diff --git a/src/paleoclimatology/alignment.ts b/src/paleoclimatology/alignment.ts
new file mode 100644
index 000000000..9e7a5be5c
--- /dev/null
+++ b/src/paleoclimatology/alignment.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology alignment module — tsb analytics library. */
+export interface PaleoclimatologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyAlignmentResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyAlignment(data: number[], opts: PaleoclimatologyAlignmentOptions = {}): PaleoclimatologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyAlignment };
diff --git a/src/paleoclimatology/analysis.ts b/src/paleoclimatology/analysis.ts
new file mode 100644
index 000000000..6d3234057
--- /dev/null
+++ b/src/paleoclimatology/analysis.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology analysis module — tsb analytics library. */
+export interface PaleoclimatologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyAnalysisResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyAnalysis(data: number[], opts: PaleoclimatologyAnalysisOptions = {}): PaleoclimatologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyAnalysis };
diff --git a/src/paleoclimatology/augmentation.ts b/src/paleoclimatology/augmentation.ts
new file mode 100644
index 000000000..2a290e243
--- /dev/null
+++ b/src/paleoclimatology/augmentation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology augmentation module — tsb analytics library. */
+export interface PaleoclimatologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyAugmentationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyAugmentation(data: number[], opts: PaleoclimatologyAugmentationOptions = {}): PaleoclimatologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyAugmentation };
diff --git a/src/paleoclimatology/bagging.ts b/src/paleoclimatology/bagging.ts
new file mode 100644
index 000000000..3df5ea2e0
--- /dev/null
+++ b/src/paleoclimatology/bagging.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology bagging module — tsb analytics library. */
+export interface PaleoclimatologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyBaggingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyBagging(data: number[], opts: PaleoclimatologyBaggingOptions = {}): PaleoclimatologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyBagging };
diff --git a/src/paleoclimatology/basis.ts b/src/paleoclimatology/basis.ts
new file mode 100644
index 000000000..159d371da
--- /dev/null
+++ b/src/paleoclimatology/basis.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology basis module — tsb analytics library. */
+export interface PaleoclimatologyBasisOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyBasisResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyBasis(data: number[], opts: PaleoclimatologyBasisOptions = {}): PaleoclimatologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyBasis };
diff --git a/src/paleoclimatology/benchmarking.ts b/src/paleoclimatology/benchmarking.ts
new file mode 100644
index 000000000..22021b0d7
--- /dev/null
+++ b/src/paleoclimatology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology benchmarking module — tsb analytics library. */
+export interface PaleoclimatologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyBenchmarking(data: number[], opts: PaleoclimatologyBenchmarkingOptions = {}): PaleoclimatologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyBenchmarking };
diff --git a/src/paleoclimatology/blending.ts b/src/paleoclimatology/blending.ts
new file mode 100644
index 000000000..253044d1d
--- /dev/null
+++ b/src/paleoclimatology/blending.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology blending module — tsb analytics library. */
+export interface PaleoclimatologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyBlendingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyBlending(data: number[], opts: PaleoclimatologyBlendingOptions = {}): PaleoclimatologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyBlending };
diff --git a/src/paleoclimatology/boosting.ts b/src/paleoclimatology/boosting.ts
new file mode 100644
index 000000000..cd625d949
--- /dev/null
+++ b/src/paleoclimatology/boosting.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology boosting module — tsb analytics library. */
+export interface PaleoclimatologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyBoostingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyBoosting(data: number[], opts: PaleoclimatologyBoostingOptions = {}): PaleoclimatologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyBoosting };
diff --git a/src/paleoclimatology/bootstrap.ts b/src/paleoclimatology/bootstrap.ts
new file mode 100644
index 000000000..61f5a119d
--- /dev/null
+++ b/src/paleoclimatology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology bootstrap module — tsb analytics library. */
+export interface PaleoclimatologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyBootstrapResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyBootstrap(data: number[], opts: PaleoclimatologyBootstrapOptions = {}): PaleoclimatologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyBootstrap };
diff --git a/src/paleoclimatology/calculus.ts b/src/paleoclimatology/calculus.ts
new file mode 100644
index 000000000..4054f2fe2
--- /dev/null
+++ b/src/paleoclimatology/calculus.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology calculus module — tsb analytics library. */
+export interface PaleoclimatologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyCalculusResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyCalculus(data: number[], opts: PaleoclimatologyCalculusOptions = {}): PaleoclimatologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyCalculus };
diff --git a/src/paleoclimatology/calibration.ts b/src/paleoclimatology/calibration.ts
new file mode 100644
index 000000000..7a71f8b25
--- /dev/null
+++ b/src/paleoclimatology/calibration.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology calibration module — tsb analytics library. */
+export interface PaleoclimatologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyCalibrationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyCalibration(data: number[], opts: PaleoclimatologyCalibrationOptions = {}): PaleoclimatologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyCalibration };
diff --git a/src/paleoclimatology/characterization.ts b/src/paleoclimatology/characterization.ts
new file mode 100644
index 000000000..6e5ae5634
--- /dev/null
+++ b/src/paleoclimatology/characterization.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology characterization module — tsb analytics library. */
+export interface PaleoclimatologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyCharacterization(data: number[], opts: PaleoclimatologyCharacterizationOptions = {}): PaleoclimatologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyCharacterization };
diff --git a/src/paleoclimatology/classification.ts b/src/paleoclimatology/classification.ts
new file mode 100644
index 000000000..7ec461970
--- /dev/null
+++ b/src/paleoclimatology/classification.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology classification module — tsb analytics library. */
+export interface PaleoclimatologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyClassificationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyClassification(data: number[], opts: PaleoclimatologyClassificationOptions = {}): PaleoclimatologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyClassification };
diff --git a/src/paleoclimatology/clustering.ts b/src/paleoclimatology/clustering.ts
new file mode 100644
index 000000000..2acb81855
--- /dev/null
+++ b/src/paleoclimatology/clustering.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology clustering module — tsb analytics library. */
+export interface PaleoclimatologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyClusteringResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyClustering(data: number[], opts: PaleoclimatologyClusteringOptions = {}): PaleoclimatologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyClustering };
diff --git a/src/paleoclimatology/compression.ts b/src/paleoclimatology/compression.ts
new file mode 100644
index 000000000..f88bd4f7c
--- /dev/null
+++ b/src/paleoclimatology/compression.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology compression module — tsb analytics library. */
+export interface PaleoclimatologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyCompressionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyCompression(data: number[], opts: PaleoclimatologyCompressionOptions = {}): PaleoclimatologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyCompression };
diff --git a/src/paleoclimatology/continuous.ts b/src/paleoclimatology/continuous.ts
new file mode 100644
index 000000000..e4b12fbea
--- /dev/null
+++ b/src/paleoclimatology/continuous.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology continuous module — tsb analytics library. */
+export interface PaleoclimatologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyContinuousResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyContinuous(data: number[], opts: PaleoclimatologyContinuousOptions = {}): PaleoclimatologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyContinuous };
diff --git a/src/paleoclimatology/control.ts b/src/paleoclimatology/control.ts
new file mode 100644
index 000000000..fa5e57ce3
--- /dev/null
+++ b/src/paleoclimatology/control.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology control module — tsb analytics library. */
+export interface PaleoclimatologyControlOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyControlResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyControl(data: number[], opts: PaleoclimatologyControlOptions = {}): PaleoclimatologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyControl };
diff --git a/src/paleoclimatology/convergence.ts b/src/paleoclimatology/convergence.ts
new file mode 100644
index 000000000..c7e40db36
--- /dev/null
+++ b/src/paleoclimatology/convergence.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology convergence module — tsb analytics library. */
+export interface PaleoclimatologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyConvergenceResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyConvergence(data: number[], opts: PaleoclimatologyConvergenceOptions = {}): PaleoclimatologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyConvergence };
diff --git a/src/paleoclimatology/convex.ts b/src/paleoclimatology/convex.ts
new file mode 100644
index 000000000..a6e88c891
--- /dev/null
+++ b/src/paleoclimatology/convex.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology convex module — tsb analytics library. */
+export interface PaleoclimatologyConvexOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyConvexResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyConvex(data: number[], opts: PaleoclimatologyConvexOptions = {}): PaleoclimatologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyConvex };
diff --git a/src/paleoclimatology/correlation.ts b/src/paleoclimatology/correlation.ts
new file mode 100644
index 000000000..4ce36bdac
--- /dev/null
+++ b/src/paleoclimatology/correlation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology correlation module — tsb analytics library. */
+export interface PaleoclimatologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyCorrelationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyCorrelation(data: number[], opts: PaleoclimatologyCorrelationOptions = {}): PaleoclimatologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyCorrelation };
diff --git a/src/paleoclimatology/covariance.ts b/src/paleoclimatology/covariance.ts
new file mode 100644
index 000000000..f04b9f94c
--- /dev/null
+++ b/src/paleoclimatology/covariance.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology covariance module — tsb analytics library. */
+export interface PaleoclimatologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyCovarianceResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyCovariance(data: number[], opts: PaleoclimatologyCovarianceOptions = {}): PaleoclimatologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyCovariance };
diff --git a/src/paleoclimatology/cross_validation.ts b/src/paleoclimatology/cross_validation.ts
new file mode 100644
index 000000000..b4f01647c
--- /dev/null
+++ b/src/paleoclimatology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology cross_validation module — tsb analytics library. */
+export interface PaleoclimatologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyCrossValidation(data: number[], opts: PaleoclimatologyCrossValidationOptions = {}): PaleoclimatologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyCrossValidation };
diff --git a/src/paleoclimatology/decoding.ts b/src/paleoclimatology/decoding.ts
new file mode 100644
index 000000000..99df6bcbf
--- /dev/null
+++ b/src/paleoclimatology/decoding.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology decoding module — tsb analytics library. */
+export interface PaleoclimatologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDecodingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDecoding(data: number[], opts: PaleoclimatologyDecodingOptions = {}): PaleoclimatologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDecoding };
diff --git a/src/paleoclimatology/decomposition.ts b/src/paleoclimatology/decomposition.ts
new file mode 100644
index 000000000..a2ba15eb4
--- /dev/null
+++ b/src/paleoclimatology/decomposition.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology decomposition module — tsb analytics library. */
+export interface PaleoclimatologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDecompositionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDecomposition(data: number[], opts: PaleoclimatologyDecompositionOptions = {}): PaleoclimatologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDecomposition };
diff --git a/src/paleoclimatology/detection.ts b/src/paleoclimatology/detection.ts
new file mode 100644
index 000000000..8c18868cd
--- /dev/null
+++ b/src/paleoclimatology/detection.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology detection module — tsb analytics library. */
+export interface PaleoclimatologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDetectionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDetection(data: number[], opts: PaleoclimatologyDetectionOptions = {}): PaleoclimatologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDetection };
diff --git a/src/paleoclimatology/deterministic.ts b/src/paleoclimatology/deterministic.ts
new file mode 100644
index 000000000..afa5d9e31
--- /dev/null
+++ b/src/paleoclimatology/deterministic.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology deterministic module — tsb analytics library. */
+export interface PaleoclimatologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDeterministicResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDeterministic(data: number[], opts: PaleoclimatologyDeterministicOptions = {}): PaleoclimatologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDeterministic };
diff --git a/src/paleoclimatology/diagnostics.ts b/src/paleoclimatology/diagnostics.ts
new file mode 100644
index 000000000..d5bedb12d
--- /dev/null
+++ b/src/paleoclimatology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology diagnostics module — tsb analytics library. */
+export interface PaleoclimatologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDiagnostics(data: number[], opts: PaleoclimatologyDiagnosticsOptions = {}): PaleoclimatologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDiagnostics };
diff --git a/src/paleoclimatology/differential.ts b/src/paleoclimatology/differential.ts
new file mode 100644
index 000000000..dae77e6a4
--- /dev/null
+++ b/src/paleoclimatology/differential.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology differential module — tsb analytics library. */
+export interface PaleoclimatologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDifferentialResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDifferential(data: number[], opts: PaleoclimatologyDifferentialOptions = {}): PaleoclimatologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDifferential };
diff --git a/src/paleoclimatology/discrete.ts b/src/paleoclimatology/discrete.ts
new file mode 100644
index 000000000..5687d8792
--- /dev/null
+++ b/src/paleoclimatology/discrete.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology discrete module — tsb analytics library. */
+export interface PaleoclimatologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDiscreteResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDiscrete(data: number[], opts: PaleoclimatologyDiscreteOptions = {}): PaleoclimatologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDiscrete };
diff --git a/src/paleoclimatology/distribution.ts b/src/paleoclimatology/distribution.ts
new file mode 100644
index 000000000..10a45cf85
--- /dev/null
+++ b/src/paleoclimatology/distribution.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology distribution module — tsb analytics library. */
+export interface PaleoclimatologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDistributionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDistribution(data: number[], opts: PaleoclimatologyDistributionOptions = {}): PaleoclimatologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDistribution };
diff --git a/src/paleoclimatology/dynamic.ts b/src/paleoclimatology/dynamic.ts
new file mode 100644
index 000000000..f52065035
--- /dev/null
+++ b/src/paleoclimatology/dynamic.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology dynamic module — tsb analytics library. */
+export interface PaleoclimatologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyDynamicResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyDynamic(data: number[], opts: PaleoclimatologyDynamicOptions = {}): PaleoclimatologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyDynamic };
diff --git a/src/paleoclimatology/embedding.ts b/src/paleoclimatology/embedding.ts
new file mode 100644
index 000000000..27548981c
--- /dev/null
+++ b/src/paleoclimatology/embedding.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology embedding module — tsb analytics library. */
+export interface PaleoclimatologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyEmbedding(data: number[], opts: PaleoclimatologyEmbeddingOptions = {}): PaleoclimatologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyEmbedding };
diff --git a/src/paleoclimatology/encoding.ts b/src/paleoclimatology/encoding.ts
new file mode 100644
index 000000000..e418ef79d
--- /dev/null
+++ b/src/paleoclimatology/encoding.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology encoding module — tsb analytics library. */
+export interface PaleoclimatologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyEncodingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyEncoding(data: number[], opts: PaleoclimatologyEncodingOptions = {}): PaleoclimatologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyEncoding };
diff --git a/src/paleoclimatology/ensemble.ts b/src/paleoclimatology/ensemble.ts
new file mode 100644
index 000000000..86f5dea7d
--- /dev/null
+++ b/src/paleoclimatology/ensemble.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology ensemble module — tsb analytics library. */
+export interface PaleoclimatologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyEnsembleResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyEnsemble(data: number[], opts: PaleoclimatologyEnsembleOptions = {}): PaleoclimatologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyEnsemble };
diff --git a/src/paleoclimatology/estimation.ts b/src/paleoclimatology/estimation.ts
new file mode 100644
index 000000000..f3395b4b2
--- /dev/null
+++ b/src/paleoclimatology/estimation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology estimation module — tsb analytics library. */
+export interface PaleoclimatologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyEstimationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyEstimation(data: number[], opts: PaleoclimatologyEstimationOptions = {}): PaleoclimatologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyEstimation };
diff --git a/src/paleoclimatology/evaluation.ts b/src/paleoclimatology/evaluation.ts
new file mode 100644
index 000000000..eac676593
--- /dev/null
+++ b/src/paleoclimatology/evaluation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology evaluation module — tsb analytics library. */
+export interface PaleoclimatologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyEvaluationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyEvaluation(data: number[], opts: PaleoclimatologyEvaluationOptions = {}): PaleoclimatologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyEvaluation };
diff --git a/src/paleoclimatology/extrapolation.ts b/src/paleoclimatology/extrapolation.ts
new file mode 100644
index 000000000..f9518641d
--- /dev/null
+++ b/src/paleoclimatology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology extrapolation module — tsb analytics library. */
+export interface PaleoclimatologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyExtrapolation(data: number[], opts: PaleoclimatologyExtrapolationOptions = {}): PaleoclimatologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyExtrapolation };
diff --git a/src/paleoclimatology/features.ts b/src/paleoclimatology/features.ts
new file mode 100644
index 000000000..5983e7cd0
--- /dev/null
+++ b/src/paleoclimatology/features.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology features module — tsb analytics library. */
+export interface PaleoclimatologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyFeaturesResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyFeatures(data: number[], opts: PaleoclimatologyFeaturesOptions = {}): PaleoclimatologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyFeatures };
diff --git a/src/paleoclimatology/feedback.ts b/src/paleoclimatology/feedback.ts
new file mode 100644
index 000000000..aadcb3af3
--- /dev/null
+++ b/src/paleoclimatology/feedback.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology feedback module — tsb analytics library. */
+export interface PaleoclimatologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyFeedbackResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyFeedback(data: number[], opts: PaleoclimatologyFeedbackOptions = {}): PaleoclimatologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyFeedback };
diff --git a/src/paleoclimatology/filtering.ts b/src/paleoclimatology/filtering.ts
new file mode 100644
index 000000000..440fed399
--- /dev/null
+++ b/src/paleoclimatology/filtering.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology filtering module — tsb analytics library. */
+export interface PaleoclimatologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyFilteringResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyFiltering(data: number[], opts: PaleoclimatologyFilteringOptions = {}): PaleoclimatologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyFiltering };
diff --git a/src/paleoclimatology/fourier.ts b/src/paleoclimatology/fourier.ts
new file mode 100644
index 000000000..0e26b1f55
--- /dev/null
+++ b/src/paleoclimatology/fourier.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology fourier module — tsb analytics library. */
+export interface PaleoclimatologyFourierOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyFourierResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyFourier(data: number[], opts: PaleoclimatologyFourierOptions = {}): PaleoclimatologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyFourier };
diff --git a/src/paleoclimatology/fusion.ts b/src/paleoclimatology/fusion.ts
new file mode 100644
index 000000000..1730bef1f
--- /dev/null
+++ b/src/paleoclimatology/fusion.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology fusion module — tsb analytics library. */
+export interface PaleoclimatologyFusionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyFusionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyFusion(data: number[], opts: PaleoclimatologyFusionOptions = {}): PaleoclimatologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyFusion };
diff --git a/src/paleoclimatology/generation.ts b/src/paleoclimatology/generation.ts
new file mode 100644
index 000000000..d18c7c490
--- /dev/null
+++ b/src/paleoclimatology/generation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology generation module — tsb analytics library. */
+export interface PaleoclimatologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyGenerationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyGeneration(data: number[], opts: PaleoclimatologyGenerationOptions = {}): PaleoclimatologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyGeneration };
diff --git a/src/paleoclimatology/geometry.ts b/src/paleoclimatology/geometry.ts
new file mode 100644
index 000000000..e587dc2c0
--- /dev/null
+++ b/src/paleoclimatology/geometry.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology geometry module — tsb analytics library. */
+export interface PaleoclimatologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyGeometryResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyGeometry(data: number[], opts: PaleoclimatologyGeometryOptions = {}): PaleoclimatologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyGeometry };
diff --git a/src/paleoclimatology/gradient.ts b/src/paleoclimatology/gradient.ts
new file mode 100644
index 000000000..88fdea898
--- /dev/null
+++ b/src/paleoclimatology/gradient.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology gradient module — tsb analytics library. */
+export interface PaleoclimatologyGradientOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyGradientResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyGradient(data: number[], opts: PaleoclimatologyGradientOptions = {}): PaleoclimatologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyGradient };
diff --git a/src/paleoclimatology/hessian.ts b/src/paleoclimatology/hessian.ts
new file mode 100644
index 000000000..ca4101c75
--- /dev/null
+++ b/src/paleoclimatology/hessian.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology hessian module — tsb analytics library. */
+export interface PaleoclimatologyHessianOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyHessianResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyHessian(data: number[], opts: PaleoclimatologyHessianOptions = {}): PaleoclimatologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyHessian };
diff --git a/src/paleoclimatology/hypothesis.ts b/src/paleoclimatology/hypothesis.ts
new file mode 100644
index 000000000..38e66b7c7
--- /dev/null
+++ b/src/paleoclimatology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology hypothesis module — tsb analytics library. */
+export interface PaleoclimatologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyHypothesisResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyHypothesis(data: number[], opts: PaleoclimatologyHypothesisOptions = {}): PaleoclimatologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyHypothesis };
diff --git a/src/paleoclimatology/inference.ts b/src/paleoclimatology/inference.ts
new file mode 100644
index 000000000..9df199c8f
--- /dev/null
+++ b/src/paleoclimatology/inference.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology inference module — tsb analytics library. */
+export interface PaleoclimatologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyInferenceResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyInference(data: number[], opts: PaleoclimatologyInferenceOptions = {}): PaleoclimatologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyInference };
diff --git a/src/paleoclimatology/inference2.ts b/src/paleoclimatology/inference2.ts
new file mode 100644
index 000000000..68020be38
--- /dev/null
+++ b/src/paleoclimatology/inference2.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology inference2 module — tsb analytics library. */
+export interface PaleoclimatologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyInferenceResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyInference(data: number[], opts: PaleoclimatologyInferenceOptions = {}): PaleoclimatologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyInference };
diff --git a/src/paleoclimatology/integral.ts b/src/paleoclimatology/integral.ts
new file mode 100644
index 000000000..a9459c61a
--- /dev/null
+++ b/src/paleoclimatology/integral.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology integral module — tsb analytics library. */
+export interface PaleoclimatologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyIntegralResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyIntegral(data: number[], opts: PaleoclimatologyIntegralOptions = {}): PaleoclimatologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyIntegral };
diff --git a/src/paleoclimatology/integration.ts b/src/paleoclimatology/integration.ts
new file mode 100644
index 000000000..3ab4cf619
--- /dev/null
+++ b/src/paleoclimatology/integration.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology integration module — tsb analytics library. */
+export interface PaleoclimatologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyIntegrationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyIntegration(data: number[], opts: PaleoclimatologyIntegrationOptions = {}): PaleoclimatologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyIntegration };
diff --git a/src/paleoclimatology/interpolation.ts b/src/paleoclimatology/interpolation.ts
new file mode 100644
index 000000000..f5728c230
--- /dev/null
+++ b/src/paleoclimatology/interpolation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology interpolation module — tsb analytics library. */
+export interface PaleoclimatologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyInterpolationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyInterpolation(data: number[], opts: PaleoclimatologyInterpolationOptions = {}): PaleoclimatologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyInterpolation };
diff --git a/src/paleoclimatology/jacobian.ts b/src/paleoclimatology/jacobian.ts
new file mode 100644
index 000000000..cf56f1fe0
--- /dev/null
+++ b/src/paleoclimatology/jacobian.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology jacobian module — tsb analytics library. */
+export interface PaleoclimatologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyJacobianResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyJacobian(data: number[], opts: PaleoclimatologyJacobianOptions = {}): PaleoclimatologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyJacobian };
diff --git a/src/paleoclimatology/kernel.ts b/src/paleoclimatology/kernel.ts
new file mode 100644
index 000000000..4108b7b79
--- /dev/null
+++ b/src/paleoclimatology/kernel.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology kernel module — tsb analytics library. */
+export interface PaleoclimatologyKernelOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyKernelResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyKernel(data: number[], opts: PaleoclimatologyKernelOptions = {}): PaleoclimatologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyKernel };
diff --git a/src/paleoclimatology/laplacian.ts b/src/paleoclimatology/laplacian.ts
new file mode 100644
index 000000000..a93682f35
--- /dev/null
+++ b/src/paleoclimatology/laplacian.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology laplacian module — tsb analytics library. */
+export interface PaleoclimatologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyLaplacianResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyLaplacian(data: number[], opts: PaleoclimatologyLaplacianOptions = {}): PaleoclimatologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyLaplacian };
diff --git a/src/paleoclimatology/learning.ts b/src/paleoclimatology/learning.ts
new file mode 100644
index 000000000..98e0c8adb
--- /dev/null
+++ b/src/paleoclimatology/learning.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology learning module — tsb analytics library. */
+export interface PaleoclimatologyLearningOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyLearningResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyLearning(data: number[], opts: PaleoclimatologyLearningOptions = {}): PaleoclimatologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyLearning };
diff --git a/src/paleoclimatology/linear.ts b/src/paleoclimatology/linear.ts
new file mode 100644
index 000000000..0747220b3
--- /dev/null
+++ b/src/paleoclimatology/linear.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology linear module — tsb analytics library. */
+export interface PaleoclimatologyLinearOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyLinearResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyLinear(data: number[], opts: PaleoclimatologyLinearOptions = {}): PaleoclimatologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyLinear };
diff --git a/src/paleoclimatology/manifold.ts b/src/paleoclimatology/manifold.ts
new file mode 100644
index 000000000..3eccb533e
--- /dev/null
+++ b/src/paleoclimatology/manifold.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology manifold module — tsb analytics library. */
+export interface PaleoclimatologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyManifoldResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyManifold(data: number[], opts: PaleoclimatologyManifoldOptions = {}): PaleoclimatologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyManifold };
diff --git a/src/paleoclimatology/matching.ts b/src/paleoclimatology/matching.ts
new file mode 100644
index 000000000..495f74210
--- /dev/null
+++ b/src/paleoclimatology/matching.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology matching module — tsb analytics library. */
+export interface PaleoclimatologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyMatchingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyMatching(data: number[], opts: PaleoclimatologyMatchingOptions = {}): PaleoclimatologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyMatching };
diff --git a/src/paleoclimatology/measurement.ts b/src/paleoclimatology/measurement.ts
new file mode 100644
index 000000000..0083df0eb
--- /dev/null
+++ b/src/paleoclimatology/measurement.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology measurement module — tsb analytics library. */
+export interface PaleoclimatologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyMeasurementResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyMeasurement(data: number[], opts: PaleoclimatologyMeasurementOptions = {}): PaleoclimatologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyMeasurement };
diff --git a/src/paleoclimatology/metrics.ts b/src/paleoclimatology/metrics.ts
new file mode 100644
index 000000000..fcdbb2f8f
--- /dev/null
+++ b/src/paleoclimatology/metrics.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology metrics module — tsb analytics library. */
+export interface PaleoclimatologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyMetricsResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyMetrics(data: number[], opts: PaleoclimatologyMetricsOptions = {}): PaleoclimatologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyMetrics };
diff --git a/src/paleoclimatology/modeling.ts b/src/paleoclimatology/modeling.ts
new file mode 100644
index 000000000..986f1544e
--- /dev/null
+++ b/src/paleoclimatology/modeling.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology modeling module — tsb analytics library. */
+export interface PaleoclimatologyModelingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyModelingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyModeling(data: number[], opts: PaleoclimatologyModelingOptions = {}): PaleoclimatologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyModeling };
diff --git a/src/paleoclimatology/monitoring.ts b/src/paleoclimatology/monitoring.ts
new file mode 100644
index 000000000..296982f04
--- /dev/null
+++ b/src/paleoclimatology/monitoring.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology monitoring module — tsb analytics library. */
+export interface PaleoclimatologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyMonitoringResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyMonitoring(data: number[], opts: PaleoclimatologyMonitoringOptions = {}): PaleoclimatologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyMonitoring };
diff --git a/src/paleoclimatology/nonlinear.ts b/src/paleoclimatology/nonlinear.ts
new file mode 100644
index 000000000..4ce3b609b
--- /dev/null
+++ b/src/paleoclimatology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology nonlinear module — tsb analytics library. */
+export interface PaleoclimatologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyNonlinearResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyNonlinear(data: number[], opts: PaleoclimatologyNonlinearOptions = {}): PaleoclimatologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyNonlinear };
diff --git a/src/paleoclimatology/normalization.ts b/src/paleoclimatology/normalization.ts
new file mode 100644
index 000000000..7e8c007cf
--- /dev/null
+++ b/src/paleoclimatology/normalization.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology normalization module — tsb analytics library. */
+export interface PaleoclimatologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyNormalizationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyNormalization(data: number[], opts: PaleoclimatologyNormalizationOptions = {}): PaleoclimatologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyNormalization };
diff --git a/src/paleoclimatology/optimization.ts b/src/paleoclimatology/optimization.ts
new file mode 100644
index 000000000..ffb5a7ca3
--- /dev/null
+++ b/src/paleoclimatology/optimization.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology optimization module — tsb analytics library. */
+export interface PaleoclimatologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyOptimizationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyOptimization(data: number[], opts: PaleoclimatologyOptimizationOptions = {}): PaleoclimatologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyOptimization };
diff --git a/src/paleoclimatology/patterns.ts b/src/paleoclimatology/patterns.ts
new file mode 100644
index 000000000..5a23abc2a
--- /dev/null
+++ b/src/paleoclimatology/patterns.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology patterns module — tsb analytics library. */
+export interface PaleoclimatologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyPatternsResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyPatterns(data: number[], opts: PaleoclimatologyPatternsOptions = {}): PaleoclimatologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyPatterns };
diff --git a/src/paleoclimatology/permutation.ts b/src/paleoclimatology/permutation.ts
new file mode 100644
index 000000000..2f1b695a8
--- /dev/null
+++ b/src/paleoclimatology/permutation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology permutation module — tsb analytics library. */
+export interface PaleoclimatologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyPermutationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyPermutation(data: number[], opts: PaleoclimatologyPermutationOptions = {}): PaleoclimatologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyPermutation };
diff --git a/src/paleoclimatology/prediction.ts b/src/paleoclimatology/prediction.ts
new file mode 100644
index 000000000..bbc721ef9
--- /dev/null
+++ b/src/paleoclimatology/prediction.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology prediction module — tsb analytics library. */
+export interface PaleoclimatologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyPredictionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyPrediction(data: number[], opts: PaleoclimatologyPredictionOptions = {}): PaleoclimatologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyPrediction };
diff --git a/src/paleoclimatology/processing.ts b/src/paleoclimatology/processing.ts
new file mode 100644
index 000000000..b12dd7743
--- /dev/null
+++ b/src/paleoclimatology/processing.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology processing module — tsb analytics library. */
+export interface PaleoclimatologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyProcessingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyProcessing(data: number[], opts: PaleoclimatologyProcessingOptions = {}): PaleoclimatologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyProcessing };
diff --git a/src/paleoclimatology/profiling.ts b/src/paleoclimatology/profiling.ts
new file mode 100644
index 000000000..f202d4ca6
--- /dev/null
+++ b/src/paleoclimatology/profiling.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology profiling module — tsb analytics library. */
+export interface PaleoclimatologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyProfilingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyProfiling(data: number[], opts: PaleoclimatologyProfilingOptions = {}): PaleoclimatologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyProfiling };
diff --git a/src/paleoclimatology/projection.ts b/src/paleoclimatology/projection.ts
new file mode 100644
index 000000000..379a29c70
--- /dev/null
+++ b/src/paleoclimatology/projection.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology projection module — tsb analytics library. */
+export interface PaleoclimatologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyProjectionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyProjection(data: number[], opts: PaleoclimatologyProjectionOptions = {}): PaleoclimatologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyProjection };
diff --git a/src/paleoclimatology/ranking.ts b/src/paleoclimatology/ranking.ts
new file mode 100644
index 000000000..d3b0aad59
--- /dev/null
+++ b/src/paleoclimatology/ranking.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology ranking module — tsb analytics library. */
+export interface PaleoclimatologyRankingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyRankingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyRanking(data: number[], opts: PaleoclimatologyRankingOptions = {}): PaleoclimatologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyRanking };
diff --git a/src/paleoclimatology/reconstruction.ts b/src/paleoclimatology/reconstruction.ts
new file mode 100644
index 000000000..da21f2b0c
--- /dev/null
+++ b/src/paleoclimatology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology reconstruction module — tsb analytics library. */
+export interface PaleoclimatologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyReconstructionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyReconstruction(data: number[], opts: PaleoclimatologyReconstructionOptions = {}): PaleoclimatologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyReconstruction };
diff --git a/src/paleoclimatology/registration.ts b/src/paleoclimatology/registration.ts
new file mode 100644
index 000000000..834aaff44
--- /dev/null
+++ b/src/paleoclimatology/registration.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology registration module — tsb analytics library. */
+export interface PaleoclimatologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyRegistrationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyRegistration(data: number[], opts: PaleoclimatologyRegistrationOptions = {}): PaleoclimatologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyRegistration };
diff --git a/src/paleoclimatology/regression.ts b/src/paleoclimatology/regression.ts
new file mode 100644
index 000000000..9950b94df
--- /dev/null
+++ b/src/paleoclimatology/regression.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology regression module — tsb analytics library. */
+export interface PaleoclimatologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyRegressionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyRegression(data: number[], opts: PaleoclimatologyRegressionOptions = {}): PaleoclimatologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyRegression };
diff --git a/src/paleoclimatology/regularization.ts b/src/paleoclimatology/regularization.ts
new file mode 100644
index 000000000..2301d8957
--- /dev/null
+++ b/src/paleoclimatology/regularization.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology regularization module — tsb analytics library. */
+export interface PaleoclimatologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyRegularizationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyRegularization(data: number[], opts: PaleoclimatologyRegularizationOptions = {}): PaleoclimatologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyRegularization };
diff --git a/src/paleoclimatology/robustness.ts b/src/paleoclimatology/robustness.ts
new file mode 100644
index 000000000..5150e9270
--- /dev/null
+++ b/src/paleoclimatology/robustness.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology robustness module — tsb analytics library. */
+export interface PaleoclimatologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyRobustnessResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyRobustness(data: number[], opts: PaleoclimatologyRobustnessOptions = {}): PaleoclimatologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyRobustness };
diff --git a/src/paleoclimatology/sampling.ts b/src/paleoclimatology/sampling.ts
new file mode 100644
index 000000000..4fbe1b674
--- /dev/null
+++ b/src/paleoclimatology/sampling.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology sampling module — tsb analytics library. */
+export interface PaleoclimatologySamplingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologySamplingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologySampling(data: number[], opts: PaleoclimatologySamplingOptions = {}): PaleoclimatologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologySampling };
diff --git a/src/paleoclimatology/sampling2.ts b/src/paleoclimatology/sampling2.ts
new file mode 100644
index 000000000..6dd675456
--- /dev/null
+++ b/src/paleoclimatology/sampling2.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology sampling2 module — tsb analytics library. */
+export interface PaleoclimatologySamplingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologySamplingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologySampling(data: number[], opts: PaleoclimatologySamplingOptions = {}): PaleoclimatologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologySampling };
diff --git a/src/paleoclimatology/scaling.ts b/src/paleoclimatology/scaling.ts
new file mode 100644
index 000000000..687c82200
--- /dev/null
+++ b/src/paleoclimatology/scaling.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology scaling module — tsb analytics library. */
+export interface PaleoclimatologyScalingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyScalingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyScaling(data: number[], opts: PaleoclimatologyScalingOptions = {}): PaleoclimatologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyScaling };
diff --git a/src/paleoclimatology/scoring.ts b/src/paleoclimatology/scoring.ts
new file mode 100644
index 000000000..0dce6a108
--- /dev/null
+++ b/src/paleoclimatology/scoring.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology scoring module — tsb analytics library. */
+export interface PaleoclimatologyScoringOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyScoringResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyScoring(data: number[], opts: PaleoclimatologyScoringOptions = {}): PaleoclimatologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyScoring };
diff --git a/src/paleoclimatology/segmentation.ts b/src/paleoclimatology/segmentation.ts
new file mode 100644
index 000000000..fc753db14
--- /dev/null
+++ b/src/paleoclimatology/segmentation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology segmentation module — tsb analytics library. */
+export interface PaleoclimatologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologySegmentationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologySegmentation(data: number[], opts: PaleoclimatologySegmentationOptions = {}): PaleoclimatologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologySegmentation };
diff --git a/src/paleoclimatology/selection.ts b/src/paleoclimatology/selection.ts
new file mode 100644
index 000000000..b1a1a7e5d
--- /dev/null
+++ b/src/paleoclimatology/selection.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology selection module — tsb analytics library. */
+export interface PaleoclimatologySelectionOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologySelectionResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologySelection(data: number[], opts: PaleoclimatologySelectionOptions = {}): PaleoclimatologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologySelection };
diff --git a/src/paleoclimatology/sensitivity.ts b/src/paleoclimatology/sensitivity.ts
new file mode 100644
index 000000000..ab3896125
--- /dev/null
+++ b/src/paleoclimatology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology sensitivity module — tsb analytics library. */
+export interface PaleoclimatologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologySensitivityResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologySensitivity(data: number[], opts: PaleoclimatologySensitivityOptions = {}): PaleoclimatologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologySensitivity };
diff --git a/src/paleoclimatology/simulation.ts b/src/paleoclimatology/simulation.ts
new file mode 100644
index 000000000..d70b70ad0
--- /dev/null
+++ b/src/paleoclimatology/simulation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology simulation module — tsb analytics library. */
+export interface PaleoclimatologySimulationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologySimulationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologySimulation(data: number[], opts: PaleoclimatologySimulationOptions = {}): PaleoclimatologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologySimulation };
diff --git a/src/paleoclimatology/smoothing.ts b/src/paleoclimatology/smoothing.ts
new file mode 100644
index 000000000..0ee644f97
--- /dev/null
+++ b/src/paleoclimatology/smoothing.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology smoothing module — tsb analytics library. */
+export interface PaleoclimatologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologySmoothingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologySmoothing(data: number[], opts: PaleoclimatologySmoothingOptions = {}): PaleoclimatologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologySmoothing };
diff --git a/src/paleoclimatology/stability.ts b/src/paleoclimatology/stability.ts
new file mode 100644
index 000000000..7331bc2e1
--- /dev/null
+++ b/src/paleoclimatology/stability.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology stability module — tsb analytics library. */
+export interface PaleoclimatologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyStabilityResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyStability(data: number[], opts: PaleoclimatologyStabilityOptions = {}): PaleoclimatologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyStability };
diff --git a/src/paleoclimatology/stacking.ts b/src/paleoclimatology/stacking.ts
new file mode 100644
index 000000000..6be0649cc
--- /dev/null
+++ b/src/paleoclimatology/stacking.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology stacking module — tsb analytics library. */
+export interface PaleoclimatologyStackingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyStackingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyStacking(data: number[], opts: PaleoclimatologyStackingOptions = {}): PaleoclimatologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyStacking };
diff --git a/src/paleoclimatology/standardization.ts b/src/paleoclimatology/standardization.ts
new file mode 100644
index 000000000..806ac632a
--- /dev/null
+++ b/src/paleoclimatology/standardization.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology standardization module — tsb analytics library. */
+export interface PaleoclimatologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyStandardizationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyStandardization(data: number[], opts: PaleoclimatologyStandardizationOptions = {}): PaleoclimatologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyStandardization };
diff --git a/src/paleoclimatology/static.ts b/src/paleoclimatology/static.ts
new file mode 100644
index 000000000..14b59240a
--- /dev/null
+++ b/src/paleoclimatology/static.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology static module — tsb analytics library. */
+export interface PaleoclimatologyStaticOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyStaticResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyStatic(data: number[], opts: PaleoclimatologyStaticOptions = {}): PaleoclimatologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyStatic };
diff --git a/src/paleoclimatology/stochastic.ts b/src/paleoclimatology/stochastic.ts
new file mode 100644
index 000000000..c6853ec3f
--- /dev/null
+++ b/src/paleoclimatology/stochastic.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology stochastic module — tsb analytics library. */
+export interface PaleoclimatologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyStochasticResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyStochastic(data: number[], opts: PaleoclimatologyStochasticOptions = {}): PaleoclimatologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyStochastic };
diff --git a/src/paleoclimatology/synthesis.ts b/src/paleoclimatology/synthesis.ts
new file mode 100644
index 000000000..4a543dd51
--- /dev/null
+++ b/src/paleoclimatology/synthesis.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology synthesis module — tsb analytics library. */
+export interface PaleoclimatologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologySynthesisResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologySynthesis(data: number[], opts: PaleoclimatologySynthesisOptions = {}): PaleoclimatologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologySynthesis };
diff --git a/src/paleoclimatology/topology.ts b/src/paleoclimatology/topology.ts
new file mode 100644
index 000000000..6a652cce3
--- /dev/null
+++ b/src/paleoclimatology/topology.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology topology module — tsb analytics library. */
+export interface PaleoclimatologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyTopologyResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyTopology(data: number[], opts: PaleoclimatologyTopologyOptions = {}): PaleoclimatologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyTopology };
diff --git a/src/paleoclimatology/tracking.ts b/src/paleoclimatology/tracking.ts
new file mode 100644
index 000000000..7763cd4ff
--- /dev/null
+++ b/src/paleoclimatology/tracking.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology tracking module — tsb analytics library. */
+export interface PaleoclimatologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyTrackingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyTracking(data: number[], opts: PaleoclimatologyTrackingOptions = {}): PaleoclimatologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyTracking };
diff --git a/src/paleoclimatology/transform.ts b/src/paleoclimatology/transform.ts
new file mode 100644
index 000000000..bf17fdf8e
--- /dev/null
+++ b/src/paleoclimatology/transform.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology transform module — tsb analytics library. */
+export interface PaleoclimatologyTransformOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyTransformResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyTransform(data: number[], opts: PaleoclimatologyTransformOptions = {}): PaleoclimatologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyTransform };
diff --git a/src/paleoclimatology/uncertainty.ts b/src/paleoclimatology/uncertainty.ts
new file mode 100644
index 000000000..e288c6e16
--- /dev/null
+++ b/src/paleoclimatology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology uncertainty module — tsb analytics library. */
+export interface PaleoclimatologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyUncertainty(data: number[], opts: PaleoclimatologyUncertaintyOptions = {}): PaleoclimatologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyUncertainty };
diff --git a/src/paleoclimatology/validation.ts b/src/paleoclimatology/validation.ts
new file mode 100644
index 000000000..a91b31c7a
--- /dev/null
+++ b/src/paleoclimatology/validation.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology validation module — tsb analytics library. */
+export interface PaleoclimatologyValidationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyValidationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyValidation(data: number[], opts: PaleoclimatologyValidationOptions = {}): PaleoclimatologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyValidation };
diff --git a/src/paleoclimatology/verification.ts b/src/paleoclimatology/verification.ts
new file mode 100644
index 000000000..acc7a4a4b
--- /dev/null
+++ b/src/paleoclimatology/verification.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology verification module — tsb analytics library. */
+export interface PaleoclimatologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyVerificationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyVerification(data: number[], opts: PaleoclimatologyVerificationOptions = {}): PaleoclimatologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyVerification };
diff --git a/src/paleoclimatology/visualization.ts b/src/paleoclimatology/visualization.ts
new file mode 100644
index 000000000..7e0b34629
--- /dev/null
+++ b/src/paleoclimatology/visualization.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology visualization module — tsb analytics library. */
+export interface PaleoclimatologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyVisualizationResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyVisualization(data: number[], opts: PaleoclimatologyVisualizationOptions = {}): PaleoclimatologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyVisualization };
diff --git a/src/paleoclimatology/voting.ts b/src/paleoclimatology/voting.ts
new file mode 100644
index 000000000..a90736c8a
--- /dev/null
+++ b/src/paleoclimatology/voting.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology voting module — tsb analytics library. */
+export interface PaleoclimatologyVotingOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyVotingResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyVoting(data: number[], opts: PaleoclimatologyVotingOptions = {}): PaleoclimatologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyVoting };
diff --git a/src/paleoclimatology/wavelet.ts b/src/paleoclimatology/wavelet.ts
new file mode 100644
index 000000000..5daa040e0
--- /dev/null
+++ b/src/paleoclimatology/wavelet.ts
@@ -0,0 +1,14 @@
+/** paleoclimatology wavelet module — tsb analytics library. */
+export interface PaleoclimatologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface PaleoclimatologyWaveletResult { values: number[]; converged: boolean; }
+export function computePaleoclimatologyWavelet(data: number[], opts: PaleoclimatologyWaveletOptions = {}): PaleoclimatologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoclimatologyWavelet };
diff --git a/src/paleoecology/adaptation.ts b/src/paleoecology/adaptation.ts
new file mode 100644
index 000000000..96d7fc62b
--- /dev/null
+++ b/src/paleoecology/adaptation.ts
@@ -0,0 +1,14 @@
+/** paleoecology adaptation module — tsb analytics library. */
+export interface PaleoecologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyAdaptationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyAdaptation(data: number[], opts: PaleoecologyAdaptationOptions = {}): PaleoecologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyAdaptation };
diff --git a/src/paleoecology/aggregation.ts b/src/paleoecology/aggregation.ts
new file mode 100644
index 000000000..db8bd2c08
--- /dev/null
+++ b/src/paleoecology/aggregation.ts
@@ -0,0 +1,14 @@
+/** paleoecology aggregation module — tsb analytics library. */
+export interface PaleoecologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyAggregationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyAggregation(data: number[], opts: PaleoecologyAggregationOptions = {}): PaleoecologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyAggregation };
diff --git a/src/paleoecology/algebra.ts b/src/paleoecology/algebra.ts
new file mode 100644
index 000000000..c5993a242
--- /dev/null
+++ b/src/paleoecology/algebra.ts
@@ -0,0 +1,14 @@
+/** paleoecology algebra module — tsb analytics library. */
+export interface PaleoecologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyAlgebraResult { values: number[]; converged: boolean; }
+export function computePaleoecologyAlgebra(data: number[], opts: PaleoecologyAlgebraOptions = {}): PaleoecologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyAlgebra };
diff --git a/src/paleoecology/alignment.ts b/src/paleoecology/alignment.ts
new file mode 100644
index 000000000..5e00d58be
--- /dev/null
+++ b/src/paleoecology/alignment.ts
@@ -0,0 +1,14 @@
+/** paleoecology alignment module — tsb analytics library. */
+export interface PaleoecologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyAlignmentResult { values: number[]; converged: boolean; }
+export function computePaleoecologyAlignment(data: number[], opts: PaleoecologyAlignmentOptions = {}): PaleoecologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyAlignment };
diff --git a/src/paleoecology/analysis.ts b/src/paleoecology/analysis.ts
new file mode 100644
index 000000000..fe028e8a1
--- /dev/null
+++ b/src/paleoecology/analysis.ts
@@ -0,0 +1,14 @@
+/** paleoecology analysis module — tsb analytics library. */
+export interface PaleoecologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyAnalysisResult { values: number[]; converged: boolean; }
+export function computePaleoecologyAnalysis(data: number[], opts: PaleoecologyAnalysisOptions = {}): PaleoecologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyAnalysis };
diff --git a/src/paleoecology/augmentation.ts b/src/paleoecology/augmentation.ts
new file mode 100644
index 000000000..144c34b0a
--- /dev/null
+++ b/src/paleoecology/augmentation.ts
@@ -0,0 +1,14 @@
+/** paleoecology augmentation module — tsb analytics library. */
+export interface PaleoecologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyAugmentationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyAugmentation(data: number[], opts: PaleoecologyAugmentationOptions = {}): PaleoecologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyAugmentation };
diff --git a/src/paleoecology/bagging.ts b/src/paleoecology/bagging.ts
new file mode 100644
index 000000000..865658763
--- /dev/null
+++ b/src/paleoecology/bagging.ts
@@ -0,0 +1,14 @@
+/** paleoecology bagging module — tsb analytics library. */
+export interface PaleoecologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyBaggingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyBagging(data: number[], opts: PaleoecologyBaggingOptions = {}): PaleoecologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyBagging };
diff --git a/src/paleoecology/basis.ts b/src/paleoecology/basis.ts
new file mode 100644
index 000000000..cf05a2299
--- /dev/null
+++ b/src/paleoecology/basis.ts
@@ -0,0 +1,14 @@
+/** paleoecology basis module — tsb analytics library. */
+export interface PaleoecologyBasisOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyBasisResult { values: number[]; converged: boolean; }
+export function computePaleoecologyBasis(data: number[], opts: PaleoecologyBasisOptions = {}): PaleoecologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyBasis };
diff --git a/src/paleoecology/benchmarking.ts b/src/paleoecology/benchmarking.ts
new file mode 100644
index 000000000..120b8d865
--- /dev/null
+++ b/src/paleoecology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** paleoecology benchmarking module — tsb analytics library. */
+export interface PaleoecologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyBenchmarking(data: number[], opts: PaleoecologyBenchmarkingOptions = {}): PaleoecologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyBenchmarking };
diff --git a/src/paleoecology/blending.ts b/src/paleoecology/blending.ts
new file mode 100644
index 000000000..03108e7a4
--- /dev/null
+++ b/src/paleoecology/blending.ts
@@ -0,0 +1,14 @@
+/** paleoecology blending module — tsb analytics library. */
+export interface PaleoecologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyBlendingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyBlending(data: number[], opts: PaleoecologyBlendingOptions = {}): PaleoecologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyBlending };
diff --git a/src/paleoecology/boosting.ts b/src/paleoecology/boosting.ts
new file mode 100644
index 000000000..c618fe38d
--- /dev/null
+++ b/src/paleoecology/boosting.ts
@@ -0,0 +1,14 @@
+/** paleoecology boosting module — tsb analytics library. */
+export interface PaleoecologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyBoostingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyBoosting(data: number[], opts: PaleoecologyBoostingOptions = {}): PaleoecologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyBoosting };
diff --git a/src/paleoecology/bootstrap.ts b/src/paleoecology/bootstrap.ts
new file mode 100644
index 000000000..915a33525
--- /dev/null
+++ b/src/paleoecology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** paleoecology bootstrap module — tsb analytics library. */
+export interface PaleoecologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyBootstrapResult { values: number[]; converged: boolean; }
+export function computePaleoecologyBootstrap(data: number[], opts: PaleoecologyBootstrapOptions = {}): PaleoecologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyBootstrap };
diff --git a/src/paleoecology/calculus.ts b/src/paleoecology/calculus.ts
new file mode 100644
index 000000000..ed8346aea
--- /dev/null
+++ b/src/paleoecology/calculus.ts
@@ -0,0 +1,14 @@
+/** paleoecology calculus module — tsb analytics library. */
+export interface PaleoecologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyCalculusResult { values: number[]; converged: boolean; }
+export function computePaleoecologyCalculus(data: number[], opts: PaleoecologyCalculusOptions = {}): PaleoecologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyCalculus };
diff --git a/src/paleoecology/calibration.ts b/src/paleoecology/calibration.ts
new file mode 100644
index 000000000..a3adbfd7c
--- /dev/null
+++ b/src/paleoecology/calibration.ts
@@ -0,0 +1,14 @@
+/** paleoecology calibration module — tsb analytics library. */
+export interface PaleoecologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyCalibrationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyCalibration(data: number[], opts: PaleoecologyCalibrationOptions = {}): PaleoecologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyCalibration };
diff --git a/src/paleoecology/characterization.ts b/src/paleoecology/characterization.ts
new file mode 100644
index 000000000..b23246db5
--- /dev/null
+++ b/src/paleoecology/characterization.ts
@@ -0,0 +1,14 @@
+/** paleoecology characterization module — tsb analytics library. */
+export interface PaleoecologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyCharacterization(data: number[], opts: PaleoecologyCharacterizationOptions = {}): PaleoecologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyCharacterization };
diff --git a/src/paleoecology/classification.ts b/src/paleoecology/classification.ts
new file mode 100644
index 000000000..ec25c806c
--- /dev/null
+++ b/src/paleoecology/classification.ts
@@ -0,0 +1,14 @@
+/** paleoecology classification module — tsb analytics library. */
+export interface PaleoecologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyClassificationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyClassification(data: number[], opts: PaleoecologyClassificationOptions = {}): PaleoecologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyClassification };
diff --git a/src/paleoecology/clustering.ts b/src/paleoecology/clustering.ts
new file mode 100644
index 000000000..8b73ddfed
--- /dev/null
+++ b/src/paleoecology/clustering.ts
@@ -0,0 +1,14 @@
+/** paleoecology clustering module — tsb analytics library. */
+export interface PaleoecologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyClusteringResult { values: number[]; converged: boolean; }
+export function computePaleoecologyClustering(data: number[], opts: PaleoecologyClusteringOptions = {}): PaleoecologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyClustering };
diff --git a/src/paleoecology/compression.ts b/src/paleoecology/compression.ts
new file mode 100644
index 000000000..72349245d
--- /dev/null
+++ b/src/paleoecology/compression.ts
@@ -0,0 +1,14 @@
+/** paleoecology compression module — tsb analytics library. */
+export interface PaleoecologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyCompressionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyCompression(data: number[], opts: PaleoecologyCompressionOptions = {}): PaleoecologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyCompression };
diff --git a/src/paleoecology/continuous.ts b/src/paleoecology/continuous.ts
new file mode 100644
index 000000000..6e9c445c3
--- /dev/null
+++ b/src/paleoecology/continuous.ts
@@ -0,0 +1,14 @@
+/** paleoecology continuous module — tsb analytics library. */
+export interface PaleoecologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyContinuousResult { values: number[]; converged: boolean; }
+export function computePaleoecologyContinuous(data: number[], opts: PaleoecologyContinuousOptions = {}): PaleoecologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyContinuous };
diff --git a/src/paleoecology/control.ts b/src/paleoecology/control.ts
new file mode 100644
index 000000000..370076171
--- /dev/null
+++ b/src/paleoecology/control.ts
@@ -0,0 +1,14 @@
+/** paleoecology control module — tsb analytics library. */
+export interface PaleoecologyControlOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyControlResult { values: number[]; converged: boolean; }
+export function computePaleoecologyControl(data: number[], opts: PaleoecologyControlOptions = {}): PaleoecologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyControl };
diff --git a/src/paleoecology/convergence.ts b/src/paleoecology/convergence.ts
new file mode 100644
index 000000000..97428fe59
--- /dev/null
+++ b/src/paleoecology/convergence.ts
@@ -0,0 +1,14 @@
+/** paleoecology convergence module — tsb analytics library. */
+export interface PaleoecologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyConvergenceResult { values: number[]; converged: boolean; }
+export function computePaleoecologyConvergence(data: number[], opts: PaleoecologyConvergenceOptions = {}): PaleoecologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyConvergence };
diff --git a/src/paleoecology/convex.ts b/src/paleoecology/convex.ts
new file mode 100644
index 000000000..7835810d9
--- /dev/null
+++ b/src/paleoecology/convex.ts
@@ -0,0 +1,14 @@
+/** paleoecology convex module — tsb analytics library. */
+export interface PaleoecologyConvexOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyConvexResult { values: number[]; converged: boolean; }
+export function computePaleoecologyConvex(data: number[], opts: PaleoecologyConvexOptions = {}): PaleoecologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyConvex };
diff --git a/src/paleoecology/correlation.ts b/src/paleoecology/correlation.ts
new file mode 100644
index 000000000..0c61c5409
--- /dev/null
+++ b/src/paleoecology/correlation.ts
@@ -0,0 +1,14 @@
+/** paleoecology correlation module — tsb analytics library. */
+export interface PaleoecologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyCorrelationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyCorrelation(data: number[], opts: PaleoecologyCorrelationOptions = {}): PaleoecologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyCorrelation };
diff --git a/src/paleoecology/covariance.ts b/src/paleoecology/covariance.ts
new file mode 100644
index 000000000..2e9165f69
--- /dev/null
+++ b/src/paleoecology/covariance.ts
@@ -0,0 +1,14 @@
+/** paleoecology covariance module — tsb analytics library. */
+export interface PaleoecologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyCovarianceResult { values: number[]; converged: boolean; }
+export function computePaleoecologyCovariance(data: number[], opts: PaleoecologyCovarianceOptions = {}): PaleoecologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyCovariance };
diff --git a/src/paleoecology/cross_validation.ts b/src/paleoecology/cross_validation.ts
new file mode 100644
index 000000000..eb5808bcd
--- /dev/null
+++ b/src/paleoecology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** paleoecology cross_validation module — tsb analytics library. */
+export interface PaleoecologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyCrossValidation(data: number[], opts: PaleoecologyCrossValidationOptions = {}): PaleoecologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyCrossValidation };
diff --git a/src/paleoecology/decoding.ts b/src/paleoecology/decoding.ts
new file mode 100644
index 000000000..daee9a4e1
--- /dev/null
+++ b/src/paleoecology/decoding.ts
@@ -0,0 +1,14 @@
+/** paleoecology decoding module — tsb analytics library. */
+export interface PaleoecologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDecodingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDecoding(data: number[], opts: PaleoecologyDecodingOptions = {}): PaleoecologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDecoding };
diff --git a/src/paleoecology/decomposition.ts b/src/paleoecology/decomposition.ts
new file mode 100644
index 000000000..5e5fa6e45
--- /dev/null
+++ b/src/paleoecology/decomposition.ts
@@ -0,0 +1,14 @@
+/** paleoecology decomposition module — tsb analytics library. */
+export interface PaleoecologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDecompositionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDecomposition(data: number[], opts: PaleoecologyDecompositionOptions = {}): PaleoecologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDecomposition };
diff --git a/src/paleoecology/detection.ts b/src/paleoecology/detection.ts
new file mode 100644
index 000000000..8beadfd1f
--- /dev/null
+++ b/src/paleoecology/detection.ts
@@ -0,0 +1,14 @@
+/** paleoecology detection module — tsb analytics library. */
+export interface PaleoecologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDetectionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDetection(data: number[], opts: PaleoecologyDetectionOptions = {}): PaleoecologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDetection };
diff --git a/src/paleoecology/deterministic.ts b/src/paleoecology/deterministic.ts
new file mode 100644
index 000000000..7b01e36e9
--- /dev/null
+++ b/src/paleoecology/deterministic.ts
@@ -0,0 +1,14 @@
+/** paleoecology deterministic module — tsb analytics library. */
+export interface PaleoecologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDeterministicResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDeterministic(data: number[], opts: PaleoecologyDeterministicOptions = {}): PaleoecologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDeterministic };
diff --git a/src/paleoecology/diagnostics.ts b/src/paleoecology/diagnostics.ts
new file mode 100644
index 000000000..3892d131a
--- /dev/null
+++ b/src/paleoecology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** paleoecology diagnostics module — tsb analytics library. */
+export interface PaleoecologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDiagnostics(data: number[], opts: PaleoecologyDiagnosticsOptions = {}): PaleoecologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDiagnostics };
diff --git a/src/paleoecology/differential.ts b/src/paleoecology/differential.ts
new file mode 100644
index 000000000..8e57aca8f
--- /dev/null
+++ b/src/paleoecology/differential.ts
@@ -0,0 +1,14 @@
+/** paleoecology differential module — tsb analytics library. */
+export interface PaleoecologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDifferentialResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDifferential(data: number[], opts: PaleoecologyDifferentialOptions = {}): PaleoecologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDifferential };
diff --git a/src/paleoecology/discrete.ts b/src/paleoecology/discrete.ts
new file mode 100644
index 000000000..a32dc92bb
--- /dev/null
+++ b/src/paleoecology/discrete.ts
@@ -0,0 +1,14 @@
+/** paleoecology discrete module — tsb analytics library. */
+export interface PaleoecologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDiscreteResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDiscrete(data: number[], opts: PaleoecologyDiscreteOptions = {}): PaleoecologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDiscrete };
diff --git a/src/paleoecology/distribution.ts b/src/paleoecology/distribution.ts
new file mode 100644
index 000000000..6cc2b75f3
--- /dev/null
+++ b/src/paleoecology/distribution.ts
@@ -0,0 +1,14 @@
+/** paleoecology distribution module — tsb analytics library. */
+export interface PaleoecologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDistributionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDistribution(data: number[], opts: PaleoecologyDistributionOptions = {}): PaleoecologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDistribution };
diff --git a/src/paleoecology/dynamic.ts b/src/paleoecology/dynamic.ts
new file mode 100644
index 000000000..24755e726
--- /dev/null
+++ b/src/paleoecology/dynamic.ts
@@ -0,0 +1,14 @@
+/** paleoecology dynamic module — tsb analytics library. */
+export interface PaleoecologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyDynamicResult { values: number[]; converged: boolean; }
+export function computePaleoecologyDynamic(data: number[], opts: PaleoecologyDynamicOptions = {}): PaleoecologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyDynamic };
diff --git a/src/paleoecology/embedding.ts b/src/paleoecology/embedding.ts
new file mode 100644
index 000000000..93f7d6309
--- /dev/null
+++ b/src/paleoecology/embedding.ts
@@ -0,0 +1,14 @@
+/** paleoecology embedding module — tsb analytics library. */
+export interface PaleoecologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyEmbedding(data: number[], opts: PaleoecologyEmbeddingOptions = {}): PaleoecologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyEmbedding };
diff --git a/src/paleoecology/encoding.ts b/src/paleoecology/encoding.ts
new file mode 100644
index 000000000..6c348b218
--- /dev/null
+++ b/src/paleoecology/encoding.ts
@@ -0,0 +1,14 @@
+/** paleoecology encoding module — tsb analytics library. */
+export interface PaleoecologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyEncodingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyEncoding(data: number[], opts: PaleoecologyEncodingOptions = {}): PaleoecologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyEncoding };
diff --git a/src/paleoecology/ensemble.ts b/src/paleoecology/ensemble.ts
new file mode 100644
index 000000000..75677369b
--- /dev/null
+++ b/src/paleoecology/ensemble.ts
@@ -0,0 +1,14 @@
+/** paleoecology ensemble module — tsb analytics library. */
+export interface PaleoecologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyEnsembleResult { values: number[]; converged: boolean; }
+export function computePaleoecologyEnsemble(data: number[], opts: PaleoecologyEnsembleOptions = {}): PaleoecologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyEnsemble };
diff --git a/src/paleoecology/estimation.ts b/src/paleoecology/estimation.ts
new file mode 100644
index 000000000..aa28b8838
--- /dev/null
+++ b/src/paleoecology/estimation.ts
@@ -0,0 +1,14 @@
+/** paleoecology estimation module — tsb analytics library. */
+export interface PaleoecologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyEstimationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyEstimation(data: number[], opts: PaleoecologyEstimationOptions = {}): PaleoecologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyEstimation };
diff --git a/src/paleoecology/evaluation.ts b/src/paleoecology/evaluation.ts
new file mode 100644
index 000000000..8a82e6e5d
--- /dev/null
+++ b/src/paleoecology/evaluation.ts
@@ -0,0 +1,14 @@
+/** paleoecology evaluation module — tsb analytics library. */
+export interface PaleoecologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyEvaluationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyEvaluation(data: number[], opts: PaleoecologyEvaluationOptions = {}): PaleoecologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyEvaluation };
diff --git a/src/paleoecology/extrapolation.ts b/src/paleoecology/extrapolation.ts
new file mode 100644
index 000000000..64317681f
--- /dev/null
+++ b/src/paleoecology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** paleoecology extrapolation module — tsb analytics library. */
+export interface PaleoecologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyExtrapolation(data: number[], opts: PaleoecologyExtrapolationOptions = {}): PaleoecologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyExtrapolation };
diff --git a/src/paleoecology/features.ts b/src/paleoecology/features.ts
new file mode 100644
index 000000000..b7996cd32
--- /dev/null
+++ b/src/paleoecology/features.ts
@@ -0,0 +1,14 @@
+/** paleoecology features module — tsb analytics library. */
+export interface PaleoecologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyFeaturesResult { values: number[]; converged: boolean; }
+export function computePaleoecologyFeatures(data: number[], opts: PaleoecologyFeaturesOptions = {}): PaleoecologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyFeatures };
diff --git a/src/paleoecology/feedback.ts b/src/paleoecology/feedback.ts
new file mode 100644
index 000000000..256e9a491
--- /dev/null
+++ b/src/paleoecology/feedback.ts
@@ -0,0 +1,14 @@
+/** paleoecology feedback module — tsb analytics library. */
+export interface PaleoecologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyFeedbackResult { values: number[]; converged: boolean; }
+export function computePaleoecologyFeedback(data: number[], opts: PaleoecologyFeedbackOptions = {}): PaleoecologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyFeedback };
diff --git a/src/paleoecology/filtering.ts b/src/paleoecology/filtering.ts
new file mode 100644
index 000000000..8c4853b52
--- /dev/null
+++ b/src/paleoecology/filtering.ts
@@ -0,0 +1,14 @@
+/** paleoecology filtering module — tsb analytics library. */
+export interface PaleoecologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyFilteringResult { values: number[]; converged: boolean; }
+export function computePaleoecologyFiltering(data: number[], opts: PaleoecologyFilteringOptions = {}): PaleoecologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyFiltering };
diff --git a/src/paleoecology/fourier.ts b/src/paleoecology/fourier.ts
new file mode 100644
index 000000000..5ce90f4f0
--- /dev/null
+++ b/src/paleoecology/fourier.ts
@@ -0,0 +1,14 @@
+/** paleoecology fourier module — tsb analytics library. */
+export interface PaleoecologyFourierOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyFourierResult { values: number[]; converged: boolean; }
+export function computePaleoecologyFourier(data: number[], opts: PaleoecologyFourierOptions = {}): PaleoecologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyFourier };
diff --git a/src/paleoecology/fusion.ts b/src/paleoecology/fusion.ts
new file mode 100644
index 000000000..f34d94714
--- /dev/null
+++ b/src/paleoecology/fusion.ts
@@ -0,0 +1,14 @@
+/** paleoecology fusion module — tsb analytics library. */
+export interface PaleoecologyFusionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyFusionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyFusion(data: number[], opts: PaleoecologyFusionOptions = {}): PaleoecologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyFusion };
diff --git a/src/paleoecology/generation.ts b/src/paleoecology/generation.ts
new file mode 100644
index 000000000..748ec2bb7
--- /dev/null
+++ b/src/paleoecology/generation.ts
@@ -0,0 +1,14 @@
+/** paleoecology generation module — tsb analytics library. */
+export interface PaleoecologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyGenerationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyGeneration(data: number[], opts: PaleoecologyGenerationOptions = {}): PaleoecologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyGeneration };
diff --git a/src/paleoecology/geometry.ts b/src/paleoecology/geometry.ts
new file mode 100644
index 000000000..024c2efad
--- /dev/null
+++ b/src/paleoecology/geometry.ts
@@ -0,0 +1,14 @@
+/** paleoecology geometry module — tsb analytics library. */
+export interface PaleoecologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyGeometryResult { values: number[]; converged: boolean; }
+export function computePaleoecologyGeometry(data: number[], opts: PaleoecologyGeometryOptions = {}): PaleoecologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyGeometry };
diff --git a/src/paleoecology/gradient.ts b/src/paleoecology/gradient.ts
new file mode 100644
index 000000000..938216728
--- /dev/null
+++ b/src/paleoecology/gradient.ts
@@ -0,0 +1,14 @@
+/** paleoecology gradient module — tsb analytics library. */
+export interface PaleoecologyGradientOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyGradientResult { values: number[]; converged: boolean; }
+export function computePaleoecologyGradient(data: number[], opts: PaleoecologyGradientOptions = {}): PaleoecologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyGradient };
diff --git a/src/paleoecology/hessian.ts b/src/paleoecology/hessian.ts
new file mode 100644
index 000000000..0b11bc3fb
--- /dev/null
+++ b/src/paleoecology/hessian.ts
@@ -0,0 +1,14 @@
+/** paleoecology hessian module — tsb analytics library. */
+export interface PaleoecologyHessianOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyHessianResult { values: number[]; converged: boolean; }
+export function computePaleoecologyHessian(data: number[], opts: PaleoecologyHessianOptions = {}): PaleoecologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyHessian };
diff --git a/src/paleoecology/hypothesis.ts b/src/paleoecology/hypothesis.ts
new file mode 100644
index 000000000..180415160
--- /dev/null
+++ b/src/paleoecology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** paleoecology hypothesis module — tsb analytics library. */
+export interface PaleoecologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyHypothesisResult { values: number[]; converged: boolean; }
+export function computePaleoecologyHypothesis(data: number[], opts: PaleoecologyHypothesisOptions = {}): PaleoecologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyHypothesis };
diff --git a/src/paleoecology/inference.ts b/src/paleoecology/inference.ts
new file mode 100644
index 000000000..ffd8353f6
--- /dev/null
+++ b/src/paleoecology/inference.ts
@@ -0,0 +1,14 @@
+/** paleoecology inference module — tsb analytics library. */
+export interface PaleoecologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyInferenceResult { values: number[]; converged: boolean; }
+export function computePaleoecologyInference(data: number[], opts: PaleoecologyInferenceOptions = {}): PaleoecologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyInference };
diff --git a/src/paleoecology/inference2.ts b/src/paleoecology/inference2.ts
new file mode 100644
index 000000000..4e15472b1
--- /dev/null
+++ b/src/paleoecology/inference2.ts
@@ -0,0 +1,14 @@
+/** paleoecology inference2 module — tsb analytics library. */
+export interface PaleoecologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyInferenceResult { values: number[]; converged: boolean; }
+export function computePaleoecologyInference(data: number[], opts: PaleoecologyInferenceOptions = {}): PaleoecologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyInference };
diff --git a/src/paleoecology/integral.ts b/src/paleoecology/integral.ts
new file mode 100644
index 000000000..de2176240
--- /dev/null
+++ b/src/paleoecology/integral.ts
@@ -0,0 +1,14 @@
+/** paleoecology integral module — tsb analytics library. */
+export interface PaleoecologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyIntegralResult { values: number[]; converged: boolean; }
+export function computePaleoecologyIntegral(data: number[], opts: PaleoecologyIntegralOptions = {}): PaleoecologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyIntegral };
diff --git a/src/paleoecology/integration.ts b/src/paleoecology/integration.ts
new file mode 100644
index 000000000..091d5ffaf
--- /dev/null
+++ b/src/paleoecology/integration.ts
@@ -0,0 +1,14 @@
+/** paleoecology integration module — tsb analytics library. */
+export interface PaleoecologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyIntegrationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyIntegration(data: number[], opts: PaleoecologyIntegrationOptions = {}): PaleoecologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyIntegration };
diff --git a/src/paleoecology/interpolation.ts b/src/paleoecology/interpolation.ts
new file mode 100644
index 000000000..a9e5e5eb6
--- /dev/null
+++ b/src/paleoecology/interpolation.ts
@@ -0,0 +1,14 @@
+/** paleoecology interpolation module — tsb analytics library. */
+export interface PaleoecologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyInterpolationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyInterpolation(data: number[], opts: PaleoecologyInterpolationOptions = {}): PaleoecologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyInterpolation };
diff --git a/src/paleoecology/jacobian.ts b/src/paleoecology/jacobian.ts
new file mode 100644
index 000000000..1b289ea80
--- /dev/null
+++ b/src/paleoecology/jacobian.ts
@@ -0,0 +1,14 @@
+/** paleoecology jacobian module — tsb analytics library. */
+export interface PaleoecologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyJacobianResult { values: number[]; converged: boolean; }
+export function computePaleoecologyJacobian(data: number[], opts: PaleoecologyJacobianOptions = {}): PaleoecologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyJacobian };
diff --git a/src/paleoecology/kernel.ts b/src/paleoecology/kernel.ts
new file mode 100644
index 000000000..f872a3452
--- /dev/null
+++ b/src/paleoecology/kernel.ts
@@ -0,0 +1,14 @@
+/** paleoecology kernel module — tsb analytics library. */
+export interface PaleoecologyKernelOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyKernelResult { values: number[]; converged: boolean; }
+export function computePaleoecologyKernel(data: number[], opts: PaleoecologyKernelOptions = {}): PaleoecologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyKernel };
diff --git a/src/paleoecology/laplacian.ts b/src/paleoecology/laplacian.ts
new file mode 100644
index 000000000..0f14552c6
--- /dev/null
+++ b/src/paleoecology/laplacian.ts
@@ -0,0 +1,14 @@
+/** paleoecology laplacian module — tsb analytics library. */
+export interface PaleoecologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyLaplacianResult { values: number[]; converged: boolean; }
+export function computePaleoecologyLaplacian(data: number[], opts: PaleoecologyLaplacianOptions = {}): PaleoecologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyLaplacian };
diff --git a/src/paleoecology/learning.ts b/src/paleoecology/learning.ts
new file mode 100644
index 000000000..7b13cc758
--- /dev/null
+++ b/src/paleoecology/learning.ts
@@ -0,0 +1,14 @@
+/** paleoecology learning module — tsb analytics library. */
+export interface PaleoecologyLearningOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyLearningResult { values: number[]; converged: boolean; }
+export function computePaleoecologyLearning(data: number[], opts: PaleoecologyLearningOptions = {}): PaleoecologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyLearning };
diff --git a/src/paleoecology/linear.ts b/src/paleoecology/linear.ts
new file mode 100644
index 000000000..b26f8ad1d
--- /dev/null
+++ b/src/paleoecology/linear.ts
@@ -0,0 +1,14 @@
+/** paleoecology linear module — tsb analytics library. */
+export interface PaleoecologyLinearOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyLinearResult { values: number[]; converged: boolean; }
+export function computePaleoecologyLinear(data: number[], opts: PaleoecologyLinearOptions = {}): PaleoecologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyLinear };
diff --git a/src/paleoecology/manifold.ts b/src/paleoecology/manifold.ts
new file mode 100644
index 000000000..fb306caee
--- /dev/null
+++ b/src/paleoecology/manifold.ts
@@ -0,0 +1,14 @@
+/** paleoecology manifold module — tsb analytics library. */
+export interface PaleoecologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyManifoldResult { values: number[]; converged: boolean; }
+export function computePaleoecologyManifold(data: number[], opts: PaleoecologyManifoldOptions = {}): PaleoecologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyManifold };
diff --git a/src/paleoecology/matching.ts b/src/paleoecology/matching.ts
new file mode 100644
index 000000000..fa9efb173
--- /dev/null
+++ b/src/paleoecology/matching.ts
@@ -0,0 +1,14 @@
+/** paleoecology matching module — tsb analytics library. */
+export interface PaleoecologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyMatchingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyMatching(data: number[], opts: PaleoecologyMatchingOptions = {}): PaleoecologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyMatching };
diff --git a/src/paleoecology/measurement.ts b/src/paleoecology/measurement.ts
new file mode 100644
index 000000000..2a7edc0e5
--- /dev/null
+++ b/src/paleoecology/measurement.ts
@@ -0,0 +1,14 @@
+/** paleoecology measurement module — tsb analytics library. */
+export interface PaleoecologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyMeasurementResult { values: number[]; converged: boolean; }
+export function computePaleoecologyMeasurement(data: number[], opts: PaleoecologyMeasurementOptions = {}): PaleoecologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyMeasurement };
diff --git a/src/paleoecology/metrics.ts b/src/paleoecology/metrics.ts
new file mode 100644
index 000000000..6717afdeb
--- /dev/null
+++ b/src/paleoecology/metrics.ts
@@ -0,0 +1,14 @@
+/** paleoecology metrics module — tsb analytics library. */
+export interface PaleoecologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyMetricsResult { values: number[]; converged: boolean; }
+export function computePaleoecologyMetrics(data: number[], opts: PaleoecologyMetricsOptions = {}): PaleoecologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyMetrics };
diff --git a/src/paleoecology/modeling.ts b/src/paleoecology/modeling.ts
new file mode 100644
index 000000000..f4b5cdd9a
--- /dev/null
+++ b/src/paleoecology/modeling.ts
@@ -0,0 +1,14 @@
+/** paleoecology modeling module — tsb analytics library. */
+export interface PaleoecologyModelingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyModelingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyModeling(data: number[], opts: PaleoecologyModelingOptions = {}): PaleoecologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyModeling };
diff --git a/src/paleoecology/monitoring.ts b/src/paleoecology/monitoring.ts
new file mode 100644
index 000000000..f86589662
--- /dev/null
+++ b/src/paleoecology/monitoring.ts
@@ -0,0 +1,14 @@
+/** paleoecology monitoring module — tsb analytics library. */
+export interface PaleoecologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyMonitoringResult { values: number[]; converged: boolean; }
+export function computePaleoecologyMonitoring(data: number[], opts: PaleoecologyMonitoringOptions = {}): PaleoecologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyMonitoring };
diff --git a/src/paleoecology/nonlinear.ts b/src/paleoecology/nonlinear.ts
new file mode 100644
index 000000000..e38a0b0cf
--- /dev/null
+++ b/src/paleoecology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** paleoecology nonlinear module — tsb analytics library. */
+export interface PaleoecologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyNonlinearResult { values: number[]; converged: boolean; }
+export function computePaleoecologyNonlinear(data: number[], opts: PaleoecologyNonlinearOptions = {}): PaleoecologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyNonlinear };
diff --git a/src/paleoecology/normalization.ts b/src/paleoecology/normalization.ts
new file mode 100644
index 000000000..97327a535
--- /dev/null
+++ b/src/paleoecology/normalization.ts
@@ -0,0 +1,14 @@
+/** paleoecology normalization module — tsb analytics library. */
+export interface PaleoecologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyNormalizationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyNormalization(data: number[], opts: PaleoecologyNormalizationOptions = {}): PaleoecologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyNormalization };
diff --git a/src/paleoecology/optimization.ts b/src/paleoecology/optimization.ts
new file mode 100644
index 000000000..ca7e9ea45
--- /dev/null
+++ b/src/paleoecology/optimization.ts
@@ -0,0 +1,14 @@
+/** paleoecology optimization module — tsb analytics library. */
+export interface PaleoecologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyOptimizationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyOptimization(data: number[], opts: PaleoecologyOptimizationOptions = {}): PaleoecologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyOptimization };
diff --git a/src/paleoecology/patterns.ts b/src/paleoecology/patterns.ts
new file mode 100644
index 000000000..16f7ae6c8
--- /dev/null
+++ b/src/paleoecology/patterns.ts
@@ -0,0 +1,14 @@
+/** paleoecology patterns module — tsb analytics library. */
+export interface PaleoecologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyPatternsResult { values: number[]; converged: boolean; }
+export function computePaleoecologyPatterns(data: number[], opts: PaleoecologyPatternsOptions = {}): PaleoecologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyPatterns };
diff --git a/src/paleoecology/permutation.ts b/src/paleoecology/permutation.ts
new file mode 100644
index 000000000..e28223074
--- /dev/null
+++ b/src/paleoecology/permutation.ts
@@ -0,0 +1,14 @@
+/** paleoecology permutation module — tsb analytics library. */
+export interface PaleoecologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyPermutationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyPermutation(data: number[], opts: PaleoecologyPermutationOptions = {}): PaleoecologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyPermutation };
diff --git a/src/paleoecology/prediction.ts b/src/paleoecology/prediction.ts
new file mode 100644
index 000000000..c1c96b233
--- /dev/null
+++ b/src/paleoecology/prediction.ts
@@ -0,0 +1,14 @@
+/** paleoecology prediction module — tsb analytics library. */
+export interface PaleoecologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyPredictionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyPrediction(data: number[], opts: PaleoecologyPredictionOptions = {}): PaleoecologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyPrediction };
diff --git a/src/paleoecology/processing.ts b/src/paleoecology/processing.ts
new file mode 100644
index 000000000..ff4996a4a
--- /dev/null
+++ b/src/paleoecology/processing.ts
@@ -0,0 +1,14 @@
+/** paleoecology processing module — tsb analytics library. */
+export interface PaleoecologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyProcessingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyProcessing(data: number[], opts: PaleoecologyProcessingOptions = {}): PaleoecologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyProcessing };
diff --git a/src/paleoecology/profiling.ts b/src/paleoecology/profiling.ts
new file mode 100644
index 000000000..a28ad942a
--- /dev/null
+++ b/src/paleoecology/profiling.ts
@@ -0,0 +1,14 @@
+/** paleoecology profiling module — tsb analytics library. */
+export interface PaleoecologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyProfilingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyProfiling(data: number[], opts: PaleoecologyProfilingOptions = {}): PaleoecologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyProfiling };
diff --git a/src/paleoecology/projection.ts b/src/paleoecology/projection.ts
new file mode 100644
index 000000000..d2422c7f4
--- /dev/null
+++ b/src/paleoecology/projection.ts
@@ -0,0 +1,14 @@
+/** paleoecology projection module — tsb analytics library. */
+export interface PaleoecologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyProjectionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyProjection(data: number[], opts: PaleoecologyProjectionOptions = {}): PaleoecologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyProjection };
diff --git a/src/paleoecology/ranking.ts b/src/paleoecology/ranking.ts
new file mode 100644
index 000000000..f397d11a7
--- /dev/null
+++ b/src/paleoecology/ranking.ts
@@ -0,0 +1,14 @@
+/** paleoecology ranking module — tsb analytics library. */
+export interface PaleoecologyRankingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyRankingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyRanking(data: number[], opts: PaleoecologyRankingOptions = {}): PaleoecologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyRanking };
diff --git a/src/paleoecology/reconstruction.ts b/src/paleoecology/reconstruction.ts
new file mode 100644
index 000000000..72cc5366b
--- /dev/null
+++ b/src/paleoecology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** paleoecology reconstruction module — tsb analytics library. */
+export interface PaleoecologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyReconstructionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyReconstruction(data: number[], opts: PaleoecologyReconstructionOptions = {}): PaleoecologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyReconstruction };
diff --git a/src/paleoecology/registration.ts b/src/paleoecology/registration.ts
new file mode 100644
index 000000000..5df64bf4e
--- /dev/null
+++ b/src/paleoecology/registration.ts
@@ -0,0 +1,14 @@
+/** paleoecology registration module — tsb analytics library. */
+export interface PaleoecologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyRegistrationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyRegistration(data: number[], opts: PaleoecologyRegistrationOptions = {}): PaleoecologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyRegistration };
diff --git a/src/paleoecology/regression.ts b/src/paleoecology/regression.ts
new file mode 100644
index 000000000..efee2ddb5
--- /dev/null
+++ b/src/paleoecology/regression.ts
@@ -0,0 +1,14 @@
+/** paleoecology regression module — tsb analytics library. */
+export interface PaleoecologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyRegressionResult { values: number[]; converged: boolean; }
+export function computePaleoecologyRegression(data: number[], opts: PaleoecologyRegressionOptions = {}): PaleoecologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyRegression };
diff --git a/src/paleoecology/regularization.ts b/src/paleoecology/regularization.ts
new file mode 100644
index 000000000..7f5addf94
--- /dev/null
+++ b/src/paleoecology/regularization.ts
@@ -0,0 +1,14 @@
+/** paleoecology regularization module — tsb analytics library. */
+export interface PaleoecologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyRegularizationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyRegularization(data: number[], opts: PaleoecologyRegularizationOptions = {}): PaleoecologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyRegularization };
diff --git a/src/paleoecology/robustness.ts b/src/paleoecology/robustness.ts
new file mode 100644
index 000000000..dca19a668
--- /dev/null
+++ b/src/paleoecology/robustness.ts
@@ -0,0 +1,14 @@
+/** paleoecology robustness module — tsb analytics library. */
+export interface PaleoecologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyRobustnessResult { values: number[]; converged: boolean; }
+export function computePaleoecologyRobustness(data: number[], opts: PaleoecologyRobustnessOptions = {}): PaleoecologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyRobustness };
diff --git a/src/paleoecology/sampling.ts b/src/paleoecology/sampling.ts
new file mode 100644
index 000000000..18b57a35f
--- /dev/null
+++ b/src/paleoecology/sampling.ts
@@ -0,0 +1,14 @@
+/** paleoecology sampling module — tsb analytics library. */
+export interface PaleoecologySamplingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologySamplingResult { values: number[]; converged: boolean; }
+export function computePaleoecologySampling(data: number[], opts: PaleoecologySamplingOptions = {}): PaleoecologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologySampling };
diff --git a/src/paleoecology/sampling2.ts b/src/paleoecology/sampling2.ts
new file mode 100644
index 000000000..9248c69f5
--- /dev/null
+++ b/src/paleoecology/sampling2.ts
@@ -0,0 +1,14 @@
+/** paleoecology sampling2 module — tsb analytics library. */
+export interface PaleoecologySamplingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologySamplingResult { values: number[]; converged: boolean; }
+export function computePaleoecologySampling(data: number[], opts: PaleoecologySamplingOptions = {}): PaleoecologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologySampling };
diff --git a/src/paleoecology/scaling.ts b/src/paleoecology/scaling.ts
new file mode 100644
index 000000000..c15a5273b
--- /dev/null
+++ b/src/paleoecology/scaling.ts
@@ -0,0 +1,14 @@
+/** paleoecology scaling module — tsb analytics library. */
+export interface PaleoecologyScalingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyScalingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyScaling(data: number[], opts: PaleoecologyScalingOptions = {}): PaleoecologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyScaling };
diff --git a/src/paleoecology/scoring.ts b/src/paleoecology/scoring.ts
new file mode 100644
index 000000000..6d6ca828b
--- /dev/null
+++ b/src/paleoecology/scoring.ts
@@ -0,0 +1,14 @@
+/** paleoecology scoring module — tsb analytics library. */
+export interface PaleoecologyScoringOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyScoringResult { values: number[]; converged: boolean; }
+export function computePaleoecologyScoring(data: number[], opts: PaleoecologyScoringOptions = {}): PaleoecologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyScoring };
diff --git a/src/paleoecology/segmentation.ts b/src/paleoecology/segmentation.ts
new file mode 100644
index 000000000..059e22394
--- /dev/null
+++ b/src/paleoecology/segmentation.ts
@@ -0,0 +1,14 @@
+/** paleoecology segmentation module — tsb analytics library. */
+export interface PaleoecologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologySegmentationResult { values: number[]; converged: boolean; }
+export function computePaleoecologySegmentation(data: number[], opts: PaleoecologySegmentationOptions = {}): PaleoecologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologySegmentation };
diff --git a/src/paleoecology/selection.ts b/src/paleoecology/selection.ts
new file mode 100644
index 000000000..2d1c7b087
--- /dev/null
+++ b/src/paleoecology/selection.ts
@@ -0,0 +1,14 @@
+/** paleoecology selection module — tsb analytics library. */
+export interface PaleoecologySelectionOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologySelectionResult { values: number[]; converged: boolean; }
+export function computePaleoecologySelection(data: number[], opts: PaleoecologySelectionOptions = {}): PaleoecologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologySelection };
diff --git a/src/paleoecology/sensitivity.ts b/src/paleoecology/sensitivity.ts
new file mode 100644
index 000000000..d56c47751
--- /dev/null
+++ b/src/paleoecology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** paleoecology sensitivity module — tsb analytics library. */
+export interface PaleoecologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologySensitivityResult { values: number[]; converged: boolean; }
+export function computePaleoecologySensitivity(data: number[], opts: PaleoecologySensitivityOptions = {}): PaleoecologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologySensitivity };
diff --git a/src/paleoecology/simulation.ts b/src/paleoecology/simulation.ts
new file mode 100644
index 000000000..e10ef2150
--- /dev/null
+++ b/src/paleoecology/simulation.ts
@@ -0,0 +1,14 @@
+/** paleoecology simulation module — tsb analytics library. */
+export interface PaleoecologySimulationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologySimulationResult { values: number[]; converged: boolean; }
+export function computePaleoecologySimulation(data: number[], opts: PaleoecologySimulationOptions = {}): PaleoecologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologySimulation };
diff --git a/src/paleoecology/smoothing.ts b/src/paleoecology/smoothing.ts
new file mode 100644
index 000000000..6994fac1e
--- /dev/null
+++ b/src/paleoecology/smoothing.ts
@@ -0,0 +1,14 @@
+/** paleoecology smoothing module — tsb analytics library. */
+export interface PaleoecologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologySmoothingResult { values: number[]; converged: boolean; }
+export function computePaleoecologySmoothing(data: number[], opts: PaleoecologySmoothingOptions = {}): PaleoecologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologySmoothing };
diff --git a/src/paleoecology/stability.ts b/src/paleoecology/stability.ts
new file mode 100644
index 000000000..7161fdaa3
--- /dev/null
+++ b/src/paleoecology/stability.ts
@@ -0,0 +1,14 @@
+/** paleoecology stability module — tsb analytics library. */
+export interface PaleoecologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyStabilityResult { values: number[]; converged: boolean; }
+export function computePaleoecologyStability(data: number[], opts: PaleoecologyStabilityOptions = {}): PaleoecologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyStability };
diff --git a/src/paleoecology/stacking.ts b/src/paleoecology/stacking.ts
new file mode 100644
index 000000000..a3d842a8a
--- /dev/null
+++ b/src/paleoecology/stacking.ts
@@ -0,0 +1,14 @@
+/** paleoecology stacking module — tsb analytics library. */
+export interface PaleoecologyStackingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyStackingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyStacking(data: number[], opts: PaleoecologyStackingOptions = {}): PaleoecologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyStacking };
diff --git a/src/paleoecology/standardization.ts b/src/paleoecology/standardization.ts
new file mode 100644
index 000000000..7df8227f9
--- /dev/null
+++ b/src/paleoecology/standardization.ts
@@ -0,0 +1,14 @@
+/** paleoecology standardization module — tsb analytics library. */
+export interface PaleoecologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyStandardizationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyStandardization(data: number[], opts: PaleoecologyStandardizationOptions = {}): PaleoecologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyStandardization };
diff --git a/src/paleoecology/static.ts b/src/paleoecology/static.ts
new file mode 100644
index 000000000..bab6e27b0
--- /dev/null
+++ b/src/paleoecology/static.ts
@@ -0,0 +1,14 @@
+/** paleoecology static module — tsb analytics library. */
+export interface PaleoecologyStaticOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyStaticResult { values: number[]; converged: boolean; }
+export function computePaleoecologyStatic(data: number[], opts: PaleoecologyStaticOptions = {}): PaleoecologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyStatic };
diff --git a/src/paleoecology/stochastic.ts b/src/paleoecology/stochastic.ts
new file mode 100644
index 000000000..6e1e287e8
--- /dev/null
+++ b/src/paleoecology/stochastic.ts
@@ -0,0 +1,14 @@
+/** paleoecology stochastic module — tsb analytics library. */
+export interface PaleoecologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyStochasticResult { values: number[]; converged: boolean; }
+export function computePaleoecologyStochastic(data: number[], opts: PaleoecologyStochasticOptions = {}): PaleoecologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyStochastic };
diff --git a/src/paleoecology/synthesis.ts b/src/paleoecology/synthesis.ts
new file mode 100644
index 000000000..eaa101f21
--- /dev/null
+++ b/src/paleoecology/synthesis.ts
@@ -0,0 +1,14 @@
+/** paleoecology synthesis module — tsb analytics library. */
+export interface PaleoecologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologySynthesisResult { values: number[]; converged: boolean; }
+export function computePaleoecologySynthesis(data: number[], opts: PaleoecologySynthesisOptions = {}): PaleoecologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologySynthesis };
diff --git a/src/paleoecology/topology.ts b/src/paleoecology/topology.ts
new file mode 100644
index 000000000..3872ad61b
--- /dev/null
+++ b/src/paleoecology/topology.ts
@@ -0,0 +1,14 @@
+/** paleoecology topology module — tsb analytics library. */
+export interface PaleoecologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyTopologyResult { values: number[]; converged: boolean; }
+export function computePaleoecologyTopology(data: number[], opts: PaleoecologyTopologyOptions = {}): PaleoecologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyTopology };
diff --git a/src/paleoecology/tracking.ts b/src/paleoecology/tracking.ts
new file mode 100644
index 000000000..d30e9dc29
--- /dev/null
+++ b/src/paleoecology/tracking.ts
@@ -0,0 +1,14 @@
+/** paleoecology tracking module — tsb analytics library. */
+export interface PaleoecologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyTrackingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyTracking(data: number[], opts: PaleoecologyTrackingOptions = {}): PaleoecologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyTracking };
diff --git a/src/paleoecology/transform.ts b/src/paleoecology/transform.ts
new file mode 100644
index 000000000..f8d1c0b7a
--- /dev/null
+++ b/src/paleoecology/transform.ts
@@ -0,0 +1,14 @@
+/** paleoecology transform module — tsb analytics library. */
+export interface PaleoecologyTransformOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyTransformResult { values: number[]; converged: boolean; }
+export function computePaleoecologyTransform(data: number[], opts: PaleoecologyTransformOptions = {}): PaleoecologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyTransform };
diff --git a/src/paleoecology/uncertainty.ts b/src/paleoecology/uncertainty.ts
new file mode 100644
index 000000000..ddd3cf043
--- /dev/null
+++ b/src/paleoecology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** paleoecology uncertainty module — tsb analytics library. */
+export interface PaleoecologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computePaleoecologyUncertainty(data: number[], opts: PaleoecologyUncertaintyOptions = {}): PaleoecologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyUncertainty };
diff --git a/src/paleoecology/validation.ts b/src/paleoecology/validation.ts
new file mode 100644
index 000000000..6058e1bdb
--- /dev/null
+++ b/src/paleoecology/validation.ts
@@ -0,0 +1,14 @@
+/** paleoecology validation module — tsb analytics library. */
+export interface PaleoecologyValidationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyValidationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyValidation(data: number[], opts: PaleoecologyValidationOptions = {}): PaleoecologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyValidation };
diff --git a/src/paleoecology/verification.ts b/src/paleoecology/verification.ts
new file mode 100644
index 000000000..b450637e1
--- /dev/null
+++ b/src/paleoecology/verification.ts
@@ -0,0 +1,14 @@
+/** paleoecology verification module — tsb analytics library. */
+export interface PaleoecologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyVerificationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyVerification(data: number[], opts: PaleoecologyVerificationOptions = {}): PaleoecologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyVerification };
diff --git a/src/paleoecology/visualization.ts b/src/paleoecology/visualization.ts
new file mode 100644
index 000000000..5228e8fb5
--- /dev/null
+++ b/src/paleoecology/visualization.ts
@@ -0,0 +1,14 @@
+/** paleoecology visualization module — tsb analytics library. */
+export interface PaleoecologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyVisualizationResult { values: number[]; converged: boolean; }
+export function computePaleoecologyVisualization(data: number[], opts: PaleoecologyVisualizationOptions = {}): PaleoecologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyVisualization };
diff --git a/src/paleoecology/voting.ts b/src/paleoecology/voting.ts
new file mode 100644
index 000000000..5262e1066
--- /dev/null
+++ b/src/paleoecology/voting.ts
@@ -0,0 +1,14 @@
+/** paleoecology voting module — tsb analytics library. */
+export interface PaleoecologyVotingOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyVotingResult { values: number[]; converged: boolean; }
+export function computePaleoecologyVoting(data: number[], opts: PaleoecologyVotingOptions = {}): PaleoecologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyVoting };
diff --git a/src/paleoecology/wavelet.ts b/src/paleoecology/wavelet.ts
new file mode 100644
index 000000000..1a581dff9
--- /dev/null
+++ b/src/paleoecology/wavelet.ts
@@ -0,0 +1,14 @@
+/** paleoecology wavelet module — tsb analytics library. */
+export interface PaleoecologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface PaleoecologyWaveletResult { values: number[]; converged: boolean; }
+export function computePaleoecologyWavelet(data: number[], opts: PaleoecologyWaveletOptions = {}): PaleoecologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleoecologyWavelet };
diff --git a/src/paleontology/adaptation.ts b/src/paleontology/adaptation.ts
new file mode 100644
index 000000000..468aced08
--- /dev/null
+++ b/src/paleontology/adaptation.ts
@@ -0,0 +1,14 @@
+/** paleontology adaptation module — tsb analytics library. */
+export interface PaleontologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyAdaptationResult { values: number[]; converged: boolean; }
+export function computePaleontologyAdaptation(data: number[], opts: PaleontologyAdaptationOptions = {}): PaleontologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyAdaptation };
diff --git a/src/paleontology/aggregation.ts b/src/paleontology/aggregation.ts
new file mode 100644
index 000000000..20cfe79ad
--- /dev/null
+++ b/src/paleontology/aggregation.ts
@@ -0,0 +1,14 @@
+/** paleontology aggregation module — tsb analytics library. */
+export interface PaleontologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyAggregationResult { values: number[]; converged: boolean; }
+export function computePaleontologyAggregation(data: number[], opts: PaleontologyAggregationOptions = {}): PaleontologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyAggregation };
diff --git a/src/paleontology/algebra.ts b/src/paleontology/algebra.ts
new file mode 100644
index 000000000..e4db354bd
--- /dev/null
+++ b/src/paleontology/algebra.ts
@@ -0,0 +1,14 @@
+/** paleontology algebra module — tsb analytics library. */
+export interface PaleontologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyAlgebraResult { values: number[]; converged: boolean; }
+export function computePaleontologyAlgebra(data: number[], opts: PaleontologyAlgebraOptions = {}): PaleontologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyAlgebra };
diff --git a/src/paleontology/alignment.ts b/src/paleontology/alignment.ts
new file mode 100644
index 000000000..9f0d6dada
--- /dev/null
+++ b/src/paleontology/alignment.ts
@@ -0,0 +1,14 @@
+/** paleontology alignment module — tsb analytics library. */
+export interface PaleontologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyAlignmentResult { values: number[]; converged: boolean; }
+export function computePaleontologyAlignment(data: number[], opts: PaleontologyAlignmentOptions = {}): PaleontologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyAlignment };
diff --git a/src/paleontology/analysis.ts b/src/paleontology/analysis.ts
new file mode 100644
index 000000000..0f25c301a
--- /dev/null
+++ b/src/paleontology/analysis.ts
@@ -0,0 +1,14 @@
+/** paleontology analysis module — tsb analytics library. */
+export interface PaleontologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyAnalysisResult { values: number[]; converged: boolean; }
+export function computePaleontologyAnalysis(data: number[], opts: PaleontologyAnalysisOptions = {}): PaleontologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyAnalysis };
diff --git a/src/paleontology/augmentation.ts b/src/paleontology/augmentation.ts
new file mode 100644
index 000000000..c2eff4050
--- /dev/null
+++ b/src/paleontology/augmentation.ts
@@ -0,0 +1,14 @@
+/** paleontology augmentation module — tsb analytics library. */
+export interface PaleontologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyAugmentationResult { values: number[]; converged: boolean; }
+export function computePaleontologyAugmentation(data: number[], opts: PaleontologyAugmentationOptions = {}): PaleontologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyAugmentation };
diff --git a/src/paleontology/bagging.ts b/src/paleontology/bagging.ts
new file mode 100644
index 000000000..b3adce539
--- /dev/null
+++ b/src/paleontology/bagging.ts
@@ -0,0 +1,14 @@
+/** paleontology bagging module — tsb analytics library. */
+export interface PaleontologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyBaggingResult { values: number[]; converged: boolean; }
+export function computePaleontologyBagging(data: number[], opts: PaleontologyBaggingOptions = {}): PaleontologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyBagging };
diff --git a/src/paleontology/basis.ts b/src/paleontology/basis.ts
new file mode 100644
index 000000000..5736cc3e2
--- /dev/null
+++ b/src/paleontology/basis.ts
@@ -0,0 +1,14 @@
+/** paleontology basis module — tsb analytics library. */
+export interface PaleontologyBasisOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyBasisResult { values: number[]; converged: boolean; }
+export function computePaleontologyBasis(data: number[], opts: PaleontologyBasisOptions = {}): PaleontologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyBasis };
diff --git a/src/paleontology/benchmarking.ts b/src/paleontology/benchmarking.ts
new file mode 100644
index 000000000..6c1ee54c4
--- /dev/null
+++ b/src/paleontology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** paleontology benchmarking module — tsb analytics library. */
+export interface PaleontologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePaleontologyBenchmarking(data: number[], opts: PaleontologyBenchmarkingOptions = {}): PaleontologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyBenchmarking };
diff --git a/src/paleontology/blending.ts b/src/paleontology/blending.ts
new file mode 100644
index 000000000..2b5542637
--- /dev/null
+++ b/src/paleontology/blending.ts
@@ -0,0 +1,14 @@
+/** paleontology blending module — tsb analytics library. */
+export interface PaleontologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyBlendingResult { values: number[]; converged: boolean; }
+export function computePaleontologyBlending(data: number[], opts: PaleontologyBlendingOptions = {}): PaleontologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyBlending };
diff --git a/src/paleontology/boosting.ts b/src/paleontology/boosting.ts
new file mode 100644
index 000000000..ca656f915
--- /dev/null
+++ b/src/paleontology/boosting.ts
@@ -0,0 +1,14 @@
+/** paleontology boosting module — tsb analytics library. */
+export interface PaleontologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyBoostingResult { values: number[]; converged: boolean; }
+export function computePaleontologyBoosting(data: number[], opts: PaleontologyBoostingOptions = {}): PaleontologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyBoosting };
diff --git a/src/paleontology/bootstrap.ts b/src/paleontology/bootstrap.ts
new file mode 100644
index 000000000..d9c76136f
--- /dev/null
+++ b/src/paleontology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** paleontology bootstrap module — tsb analytics library. */
+export interface PaleontologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyBootstrapResult { values: number[]; converged: boolean; }
+export function computePaleontologyBootstrap(data: number[], opts: PaleontologyBootstrapOptions = {}): PaleontologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyBootstrap };
diff --git a/src/paleontology/calculus.ts b/src/paleontology/calculus.ts
new file mode 100644
index 000000000..b42ef7f55
--- /dev/null
+++ b/src/paleontology/calculus.ts
@@ -0,0 +1,14 @@
+/** paleontology calculus module — tsb analytics library. */
+export interface PaleontologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyCalculusResult { values: number[]; converged: boolean; }
+export function computePaleontologyCalculus(data: number[], opts: PaleontologyCalculusOptions = {}): PaleontologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyCalculus };
diff --git a/src/paleontology/calibration.ts b/src/paleontology/calibration.ts
new file mode 100644
index 000000000..792eb06b5
--- /dev/null
+++ b/src/paleontology/calibration.ts
@@ -0,0 +1,14 @@
+/** paleontology calibration module — tsb analytics library. */
+export interface PaleontologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyCalibrationResult { values: number[]; converged: boolean; }
+export function computePaleontologyCalibration(data: number[], opts: PaleontologyCalibrationOptions = {}): PaleontologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyCalibration };
diff --git a/src/paleontology/characterization.ts b/src/paleontology/characterization.ts
new file mode 100644
index 000000000..e4ed527b7
--- /dev/null
+++ b/src/paleontology/characterization.ts
@@ -0,0 +1,14 @@
+/** paleontology characterization module — tsb analytics library. */
+export interface PaleontologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computePaleontologyCharacterization(data: number[], opts: PaleontologyCharacterizationOptions = {}): PaleontologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyCharacterization };
diff --git a/src/paleontology/classification.ts b/src/paleontology/classification.ts
new file mode 100644
index 000000000..68d539a06
--- /dev/null
+++ b/src/paleontology/classification.ts
@@ -0,0 +1,14 @@
+/** paleontology classification module — tsb analytics library. */
+export interface PaleontologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyClassificationResult { values: number[]; converged: boolean; }
+export function computePaleontologyClassification(data: number[], opts: PaleontologyClassificationOptions = {}): PaleontologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyClassification };
diff --git a/src/paleontology/clustering.ts b/src/paleontology/clustering.ts
new file mode 100644
index 000000000..6ead1b193
--- /dev/null
+++ b/src/paleontology/clustering.ts
@@ -0,0 +1,14 @@
+/** paleontology clustering module — tsb analytics library. */
+export interface PaleontologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyClusteringResult { values: number[]; converged: boolean; }
+export function computePaleontologyClustering(data: number[], opts: PaleontologyClusteringOptions = {}): PaleontologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyClustering };
diff --git a/src/paleontology/compression.ts b/src/paleontology/compression.ts
new file mode 100644
index 000000000..94d240ef0
--- /dev/null
+++ b/src/paleontology/compression.ts
@@ -0,0 +1,14 @@
+/** paleontology compression module — tsb analytics library. */
+export interface PaleontologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyCompressionResult { values: number[]; converged: boolean; }
+export function computePaleontologyCompression(data: number[], opts: PaleontologyCompressionOptions = {}): PaleontologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyCompression };
diff --git a/src/paleontology/continuous.ts b/src/paleontology/continuous.ts
new file mode 100644
index 000000000..e573e842a
--- /dev/null
+++ b/src/paleontology/continuous.ts
@@ -0,0 +1,14 @@
+/** paleontology continuous module — tsb analytics library. */
+export interface PaleontologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyContinuousResult { values: number[]; converged: boolean; }
+export function computePaleontologyContinuous(data: number[], opts: PaleontologyContinuousOptions = {}): PaleontologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyContinuous };
diff --git a/src/paleontology/control.ts b/src/paleontology/control.ts
new file mode 100644
index 000000000..29f47c1d6
--- /dev/null
+++ b/src/paleontology/control.ts
@@ -0,0 +1,14 @@
+/** paleontology control module — tsb analytics library. */
+export interface PaleontologyControlOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyControlResult { values: number[]; converged: boolean; }
+export function computePaleontologyControl(data: number[], opts: PaleontologyControlOptions = {}): PaleontologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyControl };
diff --git a/src/paleontology/convergence.ts b/src/paleontology/convergence.ts
new file mode 100644
index 000000000..7839b1f03
--- /dev/null
+++ b/src/paleontology/convergence.ts
@@ -0,0 +1,14 @@
+/** paleontology convergence module — tsb analytics library. */
+export interface PaleontologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyConvergenceResult { values: number[]; converged: boolean; }
+export function computePaleontologyConvergence(data: number[], opts: PaleontologyConvergenceOptions = {}): PaleontologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyConvergence };
diff --git a/src/paleontology/convex.ts b/src/paleontology/convex.ts
new file mode 100644
index 000000000..79887ffe6
--- /dev/null
+++ b/src/paleontology/convex.ts
@@ -0,0 +1,14 @@
+/** paleontology convex module — tsb analytics library. */
+export interface PaleontologyConvexOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyConvexResult { values: number[]; converged: boolean; }
+export function computePaleontologyConvex(data: number[], opts: PaleontologyConvexOptions = {}): PaleontologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyConvex };
diff --git a/src/paleontology/correlation.ts b/src/paleontology/correlation.ts
new file mode 100644
index 000000000..ba7a8c0c9
--- /dev/null
+++ b/src/paleontology/correlation.ts
@@ -0,0 +1,14 @@
+/** paleontology correlation module — tsb analytics library. */
+export interface PaleontologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyCorrelationResult { values: number[]; converged: boolean; }
+export function computePaleontologyCorrelation(data: number[], opts: PaleontologyCorrelationOptions = {}): PaleontologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyCorrelation };
diff --git a/src/paleontology/covariance.ts b/src/paleontology/covariance.ts
new file mode 100644
index 000000000..fa4a5106c
--- /dev/null
+++ b/src/paleontology/covariance.ts
@@ -0,0 +1,14 @@
+/** paleontology covariance module — tsb analytics library. */
+export interface PaleontologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyCovarianceResult { values: number[]; converged: boolean; }
+export function computePaleontologyCovariance(data: number[], opts: PaleontologyCovarianceOptions = {}): PaleontologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyCovariance };
diff --git a/src/paleontology/cross_validation.ts b/src/paleontology/cross_validation.ts
new file mode 100644
index 000000000..ce256cbfe
--- /dev/null
+++ b/src/paleontology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** paleontology cross_validation module — tsb analytics library. */
+export interface PaleontologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computePaleontologyCrossValidation(data: number[], opts: PaleontologyCrossValidationOptions = {}): PaleontologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyCrossValidation };
diff --git a/src/paleontology/decoding.ts b/src/paleontology/decoding.ts
new file mode 100644
index 000000000..113a89975
--- /dev/null
+++ b/src/paleontology/decoding.ts
@@ -0,0 +1,14 @@
+/** paleontology decoding module — tsb analytics library. */
+export interface PaleontologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDecodingResult { values: number[]; converged: boolean; }
+export function computePaleontologyDecoding(data: number[], opts: PaleontologyDecodingOptions = {}): PaleontologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDecoding };
diff --git a/src/paleontology/decomposition.ts b/src/paleontology/decomposition.ts
new file mode 100644
index 000000000..3c03e0bce
--- /dev/null
+++ b/src/paleontology/decomposition.ts
@@ -0,0 +1,14 @@
+/** paleontology decomposition module — tsb analytics library. */
+export interface PaleontologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDecompositionResult { values: number[]; converged: boolean; }
+export function computePaleontologyDecomposition(data: number[], opts: PaleontologyDecompositionOptions = {}): PaleontologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDecomposition };
diff --git a/src/paleontology/detection.ts b/src/paleontology/detection.ts
new file mode 100644
index 000000000..31767ba30
--- /dev/null
+++ b/src/paleontology/detection.ts
@@ -0,0 +1,14 @@
+/** paleontology detection module — tsb analytics library. */
+export interface PaleontologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDetectionResult { values: number[]; converged: boolean; }
+export function computePaleontologyDetection(data: number[], opts: PaleontologyDetectionOptions = {}): PaleontologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDetection };
diff --git a/src/paleontology/deterministic.ts b/src/paleontology/deterministic.ts
new file mode 100644
index 000000000..85262106f
--- /dev/null
+++ b/src/paleontology/deterministic.ts
@@ -0,0 +1,14 @@
+/** paleontology deterministic module — tsb analytics library. */
+export interface PaleontologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDeterministicResult { values: number[]; converged: boolean; }
+export function computePaleontologyDeterministic(data: number[], opts: PaleontologyDeterministicOptions = {}): PaleontologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDeterministic };
diff --git a/src/paleontology/diagnostics.ts b/src/paleontology/diagnostics.ts
new file mode 100644
index 000000000..fdab2fecc
--- /dev/null
+++ b/src/paleontology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** paleontology diagnostics module — tsb analytics library. */
+export interface PaleontologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePaleontologyDiagnostics(data: number[], opts: PaleontologyDiagnosticsOptions = {}): PaleontologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDiagnostics };
diff --git a/src/paleontology/differential.ts b/src/paleontology/differential.ts
new file mode 100644
index 000000000..3b4a83226
--- /dev/null
+++ b/src/paleontology/differential.ts
@@ -0,0 +1,14 @@
+/** paleontology differential module — tsb analytics library. */
+export interface PaleontologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDifferentialResult { values: number[]; converged: boolean; }
+export function computePaleontologyDifferential(data: number[], opts: PaleontologyDifferentialOptions = {}): PaleontologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDifferential };
diff --git a/src/paleontology/discrete.ts b/src/paleontology/discrete.ts
new file mode 100644
index 000000000..0de76ea49
--- /dev/null
+++ b/src/paleontology/discrete.ts
@@ -0,0 +1,14 @@
+/** paleontology discrete module — tsb analytics library. */
+export interface PaleontologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDiscreteResult { values: number[]; converged: boolean; }
+export function computePaleontologyDiscrete(data: number[], opts: PaleontologyDiscreteOptions = {}): PaleontologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDiscrete };
diff --git a/src/paleontology/distribution.ts b/src/paleontology/distribution.ts
new file mode 100644
index 000000000..516d3eb91
--- /dev/null
+++ b/src/paleontology/distribution.ts
@@ -0,0 +1,14 @@
+/** paleontology distribution module — tsb analytics library. */
+export interface PaleontologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDistributionResult { values: number[]; converged: boolean; }
+export function computePaleontologyDistribution(data: number[], opts: PaleontologyDistributionOptions = {}): PaleontologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDistribution };
diff --git a/src/paleontology/dynamic.ts b/src/paleontology/dynamic.ts
new file mode 100644
index 000000000..e4895f9fe
--- /dev/null
+++ b/src/paleontology/dynamic.ts
@@ -0,0 +1,14 @@
+/** paleontology dynamic module — tsb analytics library. */
+export interface PaleontologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyDynamicResult { values: number[]; converged: boolean; }
+export function computePaleontologyDynamic(data: number[], opts: PaleontologyDynamicOptions = {}): PaleontologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyDynamic };
diff --git a/src/paleontology/embedding.ts b/src/paleontology/embedding.ts
new file mode 100644
index 000000000..ea340731a
--- /dev/null
+++ b/src/paleontology/embedding.ts
@@ -0,0 +1,14 @@
+/** paleontology embedding module — tsb analytics library. */
+export interface PaleontologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computePaleontologyEmbedding(data: number[], opts: PaleontologyEmbeddingOptions = {}): PaleontologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyEmbedding };
diff --git a/src/paleontology/encoding.ts b/src/paleontology/encoding.ts
new file mode 100644
index 000000000..6b49f31b8
--- /dev/null
+++ b/src/paleontology/encoding.ts
@@ -0,0 +1,14 @@
+/** paleontology encoding module — tsb analytics library. */
+export interface PaleontologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyEncodingResult { values: number[]; converged: boolean; }
+export function computePaleontologyEncoding(data: number[], opts: PaleontologyEncodingOptions = {}): PaleontologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyEncoding };
diff --git a/src/paleontology/ensemble.ts b/src/paleontology/ensemble.ts
new file mode 100644
index 000000000..1080acd2e
--- /dev/null
+++ b/src/paleontology/ensemble.ts
@@ -0,0 +1,14 @@
+/** paleontology ensemble module — tsb analytics library. */
+export interface PaleontologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyEnsembleResult { values: number[]; converged: boolean; }
+export function computePaleontologyEnsemble(data: number[], opts: PaleontologyEnsembleOptions = {}): PaleontologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyEnsemble };
diff --git a/src/paleontology/estimation.ts b/src/paleontology/estimation.ts
new file mode 100644
index 000000000..577ae7d9b
--- /dev/null
+++ b/src/paleontology/estimation.ts
@@ -0,0 +1,14 @@
+/** paleontology estimation module — tsb analytics library. */
+export interface PaleontologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyEstimationResult { values: number[]; converged: boolean; }
+export function computePaleontologyEstimation(data: number[], opts: PaleontologyEstimationOptions = {}): PaleontologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyEstimation };
diff --git a/src/paleontology/evaluation.ts b/src/paleontology/evaluation.ts
new file mode 100644
index 000000000..664dd5107
--- /dev/null
+++ b/src/paleontology/evaluation.ts
@@ -0,0 +1,14 @@
+/** paleontology evaluation module — tsb analytics library. */
+export interface PaleontologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyEvaluationResult { values: number[]; converged: boolean; }
+export function computePaleontologyEvaluation(data: number[], opts: PaleontologyEvaluationOptions = {}): PaleontologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyEvaluation };
diff --git a/src/paleontology/extrapolation.ts b/src/paleontology/extrapolation.ts
new file mode 100644
index 000000000..2a83d58b5
--- /dev/null
+++ b/src/paleontology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** paleontology extrapolation module — tsb analytics library. */
+export interface PaleontologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computePaleontologyExtrapolation(data: number[], opts: PaleontologyExtrapolationOptions = {}): PaleontologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyExtrapolation };
diff --git a/src/paleontology/features.ts b/src/paleontology/features.ts
new file mode 100644
index 000000000..300c83e48
--- /dev/null
+++ b/src/paleontology/features.ts
@@ -0,0 +1,14 @@
+/** paleontology features module — tsb analytics library. */
+export interface PaleontologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyFeaturesResult { values: number[]; converged: boolean; }
+export function computePaleontologyFeatures(data: number[], opts: PaleontologyFeaturesOptions = {}): PaleontologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyFeatures };
diff --git a/src/paleontology/feedback.ts b/src/paleontology/feedback.ts
new file mode 100644
index 000000000..9566c9dd7
--- /dev/null
+++ b/src/paleontology/feedback.ts
@@ -0,0 +1,14 @@
+/** paleontology feedback module — tsb analytics library. */
+export interface PaleontologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyFeedbackResult { values: number[]; converged: boolean; }
+export function computePaleontologyFeedback(data: number[], opts: PaleontologyFeedbackOptions = {}): PaleontologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyFeedback };
diff --git a/src/paleontology/filtering.ts b/src/paleontology/filtering.ts
new file mode 100644
index 000000000..957b93ba8
--- /dev/null
+++ b/src/paleontology/filtering.ts
@@ -0,0 +1,14 @@
+/** paleontology filtering module — tsb analytics library. */
+export interface PaleontologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyFilteringResult { values: number[]; converged: boolean; }
+export function computePaleontologyFiltering(data: number[], opts: PaleontologyFilteringOptions = {}): PaleontologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyFiltering };
diff --git a/src/paleontology/fourier.ts b/src/paleontology/fourier.ts
new file mode 100644
index 000000000..6e6d25cda
--- /dev/null
+++ b/src/paleontology/fourier.ts
@@ -0,0 +1,14 @@
+/** paleontology fourier module — tsb analytics library. */
+export interface PaleontologyFourierOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyFourierResult { values: number[]; converged: boolean; }
+export function computePaleontologyFourier(data: number[], opts: PaleontologyFourierOptions = {}): PaleontologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyFourier };
diff --git a/src/paleontology/fusion.ts b/src/paleontology/fusion.ts
new file mode 100644
index 000000000..7e4888e3b
--- /dev/null
+++ b/src/paleontology/fusion.ts
@@ -0,0 +1,14 @@
+/** paleontology fusion module — tsb analytics library. */
+export interface PaleontologyFusionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyFusionResult { values: number[]; converged: boolean; }
+export function computePaleontologyFusion(data: number[], opts: PaleontologyFusionOptions = {}): PaleontologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyFusion };
diff --git a/src/paleontology/generation.ts b/src/paleontology/generation.ts
new file mode 100644
index 000000000..02736523e
--- /dev/null
+++ b/src/paleontology/generation.ts
@@ -0,0 +1,14 @@
+/** paleontology generation module — tsb analytics library. */
+export interface PaleontologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyGenerationResult { values: number[]; converged: boolean; }
+export function computePaleontologyGeneration(data: number[], opts: PaleontologyGenerationOptions = {}): PaleontologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyGeneration };
diff --git a/src/paleontology/geometry.ts b/src/paleontology/geometry.ts
new file mode 100644
index 000000000..e9f4393b9
--- /dev/null
+++ b/src/paleontology/geometry.ts
@@ -0,0 +1,14 @@
+/** paleontology geometry module — tsb analytics library. */
+export interface PaleontologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyGeometryResult { values: number[]; converged: boolean; }
+export function computePaleontologyGeometry(data: number[], opts: PaleontologyGeometryOptions = {}): PaleontologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyGeometry };
diff --git a/src/paleontology/gradient.ts b/src/paleontology/gradient.ts
new file mode 100644
index 000000000..07be8d243
--- /dev/null
+++ b/src/paleontology/gradient.ts
@@ -0,0 +1,14 @@
+/** paleontology gradient module — tsb analytics library. */
+export interface PaleontologyGradientOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyGradientResult { values: number[]; converged: boolean; }
+export function computePaleontologyGradient(data: number[], opts: PaleontologyGradientOptions = {}): PaleontologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyGradient };
diff --git a/src/paleontology/hessian.ts b/src/paleontology/hessian.ts
new file mode 100644
index 000000000..cc0dee8c0
--- /dev/null
+++ b/src/paleontology/hessian.ts
@@ -0,0 +1,14 @@
+/** paleontology hessian module — tsb analytics library. */
+export interface PaleontologyHessianOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyHessianResult { values: number[]; converged: boolean; }
+export function computePaleontologyHessian(data: number[], opts: PaleontologyHessianOptions = {}): PaleontologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyHessian };
diff --git a/src/paleontology/hypothesis.ts b/src/paleontology/hypothesis.ts
new file mode 100644
index 000000000..a4b6d99c5
--- /dev/null
+++ b/src/paleontology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** paleontology hypothesis module — tsb analytics library. */
+export interface PaleontologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyHypothesisResult { values: number[]; converged: boolean; }
+export function computePaleontologyHypothesis(data: number[], opts: PaleontologyHypothesisOptions = {}): PaleontologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyHypothesis };
diff --git a/src/paleontology/inference.ts b/src/paleontology/inference.ts
new file mode 100644
index 000000000..ce1525e15
--- /dev/null
+++ b/src/paleontology/inference.ts
@@ -0,0 +1,14 @@
+/** paleontology inference module — tsb analytics library. */
+export interface PaleontologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyInferenceResult { values: number[]; converged: boolean; }
+export function computePaleontologyInference(data: number[], opts: PaleontologyInferenceOptions = {}): PaleontologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyInference };
diff --git a/src/paleontology/inference2.ts b/src/paleontology/inference2.ts
new file mode 100644
index 000000000..8de3646f3
--- /dev/null
+++ b/src/paleontology/inference2.ts
@@ -0,0 +1,14 @@
+/** paleontology inference2 module — tsb analytics library. */
+export interface PaleontologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyInferenceResult { values: number[]; converged: boolean; }
+export function computePaleontologyInference(data: number[], opts: PaleontologyInferenceOptions = {}): PaleontologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyInference };
diff --git a/src/paleontology/integral.ts b/src/paleontology/integral.ts
new file mode 100644
index 000000000..9298b072d
--- /dev/null
+++ b/src/paleontology/integral.ts
@@ -0,0 +1,14 @@
+/** paleontology integral module — tsb analytics library. */
+export interface PaleontologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyIntegralResult { values: number[]; converged: boolean; }
+export function computePaleontologyIntegral(data: number[], opts: PaleontologyIntegralOptions = {}): PaleontologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyIntegral };
diff --git a/src/paleontology/integration.ts b/src/paleontology/integration.ts
new file mode 100644
index 000000000..0cc416a4a
--- /dev/null
+++ b/src/paleontology/integration.ts
@@ -0,0 +1,14 @@
+/** paleontology integration module — tsb analytics library. */
+export interface PaleontologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyIntegrationResult { values: number[]; converged: boolean; }
+export function computePaleontologyIntegration(data: number[], opts: PaleontologyIntegrationOptions = {}): PaleontologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyIntegration };
diff --git a/src/paleontology/interpolation.ts b/src/paleontology/interpolation.ts
new file mode 100644
index 000000000..e30f75d25
--- /dev/null
+++ b/src/paleontology/interpolation.ts
@@ -0,0 +1,14 @@
+/** paleontology interpolation module — tsb analytics library. */
+export interface PaleontologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyInterpolationResult { values: number[]; converged: boolean; }
+export function computePaleontologyInterpolation(data: number[], opts: PaleontologyInterpolationOptions = {}): PaleontologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyInterpolation };
diff --git a/src/paleontology/jacobian.ts b/src/paleontology/jacobian.ts
new file mode 100644
index 000000000..029325fdb
--- /dev/null
+++ b/src/paleontology/jacobian.ts
@@ -0,0 +1,14 @@
+/** paleontology jacobian module — tsb analytics library. */
+export interface PaleontologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyJacobianResult { values: number[]; converged: boolean; }
+export function computePaleontologyJacobian(data: number[], opts: PaleontologyJacobianOptions = {}): PaleontologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyJacobian };
diff --git a/src/paleontology/kernel.ts b/src/paleontology/kernel.ts
new file mode 100644
index 000000000..71cc8cda0
--- /dev/null
+++ b/src/paleontology/kernel.ts
@@ -0,0 +1,14 @@
+/** paleontology kernel module — tsb analytics library. */
+export interface PaleontologyKernelOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyKernelResult { values: number[]; converged: boolean; }
+export function computePaleontologyKernel(data: number[], opts: PaleontologyKernelOptions = {}): PaleontologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyKernel };
diff --git a/src/paleontology/laplacian.ts b/src/paleontology/laplacian.ts
new file mode 100644
index 000000000..c8a226e68
--- /dev/null
+++ b/src/paleontology/laplacian.ts
@@ -0,0 +1,14 @@
+/** paleontology laplacian module — tsb analytics library. */
+export interface PaleontologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyLaplacianResult { values: number[]; converged: boolean; }
+export function computePaleontologyLaplacian(data: number[], opts: PaleontologyLaplacianOptions = {}): PaleontologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyLaplacian };
diff --git a/src/paleontology/learning.ts b/src/paleontology/learning.ts
new file mode 100644
index 000000000..b3f0a7feb
--- /dev/null
+++ b/src/paleontology/learning.ts
@@ -0,0 +1,14 @@
+/** paleontology learning module — tsb analytics library. */
+export interface PaleontologyLearningOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyLearningResult { values: number[]; converged: boolean; }
+export function computePaleontologyLearning(data: number[], opts: PaleontologyLearningOptions = {}): PaleontologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyLearning };
diff --git a/src/paleontology/linear.ts b/src/paleontology/linear.ts
new file mode 100644
index 000000000..eedf386f9
--- /dev/null
+++ b/src/paleontology/linear.ts
@@ -0,0 +1,14 @@
+/** paleontology linear module — tsb analytics library. */
+export interface PaleontologyLinearOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyLinearResult { values: number[]; converged: boolean; }
+export function computePaleontologyLinear(data: number[], opts: PaleontologyLinearOptions = {}): PaleontologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyLinear };
diff --git a/src/paleontology/manifold.ts b/src/paleontology/manifold.ts
new file mode 100644
index 000000000..749882d1d
--- /dev/null
+++ b/src/paleontology/manifold.ts
@@ -0,0 +1,14 @@
+/** paleontology manifold module — tsb analytics library. */
+export interface PaleontologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyManifoldResult { values: number[]; converged: boolean; }
+export function computePaleontologyManifold(data: number[], opts: PaleontologyManifoldOptions = {}): PaleontologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyManifold };
diff --git a/src/paleontology/matching.ts b/src/paleontology/matching.ts
new file mode 100644
index 000000000..cbc79fb1a
--- /dev/null
+++ b/src/paleontology/matching.ts
@@ -0,0 +1,14 @@
+/** paleontology matching module — tsb analytics library. */
+export interface PaleontologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyMatchingResult { values: number[]; converged: boolean; }
+export function computePaleontologyMatching(data: number[], opts: PaleontologyMatchingOptions = {}): PaleontologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyMatching };
diff --git a/src/paleontology/measurement.ts b/src/paleontology/measurement.ts
new file mode 100644
index 000000000..c4e6650dd
--- /dev/null
+++ b/src/paleontology/measurement.ts
@@ -0,0 +1,14 @@
+/** paleontology measurement module — tsb analytics library. */
+export interface PaleontologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyMeasurementResult { values: number[]; converged: boolean; }
+export function computePaleontologyMeasurement(data: number[], opts: PaleontologyMeasurementOptions = {}): PaleontologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyMeasurement };
diff --git a/src/paleontology/metrics.ts b/src/paleontology/metrics.ts
new file mode 100644
index 000000000..cb5655e65
--- /dev/null
+++ b/src/paleontology/metrics.ts
@@ -0,0 +1,14 @@
+/** paleontology metrics module — tsb analytics library. */
+export interface PaleontologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyMetricsResult { values: number[]; converged: boolean; }
+export function computePaleontologyMetrics(data: number[], opts: PaleontologyMetricsOptions = {}): PaleontologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyMetrics };
diff --git a/src/paleontology/modeling.ts b/src/paleontology/modeling.ts
new file mode 100644
index 000000000..3b56414c1
--- /dev/null
+++ b/src/paleontology/modeling.ts
@@ -0,0 +1,14 @@
+/** paleontology modeling module — tsb analytics library. */
+export interface PaleontologyModelingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyModelingResult { values: number[]; converged: boolean; }
+export function computePaleontologyModeling(data: number[], opts: PaleontologyModelingOptions = {}): PaleontologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyModeling };
diff --git a/src/paleontology/monitoring.ts b/src/paleontology/monitoring.ts
new file mode 100644
index 000000000..18b9f15d3
--- /dev/null
+++ b/src/paleontology/monitoring.ts
@@ -0,0 +1,14 @@
+/** paleontology monitoring module — tsb analytics library. */
+export interface PaleontologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyMonitoringResult { values: number[]; converged: boolean; }
+export function computePaleontologyMonitoring(data: number[], opts: PaleontologyMonitoringOptions = {}): PaleontologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyMonitoring };
diff --git a/src/paleontology/nonlinear.ts b/src/paleontology/nonlinear.ts
new file mode 100644
index 000000000..c2acaca65
--- /dev/null
+++ b/src/paleontology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** paleontology nonlinear module — tsb analytics library. */
+export interface PaleontologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyNonlinearResult { values: number[]; converged: boolean; }
+export function computePaleontologyNonlinear(data: number[], opts: PaleontologyNonlinearOptions = {}): PaleontologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyNonlinear };
diff --git a/src/paleontology/normalization.ts b/src/paleontology/normalization.ts
new file mode 100644
index 000000000..03eeb84e4
--- /dev/null
+++ b/src/paleontology/normalization.ts
@@ -0,0 +1,14 @@
+/** paleontology normalization module — tsb analytics library. */
+export interface PaleontologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyNormalizationResult { values: number[]; converged: boolean; }
+export function computePaleontologyNormalization(data: number[], opts: PaleontologyNormalizationOptions = {}): PaleontologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyNormalization };
diff --git a/src/paleontology/optimization.ts b/src/paleontology/optimization.ts
new file mode 100644
index 000000000..b678a8221
--- /dev/null
+++ b/src/paleontology/optimization.ts
@@ -0,0 +1,14 @@
+/** paleontology optimization module — tsb analytics library. */
+export interface PaleontologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyOptimizationResult { values: number[]; converged: boolean; }
+export function computePaleontologyOptimization(data: number[], opts: PaleontologyOptimizationOptions = {}): PaleontologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyOptimization };
diff --git a/src/paleontology/patterns.ts b/src/paleontology/patterns.ts
new file mode 100644
index 000000000..4a12e16d8
--- /dev/null
+++ b/src/paleontology/patterns.ts
@@ -0,0 +1,14 @@
+/** paleontology patterns module — tsb analytics library. */
+export interface PaleontologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyPatternsResult { values: number[]; converged: boolean; }
+export function computePaleontologyPatterns(data: number[], opts: PaleontologyPatternsOptions = {}): PaleontologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyPatterns };
diff --git a/src/paleontology/permutation.ts b/src/paleontology/permutation.ts
new file mode 100644
index 000000000..6504efae4
--- /dev/null
+++ b/src/paleontology/permutation.ts
@@ -0,0 +1,14 @@
+/** paleontology permutation module — tsb analytics library. */
+export interface PaleontologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyPermutationResult { values: number[]; converged: boolean; }
+export function computePaleontologyPermutation(data: number[], opts: PaleontologyPermutationOptions = {}): PaleontologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyPermutation };
diff --git a/src/paleontology/prediction.ts b/src/paleontology/prediction.ts
new file mode 100644
index 000000000..df56af51f
--- /dev/null
+++ b/src/paleontology/prediction.ts
@@ -0,0 +1,14 @@
+/** paleontology prediction module — tsb analytics library. */
+export interface PaleontologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyPredictionResult { values: number[]; converged: boolean; }
+export function computePaleontologyPrediction(data: number[], opts: PaleontologyPredictionOptions = {}): PaleontologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyPrediction };
diff --git a/src/paleontology/processing.ts b/src/paleontology/processing.ts
new file mode 100644
index 000000000..de3b84eb3
--- /dev/null
+++ b/src/paleontology/processing.ts
@@ -0,0 +1,14 @@
+/** paleontology processing module — tsb analytics library. */
+export interface PaleontologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyProcessingResult { values: number[]; converged: boolean; }
+export function computePaleontologyProcessing(data: number[], opts: PaleontologyProcessingOptions = {}): PaleontologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyProcessing };
diff --git a/src/paleontology/profiling.ts b/src/paleontology/profiling.ts
new file mode 100644
index 000000000..d875cbfd4
--- /dev/null
+++ b/src/paleontology/profiling.ts
@@ -0,0 +1,14 @@
+/** paleontology profiling module — tsb analytics library. */
+export interface PaleontologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyProfilingResult { values: number[]; converged: boolean; }
+export function computePaleontologyProfiling(data: number[], opts: PaleontologyProfilingOptions = {}): PaleontologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyProfiling };
diff --git a/src/paleontology/projection.ts b/src/paleontology/projection.ts
new file mode 100644
index 000000000..c77092625
--- /dev/null
+++ b/src/paleontology/projection.ts
@@ -0,0 +1,14 @@
+/** paleontology projection module — tsb analytics library. */
+export interface PaleontologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyProjectionResult { values: number[]; converged: boolean; }
+export function computePaleontologyProjection(data: number[], opts: PaleontologyProjectionOptions = {}): PaleontologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyProjection };
diff --git a/src/paleontology/ranking.ts b/src/paleontology/ranking.ts
new file mode 100644
index 000000000..4d68b24c8
--- /dev/null
+++ b/src/paleontology/ranking.ts
@@ -0,0 +1,14 @@
+/** paleontology ranking module — tsb analytics library. */
+export interface PaleontologyRankingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyRankingResult { values: number[]; converged: boolean; }
+export function computePaleontologyRanking(data: number[], opts: PaleontologyRankingOptions = {}): PaleontologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyRanking };
diff --git a/src/paleontology/reconstruction.ts b/src/paleontology/reconstruction.ts
new file mode 100644
index 000000000..53275edb2
--- /dev/null
+++ b/src/paleontology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** paleontology reconstruction module — tsb analytics library. */
+export interface PaleontologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyReconstructionResult { values: number[]; converged: boolean; }
+export function computePaleontologyReconstruction(data: number[], opts: PaleontologyReconstructionOptions = {}): PaleontologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyReconstruction };
diff --git a/src/paleontology/registration.ts b/src/paleontology/registration.ts
new file mode 100644
index 000000000..b48d10e87
--- /dev/null
+++ b/src/paleontology/registration.ts
@@ -0,0 +1,14 @@
+/** paleontology registration module — tsb analytics library. */
+export interface PaleontologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyRegistrationResult { values: number[]; converged: boolean; }
+export function computePaleontologyRegistration(data: number[], opts: PaleontologyRegistrationOptions = {}): PaleontologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyRegistration };
diff --git a/src/paleontology/regression.ts b/src/paleontology/regression.ts
new file mode 100644
index 000000000..80d55aa9e
--- /dev/null
+++ b/src/paleontology/regression.ts
@@ -0,0 +1,14 @@
+/** paleontology regression module — tsb analytics library. */
+export interface PaleontologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyRegressionResult { values: number[]; converged: boolean; }
+export function computePaleontologyRegression(data: number[], opts: PaleontologyRegressionOptions = {}): PaleontologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyRegression };
diff --git a/src/paleontology/regularization.ts b/src/paleontology/regularization.ts
new file mode 100644
index 000000000..3ecdd6dec
--- /dev/null
+++ b/src/paleontology/regularization.ts
@@ -0,0 +1,14 @@
+/** paleontology regularization module — tsb analytics library. */
+export interface PaleontologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyRegularizationResult { values: number[]; converged: boolean; }
+export function computePaleontologyRegularization(data: number[], opts: PaleontologyRegularizationOptions = {}): PaleontologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyRegularization };
diff --git a/src/paleontology/robustness.ts b/src/paleontology/robustness.ts
new file mode 100644
index 000000000..a054b77a9
--- /dev/null
+++ b/src/paleontology/robustness.ts
@@ -0,0 +1,14 @@
+/** paleontology robustness module — tsb analytics library. */
+export interface PaleontologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyRobustnessResult { values: number[]; converged: boolean; }
+export function computePaleontologyRobustness(data: number[], opts: PaleontologyRobustnessOptions = {}): PaleontologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyRobustness };
diff --git a/src/paleontology/sampling.ts b/src/paleontology/sampling.ts
new file mode 100644
index 000000000..f010f44fb
--- /dev/null
+++ b/src/paleontology/sampling.ts
@@ -0,0 +1,14 @@
+/** paleontology sampling module — tsb analytics library. */
+export interface PaleontologySamplingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologySamplingResult { values: number[]; converged: boolean; }
+export function computePaleontologySampling(data: number[], opts: PaleontologySamplingOptions = {}): PaleontologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologySampling };
diff --git a/src/paleontology/sampling2.ts b/src/paleontology/sampling2.ts
new file mode 100644
index 000000000..ce2ee0584
--- /dev/null
+++ b/src/paleontology/sampling2.ts
@@ -0,0 +1,14 @@
+/** paleontology sampling2 module — tsb analytics library. */
+export interface PaleontologySamplingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologySamplingResult { values: number[]; converged: boolean; }
+export function computePaleontologySampling(data: number[], opts: PaleontologySamplingOptions = {}): PaleontologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologySampling };
diff --git a/src/paleontology/scaling.ts b/src/paleontology/scaling.ts
new file mode 100644
index 000000000..3b151e9da
--- /dev/null
+++ b/src/paleontology/scaling.ts
@@ -0,0 +1,14 @@
+/** paleontology scaling module — tsb analytics library. */
+export interface PaleontologyScalingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyScalingResult { values: number[]; converged: boolean; }
+export function computePaleontologyScaling(data: number[], opts: PaleontologyScalingOptions = {}): PaleontologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyScaling };
diff --git a/src/paleontology/scoring.ts b/src/paleontology/scoring.ts
new file mode 100644
index 000000000..250393424
--- /dev/null
+++ b/src/paleontology/scoring.ts
@@ -0,0 +1,14 @@
+/** paleontology scoring module — tsb analytics library. */
+export interface PaleontologyScoringOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyScoringResult { values: number[]; converged: boolean; }
+export function computePaleontologyScoring(data: number[], opts: PaleontologyScoringOptions = {}): PaleontologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyScoring };
diff --git a/src/paleontology/segmentation.ts b/src/paleontology/segmentation.ts
new file mode 100644
index 000000000..11daa71f6
--- /dev/null
+++ b/src/paleontology/segmentation.ts
@@ -0,0 +1,14 @@
+/** paleontology segmentation module — tsb analytics library. */
+export interface PaleontologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologySegmentationResult { values: number[]; converged: boolean; }
+export function computePaleontologySegmentation(data: number[], opts: PaleontologySegmentationOptions = {}): PaleontologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologySegmentation };
diff --git a/src/paleontology/selection.ts b/src/paleontology/selection.ts
new file mode 100644
index 000000000..18fe7bd5e
--- /dev/null
+++ b/src/paleontology/selection.ts
@@ -0,0 +1,14 @@
+/** paleontology selection module — tsb analytics library. */
+export interface PaleontologySelectionOptions { tol?: number; maxIter?: number; }
+export interface PaleontologySelectionResult { values: number[]; converged: boolean; }
+export function computePaleontologySelection(data: number[], opts: PaleontologySelectionOptions = {}): PaleontologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologySelection };
diff --git a/src/paleontology/sensitivity.ts b/src/paleontology/sensitivity.ts
new file mode 100644
index 000000000..776165881
--- /dev/null
+++ b/src/paleontology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** paleontology sensitivity module — tsb analytics library. */
+export interface PaleontologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface PaleontologySensitivityResult { values: number[]; converged: boolean; }
+export function computePaleontologySensitivity(data: number[], opts: PaleontologySensitivityOptions = {}): PaleontologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologySensitivity };
diff --git a/src/paleontology/simulation.ts b/src/paleontology/simulation.ts
new file mode 100644
index 000000000..5d4c85379
--- /dev/null
+++ b/src/paleontology/simulation.ts
@@ -0,0 +1,14 @@
+/** paleontology simulation module — tsb analytics library. */
+export interface PaleontologySimulationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologySimulationResult { values: number[]; converged: boolean; }
+export function computePaleontologySimulation(data: number[], opts: PaleontologySimulationOptions = {}): PaleontologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologySimulation };
diff --git a/src/paleontology/smoothing.ts b/src/paleontology/smoothing.ts
new file mode 100644
index 000000000..2f977390d
--- /dev/null
+++ b/src/paleontology/smoothing.ts
@@ -0,0 +1,14 @@
+/** paleontology smoothing module — tsb analytics library. */
+export interface PaleontologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologySmoothingResult { values: number[]; converged: boolean; }
+export function computePaleontologySmoothing(data: number[], opts: PaleontologySmoothingOptions = {}): PaleontologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologySmoothing };
diff --git a/src/paleontology/stability.ts b/src/paleontology/stability.ts
new file mode 100644
index 000000000..5d5bc0189
--- /dev/null
+++ b/src/paleontology/stability.ts
@@ -0,0 +1,14 @@
+/** paleontology stability module — tsb analytics library. */
+export interface PaleontologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyStabilityResult { values: number[]; converged: boolean; }
+export function computePaleontologyStability(data: number[], opts: PaleontologyStabilityOptions = {}): PaleontologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyStability };
diff --git a/src/paleontology/stacking.ts b/src/paleontology/stacking.ts
new file mode 100644
index 000000000..4d5ffa93a
--- /dev/null
+++ b/src/paleontology/stacking.ts
@@ -0,0 +1,14 @@
+/** paleontology stacking module — tsb analytics library. */
+export interface PaleontologyStackingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyStackingResult { values: number[]; converged: boolean; }
+export function computePaleontologyStacking(data: number[], opts: PaleontologyStackingOptions = {}): PaleontologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyStacking };
diff --git a/src/paleontology/standardization.ts b/src/paleontology/standardization.ts
new file mode 100644
index 000000000..0376124ed
--- /dev/null
+++ b/src/paleontology/standardization.ts
@@ -0,0 +1,14 @@
+/** paleontology standardization module — tsb analytics library. */
+export interface PaleontologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyStandardizationResult { values: number[]; converged: boolean; }
+export function computePaleontologyStandardization(data: number[], opts: PaleontologyStandardizationOptions = {}): PaleontologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyStandardization };
diff --git a/src/paleontology/static.ts b/src/paleontology/static.ts
new file mode 100644
index 000000000..1e475599c
--- /dev/null
+++ b/src/paleontology/static.ts
@@ -0,0 +1,14 @@
+/** paleontology static module — tsb analytics library. */
+export interface PaleontologyStaticOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyStaticResult { values: number[]; converged: boolean; }
+export function computePaleontologyStatic(data: number[], opts: PaleontologyStaticOptions = {}): PaleontologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyStatic };
diff --git a/src/paleontology/stochastic.ts b/src/paleontology/stochastic.ts
new file mode 100644
index 000000000..72cf3b8a4
--- /dev/null
+++ b/src/paleontology/stochastic.ts
@@ -0,0 +1,14 @@
+/** paleontology stochastic module — tsb analytics library. */
+export interface PaleontologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyStochasticResult { values: number[]; converged: boolean; }
+export function computePaleontologyStochastic(data: number[], opts: PaleontologyStochasticOptions = {}): PaleontologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyStochastic };
diff --git a/src/paleontology/synthesis.ts b/src/paleontology/synthesis.ts
new file mode 100644
index 000000000..59f89fbec
--- /dev/null
+++ b/src/paleontology/synthesis.ts
@@ -0,0 +1,14 @@
+/** paleontology synthesis module — tsb analytics library. */
+export interface PaleontologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface PaleontologySynthesisResult { values: number[]; converged: boolean; }
+export function computePaleontologySynthesis(data: number[], opts: PaleontologySynthesisOptions = {}): PaleontologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologySynthesis };
diff --git a/src/paleontology/topology.ts b/src/paleontology/topology.ts
new file mode 100644
index 000000000..705c4c62b
--- /dev/null
+++ b/src/paleontology/topology.ts
@@ -0,0 +1,14 @@
+/** paleontology topology module — tsb analytics library. */
+export interface PaleontologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyTopologyResult { values: number[]; converged: boolean; }
+export function computePaleontologyTopology(data: number[], opts: PaleontologyTopologyOptions = {}): PaleontologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyTopology };
diff --git a/src/paleontology/tracking.ts b/src/paleontology/tracking.ts
new file mode 100644
index 000000000..211f01a95
--- /dev/null
+++ b/src/paleontology/tracking.ts
@@ -0,0 +1,14 @@
+/** paleontology tracking module — tsb analytics library. */
+export interface PaleontologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyTrackingResult { values: number[]; converged: boolean; }
+export function computePaleontologyTracking(data: number[], opts: PaleontologyTrackingOptions = {}): PaleontologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyTracking };
diff --git a/src/paleontology/transform.ts b/src/paleontology/transform.ts
new file mode 100644
index 000000000..9adbf4b41
--- /dev/null
+++ b/src/paleontology/transform.ts
@@ -0,0 +1,14 @@
+/** paleontology transform module — tsb analytics library. */
+export interface PaleontologyTransformOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyTransformResult { values: number[]; converged: boolean; }
+export function computePaleontologyTransform(data: number[], opts: PaleontologyTransformOptions = {}): PaleontologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyTransform };
diff --git a/src/paleontology/uncertainty.ts b/src/paleontology/uncertainty.ts
new file mode 100644
index 000000000..274b948fa
--- /dev/null
+++ b/src/paleontology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** paleontology uncertainty module — tsb analytics library. */
+export interface PaleontologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computePaleontologyUncertainty(data: number[], opts: PaleontologyUncertaintyOptions = {}): PaleontologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyUncertainty };
diff --git a/src/paleontology/validation.ts b/src/paleontology/validation.ts
new file mode 100644
index 000000000..4a7ece74f
--- /dev/null
+++ b/src/paleontology/validation.ts
@@ -0,0 +1,14 @@
+/** paleontology validation module — tsb analytics library. */
+export interface PaleontologyValidationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyValidationResult { values: number[]; converged: boolean; }
+export function computePaleontologyValidation(data: number[], opts: PaleontologyValidationOptions = {}): PaleontologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyValidation };
diff --git a/src/paleontology/verification.ts b/src/paleontology/verification.ts
new file mode 100644
index 000000000..cc27e4790
--- /dev/null
+++ b/src/paleontology/verification.ts
@@ -0,0 +1,14 @@
+/** paleontology verification module — tsb analytics library. */
+export interface PaleontologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyVerificationResult { values: number[]; converged: boolean; }
+export function computePaleontologyVerification(data: number[], opts: PaleontologyVerificationOptions = {}): PaleontologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyVerification };
diff --git a/src/paleontology/visualization.ts b/src/paleontology/visualization.ts
new file mode 100644
index 000000000..e895f4409
--- /dev/null
+++ b/src/paleontology/visualization.ts
@@ -0,0 +1,14 @@
+/** paleontology visualization module — tsb analytics library. */
+export interface PaleontologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyVisualizationResult { values: number[]; converged: boolean; }
+export function computePaleontologyVisualization(data: number[], opts: PaleontologyVisualizationOptions = {}): PaleontologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyVisualization };
diff --git a/src/paleontology/voting.ts b/src/paleontology/voting.ts
new file mode 100644
index 000000000..0a8114e19
--- /dev/null
+++ b/src/paleontology/voting.ts
@@ -0,0 +1,14 @@
+/** paleontology voting module — tsb analytics library. */
+export interface PaleontologyVotingOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyVotingResult { values: number[]; converged: boolean; }
+export function computePaleontologyVoting(data: number[], opts: PaleontologyVotingOptions = {}): PaleontologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyVoting };
diff --git a/src/paleontology/wavelet.ts b/src/paleontology/wavelet.ts
new file mode 100644
index 000000000..7111a3284
--- /dev/null
+++ b/src/paleontology/wavelet.ts
@@ -0,0 +1,14 @@
+/** paleontology wavelet module — tsb analytics library. */
+export interface PaleontologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface PaleontologyWaveletResult { values: number[]; converged: boolean; }
+export function computePaleontologyWavelet(data: number[], opts: PaleontologyWaveletOptions = {}): PaleontologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePaleontologyWavelet };
diff --git a/src/petrology/adaptation.ts b/src/petrology/adaptation.ts
new file mode 100644
index 000000000..84c58b752
--- /dev/null
+++ b/src/petrology/adaptation.ts
@@ -0,0 +1,14 @@
+/** petrology adaptation module — tsb analytics library. */
+export interface PetrologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyAdaptationResult { values: number[]; converged: boolean; }
+export function computePetrologyAdaptation(data: number[], opts: PetrologyAdaptationOptions = {}): PetrologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyAdaptation };
diff --git a/src/petrology/aggregation.ts b/src/petrology/aggregation.ts
new file mode 100644
index 000000000..97a2b997f
--- /dev/null
+++ b/src/petrology/aggregation.ts
@@ -0,0 +1,14 @@
+/** petrology aggregation module — tsb analytics library. */
+export interface PetrologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyAggregationResult { values: number[]; converged: boolean; }
+export function computePetrologyAggregation(data: number[], opts: PetrologyAggregationOptions = {}): PetrologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyAggregation };
diff --git a/src/petrology/algebra.ts b/src/petrology/algebra.ts
new file mode 100644
index 000000000..1a438c188
--- /dev/null
+++ b/src/petrology/algebra.ts
@@ -0,0 +1,14 @@
+/** petrology algebra module — tsb analytics library. */
+export interface PetrologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PetrologyAlgebraResult { values: number[]; converged: boolean; }
+export function computePetrologyAlgebra(data: number[], opts: PetrologyAlgebraOptions = {}): PetrologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyAlgebra };
diff --git a/src/petrology/alignment.ts b/src/petrology/alignment.ts
new file mode 100644
index 000000000..81027d3ae
--- /dev/null
+++ b/src/petrology/alignment.ts
@@ -0,0 +1,14 @@
+/** petrology alignment module — tsb analytics library. */
+export interface PetrologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PetrologyAlignmentResult { values: number[]; converged: boolean; }
+export function computePetrologyAlignment(data: number[], opts: PetrologyAlignmentOptions = {}): PetrologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyAlignment };
diff --git a/src/petrology/analysis.ts b/src/petrology/analysis.ts
new file mode 100644
index 000000000..55b88c1bc
--- /dev/null
+++ b/src/petrology/analysis.ts
@@ -0,0 +1,14 @@
+/** petrology analysis module — tsb analytics library. */
+export interface PetrologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PetrologyAnalysisResult { values: number[]; converged: boolean; }
+export function computePetrologyAnalysis(data: number[], opts: PetrologyAnalysisOptions = {}): PetrologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyAnalysis };
diff --git a/src/petrology/augmentation.ts b/src/petrology/augmentation.ts
new file mode 100644
index 000000000..b7b27523b
--- /dev/null
+++ b/src/petrology/augmentation.ts
@@ -0,0 +1,14 @@
+/** petrology augmentation module — tsb analytics library. */
+export interface PetrologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyAugmentationResult { values: number[]; converged: boolean; }
+export function computePetrologyAugmentation(data: number[], opts: PetrologyAugmentationOptions = {}): PetrologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyAugmentation };
diff --git a/src/petrology/bagging.ts b/src/petrology/bagging.ts
new file mode 100644
index 000000000..0dc6e8420
--- /dev/null
+++ b/src/petrology/bagging.ts
@@ -0,0 +1,14 @@
+/** petrology bagging module — tsb analytics library. */
+export interface PetrologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyBaggingResult { values: number[]; converged: boolean; }
+export function computePetrologyBagging(data: number[], opts: PetrologyBaggingOptions = {}): PetrologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyBagging };
diff --git a/src/petrology/basis.ts b/src/petrology/basis.ts
new file mode 100644
index 000000000..ab0d21e9f
--- /dev/null
+++ b/src/petrology/basis.ts
@@ -0,0 +1,14 @@
+/** petrology basis module — tsb analytics library. */
+export interface PetrologyBasisOptions { tol?: number; maxIter?: number; }
+export interface PetrologyBasisResult { values: number[]; converged: boolean; }
+export function computePetrologyBasis(data: number[], opts: PetrologyBasisOptions = {}): PetrologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyBasis };
diff --git a/src/petrology/benchmarking.ts b/src/petrology/benchmarking.ts
new file mode 100644
index 000000000..0b8081b85
--- /dev/null
+++ b/src/petrology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** petrology benchmarking module — tsb analytics library. */
+export interface PetrologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePetrologyBenchmarking(data: number[], opts: PetrologyBenchmarkingOptions = {}): PetrologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyBenchmarking };
diff --git a/src/petrology/blending.ts b/src/petrology/blending.ts
new file mode 100644
index 000000000..0fddf09ca
--- /dev/null
+++ b/src/petrology/blending.ts
@@ -0,0 +1,14 @@
+/** petrology blending module — tsb analytics library. */
+export interface PetrologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyBlendingResult { values: number[]; converged: boolean; }
+export function computePetrologyBlending(data: number[], opts: PetrologyBlendingOptions = {}): PetrologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyBlending };
diff --git a/src/petrology/boosting.ts b/src/petrology/boosting.ts
new file mode 100644
index 000000000..22cf2aa3d
--- /dev/null
+++ b/src/petrology/boosting.ts
@@ -0,0 +1,14 @@
+/** petrology boosting module — tsb analytics library. */
+export interface PetrologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyBoostingResult { values: number[]; converged: boolean; }
+export function computePetrologyBoosting(data: number[], opts: PetrologyBoostingOptions = {}): PetrologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyBoosting };
diff --git a/src/petrology/bootstrap.ts b/src/petrology/bootstrap.ts
new file mode 100644
index 000000000..570b56adb
--- /dev/null
+++ b/src/petrology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** petrology bootstrap module — tsb analytics library. */
+export interface PetrologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PetrologyBootstrapResult { values: number[]; converged: boolean; }
+export function computePetrologyBootstrap(data: number[], opts: PetrologyBootstrapOptions = {}): PetrologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyBootstrap };
diff --git a/src/petrology/calculus.ts b/src/petrology/calculus.ts
new file mode 100644
index 000000000..7c7d5c0e9
--- /dev/null
+++ b/src/petrology/calculus.ts
@@ -0,0 +1,14 @@
+/** petrology calculus module — tsb analytics library. */
+export interface PetrologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface PetrologyCalculusResult { values: number[]; converged: boolean; }
+export function computePetrologyCalculus(data: number[], opts: PetrologyCalculusOptions = {}): PetrologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyCalculus };
diff --git a/src/petrology/calibration.ts b/src/petrology/calibration.ts
new file mode 100644
index 000000000..b119837e4
--- /dev/null
+++ b/src/petrology/calibration.ts
@@ -0,0 +1,14 @@
+/** petrology calibration module — tsb analytics library. */
+export interface PetrologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyCalibrationResult { values: number[]; converged: boolean; }
+export function computePetrologyCalibration(data: number[], opts: PetrologyCalibrationOptions = {}): PetrologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyCalibration };
diff --git a/src/petrology/characterization.ts b/src/petrology/characterization.ts
new file mode 100644
index 000000000..cb01e4d1f
--- /dev/null
+++ b/src/petrology/characterization.ts
@@ -0,0 +1,14 @@
+/** petrology characterization module — tsb analytics library. */
+export interface PetrologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computePetrologyCharacterization(data: number[], opts: PetrologyCharacterizationOptions = {}): PetrologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyCharacterization };
diff --git a/src/petrology/classification.ts b/src/petrology/classification.ts
new file mode 100644
index 000000000..c9e856df8
--- /dev/null
+++ b/src/petrology/classification.ts
@@ -0,0 +1,14 @@
+/** petrology classification module — tsb analytics library. */
+export interface PetrologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyClassificationResult { values: number[]; converged: boolean; }
+export function computePetrologyClassification(data: number[], opts: PetrologyClassificationOptions = {}): PetrologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyClassification };
diff --git a/src/petrology/clustering.ts b/src/petrology/clustering.ts
new file mode 100644
index 000000000..77ce89235
--- /dev/null
+++ b/src/petrology/clustering.ts
@@ -0,0 +1,14 @@
+/** petrology clustering module — tsb analytics library. */
+export interface PetrologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface PetrologyClusteringResult { values: number[]; converged: boolean; }
+export function computePetrologyClustering(data: number[], opts: PetrologyClusteringOptions = {}): PetrologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyClustering };
diff --git a/src/petrology/compression.ts b/src/petrology/compression.ts
new file mode 100644
index 000000000..6a2f952cc
--- /dev/null
+++ b/src/petrology/compression.ts
@@ -0,0 +1,14 @@
+/** petrology compression module — tsb analytics library. */
+export interface PetrologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyCompressionResult { values: number[]; converged: boolean; }
+export function computePetrologyCompression(data: number[], opts: PetrologyCompressionOptions = {}): PetrologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyCompression };
diff --git a/src/petrology/continuous.ts b/src/petrology/continuous.ts
new file mode 100644
index 000000000..70954a819
--- /dev/null
+++ b/src/petrology/continuous.ts
@@ -0,0 +1,14 @@
+/** petrology continuous module — tsb analytics library. */
+export interface PetrologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface PetrologyContinuousResult { values: number[]; converged: boolean; }
+export function computePetrologyContinuous(data: number[], opts: PetrologyContinuousOptions = {}): PetrologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyContinuous };
diff --git a/src/petrology/control.ts b/src/petrology/control.ts
new file mode 100644
index 000000000..eaa255a22
--- /dev/null
+++ b/src/petrology/control.ts
@@ -0,0 +1,14 @@
+/** petrology control module — tsb analytics library. */
+export interface PetrologyControlOptions { tol?: number; maxIter?: number; }
+export interface PetrologyControlResult { values: number[]; converged: boolean; }
+export function computePetrologyControl(data: number[], opts: PetrologyControlOptions = {}): PetrologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyControl };
diff --git a/src/petrology/convergence.ts b/src/petrology/convergence.ts
new file mode 100644
index 000000000..4c01586ee
--- /dev/null
+++ b/src/petrology/convergence.ts
@@ -0,0 +1,14 @@
+/** petrology convergence module — tsb analytics library. */
+export interface PetrologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PetrologyConvergenceResult { values: number[]; converged: boolean; }
+export function computePetrologyConvergence(data: number[], opts: PetrologyConvergenceOptions = {}): PetrologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyConvergence };
diff --git a/src/petrology/convex.ts b/src/petrology/convex.ts
new file mode 100644
index 000000000..e1a553b62
--- /dev/null
+++ b/src/petrology/convex.ts
@@ -0,0 +1,14 @@
+/** petrology convex module — tsb analytics library. */
+export interface PetrologyConvexOptions { tol?: number; maxIter?: number; }
+export interface PetrologyConvexResult { values: number[]; converged: boolean; }
+export function computePetrologyConvex(data: number[], opts: PetrologyConvexOptions = {}): PetrologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyConvex };
diff --git a/src/petrology/correlation.ts b/src/petrology/correlation.ts
new file mode 100644
index 000000000..5c371e767
--- /dev/null
+++ b/src/petrology/correlation.ts
@@ -0,0 +1,14 @@
+/** petrology correlation module — tsb analytics library. */
+export interface PetrologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyCorrelationResult { values: number[]; converged: boolean; }
+export function computePetrologyCorrelation(data: number[], opts: PetrologyCorrelationOptions = {}): PetrologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyCorrelation };
diff --git a/src/petrology/covariance.ts b/src/petrology/covariance.ts
new file mode 100644
index 000000000..5b56cc2b8
--- /dev/null
+++ b/src/petrology/covariance.ts
@@ -0,0 +1,14 @@
+/** petrology covariance module — tsb analytics library. */
+export interface PetrologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PetrologyCovarianceResult { values: number[]; converged: boolean; }
+export function computePetrologyCovariance(data: number[], opts: PetrologyCovarianceOptions = {}): PetrologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyCovariance };
diff --git a/src/petrology/cross_validation.ts b/src/petrology/cross_validation.ts
new file mode 100644
index 000000000..001f2e71f
--- /dev/null
+++ b/src/petrology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** petrology cross_validation module — tsb analytics library. */
+export interface PetrologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computePetrologyCrossValidation(data: number[], opts: PetrologyCrossValidationOptions = {}): PetrologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyCrossValidation };
diff --git a/src/petrology/decoding.ts b/src/petrology/decoding.ts
new file mode 100644
index 000000000..e19b1b94c
--- /dev/null
+++ b/src/petrology/decoding.ts
@@ -0,0 +1,14 @@
+/** petrology decoding module — tsb analytics library. */
+export interface PetrologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDecodingResult { values: number[]; converged: boolean; }
+export function computePetrologyDecoding(data: number[], opts: PetrologyDecodingOptions = {}): PetrologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDecoding };
diff --git a/src/petrology/decomposition.ts b/src/petrology/decomposition.ts
new file mode 100644
index 000000000..54686bf6b
--- /dev/null
+++ b/src/petrology/decomposition.ts
@@ -0,0 +1,14 @@
+/** petrology decomposition module — tsb analytics library. */
+export interface PetrologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDecompositionResult { values: number[]; converged: boolean; }
+export function computePetrologyDecomposition(data: number[], opts: PetrologyDecompositionOptions = {}): PetrologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDecomposition };
diff --git a/src/petrology/detection.ts b/src/petrology/detection.ts
new file mode 100644
index 000000000..ebfa897ae
--- /dev/null
+++ b/src/petrology/detection.ts
@@ -0,0 +1,14 @@
+/** petrology detection module — tsb analytics library. */
+export interface PetrologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDetectionResult { values: number[]; converged: boolean; }
+export function computePetrologyDetection(data: number[], opts: PetrologyDetectionOptions = {}): PetrologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDetection };
diff --git a/src/petrology/deterministic.ts b/src/petrology/deterministic.ts
new file mode 100644
index 000000000..6b8bca080
--- /dev/null
+++ b/src/petrology/deterministic.ts
@@ -0,0 +1,14 @@
+/** petrology deterministic module — tsb analytics library. */
+export interface PetrologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDeterministicResult { values: number[]; converged: boolean; }
+export function computePetrologyDeterministic(data: number[], opts: PetrologyDeterministicOptions = {}): PetrologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDeterministic };
diff --git a/src/petrology/diagnostics.ts b/src/petrology/diagnostics.ts
new file mode 100644
index 000000000..c96dd921e
--- /dev/null
+++ b/src/petrology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** petrology diagnostics module — tsb analytics library. */
+export interface PetrologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePetrologyDiagnostics(data: number[], opts: PetrologyDiagnosticsOptions = {}): PetrologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDiagnostics };
diff --git a/src/petrology/differential.ts b/src/petrology/differential.ts
new file mode 100644
index 000000000..1e48a4ea7
--- /dev/null
+++ b/src/petrology/differential.ts
@@ -0,0 +1,14 @@
+/** petrology differential module — tsb analytics library. */
+export interface PetrologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDifferentialResult { values: number[]; converged: boolean; }
+export function computePetrologyDifferential(data: number[], opts: PetrologyDifferentialOptions = {}): PetrologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDifferential };
diff --git a/src/petrology/discrete.ts b/src/petrology/discrete.ts
new file mode 100644
index 000000000..a90905ead
--- /dev/null
+++ b/src/petrology/discrete.ts
@@ -0,0 +1,14 @@
+/** petrology discrete module — tsb analytics library. */
+export interface PetrologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDiscreteResult { values: number[]; converged: boolean; }
+export function computePetrologyDiscrete(data: number[], opts: PetrologyDiscreteOptions = {}): PetrologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDiscrete };
diff --git a/src/petrology/distribution.ts b/src/petrology/distribution.ts
new file mode 100644
index 000000000..9190e9488
--- /dev/null
+++ b/src/petrology/distribution.ts
@@ -0,0 +1,14 @@
+/** petrology distribution module — tsb analytics library. */
+export interface PetrologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDistributionResult { values: number[]; converged: boolean; }
+export function computePetrologyDistribution(data: number[], opts: PetrologyDistributionOptions = {}): PetrologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDistribution };
diff --git a/src/petrology/dynamic.ts b/src/petrology/dynamic.ts
new file mode 100644
index 000000000..99e05cf9e
--- /dev/null
+++ b/src/petrology/dynamic.ts
@@ -0,0 +1,14 @@
+/** petrology dynamic module — tsb analytics library. */
+export interface PetrologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface PetrologyDynamicResult { values: number[]; converged: boolean; }
+export function computePetrologyDynamic(data: number[], opts: PetrologyDynamicOptions = {}): PetrologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyDynamic };
diff --git a/src/petrology/embedding.ts b/src/petrology/embedding.ts
new file mode 100644
index 000000000..f71172050
--- /dev/null
+++ b/src/petrology/embedding.ts
@@ -0,0 +1,14 @@
+/** petrology embedding module — tsb analytics library. */
+export interface PetrologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computePetrologyEmbedding(data: number[], opts: PetrologyEmbeddingOptions = {}): PetrologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyEmbedding };
diff --git a/src/petrology/encoding.ts b/src/petrology/encoding.ts
new file mode 100644
index 000000000..52fd2d93e
--- /dev/null
+++ b/src/petrology/encoding.ts
@@ -0,0 +1,14 @@
+/** petrology encoding module — tsb analytics library. */
+export interface PetrologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyEncodingResult { values: number[]; converged: boolean; }
+export function computePetrologyEncoding(data: number[], opts: PetrologyEncodingOptions = {}): PetrologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyEncoding };
diff --git a/src/petrology/ensemble.ts b/src/petrology/ensemble.ts
new file mode 100644
index 000000000..73a350eb0
--- /dev/null
+++ b/src/petrology/ensemble.ts
@@ -0,0 +1,14 @@
+/** petrology ensemble module — tsb analytics library. */
+export interface PetrologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PetrologyEnsembleResult { values: number[]; converged: boolean; }
+export function computePetrologyEnsemble(data: number[], opts: PetrologyEnsembleOptions = {}): PetrologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyEnsemble };
diff --git a/src/petrology/estimation.ts b/src/petrology/estimation.ts
new file mode 100644
index 000000000..7605918ab
--- /dev/null
+++ b/src/petrology/estimation.ts
@@ -0,0 +1,14 @@
+/** petrology estimation module — tsb analytics library. */
+export interface PetrologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyEstimationResult { values: number[]; converged: boolean; }
+export function computePetrologyEstimation(data: number[], opts: PetrologyEstimationOptions = {}): PetrologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyEstimation };
diff --git a/src/petrology/evaluation.ts b/src/petrology/evaluation.ts
new file mode 100644
index 000000000..16ae612c7
--- /dev/null
+++ b/src/petrology/evaluation.ts
@@ -0,0 +1,14 @@
+/** petrology evaluation module — tsb analytics library. */
+export interface PetrologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyEvaluationResult { values: number[]; converged: boolean; }
+export function computePetrologyEvaluation(data: number[], opts: PetrologyEvaluationOptions = {}): PetrologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyEvaluation };
diff --git a/src/petrology/extrapolation.ts b/src/petrology/extrapolation.ts
new file mode 100644
index 000000000..f2e78d0a7
--- /dev/null
+++ b/src/petrology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** petrology extrapolation module — tsb analytics library. */
+export interface PetrologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computePetrologyExtrapolation(data: number[], opts: PetrologyExtrapolationOptions = {}): PetrologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyExtrapolation };
diff --git a/src/petrology/features.ts b/src/petrology/features.ts
new file mode 100644
index 000000000..3399bced6
--- /dev/null
+++ b/src/petrology/features.ts
@@ -0,0 +1,14 @@
+/** petrology features module — tsb analytics library. */
+export interface PetrologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PetrologyFeaturesResult { values: number[]; converged: boolean; }
+export function computePetrologyFeatures(data: number[], opts: PetrologyFeaturesOptions = {}): PetrologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyFeatures };
diff --git a/src/petrology/feedback.ts b/src/petrology/feedback.ts
new file mode 100644
index 000000000..3b87df671
--- /dev/null
+++ b/src/petrology/feedback.ts
@@ -0,0 +1,14 @@
+/** petrology feedback module — tsb analytics library. */
+export interface PetrologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PetrologyFeedbackResult { values: number[]; converged: boolean; }
+export function computePetrologyFeedback(data: number[], opts: PetrologyFeedbackOptions = {}): PetrologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyFeedback };
diff --git a/src/petrology/filtering.ts b/src/petrology/filtering.ts
new file mode 100644
index 000000000..0d5cafbe4
--- /dev/null
+++ b/src/petrology/filtering.ts
@@ -0,0 +1,14 @@
+/** petrology filtering module — tsb analytics library. */
+export interface PetrologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface PetrologyFilteringResult { values: number[]; converged: boolean; }
+export function computePetrologyFiltering(data: number[], opts: PetrologyFilteringOptions = {}): PetrologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyFiltering };
diff --git a/src/petrology/fourier.ts b/src/petrology/fourier.ts
new file mode 100644
index 000000000..9f53ea2d5
--- /dev/null
+++ b/src/petrology/fourier.ts
@@ -0,0 +1,14 @@
+/** petrology fourier module — tsb analytics library. */
+export interface PetrologyFourierOptions { tol?: number; maxIter?: number; }
+export interface PetrologyFourierResult { values: number[]; converged: boolean; }
+export function computePetrologyFourier(data: number[], opts: PetrologyFourierOptions = {}): PetrologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyFourier };
diff --git a/src/petrology/fusion.ts b/src/petrology/fusion.ts
new file mode 100644
index 000000000..f56755612
--- /dev/null
+++ b/src/petrology/fusion.ts
@@ -0,0 +1,14 @@
+/** petrology fusion module — tsb analytics library. */
+export interface PetrologyFusionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyFusionResult { values: number[]; converged: boolean; }
+export function computePetrologyFusion(data: number[], opts: PetrologyFusionOptions = {}): PetrologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyFusion };
diff --git a/src/petrology/generation.ts b/src/petrology/generation.ts
new file mode 100644
index 000000000..9b62c65eb
--- /dev/null
+++ b/src/petrology/generation.ts
@@ -0,0 +1,14 @@
+/** petrology generation module — tsb analytics library. */
+export interface PetrologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyGenerationResult { values: number[]; converged: boolean; }
+export function computePetrologyGeneration(data: number[], opts: PetrologyGenerationOptions = {}): PetrologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyGeneration };
diff --git a/src/petrology/geometry.ts b/src/petrology/geometry.ts
new file mode 100644
index 000000000..8f2f3d1e7
--- /dev/null
+++ b/src/petrology/geometry.ts
@@ -0,0 +1,14 @@
+/** petrology geometry module — tsb analytics library. */
+export interface PetrologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface PetrologyGeometryResult { values: number[]; converged: boolean; }
+export function computePetrologyGeometry(data: number[], opts: PetrologyGeometryOptions = {}): PetrologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyGeometry };
diff --git a/src/petrology/gradient.ts b/src/petrology/gradient.ts
new file mode 100644
index 000000000..5b3a968be
--- /dev/null
+++ b/src/petrology/gradient.ts
@@ -0,0 +1,14 @@
+/** petrology gradient module — tsb analytics library. */
+export interface PetrologyGradientOptions { tol?: number; maxIter?: number; }
+export interface PetrologyGradientResult { values: number[]; converged: boolean; }
+export function computePetrologyGradient(data: number[], opts: PetrologyGradientOptions = {}): PetrologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyGradient };
diff --git a/src/petrology/hessian.ts b/src/petrology/hessian.ts
new file mode 100644
index 000000000..1cb42cca6
--- /dev/null
+++ b/src/petrology/hessian.ts
@@ -0,0 +1,14 @@
+/** petrology hessian module — tsb analytics library. */
+export interface PetrologyHessianOptions { tol?: number; maxIter?: number; }
+export interface PetrologyHessianResult { values: number[]; converged: boolean; }
+export function computePetrologyHessian(data: number[], opts: PetrologyHessianOptions = {}): PetrologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyHessian };
diff --git a/src/petrology/hypothesis.ts b/src/petrology/hypothesis.ts
new file mode 100644
index 000000000..7f69e3410
--- /dev/null
+++ b/src/petrology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** petrology hypothesis module — tsb analytics library. */
+export interface PetrologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PetrologyHypothesisResult { values: number[]; converged: boolean; }
+export function computePetrologyHypothesis(data: number[], opts: PetrologyHypothesisOptions = {}): PetrologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyHypothesis };
diff --git a/src/petrology/inference.ts b/src/petrology/inference.ts
new file mode 100644
index 000000000..738b6dd95
--- /dev/null
+++ b/src/petrology/inference.ts
@@ -0,0 +1,14 @@
+/** petrology inference module — tsb analytics library. */
+export interface PetrologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface PetrologyInferenceResult { values: number[]; converged: boolean; }
+export function computePetrologyInference(data: number[], opts: PetrologyInferenceOptions = {}): PetrologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyInference };
diff --git a/src/petrology/inference2.ts b/src/petrology/inference2.ts
new file mode 100644
index 000000000..857967251
--- /dev/null
+++ b/src/petrology/inference2.ts
@@ -0,0 +1,14 @@
+/** petrology inference2 module — tsb analytics library. */
+export interface PetrologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface PetrologyInferenceResult { values: number[]; converged: boolean; }
+export function computePetrologyInference(data: number[], opts: PetrologyInferenceOptions = {}): PetrologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyInference };
diff --git a/src/petrology/integral.ts b/src/petrology/integral.ts
new file mode 100644
index 000000000..018760a0e
--- /dev/null
+++ b/src/petrology/integral.ts
@@ -0,0 +1,14 @@
+/** petrology integral module — tsb analytics library. */
+export interface PetrologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface PetrologyIntegralResult { values: number[]; converged: boolean; }
+export function computePetrologyIntegral(data: number[], opts: PetrologyIntegralOptions = {}): PetrologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyIntegral };
diff --git a/src/petrology/integration.ts b/src/petrology/integration.ts
new file mode 100644
index 000000000..e5232d20c
--- /dev/null
+++ b/src/petrology/integration.ts
@@ -0,0 +1,14 @@
+/** petrology integration module — tsb analytics library. */
+export interface PetrologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyIntegrationResult { values: number[]; converged: boolean; }
+export function computePetrologyIntegration(data: number[], opts: PetrologyIntegrationOptions = {}): PetrologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyIntegration };
diff --git a/src/petrology/interpolation.ts b/src/petrology/interpolation.ts
new file mode 100644
index 000000000..d6c295e0a
--- /dev/null
+++ b/src/petrology/interpolation.ts
@@ -0,0 +1,14 @@
+/** petrology interpolation module — tsb analytics library. */
+export interface PetrologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyInterpolationResult { values: number[]; converged: boolean; }
+export function computePetrologyInterpolation(data: number[], opts: PetrologyInterpolationOptions = {}): PetrologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyInterpolation };
diff --git a/src/petrology/jacobian.ts b/src/petrology/jacobian.ts
new file mode 100644
index 000000000..5cce59e27
--- /dev/null
+++ b/src/petrology/jacobian.ts
@@ -0,0 +1,14 @@
+/** petrology jacobian module — tsb analytics library. */
+export interface PetrologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface PetrologyJacobianResult { values: number[]; converged: boolean; }
+export function computePetrologyJacobian(data: number[], opts: PetrologyJacobianOptions = {}): PetrologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyJacobian };
diff --git a/src/petrology/kernel.ts b/src/petrology/kernel.ts
new file mode 100644
index 000000000..e9a03cf9a
--- /dev/null
+++ b/src/petrology/kernel.ts
@@ -0,0 +1,14 @@
+/** petrology kernel module — tsb analytics library. */
+export interface PetrologyKernelOptions { tol?: number; maxIter?: number; }
+export interface PetrologyKernelResult { values: number[]; converged: boolean; }
+export function computePetrologyKernel(data: number[], opts: PetrologyKernelOptions = {}): PetrologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyKernel };
diff --git a/src/petrology/laplacian.ts b/src/petrology/laplacian.ts
new file mode 100644
index 000000000..17fdf7687
--- /dev/null
+++ b/src/petrology/laplacian.ts
@@ -0,0 +1,14 @@
+/** petrology laplacian module — tsb analytics library. */
+export interface PetrologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PetrologyLaplacianResult { values: number[]; converged: boolean; }
+export function computePetrologyLaplacian(data: number[], opts: PetrologyLaplacianOptions = {}): PetrologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyLaplacian };
diff --git a/src/petrology/learning.ts b/src/petrology/learning.ts
new file mode 100644
index 000000000..7e8e88bdd
--- /dev/null
+++ b/src/petrology/learning.ts
@@ -0,0 +1,14 @@
+/** petrology learning module — tsb analytics library. */
+export interface PetrologyLearningOptions { tol?: number; maxIter?: number; }
+export interface PetrologyLearningResult { values: number[]; converged: boolean; }
+export function computePetrologyLearning(data: number[], opts: PetrologyLearningOptions = {}): PetrologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyLearning };
diff --git a/src/petrology/linear.ts b/src/petrology/linear.ts
new file mode 100644
index 000000000..2449ac4e1
--- /dev/null
+++ b/src/petrology/linear.ts
@@ -0,0 +1,14 @@
+/** petrology linear module — tsb analytics library. */
+export interface PetrologyLinearOptions { tol?: number; maxIter?: number; }
+export interface PetrologyLinearResult { values: number[]; converged: boolean; }
+export function computePetrologyLinear(data: number[], opts: PetrologyLinearOptions = {}): PetrologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyLinear };
diff --git a/src/petrology/manifold.ts b/src/petrology/manifold.ts
new file mode 100644
index 000000000..742893d15
--- /dev/null
+++ b/src/petrology/manifold.ts
@@ -0,0 +1,14 @@
+/** petrology manifold module — tsb analytics library. */
+export interface PetrologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface PetrologyManifoldResult { values: number[]; converged: boolean; }
+export function computePetrologyManifold(data: number[], opts: PetrologyManifoldOptions = {}): PetrologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyManifold };
diff --git a/src/petrology/matching.ts b/src/petrology/matching.ts
new file mode 100644
index 000000000..8e5712203
--- /dev/null
+++ b/src/petrology/matching.ts
@@ -0,0 +1,14 @@
+/** petrology matching module — tsb analytics library. */
+export interface PetrologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyMatchingResult { values: number[]; converged: boolean; }
+export function computePetrologyMatching(data: number[], opts: PetrologyMatchingOptions = {}): PetrologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyMatching };
diff --git a/src/petrology/measurement.ts b/src/petrology/measurement.ts
new file mode 100644
index 000000000..582dee857
--- /dev/null
+++ b/src/petrology/measurement.ts
@@ -0,0 +1,14 @@
+/** petrology measurement module — tsb analytics library. */
+export interface PetrologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PetrologyMeasurementResult { values: number[]; converged: boolean; }
+export function computePetrologyMeasurement(data: number[], opts: PetrologyMeasurementOptions = {}): PetrologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyMeasurement };
diff --git a/src/petrology/metrics.ts b/src/petrology/metrics.ts
new file mode 100644
index 000000000..148e72b4e
--- /dev/null
+++ b/src/petrology/metrics.ts
@@ -0,0 +1,14 @@
+/** petrology metrics module — tsb analytics library. */
+export interface PetrologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface PetrologyMetricsResult { values: number[]; converged: boolean; }
+export function computePetrologyMetrics(data: number[], opts: PetrologyMetricsOptions = {}): PetrologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyMetrics };
diff --git a/src/petrology/modeling.ts b/src/petrology/modeling.ts
new file mode 100644
index 000000000..cf64d430c
--- /dev/null
+++ b/src/petrology/modeling.ts
@@ -0,0 +1,14 @@
+/** petrology modeling module — tsb analytics library. */
+export interface PetrologyModelingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyModelingResult { values: number[]; converged: boolean; }
+export function computePetrologyModeling(data: number[], opts: PetrologyModelingOptions = {}): PetrologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyModeling };
diff --git a/src/petrology/monitoring.ts b/src/petrology/monitoring.ts
new file mode 100644
index 000000000..561f90224
--- /dev/null
+++ b/src/petrology/monitoring.ts
@@ -0,0 +1,14 @@
+/** petrology monitoring module — tsb analytics library. */
+export interface PetrologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PetrologyMonitoringResult { values: number[]; converged: boolean; }
+export function computePetrologyMonitoring(data: number[], opts: PetrologyMonitoringOptions = {}): PetrologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyMonitoring };
diff --git a/src/petrology/nonlinear.ts b/src/petrology/nonlinear.ts
new file mode 100644
index 000000000..a4faa5b6c
--- /dev/null
+++ b/src/petrology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** petrology nonlinear module — tsb analytics library. */
+export interface PetrologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PetrologyNonlinearResult { values: number[]; converged: boolean; }
+export function computePetrologyNonlinear(data: number[], opts: PetrologyNonlinearOptions = {}): PetrologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyNonlinear };
diff --git a/src/petrology/normalization.ts b/src/petrology/normalization.ts
new file mode 100644
index 000000000..45f051951
--- /dev/null
+++ b/src/petrology/normalization.ts
@@ -0,0 +1,14 @@
+/** petrology normalization module — tsb analytics library. */
+export interface PetrologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyNormalizationResult { values: number[]; converged: boolean; }
+export function computePetrologyNormalization(data: number[], opts: PetrologyNormalizationOptions = {}): PetrologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyNormalization };
diff --git a/src/petrology/optimization.ts b/src/petrology/optimization.ts
new file mode 100644
index 000000000..519791f09
--- /dev/null
+++ b/src/petrology/optimization.ts
@@ -0,0 +1,14 @@
+/** petrology optimization module — tsb analytics library. */
+export interface PetrologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyOptimizationResult { values: number[]; converged: boolean; }
+export function computePetrologyOptimization(data: number[], opts: PetrologyOptimizationOptions = {}): PetrologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyOptimization };
diff --git a/src/petrology/patterns.ts b/src/petrology/patterns.ts
new file mode 100644
index 000000000..1de9b5d56
--- /dev/null
+++ b/src/petrology/patterns.ts
@@ -0,0 +1,14 @@
+/** petrology patterns module — tsb analytics library. */
+export interface PetrologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface PetrologyPatternsResult { values: number[]; converged: boolean; }
+export function computePetrologyPatterns(data: number[], opts: PetrologyPatternsOptions = {}): PetrologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyPatterns };
diff --git a/src/petrology/permutation.ts b/src/petrology/permutation.ts
new file mode 100644
index 000000000..2ad2249e0
--- /dev/null
+++ b/src/petrology/permutation.ts
@@ -0,0 +1,14 @@
+/** petrology permutation module — tsb analytics library. */
+export interface PetrologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyPermutationResult { values: number[]; converged: boolean; }
+export function computePetrologyPermutation(data: number[], opts: PetrologyPermutationOptions = {}): PetrologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyPermutation };
diff --git a/src/petrology/prediction.ts b/src/petrology/prediction.ts
new file mode 100644
index 000000000..3231855b5
--- /dev/null
+++ b/src/petrology/prediction.ts
@@ -0,0 +1,14 @@
+/** petrology prediction module — tsb analytics library. */
+export interface PetrologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyPredictionResult { values: number[]; converged: boolean; }
+export function computePetrologyPrediction(data: number[], opts: PetrologyPredictionOptions = {}): PetrologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyPrediction };
diff --git a/src/petrology/processing.ts b/src/petrology/processing.ts
new file mode 100644
index 000000000..7e7b2e57c
--- /dev/null
+++ b/src/petrology/processing.ts
@@ -0,0 +1,14 @@
+/** petrology processing module — tsb analytics library. */
+export interface PetrologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyProcessingResult { values: number[]; converged: boolean; }
+export function computePetrologyProcessing(data: number[], opts: PetrologyProcessingOptions = {}): PetrologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyProcessing };
diff --git a/src/petrology/profiling.ts b/src/petrology/profiling.ts
new file mode 100644
index 000000000..49c98f575
--- /dev/null
+++ b/src/petrology/profiling.ts
@@ -0,0 +1,14 @@
+/** petrology profiling module — tsb analytics library. */
+export interface PetrologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyProfilingResult { values: number[]; converged: boolean; }
+export function computePetrologyProfiling(data: number[], opts: PetrologyProfilingOptions = {}): PetrologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyProfiling };
diff --git a/src/petrology/projection.ts b/src/petrology/projection.ts
new file mode 100644
index 000000000..8ae8054ee
--- /dev/null
+++ b/src/petrology/projection.ts
@@ -0,0 +1,14 @@
+/** petrology projection module — tsb analytics library. */
+export interface PetrologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyProjectionResult { values: number[]; converged: boolean; }
+export function computePetrologyProjection(data: number[], opts: PetrologyProjectionOptions = {}): PetrologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyProjection };
diff --git a/src/petrology/ranking.ts b/src/petrology/ranking.ts
new file mode 100644
index 000000000..219e70cf4
--- /dev/null
+++ b/src/petrology/ranking.ts
@@ -0,0 +1,14 @@
+/** petrology ranking module — tsb analytics library. */
+export interface PetrologyRankingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyRankingResult { values: number[]; converged: boolean; }
+export function computePetrologyRanking(data: number[], opts: PetrologyRankingOptions = {}): PetrologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyRanking };
diff --git a/src/petrology/reconstruction.ts b/src/petrology/reconstruction.ts
new file mode 100644
index 000000000..f47d00d5b
--- /dev/null
+++ b/src/petrology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** petrology reconstruction module — tsb analytics library. */
+export interface PetrologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyReconstructionResult { values: number[]; converged: boolean; }
+export function computePetrologyReconstruction(data: number[], opts: PetrologyReconstructionOptions = {}): PetrologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyReconstruction };
diff --git a/src/petrology/registration.ts b/src/petrology/registration.ts
new file mode 100644
index 000000000..98eb9dd65
--- /dev/null
+++ b/src/petrology/registration.ts
@@ -0,0 +1,14 @@
+/** petrology registration module — tsb analytics library. */
+export interface PetrologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyRegistrationResult { values: number[]; converged: boolean; }
+export function computePetrologyRegistration(data: number[], opts: PetrologyRegistrationOptions = {}): PetrologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyRegistration };
diff --git a/src/petrology/regression.ts b/src/petrology/regression.ts
new file mode 100644
index 000000000..41fac4048
--- /dev/null
+++ b/src/petrology/regression.ts
@@ -0,0 +1,14 @@
+/** petrology regression module — tsb analytics library. */
+export interface PetrologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface PetrologyRegressionResult { values: number[]; converged: boolean; }
+export function computePetrologyRegression(data: number[], opts: PetrologyRegressionOptions = {}): PetrologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyRegression };
diff --git a/src/petrology/regularization.ts b/src/petrology/regularization.ts
new file mode 100644
index 000000000..02719df4f
--- /dev/null
+++ b/src/petrology/regularization.ts
@@ -0,0 +1,14 @@
+/** petrology regularization module — tsb analytics library. */
+export interface PetrologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyRegularizationResult { values: number[]; converged: boolean; }
+export function computePetrologyRegularization(data: number[], opts: PetrologyRegularizationOptions = {}): PetrologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyRegularization };
diff --git a/src/petrology/robustness.ts b/src/petrology/robustness.ts
new file mode 100644
index 000000000..36adb5dfa
--- /dev/null
+++ b/src/petrology/robustness.ts
@@ -0,0 +1,14 @@
+/** petrology robustness module — tsb analytics library. */
+export interface PetrologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PetrologyRobustnessResult { values: number[]; converged: boolean; }
+export function computePetrologyRobustness(data: number[], opts: PetrologyRobustnessOptions = {}): PetrologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyRobustness };
diff --git a/src/petrology/sampling.ts b/src/petrology/sampling.ts
new file mode 100644
index 000000000..dd23a7e90
--- /dev/null
+++ b/src/petrology/sampling.ts
@@ -0,0 +1,14 @@
+/** petrology sampling module — tsb analytics library. */
+export interface PetrologySamplingOptions { tol?: number; maxIter?: number; }
+export interface PetrologySamplingResult { values: number[]; converged: boolean; }
+export function computePetrologySampling(data: number[], opts: PetrologySamplingOptions = {}): PetrologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologySampling };
diff --git a/src/petrology/sampling2.ts b/src/petrology/sampling2.ts
new file mode 100644
index 000000000..ca64ba5f8
--- /dev/null
+++ b/src/petrology/sampling2.ts
@@ -0,0 +1,14 @@
+/** petrology sampling2 module — tsb analytics library. */
+export interface PetrologySamplingOptions { tol?: number; maxIter?: number; }
+export interface PetrologySamplingResult { values: number[]; converged: boolean; }
+export function computePetrologySampling(data: number[], opts: PetrologySamplingOptions = {}): PetrologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologySampling };
diff --git a/src/petrology/scaling.ts b/src/petrology/scaling.ts
new file mode 100644
index 000000000..72425f8ea
--- /dev/null
+++ b/src/petrology/scaling.ts
@@ -0,0 +1,14 @@
+/** petrology scaling module — tsb analytics library. */
+export interface PetrologyScalingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyScalingResult { values: number[]; converged: boolean; }
+export function computePetrologyScaling(data: number[], opts: PetrologyScalingOptions = {}): PetrologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyScaling };
diff --git a/src/petrology/scoring.ts b/src/petrology/scoring.ts
new file mode 100644
index 000000000..d739c28fc
--- /dev/null
+++ b/src/petrology/scoring.ts
@@ -0,0 +1,14 @@
+/** petrology scoring module — tsb analytics library. */
+export interface PetrologyScoringOptions { tol?: number; maxIter?: number; }
+export interface PetrologyScoringResult { values: number[]; converged: boolean; }
+export function computePetrologyScoring(data: number[], opts: PetrologyScoringOptions = {}): PetrologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyScoring };
diff --git a/src/petrology/segmentation.ts b/src/petrology/segmentation.ts
new file mode 100644
index 000000000..af1a37353
--- /dev/null
+++ b/src/petrology/segmentation.ts
@@ -0,0 +1,14 @@
+/** petrology segmentation module — tsb analytics library. */
+export interface PetrologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface PetrologySegmentationResult { values: number[]; converged: boolean; }
+export function computePetrologySegmentation(data: number[], opts: PetrologySegmentationOptions = {}): PetrologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologySegmentation };
diff --git a/src/petrology/selection.ts b/src/petrology/selection.ts
new file mode 100644
index 000000000..05f02f86c
--- /dev/null
+++ b/src/petrology/selection.ts
@@ -0,0 +1,14 @@
+/** petrology selection module — tsb analytics library. */
+export interface PetrologySelectionOptions { tol?: number; maxIter?: number; }
+export interface PetrologySelectionResult { values: number[]; converged: boolean; }
+export function computePetrologySelection(data: number[], opts: PetrologySelectionOptions = {}): PetrologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologySelection };
diff --git a/src/petrology/sensitivity.ts b/src/petrology/sensitivity.ts
new file mode 100644
index 000000000..32b02a445
--- /dev/null
+++ b/src/petrology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** petrology sensitivity module — tsb analytics library. */
+export interface PetrologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface PetrologySensitivityResult { values: number[]; converged: boolean; }
+export function computePetrologySensitivity(data: number[], opts: PetrologySensitivityOptions = {}): PetrologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologySensitivity };
diff --git a/src/petrology/simulation.ts b/src/petrology/simulation.ts
new file mode 100644
index 000000000..a030c97d0
--- /dev/null
+++ b/src/petrology/simulation.ts
@@ -0,0 +1,14 @@
+/** petrology simulation module — tsb analytics library. */
+export interface PetrologySimulationOptions { tol?: number; maxIter?: number; }
+export interface PetrologySimulationResult { values: number[]; converged: boolean; }
+export function computePetrologySimulation(data: number[], opts: PetrologySimulationOptions = {}): PetrologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologySimulation };
diff --git a/src/petrology/smoothing.ts b/src/petrology/smoothing.ts
new file mode 100644
index 000000000..7eb73530e
--- /dev/null
+++ b/src/petrology/smoothing.ts
@@ -0,0 +1,14 @@
+/** petrology smoothing module — tsb analytics library. */
+export interface PetrologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface PetrologySmoothingResult { values: number[]; converged: boolean; }
+export function computePetrologySmoothing(data: number[], opts: PetrologySmoothingOptions = {}): PetrologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologySmoothing };
diff --git a/src/petrology/stability.ts b/src/petrology/stability.ts
new file mode 100644
index 000000000..3c11466bb
--- /dev/null
+++ b/src/petrology/stability.ts
@@ -0,0 +1,14 @@
+/** petrology stability module — tsb analytics library. */
+export interface PetrologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface PetrologyStabilityResult { values: number[]; converged: boolean; }
+export function computePetrologyStability(data: number[], opts: PetrologyStabilityOptions = {}): PetrologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyStability };
diff --git a/src/petrology/stacking.ts b/src/petrology/stacking.ts
new file mode 100644
index 000000000..9f38ee6fb
--- /dev/null
+++ b/src/petrology/stacking.ts
@@ -0,0 +1,14 @@
+/** petrology stacking module — tsb analytics library. */
+export interface PetrologyStackingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyStackingResult { values: number[]; converged: boolean; }
+export function computePetrologyStacking(data: number[], opts: PetrologyStackingOptions = {}): PetrologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyStacking };
diff --git a/src/petrology/standardization.ts b/src/petrology/standardization.ts
new file mode 100644
index 000000000..e699197d2
--- /dev/null
+++ b/src/petrology/standardization.ts
@@ -0,0 +1,14 @@
+/** petrology standardization module — tsb analytics library. */
+export interface PetrologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyStandardizationResult { values: number[]; converged: boolean; }
+export function computePetrologyStandardization(data: number[], opts: PetrologyStandardizationOptions = {}): PetrologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyStandardization };
diff --git a/src/petrology/static.ts b/src/petrology/static.ts
new file mode 100644
index 000000000..b17dea37d
--- /dev/null
+++ b/src/petrology/static.ts
@@ -0,0 +1,14 @@
+/** petrology static module — tsb analytics library. */
+export interface PetrologyStaticOptions { tol?: number; maxIter?: number; }
+export interface PetrologyStaticResult { values: number[]; converged: boolean; }
+export function computePetrologyStatic(data: number[], opts: PetrologyStaticOptions = {}): PetrologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyStatic };
diff --git a/src/petrology/stochastic.ts b/src/petrology/stochastic.ts
new file mode 100644
index 000000000..f57b3f02d
--- /dev/null
+++ b/src/petrology/stochastic.ts
@@ -0,0 +1,14 @@
+/** petrology stochastic module — tsb analytics library. */
+export interface PetrologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface PetrologyStochasticResult { values: number[]; converged: boolean; }
+export function computePetrologyStochastic(data: number[], opts: PetrologyStochasticOptions = {}): PetrologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyStochastic };
diff --git a/src/petrology/synthesis.ts b/src/petrology/synthesis.ts
new file mode 100644
index 000000000..4e82e4b3f
--- /dev/null
+++ b/src/petrology/synthesis.ts
@@ -0,0 +1,14 @@
+/** petrology synthesis module — tsb analytics library. */
+export interface PetrologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface PetrologySynthesisResult { values: number[]; converged: boolean; }
+export function computePetrologySynthesis(data: number[], opts: PetrologySynthesisOptions = {}): PetrologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologySynthesis };
diff --git a/src/petrology/topology.ts b/src/petrology/topology.ts
new file mode 100644
index 000000000..6192e4a53
--- /dev/null
+++ b/src/petrology/topology.ts
@@ -0,0 +1,14 @@
+/** petrology topology module — tsb analytics library. */
+export interface PetrologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface PetrologyTopologyResult { values: number[]; converged: boolean; }
+export function computePetrologyTopology(data: number[], opts: PetrologyTopologyOptions = {}): PetrologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyTopology };
diff --git a/src/petrology/tracking.ts b/src/petrology/tracking.ts
new file mode 100644
index 000000000..04e78d614
--- /dev/null
+++ b/src/petrology/tracking.ts
@@ -0,0 +1,14 @@
+/** petrology tracking module — tsb analytics library. */
+export interface PetrologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyTrackingResult { values: number[]; converged: boolean; }
+export function computePetrologyTracking(data: number[], opts: PetrologyTrackingOptions = {}): PetrologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyTracking };
diff --git a/src/petrology/transform.ts b/src/petrology/transform.ts
new file mode 100644
index 000000000..0422aac5f
--- /dev/null
+++ b/src/petrology/transform.ts
@@ -0,0 +1,14 @@
+/** petrology transform module — tsb analytics library. */
+export interface PetrologyTransformOptions { tol?: number; maxIter?: number; }
+export interface PetrologyTransformResult { values: number[]; converged: boolean; }
+export function computePetrologyTransform(data: number[], opts: PetrologyTransformOptions = {}): PetrologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyTransform };
diff --git a/src/petrology/uncertainty.ts b/src/petrology/uncertainty.ts
new file mode 100644
index 000000000..dcc091020
--- /dev/null
+++ b/src/petrology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** petrology uncertainty module — tsb analytics library. */
+export interface PetrologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PetrologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computePetrologyUncertainty(data: number[], opts: PetrologyUncertaintyOptions = {}): PetrologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyUncertainty };
diff --git a/src/petrology/validation.ts b/src/petrology/validation.ts
new file mode 100644
index 000000000..46e5c9541
--- /dev/null
+++ b/src/petrology/validation.ts
@@ -0,0 +1,14 @@
+/** petrology validation module — tsb analytics library. */
+export interface PetrologyValidationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyValidationResult { values: number[]; converged: boolean; }
+export function computePetrologyValidation(data: number[], opts: PetrologyValidationOptions = {}): PetrologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyValidation };
diff --git a/src/petrology/verification.ts b/src/petrology/verification.ts
new file mode 100644
index 000000000..d7789afe5
--- /dev/null
+++ b/src/petrology/verification.ts
@@ -0,0 +1,14 @@
+/** petrology verification module — tsb analytics library. */
+export interface PetrologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyVerificationResult { values: number[]; converged: boolean; }
+export function computePetrologyVerification(data: number[], opts: PetrologyVerificationOptions = {}): PetrologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyVerification };
diff --git a/src/petrology/visualization.ts b/src/petrology/visualization.ts
new file mode 100644
index 000000000..09552ec34
--- /dev/null
+++ b/src/petrology/visualization.ts
@@ -0,0 +1,14 @@
+/** petrology visualization module — tsb analytics library. */
+export interface PetrologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PetrologyVisualizationResult { values: number[]; converged: boolean; }
+export function computePetrologyVisualization(data: number[], opts: PetrologyVisualizationOptions = {}): PetrologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyVisualization };
diff --git a/src/petrology/voting.ts b/src/petrology/voting.ts
new file mode 100644
index 000000000..544c05780
--- /dev/null
+++ b/src/petrology/voting.ts
@@ -0,0 +1,14 @@
+/** petrology voting module — tsb analytics library. */
+export interface PetrologyVotingOptions { tol?: number; maxIter?: number; }
+export interface PetrologyVotingResult { values: number[]; converged: boolean; }
+export function computePetrologyVoting(data: number[], opts: PetrologyVotingOptions = {}): PetrologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyVoting };
diff --git a/src/petrology/wavelet.ts b/src/petrology/wavelet.ts
new file mode 100644
index 000000000..9638a8ca9
--- /dev/null
+++ b/src/petrology/wavelet.ts
@@ -0,0 +1,14 @@
+/** petrology wavelet module — tsb analytics library. */
+export interface PetrologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface PetrologyWaveletResult { values: number[]; converged: boolean; }
+export function computePetrologyWavelet(data: number[], opts: PetrologyWaveletOptions = {}): PetrologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePetrologyWavelet };
diff --git a/src/pharmacology_sci/adaptation.ts b/src/pharmacology_sci/adaptation.ts
new file mode 100644
index 000000000..97ed53ade
--- /dev/null
+++ b/src/pharmacology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci adaptation module — tsb analytics library. */
+export interface PharmacologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciAdaptation(data: number[], opts: PharmacologySciAdaptationOptions = {}): PharmacologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciAdaptation };
diff --git a/src/pharmacology_sci/aggregation.ts b/src/pharmacology_sci/aggregation.ts
new file mode 100644
index 000000000..4de605a4e
--- /dev/null
+++ b/src/pharmacology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci aggregation module — tsb analytics library. */
+export interface PharmacologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciAggregationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciAggregation(data: number[], opts: PharmacologySciAggregationOptions = {}): PharmacologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciAggregation };
diff --git a/src/pharmacology_sci/algebra.ts b/src/pharmacology_sci/algebra.ts
new file mode 100644
index 000000000..7432b6595
--- /dev/null
+++ b/src/pharmacology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci algebra module — tsb analytics library. */
+export interface PharmacologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computePharmacologySciAlgebra(data: number[], opts: PharmacologySciAlgebraOptions = {}): PharmacologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciAlgebra };
diff --git a/src/pharmacology_sci/alignment.ts b/src/pharmacology_sci/alignment.ts
new file mode 100644
index 000000000..bf7627fde
--- /dev/null
+++ b/src/pharmacology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci alignment module — tsb analytics library. */
+export interface PharmacologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computePharmacologySciAlignment(data: number[], opts: PharmacologySciAlignmentOptions = {}): PharmacologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciAlignment };
diff --git a/src/pharmacology_sci/analysis.ts b/src/pharmacology_sci/analysis.ts
new file mode 100644
index 000000000..74db83d82
--- /dev/null
+++ b/src/pharmacology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci analysis module — tsb analytics library. */
+export interface PharmacologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computePharmacologySciAnalysis(data: number[], opts: PharmacologySciAnalysisOptions = {}): PharmacologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciAnalysis };
diff --git a/src/pharmacology_sci/augmentation.ts b/src/pharmacology_sci/augmentation.ts
new file mode 100644
index 000000000..f16b07eac
--- /dev/null
+++ b/src/pharmacology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci augmentation module — tsb analytics library. */
+export interface PharmacologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciAugmentation(data: number[], opts: PharmacologySciAugmentationOptions = {}): PharmacologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciAugmentation };
diff --git a/src/pharmacology_sci/bagging.ts b/src/pharmacology_sci/bagging.ts
new file mode 100644
index 000000000..f2b7a044b
--- /dev/null
+++ b/src/pharmacology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci bagging module — tsb analytics library. */
+export interface PharmacologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciBaggingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciBagging(data: number[], opts: PharmacologySciBaggingOptions = {}): PharmacologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciBagging };
diff --git a/src/pharmacology_sci/basis.ts b/src/pharmacology_sci/basis.ts
new file mode 100644
index 000000000..e4a17b64a
--- /dev/null
+++ b/src/pharmacology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci basis module — tsb analytics library. */
+export interface PharmacologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciBasisResult { values: number[]; converged: boolean; }
+export function computePharmacologySciBasis(data: number[], opts: PharmacologySciBasisOptions = {}): PharmacologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciBasis };
diff --git a/src/pharmacology_sci/benchmarking.ts b/src/pharmacology_sci/benchmarking.ts
new file mode 100644
index 000000000..6256d82f5
--- /dev/null
+++ b/src/pharmacology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci benchmarking module — tsb analytics library. */
+export interface PharmacologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciBenchmarking(data: number[], opts: PharmacologySciBenchmarkingOptions = {}): PharmacologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciBenchmarking };
diff --git a/src/pharmacology_sci/blending.ts b/src/pharmacology_sci/blending.ts
new file mode 100644
index 000000000..54633127f
--- /dev/null
+++ b/src/pharmacology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci blending module — tsb analytics library. */
+export interface PharmacologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciBlendingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciBlending(data: number[], opts: PharmacologySciBlendingOptions = {}): PharmacologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciBlending };
diff --git a/src/pharmacology_sci/boosting.ts b/src/pharmacology_sci/boosting.ts
new file mode 100644
index 000000000..873e000ca
--- /dev/null
+++ b/src/pharmacology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci boosting module — tsb analytics library. */
+export interface PharmacologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciBoostingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciBoosting(data: number[], opts: PharmacologySciBoostingOptions = {}): PharmacologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciBoosting };
diff --git a/src/pharmacology_sci/bootstrap.ts b/src/pharmacology_sci/bootstrap.ts
new file mode 100644
index 000000000..2018bf1e2
--- /dev/null
+++ b/src/pharmacology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci bootstrap module — tsb analytics library. */
+export interface PharmacologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computePharmacologySciBootstrap(data: number[], opts: PharmacologySciBootstrapOptions = {}): PharmacologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciBootstrap };
diff --git a/src/pharmacology_sci/calculus.ts b/src/pharmacology_sci/calculus.ts
new file mode 100644
index 000000000..cb38a08c6
--- /dev/null
+++ b/src/pharmacology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci calculus module — tsb analytics library. */
+export interface PharmacologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciCalculusResult { values: number[]; converged: boolean; }
+export function computePharmacologySciCalculus(data: number[], opts: PharmacologySciCalculusOptions = {}): PharmacologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciCalculus };
diff --git a/src/pharmacology_sci/calibration.ts b/src/pharmacology_sci/calibration.ts
new file mode 100644
index 000000000..55e7b3664
--- /dev/null
+++ b/src/pharmacology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci calibration module — tsb analytics library. */
+export interface PharmacologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciCalibration(data: number[], opts: PharmacologySciCalibrationOptions = {}): PharmacologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciCalibration };
diff --git a/src/pharmacology_sci/characterization.ts b/src/pharmacology_sci/characterization.ts
new file mode 100644
index 000000000..ec478b25c
--- /dev/null
+++ b/src/pharmacology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci characterization module — tsb analytics library. */
+export interface PharmacologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciCharacterization(data: number[], opts: PharmacologySciCharacterizationOptions = {}): PharmacologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciCharacterization };
diff --git a/src/pharmacology_sci/classification.ts b/src/pharmacology_sci/classification.ts
new file mode 100644
index 000000000..93334891f
--- /dev/null
+++ b/src/pharmacology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci classification module — tsb analytics library. */
+export interface PharmacologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciClassificationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciClassification(data: number[], opts: PharmacologySciClassificationOptions = {}): PharmacologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciClassification };
diff --git a/src/pharmacology_sci/clustering.ts b/src/pharmacology_sci/clustering.ts
new file mode 100644
index 000000000..95d6cb77d
--- /dev/null
+++ b/src/pharmacology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci clustering module — tsb analytics library. */
+export interface PharmacologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciClusteringResult { values: number[]; converged: boolean; }
+export function computePharmacologySciClustering(data: number[], opts: PharmacologySciClusteringOptions = {}): PharmacologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciClustering };
diff --git a/src/pharmacology_sci/compression.ts b/src/pharmacology_sci/compression.ts
new file mode 100644
index 000000000..62978cb49
--- /dev/null
+++ b/src/pharmacology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci compression module — tsb analytics library. */
+export interface PharmacologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciCompressionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciCompression(data: number[], opts: PharmacologySciCompressionOptions = {}): PharmacologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciCompression };
diff --git a/src/pharmacology_sci/continuous.ts b/src/pharmacology_sci/continuous.ts
new file mode 100644
index 000000000..1fcd936f8
--- /dev/null
+++ b/src/pharmacology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci continuous module — tsb analytics library. */
+export interface PharmacologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciContinuousResult { values: number[]; converged: boolean; }
+export function computePharmacologySciContinuous(data: number[], opts: PharmacologySciContinuousOptions = {}): PharmacologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciContinuous };
diff --git a/src/pharmacology_sci/control.ts b/src/pharmacology_sci/control.ts
new file mode 100644
index 000000000..47fcb3086
--- /dev/null
+++ b/src/pharmacology_sci/control.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci control module — tsb analytics library. */
+export interface PharmacologySciControlOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciControlResult { values: number[]; converged: boolean; }
+export function computePharmacologySciControl(data: number[], opts: PharmacologySciControlOptions = {}): PharmacologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciControl };
diff --git a/src/pharmacology_sci/convergence.ts b/src/pharmacology_sci/convergence.ts
new file mode 100644
index 000000000..1f8d17fd7
--- /dev/null
+++ b/src/pharmacology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci convergence module — tsb analytics library. */
+export interface PharmacologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computePharmacologySciConvergence(data: number[], opts: PharmacologySciConvergenceOptions = {}): PharmacologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciConvergence };
diff --git a/src/pharmacology_sci/convex.ts b/src/pharmacology_sci/convex.ts
new file mode 100644
index 000000000..1490f356d
--- /dev/null
+++ b/src/pharmacology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci convex module — tsb analytics library. */
+export interface PharmacologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciConvexResult { values: number[]; converged: boolean; }
+export function computePharmacologySciConvex(data: number[], opts: PharmacologySciConvexOptions = {}): PharmacologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciConvex };
diff --git a/src/pharmacology_sci/correlation.ts b/src/pharmacology_sci/correlation.ts
new file mode 100644
index 000000000..0e435928a
--- /dev/null
+++ b/src/pharmacology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci correlation module — tsb analytics library. */
+export interface PharmacologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciCorrelation(data: number[], opts: PharmacologySciCorrelationOptions = {}): PharmacologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciCorrelation };
diff --git a/src/pharmacology_sci/covariance.ts b/src/pharmacology_sci/covariance.ts
new file mode 100644
index 000000000..1e298b2a8
--- /dev/null
+++ b/src/pharmacology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci covariance module — tsb analytics library. */
+export interface PharmacologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computePharmacologySciCovariance(data: number[], opts: PharmacologySciCovarianceOptions = {}): PharmacologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciCovariance };
diff --git a/src/pharmacology_sci/cross_validation.ts b/src/pharmacology_sci/cross_validation.ts
new file mode 100644
index 000000000..8d73cd95c
--- /dev/null
+++ b/src/pharmacology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci cross_validation module — tsb analytics library. */
+export interface PharmacologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciCrossValidation(data: number[], opts: PharmacologySciCrossValidationOptions = {}): PharmacologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciCrossValidation };
diff --git a/src/pharmacology_sci/decoding.ts b/src/pharmacology_sci/decoding.ts
new file mode 100644
index 000000000..2cd15cbd9
--- /dev/null
+++ b/src/pharmacology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci decoding module — tsb analytics library. */
+export interface PharmacologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDecodingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDecoding(data: number[], opts: PharmacologySciDecodingOptions = {}): PharmacologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDecoding };
diff --git a/src/pharmacology_sci/decomposition.ts b/src/pharmacology_sci/decomposition.ts
new file mode 100644
index 000000000..1510caf00
--- /dev/null
+++ b/src/pharmacology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci decomposition module — tsb analytics library. */
+export interface PharmacologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDecomposition(data: number[], opts: PharmacologySciDecompositionOptions = {}): PharmacologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDecomposition };
diff --git a/src/pharmacology_sci/detection.ts b/src/pharmacology_sci/detection.ts
new file mode 100644
index 000000000..3e2fad618
--- /dev/null
+++ b/src/pharmacology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci detection module — tsb analytics library. */
+export interface PharmacologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDetectionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDetection(data: number[], opts: PharmacologySciDetectionOptions = {}): PharmacologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDetection };
diff --git a/src/pharmacology_sci/deterministic.ts b/src/pharmacology_sci/deterministic.ts
new file mode 100644
index 000000000..5739a5320
--- /dev/null
+++ b/src/pharmacology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci deterministic module — tsb analytics library. */
+export interface PharmacologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDeterministic(data: number[], opts: PharmacologySciDeterministicOptions = {}): PharmacologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDeterministic };
diff --git a/src/pharmacology_sci/diagnostics.ts b/src/pharmacology_sci/diagnostics.ts
new file mode 100644
index 000000000..f65b56671
--- /dev/null
+++ b/src/pharmacology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci diagnostics module — tsb analytics library. */
+export interface PharmacologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDiagnostics(data: number[], opts: PharmacologySciDiagnosticsOptions = {}): PharmacologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDiagnostics };
diff --git a/src/pharmacology_sci/differential.ts b/src/pharmacology_sci/differential.ts
new file mode 100644
index 000000000..b4e24e6f8
--- /dev/null
+++ b/src/pharmacology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci differential module — tsb analytics library. */
+export interface PharmacologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDifferential(data: number[], opts: PharmacologySciDifferentialOptions = {}): PharmacologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDifferential };
diff --git a/src/pharmacology_sci/discrete.ts b/src/pharmacology_sci/discrete.ts
new file mode 100644
index 000000000..c9dc4d19d
--- /dev/null
+++ b/src/pharmacology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci discrete module — tsb analytics library. */
+export interface PharmacologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDiscrete(data: number[], opts: PharmacologySciDiscreteOptions = {}): PharmacologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDiscrete };
diff --git a/src/pharmacology_sci/distribution.ts b/src/pharmacology_sci/distribution.ts
new file mode 100644
index 000000000..129e32c98
--- /dev/null
+++ b/src/pharmacology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci distribution module — tsb analytics library. */
+export interface PharmacologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDistributionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDistribution(data: number[], opts: PharmacologySciDistributionOptions = {}): PharmacologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDistribution };
diff --git a/src/pharmacology_sci/dynamic.ts b/src/pharmacology_sci/dynamic.ts
new file mode 100644
index 000000000..20ee7bd03
--- /dev/null
+++ b/src/pharmacology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci dynamic module — tsb analytics library. */
+export interface PharmacologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciDynamicResult { values: number[]; converged: boolean; }
+export function computePharmacologySciDynamic(data: number[], opts: PharmacologySciDynamicOptions = {}): PharmacologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciDynamic };
diff --git a/src/pharmacology_sci/embedding.ts b/src/pharmacology_sci/embedding.ts
new file mode 100644
index 000000000..e043f55bb
--- /dev/null
+++ b/src/pharmacology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci embedding module — tsb analytics library. */
+export interface PharmacologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciEmbedding(data: number[], opts: PharmacologySciEmbeddingOptions = {}): PharmacologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciEmbedding };
diff --git a/src/pharmacology_sci/encoding.ts b/src/pharmacology_sci/encoding.ts
new file mode 100644
index 000000000..7cf43edc3
--- /dev/null
+++ b/src/pharmacology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci encoding module — tsb analytics library. */
+export interface PharmacologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciEncodingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciEncoding(data: number[], opts: PharmacologySciEncodingOptions = {}): PharmacologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciEncoding };
diff --git a/src/pharmacology_sci/ensemble.ts b/src/pharmacology_sci/ensemble.ts
new file mode 100644
index 000000000..e5bb0eda4
--- /dev/null
+++ b/src/pharmacology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci ensemble module — tsb analytics library. */
+export interface PharmacologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computePharmacologySciEnsemble(data: number[], opts: PharmacologySciEnsembleOptions = {}): PharmacologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciEnsemble };
diff --git a/src/pharmacology_sci/estimation.ts b/src/pharmacology_sci/estimation.ts
new file mode 100644
index 000000000..70f00d5ec
--- /dev/null
+++ b/src/pharmacology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci estimation module — tsb analytics library. */
+export interface PharmacologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciEstimationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciEstimation(data: number[], opts: PharmacologySciEstimationOptions = {}): PharmacologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciEstimation };
diff --git a/src/pharmacology_sci/evaluation.ts b/src/pharmacology_sci/evaluation.ts
new file mode 100644
index 000000000..b2d8fe66c
--- /dev/null
+++ b/src/pharmacology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci evaluation module — tsb analytics library. */
+export interface PharmacologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciEvaluation(data: number[], opts: PharmacologySciEvaluationOptions = {}): PharmacologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciEvaluation };
diff --git a/src/pharmacology_sci/extrapolation.ts b/src/pharmacology_sci/extrapolation.ts
new file mode 100644
index 000000000..173a6214c
--- /dev/null
+++ b/src/pharmacology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci extrapolation module — tsb analytics library. */
+export interface PharmacologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciExtrapolation(data: number[], opts: PharmacologySciExtrapolationOptions = {}): PharmacologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciExtrapolation };
diff --git a/src/pharmacology_sci/features.ts b/src/pharmacology_sci/features.ts
new file mode 100644
index 000000000..adbe93385
--- /dev/null
+++ b/src/pharmacology_sci/features.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci features module — tsb analytics library. */
+export interface PharmacologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computePharmacologySciFeatures(data: number[], opts: PharmacologySciFeaturesOptions = {}): PharmacologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciFeatures };
diff --git a/src/pharmacology_sci/feedback.ts b/src/pharmacology_sci/feedback.ts
new file mode 100644
index 000000000..d438ef40a
--- /dev/null
+++ b/src/pharmacology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci feedback module — tsb analytics library. */
+export interface PharmacologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computePharmacologySciFeedback(data: number[], opts: PharmacologySciFeedbackOptions = {}): PharmacologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciFeedback };
diff --git a/src/pharmacology_sci/filtering.ts b/src/pharmacology_sci/filtering.ts
new file mode 100644
index 000000000..477e1d936
--- /dev/null
+++ b/src/pharmacology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci filtering module — tsb analytics library. */
+export interface PharmacologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciFilteringResult { values: number[]; converged: boolean; }
+export function computePharmacologySciFiltering(data: number[], opts: PharmacologySciFilteringOptions = {}): PharmacologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciFiltering };
diff --git a/src/pharmacology_sci/fourier.ts b/src/pharmacology_sci/fourier.ts
new file mode 100644
index 000000000..db3b5c87d
--- /dev/null
+++ b/src/pharmacology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci fourier module — tsb analytics library. */
+export interface PharmacologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciFourierResult { values: number[]; converged: boolean; }
+export function computePharmacologySciFourier(data: number[], opts: PharmacologySciFourierOptions = {}): PharmacologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciFourier };
diff --git a/src/pharmacology_sci/fusion.ts b/src/pharmacology_sci/fusion.ts
new file mode 100644
index 000000000..937cc4ec4
--- /dev/null
+++ b/src/pharmacology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci fusion module — tsb analytics library. */
+export interface PharmacologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciFusionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciFusion(data: number[], opts: PharmacologySciFusionOptions = {}): PharmacologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciFusion };
diff --git a/src/pharmacology_sci/generation.ts b/src/pharmacology_sci/generation.ts
new file mode 100644
index 000000000..2e728b63e
--- /dev/null
+++ b/src/pharmacology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci generation module — tsb analytics library. */
+export interface PharmacologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciGenerationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciGeneration(data: number[], opts: PharmacologySciGenerationOptions = {}): PharmacologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciGeneration };
diff --git a/src/pharmacology_sci/geometry.ts b/src/pharmacology_sci/geometry.ts
new file mode 100644
index 000000000..7b3fc0c08
--- /dev/null
+++ b/src/pharmacology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci geometry module — tsb analytics library. */
+export interface PharmacologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciGeometryResult { values: number[]; converged: boolean; }
+export function computePharmacologySciGeometry(data: number[], opts: PharmacologySciGeometryOptions = {}): PharmacologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciGeometry };
diff --git a/src/pharmacology_sci/gradient.ts b/src/pharmacology_sci/gradient.ts
new file mode 100644
index 000000000..fc5833cb1
--- /dev/null
+++ b/src/pharmacology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci gradient module — tsb analytics library. */
+export interface PharmacologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciGradientResult { values: number[]; converged: boolean; }
+export function computePharmacologySciGradient(data: number[], opts: PharmacologySciGradientOptions = {}): PharmacologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciGradient };
diff --git a/src/pharmacology_sci/hessian.ts b/src/pharmacology_sci/hessian.ts
new file mode 100644
index 000000000..727d9ff43
--- /dev/null
+++ b/src/pharmacology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci hessian module — tsb analytics library. */
+export interface PharmacologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciHessianResult { values: number[]; converged: boolean; }
+export function computePharmacologySciHessian(data: number[], opts: PharmacologySciHessianOptions = {}): PharmacologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciHessian };
diff --git a/src/pharmacology_sci/hypothesis.ts b/src/pharmacology_sci/hypothesis.ts
new file mode 100644
index 000000000..56b7dc7af
--- /dev/null
+++ b/src/pharmacology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci hypothesis module — tsb analytics library. */
+export interface PharmacologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computePharmacologySciHypothesis(data: number[], opts: PharmacologySciHypothesisOptions = {}): PharmacologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciHypothesis };
diff --git a/src/pharmacology_sci/inference.ts b/src/pharmacology_sci/inference.ts
new file mode 100644
index 000000000..b4b53633e
--- /dev/null
+++ b/src/pharmacology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci inference module — tsb analytics library. */
+export interface PharmacologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciInferenceResult { values: number[]; converged: boolean; }
+export function computePharmacologySciInference(data: number[], opts: PharmacologySciInferenceOptions = {}): PharmacologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciInference };
diff --git a/src/pharmacology_sci/inference2.ts b/src/pharmacology_sci/inference2.ts
new file mode 100644
index 000000000..5316da3d1
--- /dev/null
+++ b/src/pharmacology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci inference2 module — tsb analytics library. */
+export interface PharmacologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciInferenceResult { values: number[]; converged: boolean; }
+export function computePharmacologySciInference(data: number[], opts: PharmacologySciInferenceOptions = {}): PharmacologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciInference };
diff --git a/src/pharmacology_sci/integral.ts b/src/pharmacology_sci/integral.ts
new file mode 100644
index 000000000..a76dbfbab
--- /dev/null
+++ b/src/pharmacology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci integral module — tsb analytics library. */
+export interface PharmacologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciIntegralResult { values: number[]; converged: boolean; }
+export function computePharmacologySciIntegral(data: number[], opts: PharmacologySciIntegralOptions = {}): PharmacologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciIntegral };
diff --git a/src/pharmacology_sci/integration.ts b/src/pharmacology_sci/integration.ts
new file mode 100644
index 000000000..f78c4fe25
--- /dev/null
+++ b/src/pharmacology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci integration module — tsb analytics library. */
+export interface PharmacologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciIntegration(data: number[], opts: PharmacologySciIntegrationOptions = {}): PharmacologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciIntegration };
diff --git a/src/pharmacology_sci/interpolation.ts b/src/pharmacology_sci/interpolation.ts
new file mode 100644
index 000000000..18f92f6d8
--- /dev/null
+++ b/src/pharmacology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci interpolation module — tsb analytics library. */
+export interface PharmacologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciInterpolation(data: number[], opts: PharmacologySciInterpolationOptions = {}): PharmacologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciInterpolation };
diff --git a/src/pharmacology_sci/jacobian.ts b/src/pharmacology_sci/jacobian.ts
new file mode 100644
index 000000000..cc80e0fdb
--- /dev/null
+++ b/src/pharmacology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci jacobian module — tsb analytics library. */
+export interface PharmacologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciJacobianResult { values: number[]; converged: boolean; }
+export function computePharmacologySciJacobian(data: number[], opts: PharmacologySciJacobianOptions = {}): PharmacologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciJacobian };
diff --git a/src/pharmacology_sci/kernel.ts b/src/pharmacology_sci/kernel.ts
new file mode 100644
index 000000000..5f9d58d48
--- /dev/null
+++ b/src/pharmacology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci kernel module — tsb analytics library. */
+export interface PharmacologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciKernelResult { values: number[]; converged: boolean; }
+export function computePharmacologySciKernel(data: number[], opts: PharmacologySciKernelOptions = {}): PharmacologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciKernel };
diff --git a/src/pharmacology_sci/laplacian.ts b/src/pharmacology_sci/laplacian.ts
new file mode 100644
index 000000000..6bd2b8709
--- /dev/null
+++ b/src/pharmacology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci laplacian module — tsb analytics library. */
+export interface PharmacologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computePharmacologySciLaplacian(data: number[], opts: PharmacologySciLaplacianOptions = {}): PharmacologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciLaplacian };
diff --git a/src/pharmacology_sci/learning.ts b/src/pharmacology_sci/learning.ts
new file mode 100644
index 000000000..4a230d7c8
--- /dev/null
+++ b/src/pharmacology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci learning module — tsb analytics library. */
+export interface PharmacologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciLearningResult { values: number[]; converged: boolean; }
+export function computePharmacologySciLearning(data: number[], opts: PharmacologySciLearningOptions = {}): PharmacologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciLearning };
diff --git a/src/pharmacology_sci/linear.ts b/src/pharmacology_sci/linear.ts
new file mode 100644
index 000000000..122806533
--- /dev/null
+++ b/src/pharmacology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci linear module — tsb analytics library. */
+export interface PharmacologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciLinearResult { values: number[]; converged: boolean; }
+export function computePharmacologySciLinear(data: number[], opts: PharmacologySciLinearOptions = {}): PharmacologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciLinear };
diff --git a/src/pharmacology_sci/manifold.ts b/src/pharmacology_sci/manifold.ts
new file mode 100644
index 000000000..04167e71d
--- /dev/null
+++ b/src/pharmacology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci manifold module — tsb analytics library. */
+export interface PharmacologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciManifoldResult { values: number[]; converged: boolean; }
+export function computePharmacologySciManifold(data: number[], opts: PharmacologySciManifoldOptions = {}): PharmacologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciManifold };
diff --git a/src/pharmacology_sci/matching.ts b/src/pharmacology_sci/matching.ts
new file mode 100644
index 000000000..7979d75a8
--- /dev/null
+++ b/src/pharmacology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci matching module — tsb analytics library. */
+export interface PharmacologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciMatchingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciMatching(data: number[], opts: PharmacologySciMatchingOptions = {}): PharmacologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciMatching };
diff --git a/src/pharmacology_sci/measurement.ts b/src/pharmacology_sci/measurement.ts
new file mode 100644
index 000000000..2c6541e27
--- /dev/null
+++ b/src/pharmacology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci measurement module — tsb analytics library. */
+export interface PharmacologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computePharmacologySciMeasurement(data: number[], opts: PharmacologySciMeasurementOptions = {}): PharmacologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciMeasurement };
diff --git a/src/pharmacology_sci/metrics.ts b/src/pharmacology_sci/metrics.ts
new file mode 100644
index 000000000..5efa91dab
--- /dev/null
+++ b/src/pharmacology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci metrics module — tsb analytics library. */
+export interface PharmacologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciMetricsResult { values: number[]; converged: boolean; }
+export function computePharmacologySciMetrics(data: number[], opts: PharmacologySciMetricsOptions = {}): PharmacologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciMetrics };
diff --git a/src/pharmacology_sci/modeling.ts b/src/pharmacology_sci/modeling.ts
new file mode 100644
index 000000000..4272a8827
--- /dev/null
+++ b/src/pharmacology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci modeling module — tsb analytics library. */
+export interface PharmacologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciModelingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciModeling(data: number[], opts: PharmacologySciModelingOptions = {}): PharmacologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciModeling };
diff --git a/src/pharmacology_sci/monitoring.ts b/src/pharmacology_sci/monitoring.ts
new file mode 100644
index 000000000..a502adf29
--- /dev/null
+++ b/src/pharmacology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci monitoring module — tsb analytics library. */
+export interface PharmacologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computePharmacologySciMonitoring(data: number[], opts: PharmacologySciMonitoringOptions = {}): PharmacologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciMonitoring };
diff --git a/src/pharmacology_sci/nonlinear.ts b/src/pharmacology_sci/nonlinear.ts
new file mode 100644
index 000000000..b5621c721
--- /dev/null
+++ b/src/pharmacology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci nonlinear module — tsb analytics library. */
+export interface PharmacologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computePharmacologySciNonlinear(data: number[], opts: PharmacologySciNonlinearOptions = {}): PharmacologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciNonlinear };
diff --git a/src/pharmacology_sci/normalization.ts b/src/pharmacology_sci/normalization.ts
new file mode 100644
index 000000000..bc6f3e88b
--- /dev/null
+++ b/src/pharmacology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci normalization module — tsb analytics library. */
+export interface PharmacologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciNormalization(data: number[], opts: PharmacologySciNormalizationOptions = {}): PharmacologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciNormalization };
diff --git a/src/pharmacology_sci/optimization.ts b/src/pharmacology_sci/optimization.ts
new file mode 100644
index 000000000..9a8c25b71
--- /dev/null
+++ b/src/pharmacology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci optimization module — tsb analytics library. */
+export interface PharmacologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciOptimization(data: number[], opts: PharmacologySciOptimizationOptions = {}): PharmacologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciOptimization };
diff --git a/src/pharmacology_sci/patterns.ts b/src/pharmacology_sci/patterns.ts
new file mode 100644
index 000000000..caf6d5bb2
--- /dev/null
+++ b/src/pharmacology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci patterns module — tsb analytics library. */
+export interface PharmacologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciPatternsResult { values: number[]; converged: boolean; }
+export function computePharmacologySciPatterns(data: number[], opts: PharmacologySciPatternsOptions = {}): PharmacologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciPatterns };
diff --git a/src/pharmacology_sci/permutation.ts b/src/pharmacology_sci/permutation.ts
new file mode 100644
index 000000000..4bf0bfd5b
--- /dev/null
+++ b/src/pharmacology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci permutation module — tsb analytics library. */
+export interface PharmacologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciPermutationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciPermutation(data: number[], opts: PharmacologySciPermutationOptions = {}): PharmacologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciPermutation };
diff --git a/src/pharmacology_sci/prediction.ts b/src/pharmacology_sci/prediction.ts
new file mode 100644
index 000000000..52ba89290
--- /dev/null
+++ b/src/pharmacology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci prediction module — tsb analytics library. */
+export interface PharmacologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciPredictionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciPrediction(data: number[], opts: PharmacologySciPredictionOptions = {}): PharmacologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciPrediction };
diff --git a/src/pharmacology_sci/processing.ts b/src/pharmacology_sci/processing.ts
new file mode 100644
index 000000000..a9cb00391
--- /dev/null
+++ b/src/pharmacology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci processing module — tsb analytics library. */
+export interface PharmacologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciProcessingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciProcessing(data: number[], opts: PharmacologySciProcessingOptions = {}): PharmacologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciProcessing };
diff --git a/src/pharmacology_sci/profiling.ts b/src/pharmacology_sci/profiling.ts
new file mode 100644
index 000000000..93c69786c
--- /dev/null
+++ b/src/pharmacology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci profiling module — tsb analytics library. */
+export interface PharmacologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciProfilingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciProfiling(data: number[], opts: PharmacologySciProfilingOptions = {}): PharmacologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciProfiling };
diff --git a/src/pharmacology_sci/projection.ts b/src/pharmacology_sci/projection.ts
new file mode 100644
index 000000000..add10ceeb
--- /dev/null
+++ b/src/pharmacology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci projection module — tsb analytics library. */
+export interface PharmacologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciProjectionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciProjection(data: number[], opts: PharmacologySciProjectionOptions = {}): PharmacologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciProjection };
diff --git a/src/pharmacology_sci/ranking.ts b/src/pharmacology_sci/ranking.ts
new file mode 100644
index 000000000..be87f74b0
--- /dev/null
+++ b/src/pharmacology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci ranking module — tsb analytics library. */
+export interface PharmacologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciRankingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciRanking(data: number[], opts: PharmacologySciRankingOptions = {}): PharmacologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciRanking };
diff --git a/src/pharmacology_sci/reconstruction.ts b/src/pharmacology_sci/reconstruction.ts
new file mode 100644
index 000000000..96391cde8
--- /dev/null
+++ b/src/pharmacology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci reconstruction module — tsb analytics library. */
+export interface PharmacologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciReconstruction(data: number[], opts: PharmacologySciReconstructionOptions = {}): PharmacologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciReconstruction };
diff --git a/src/pharmacology_sci/registration.ts b/src/pharmacology_sci/registration.ts
new file mode 100644
index 000000000..f0b0f7dc4
--- /dev/null
+++ b/src/pharmacology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci registration module — tsb analytics library. */
+export interface PharmacologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciRegistration(data: number[], opts: PharmacologySciRegistrationOptions = {}): PharmacologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciRegistration };
diff --git a/src/pharmacology_sci/regression.ts b/src/pharmacology_sci/regression.ts
new file mode 100644
index 000000000..e2cf9e5c7
--- /dev/null
+++ b/src/pharmacology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci regression module — tsb analytics library. */
+export interface PharmacologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciRegressionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciRegression(data: number[], opts: PharmacologySciRegressionOptions = {}): PharmacologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciRegression };
diff --git a/src/pharmacology_sci/regularization.ts b/src/pharmacology_sci/regularization.ts
new file mode 100644
index 000000000..cf8a46ab8
--- /dev/null
+++ b/src/pharmacology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci regularization module — tsb analytics library. */
+export interface PharmacologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciRegularization(data: number[], opts: PharmacologySciRegularizationOptions = {}): PharmacologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciRegularization };
diff --git a/src/pharmacology_sci/robustness.ts b/src/pharmacology_sci/robustness.ts
new file mode 100644
index 000000000..1329fb86c
--- /dev/null
+++ b/src/pharmacology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci robustness module — tsb analytics library. */
+export interface PharmacologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computePharmacologySciRobustness(data: number[], opts: PharmacologySciRobustnessOptions = {}): PharmacologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciRobustness };
diff --git a/src/pharmacology_sci/sampling.ts b/src/pharmacology_sci/sampling.ts
new file mode 100644
index 000000000..55ad9d97a
--- /dev/null
+++ b/src/pharmacology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci sampling module — tsb analytics library. */
+export interface PharmacologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciSamplingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciSampling(data: number[], opts: PharmacologySciSamplingOptions = {}): PharmacologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciSampling };
diff --git a/src/pharmacology_sci/sampling2.ts b/src/pharmacology_sci/sampling2.ts
new file mode 100644
index 000000000..e6a7244b3
--- /dev/null
+++ b/src/pharmacology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci sampling2 module — tsb analytics library. */
+export interface PharmacologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciSamplingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciSampling(data: number[], opts: PharmacologySciSamplingOptions = {}): PharmacologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciSampling };
diff --git a/src/pharmacology_sci/scaling.ts b/src/pharmacology_sci/scaling.ts
new file mode 100644
index 000000000..ea42a2066
--- /dev/null
+++ b/src/pharmacology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci scaling module — tsb analytics library. */
+export interface PharmacologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciScalingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciScaling(data: number[], opts: PharmacologySciScalingOptions = {}): PharmacologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciScaling };
diff --git a/src/pharmacology_sci/scoring.ts b/src/pharmacology_sci/scoring.ts
new file mode 100644
index 000000000..21ade94cf
--- /dev/null
+++ b/src/pharmacology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci scoring module — tsb analytics library. */
+export interface PharmacologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciScoringResult { values: number[]; converged: boolean; }
+export function computePharmacologySciScoring(data: number[], opts: PharmacologySciScoringOptions = {}): PharmacologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciScoring };
diff --git a/src/pharmacology_sci/segmentation.ts b/src/pharmacology_sci/segmentation.ts
new file mode 100644
index 000000000..59f8d0666
--- /dev/null
+++ b/src/pharmacology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci segmentation module — tsb analytics library. */
+export interface PharmacologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciSegmentation(data: number[], opts: PharmacologySciSegmentationOptions = {}): PharmacologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciSegmentation };
diff --git a/src/pharmacology_sci/selection.ts b/src/pharmacology_sci/selection.ts
new file mode 100644
index 000000000..1bb4dc005
--- /dev/null
+++ b/src/pharmacology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci selection module — tsb analytics library. */
+export interface PharmacologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciSelectionResult { values: number[]; converged: boolean; }
+export function computePharmacologySciSelection(data: number[], opts: PharmacologySciSelectionOptions = {}): PharmacologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciSelection };
diff --git a/src/pharmacology_sci/sensitivity.ts b/src/pharmacology_sci/sensitivity.ts
new file mode 100644
index 000000000..8bd73f645
--- /dev/null
+++ b/src/pharmacology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci sensitivity module — tsb analytics library. */
+export interface PharmacologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computePharmacologySciSensitivity(data: number[], opts: PharmacologySciSensitivityOptions = {}): PharmacologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciSensitivity };
diff --git a/src/pharmacology_sci/simulation.ts b/src/pharmacology_sci/simulation.ts
new file mode 100644
index 000000000..b69e954ac
--- /dev/null
+++ b/src/pharmacology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci simulation module — tsb analytics library. */
+export interface PharmacologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciSimulationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciSimulation(data: number[], opts: PharmacologySciSimulationOptions = {}): PharmacologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciSimulation };
diff --git a/src/pharmacology_sci/smoothing.ts b/src/pharmacology_sci/smoothing.ts
new file mode 100644
index 000000000..876380d8f
--- /dev/null
+++ b/src/pharmacology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci smoothing module — tsb analytics library. */
+export interface PharmacologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciSmoothing(data: number[], opts: PharmacologySciSmoothingOptions = {}): PharmacologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciSmoothing };
diff --git a/src/pharmacology_sci/stability.ts b/src/pharmacology_sci/stability.ts
new file mode 100644
index 000000000..e1538ea04
--- /dev/null
+++ b/src/pharmacology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci stability module — tsb analytics library. */
+export interface PharmacologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciStabilityResult { values: number[]; converged: boolean; }
+export function computePharmacologySciStability(data: number[], opts: PharmacologySciStabilityOptions = {}): PharmacologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciStability };
diff --git a/src/pharmacology_sci/stacking.ts b/src/pharmacology_sci/stacking.ts
new file mode 100644
index 000000000..86ac5c7b1
--- /dev/null
+++ b/src/pharmacology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci stacking module — tsb analytics library. */
+export interface PharmacologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciStackingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciStacking(data: number[], opts: PharmacologySciStackingOptions = {}): PharmacologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciStacking };
diff --git a/src/pharmacology_sci/standardization.ts b/src/pharmacology_sci/standardization.ts
new file mode 100644
index 000000000..cbb948e6f
--- /dev/null
+++ b/src/pharmacology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci standardization module — tsb analytics library. */
+export interface PharmacologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciStandardization(data: number[], opts: PharmacologySciStandardizationOptions = {}): PharmacologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciStandardization };
diff --git a/src/pharmacology_sci/static.ts b/src/pharmacology_sci/static.ts
new file mode 100644
index 000000000..41fd17ed3
--- /dev/null
+++ b/src/pharmacology_sci/static.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci static module — tsb analytics library. */
+export interface PharmacologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciStaticResult { values: number[]; converged: boolean; }
+export function computePharmacologySciStatic(data: number[], opts: PharmacologySciStaticOptions = {}): PharmacologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciStatic };
diff --git a/src/pharmacology_sci/stochastic.ts b/src/pharmacology_sci/stochastic.ts
new file mode 100644
index 000000000..9bc554099
--- /dev/null
+++ b/src/pharmacology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci stochastic module — tsb analytics library. */
+export interface PharmacologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciStochasticResult { values: number[]; converged: boolean; }
+export function computePharmacologySciStochastic(data: number[], opts: PharmacologySciStochasticOptions = {}): PharmacologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciStochastic };
diff --git a/src/pharmacology_sci/synthesis.ts b/src/pharmacology_sci/synthesis.ts
new file mode 100644
index 000000000..fd0f347f9
--- /dev/null
+++ b/src/pharmacology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci synthesis module — tsb analytics library. */
+export interface PharmacologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computePharmacologySciSynthesis(data: number[], opts: PharmacologySciSynthesisOptions = {}): PharmacologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciSynthesis };
diff --git a/src/pharmacology_sci/topology.ts b/src/pharmacology_sci/topology.ts
new file mode 100644
index 000000000..da9f167f5
--- /dev/null
+++ b/src/pharmacology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci topology module — tsb analytics library. */
+export interface PharmacologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciTopologyResult { values: number[]; converged: boolean; }
+export function computePharmacologySciTopology(data: number[], opts: PharmacologySciTopologyOptions = {}): PharmacologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciTopology };
diff --git a/src/pharmacology_sci/tracking.ts b/src/pharmacology_sci/tracking.ts
new file mode 100644
index 000000000..a9610ddbd
--- /dev/null
+++ b/src/pharmacology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci tracking module — tsb analytics library. */
+export interface PharmacologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciTrackingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciTracking(data: number[], opts: PharmacologySciTrackingOptions = {}): PharmacologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciTracking };
diff --git a/src/pharmacology_sci/transform.ts b/src/pharmacology_sci/transform.ts
new file mode 100644
index 000000000..4d3f8b739
--- /dev/null
+++ b/src/pharmacology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci transform module — tsb analytics library. */
+export interface PharmacologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciTransformResult { values: number[]; converged: boolean; }
+export function computePharmacologySciTransform(data: number[], opts: PharmacologySciTransformOptions = {}): PharmacologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciTransform };
diff --git a/src/pharmacology_sci/uncertainty.ts b/src/pharmacology_sci/uncertainty.ts
new file mode 100644
index 000000000..911570296
--- /dev/null
+++ b/src/pharmacology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci uncertainty module — tsb analytics library. */
+export interface PharmacologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computePharmacologySciUncertainty(data: number[], opts: PharmacologySciUncertaintyOptions = {}): PharmacologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciUncertainty };
diff --git a/src/pharmacology_sci/validation.ts b/src/pharmacology_sci/validation.ts
new file mode 100644
index 000000000..d8db5c52d
--- /dev/null
+++ b/src/pharmacology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci validation module — tsb analytics library. */
+export interface PharmacologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciValidationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciValidation(data: number[], opts: PharmacologySciValidationOptions = {}): PharmacologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciValidation };
diff --git a/src/pharmacology_sci/verification.ts b/src/pharmacology_sci/verification.ts
new file mode 100644
index 000000000..a7d78f4b4
--- /dev/null
+++ b/src/pharmacology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci verification module — tsb analytics library. */
+export interface PharmacologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciVerificationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciVerification(data: number[], opts: PharmacologySciVerificationOptions = {}): PharmacologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciVerification };
diff --git a/src/pharmacology_sci/visualization.ts b/src/pharmacology_sci/visualization.ts
new file mode 100644
index 000000000..869d6d66c
--- /dev/null
+++ b/src/pharmacology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci visualization module — tsb analytics library. */
+export interface PharmacologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computePharmacologySciVisualization(data: number[], opts: PharmacologySciVisualizationOptions = {}): PharmacologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciVisualization };
diff --git a/src/pharmacology_sci/voting.ts b/src/pharmacology_sci/voting.ts
new file mode 100644
index 000000000..682cbf434
--- /dev/null
+++ b/src/pharmacology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci voting module — tsb analytics library. */
+export interface PharmacologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciVotingResult { values: number[]; converged: boolean; }
+export function computePharmacologySciVoting(data: number[], opts: PharmacologySciVotingOptions = {}): PharmacologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciVoting };
diff --git a/src/pharmacology_sci/wavelet.ts b/src/pharmacology_sci/wavelet.ts
new file mode 100644
index 000000000..76b5f143b
--- /dev/null
+++ b/src/pharmacology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** pharmacology_sci wavelet module — tsb analytics library. */
+export interface PharmacologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface PharmacologySciWaveletResult { values: number[]; converged: boolean; }
+export function computePharmacologySciWavelet(data: number[], opts: PharmacologySciWaveletOptions = {}): PharmacologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePharmacologySciWavelet };
diff --git a/src/photochemistry/adaptation.ts b/src/photochemistry/adaptation.ts
new file mode 100644
index 000000000..fb769c872
--- /dev/null
+++ b/src/photochemistry/adaptation.ts
@@ -0,0 +1,14 @@
+/** photochemistry adaptation module — tsb analytics library. */
+export interface PhotochemistryAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryAdaptationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryAdaptation(data: number[], opts: PhotochemistryAdaptationOptions = {}): PhotochemistryAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryAdaptation };
diff --git a/src/photochemistry/aggregation.ts b/src/photochemistry/aggregation.ts
new file mode 100644
index 000000000..ad225d22c
--- /dev/null
+++ b/src/photochemistry/aggregation.ts
@@ -0,0 +1,14 @@
+/** photochemistry aggregation module — tsb analytics library. */
+export interface PhotochemistryAggregationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryAggregationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryAggregation(data: number[], opts: PhotochemistryAggregationOptions = {}): PhotochemistryAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryAggregation };
diff --git a/src/photochemistry/algebra.ts b/src/photochemistry/algebra.ts
new file mode 100644
index 000000000..a49f10027
--- /dev/null
+++ b/src/photochemistry/algebra.ts
@@ -0,0 +1,14 @@
+/** photochemistry algebra module — tsb analytics library. */
+export interface PhotochemistryAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryAlgebraResult { values: number[]; converged: boolean; }
+export function computePhotochemistryAlgebra(data: number[], opts: PhotochemistryAlgebraOptions = {}): PhotochemistryAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryAlgebra };
diff --git a/src/photochemistry/alignment.ts b/src/photochemistry/alignment.ts
new file mode 100644
index 000000000..cec3a06c5
--- /dev/null
+++ b/src/photochemistry/alignment.ts
@@ -0,0 +1,14 @@
+/** photochemistry alignment module — tsb analytics library. */
+export interface PhotochemistryAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryAlignmentResult { values: number[]; converged: boolean; }
+export function computePhotochemistryAlignment(data: number[], opts: PhotochemistryAlignmentOptions = {}): PhotochemistryAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryAlignment };
diff --git a/src/photochemistry/analysis.ts b/src/photochemistry/analysis.ts
new file mode 100644
index 000000000..58a3a334e
--- /dev/null
+++ b/src/photochemistry/analysis.ts
@@ -0,0 +1,14 @@
+/** photochemistry analysis module — tsb analytics library. */
+export interface PhotochemistryAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryAnalysisResult { values: number[]; converged: boolean; }
+export function computePhotochemistryAnalysis(data: number[], opts: PhotochemistryAnalysisOptions = {}): PhotochemistryAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryAnalysis };
diff --git a/src/photochemistry/augmentation.ts b/src/photochemistry/augmentation.ts
new file mode 100644
index 000000000..4a57b6e39
--- /dev/null
+++ b/src/photochemistry/augmentation.ts
@@ -0,0 +1,14 @@
+/** photochemistry augmentation module — tsb analytics library. */
+export interface PhotochemistryAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryAugmentationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryAugmentation(data: number[], opts: PhotochemistryAugmentationOptions = {}): PhotochemistryAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryAugmentation };
diff --git a/src/photochemistry/bagging.ts b/src/photochemistry/bagging.ts
new file mode 100644
index 000000000..459a23775
--- /dev/null
+++ b/src/photochemistry/bagging.ts
@@ -0,0 +1,14 @@
+/** photochemistry bagging module — tsb analytics library. */
+export interface PhotochemistryBaggingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryBaggingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryBagging(data: number[], opts: PhotochemistryBaggingOptions = {}): PhotochemistryBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryBagging };
diff --git a/src/photochemistry/basis.ts b/src/photochemistry/basis.ts
new file mode 100644
index 000000000..39ead13a9
--- /dev/null
+++ b/src/photochemistry/basis.ts
@@ -0,0 +1,14 @@
+/** photochemistry basis module — tsb analytics library. */
+export interface PhotochemistryBasisOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryBasisResult { values: number[]; converged: boolean; }
+export function computePhotochemistryBasis(data: number[], opts: PhotochemistryBasisOptions = {}): PhotochemistryBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryBasis };
diff --git a/src/photochemistry/benchmarking.ts b/src/photochemistry/benchmarking.ts
new file mode 100644
index 000000000..7117f5467
--- /dev/null
+++ b/src/photochemistry/benchmarking.ts
@@ -0,0 +1,14 @@
+/** photochemistry benchmarking module — tsb analytics library. */
+export interface PhotochemistryBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryBenchmarking(data: number[], opts: PhotochemistryBenchmarkingOptions = {}): PhotochemistryBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryBenchmarking };
diff --git a/src/photochemistry/blending.ts b/src/photochemistry/blending.ts
new file mode 100644
index 000000000..5410220f7
--- /dev/null
+++ b/src/photochemistry/blending.ts
@@ -0,0 +1,14 @@
+/** photochemistry blending module — tsb analytics library. */
+export interface PhotochemistryBlendingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryBlendingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryBlending(data: number[], opts: PhotochemistryBlendingOptions = {}): PhotochemistryBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryBlending };
diff --git a/src/photochemistry/boosting.ts b/src/photochemistry/boosting.ts
new file mode 100644
index 000000000..c0cc5c85c
--- /dev/null
+++ b/src/photochemistry/boosting.ts
@@ -0,0 +1,14 @@
+/** photochemistry boosting module — tsb analytics library. */
+export interface PhotochemistryBoostingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryBoostingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryBoosting(data: number[], opts: PhotochemistryBoostingOptions = {}): PhotochemistryBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryBoosting };
diff --git a/src/photochemistry/bootstrap.ts b/src/photochemistry/bootstrap.ts
new file mode 100644
index 000000000..2a1a76594
--- /dev/null
+++ b/src/photochemistry/bootstrap.ts
@@ -0,0 +1,14 @@
+/** photochemistry bootstrap module — tsb analytics library. */
+export interface PhotochemistryBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryBootstrapResult { values: number[]; converged: boolean; }
+export function computePhotochemistryBootstrap(data: number[], opts: PhotochemistryBootstrapOptions = {}): PhotochemistryBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryBootstrap };
diff --git a/src/photochemistry/calculus.ts b/src/photochemistry/calculus.ts
new file mode 100644
index 000000000..6a65a3c71
--- /dev/null
+++ b/src/photochemistry/calculus.ts
@@ -0,0 +1,14 @@
+/** photochemistry calculus module — tsb analytics library. */
+export interface PhotochemistryCalculusOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryCalculusResult { values: number[]; converged: boolean; }
+export function computePhotochemistryCalculus(data: number[], opts: PhotochemistryCalculusOptions = {}): PhotochemistryCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryCalculus };
diff --git a/src/photochemistry/calibration.ts b/src/photochemistry/calibration.ts
new file mode 100644
index 000000000..fa53de208
--- /dev/null
+++ b/src/photochemistry/calibration.ts
@@ -0,0 +1,14 @@
+/** photochemistry calibration module — tsb analytics library. */
+export interface PhotochemistryCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryCalibrationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryCalibration(data: number[], opts: PhotochemistryCalibrationOptions = {}): PhotochemistryCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryCalibration };
diff --git a/src/photochemistry/characterization.ts b/src/photochemistry/characterization.ts
new file mode 100644
index 000000000..7aec2594e
--- /dev/null
+++ b/src/photochemistry/characterization.ts
@@ -0,0 +1,14 @@
+/** photochemistry characterization module — tsb analytics library. */
+export interface PhotochemistryCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryCharacterizationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryCharacterization(data: number[], opts: PhotochemistryCharacterizationOptions = {}): PhotochemistryCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryCharacterization };
diff --git a/src/photochemistry/classification.ts b/src/photochemistry/classification.ts
new file mode 100644
index 000000000..e08183b8f
--- /dev/null
+++ b/src/photochemistry/classification.ts
@@ -0,0 +1,14 @@
+/** photochemistry classification module — tsb analytics library. */
+export interface PhotochemistryClassificationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryClassificationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryClassification(data: number[], opts: PhotochemistryClassificationOptions = {}): PhotochemistryClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryClassification };
diff --git a/src/photochemistry/clustering.ts b/src/photochemistry/clustering.ts
new file mode 100644
index 000000000..5aff6add4
--- /dev/null
+++ b/src/photochemistry/clustering.ts
@@ -0,0 +1,14 @@
+/** photochemistry clustering module — tsb analytics library. */
+export interface PhotochemistryClusteringOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryClusteringResult { values: number[]; converged: boolean; }
+export function computePhotochemistryClustering(data: number[], opts: PhotochemistryClusteringOptions = {}): PhotochemistryClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryClustering };
diff --git a/src/photochemistry/compression.ts b/src/photochemistry/compression.ts
new file mode 100644
index 000000000..2f6ae7dd7
--- /dev/null
+++ b/src/photochemistry/compression.ts
@@ -0,0 +1,14 @@
+/** photochemistry compression module — tsb analytics library. */
+export interface PhotochemistryCompressionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryCompressionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryCompression(data: number[], opts: PhotochemistryCompressionOptions = {}): PhotochemistryCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryCompression };
diff --git a/src/photochemistry/continuous.ts b/src/photochemistry/continuous.ts
new file mode 100644
index 000000000..8bab98b4e
--- /dev/null
+++ b/src/photochemistry/continuous.ts
@@ -0,0 +1,14 @@
+/** photochemistry continuous module — tsb analytics library. */
+export interface PhotochemistryContinuousOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryContinuousResult { values: number[]; converged: boolean; }
+export function computePhotochemistryContinuous(data: number[], opts: PhotochemistryContinuousOptions = {}): PhotochemistryContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryContinuous };
diff --git a/src/photochemistry/control.ts b/src/photochemistry/control.ts
new file mode 100644
index 000000000..d5fc6b0e0
--- /dev/null
+++ b/src/photochemistry/control.ts
@@ -0,0 +1,14 @@
+/** photochemistry control module — tsb analytics library. */
+export interface PhotochemistryControlOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryControlResult { values: number[]; converged: boolean; }
+export function computePhotochemistryControl(data: number[], opts: PhotochemistryControlOptions = {}): PhotochemistryControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryControl };
diff --git a/src/photochemistry/convergence.ts b/src/photochemistry/convergence.ts
new file mode 100644
index 000000000..3d05d68bb
--- /dev/null
+++ b/src/photochemistry/convergence.ts
@@ -0,0 +1,14 @@
+/** photochemistry convergence module — tsb analytics library. */
+export interface PhotochemistryConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryConvergenceResult { values: number[]; converged: boolean; }
+export function computePhotochemistryConvergence(data: number[], opts: PhotochemistryConvergenceOptions = {}): PhotochemistryConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryConvergence };
diff --git a/src/photochemistry/convex.ts b/src/photochemistry/convex.ts
new file mode 100644
index 000000000..95b3ea2d1
--- /dev/null
+++ b/src/photochemistry/convex.ts
@@ -0,0 +1,14 @@
+/** photochemistry convex module — tsb analytics library. */
+export interface PhotochemistryConvexOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryConvexResult { values: number[]; converged: boolean; }
+export function computePhotochemistryConvex(data: number[], opts: PhotochemistryConvexOptions = {}): PhotochemistryConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryConvex };
diff --git a/src/photochemistry/correlation.ts b/src/photochemistry/correlation.ts
new file mode 100644
index 000000000..c5b2c352c
--- /dev/null
+++ b/src/photochemistry/correlation.ts
@@ -0,0 +1,14 @@
+/** photochemistry correlation module — tsb analytics library. */
+export interface PhotochemistryCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryCorrelationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryCorrelation(data: number[], opts: PhotochemistryCorrelationOptions = {}): PhotochemistryCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryCorrelation };
diff --git a/src/photochemistry/covariance.ts b/src/photochemistry/covariance.ts
new file mode 100644
index 000000000..d79d2ad33
--- /dev/null
+++ b/src/photochemistry/covariance.ts
@@ -0,0 +1,14 @@
+/** photochemistry covariance module — tsb analytics library. */
+export interface PhotochemistryCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryCovarianceResult { values: number[]; converged: boolean; }
+export function computePhotochemistryCovariance(data: number[], opts: PhotochemistryCovarianceOptions = {}): PhotochemistryCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryCovariance };
diff --git a/src/photochemistry/cross_validation.ts b/src/photochemistry/cross_validation.ts
new file mode 100644
index 000000000..516411b3f
--- /dev/null
+++ b/src/photochemistry/cross_validation.ts
@@ -0,0 +1,14 @@
+/** photochemistry cross_validation module — tsb analytics library. */
+export interface PhotochemistryCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryCrossValidationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryCrossValidation(data: number[], opts: PhotochemistryCrossValidationOptions = {}): PhotochemistryCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryCrossValidation };
diff --git a/src/photochemistry/decoding.ts b/src/photochemistry/decoding.ts
new file mode 100644
index 000000000..604a2b2d9
--- /dev/null
+++ b/src/photochemistry/decoding.ts
@@ -0,0 +1,14 @@
+/** photochemistry decoding module — tsb analytics library. */
+export interface PhotochemistryDecodingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDecodingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDecoding(data: number[], opts: PhotochemistryDecodingOptions = {}): PhotochemistryDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDecoding };
diff --git a/src/photochemistry/decomposition.ts b/src/photochemistry/decomposition.ts
new file mode 100644
index 000000000..a80b261bb
--- /dev/null
+++ b/src/photochemistry/decomposition.ts
@@ -0,0 +1,14 @@
+/** photochemistry decomposition module — tsb analytics library. */
+export interface PhotochemistryDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDecompositionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDecomposition(data: number[], opts: PhotochemistryDecompositionOptions = {}): PhotochemistryDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDecomposition };
diff --git a/src/photochemistry/detection.ts b/src/photochemistry/detection.ts
new file mode 100644
index 000000000..cb40e88d1
--- /dev/null
+++ b/src/photochemistry/detection.ts
@@ -0,0 +1,14 @@
+/** photochemistry detection module — tsb analytics library. */
+export interface PhotochemistryDetectionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDetectionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDetection(data: number[], opts: PhotochemistryDetectionOptions = {}): PhotochemistryDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDetection };
diff --git a/src/photochemistry/deterministic.ts b/src/photochemistry/deterministic.ts
new file mode 100644
index 000000000..8f01858a1
--- /dev/null
+++ b/src/photochemistry/deterministic.ts
@@ -0,0 +1,14 @@
+/** photochemistry deterministic module — tsb analytics library. */
+export interface PhotochemistryDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDeterministicResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDeterministic(data: number[], opts: PhotochemistryDeterministicOptions = {}): PhotochemistryDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDeterministic };
diff --git a/src/photochemistry/diagnostics.ts b/src/photochemistry/diagnostics.ts
new file mode 100644
index 000000000..d199b720f
--- /dev/null
+++ b/src/photochemistry/diagnostics.ts
@@ -0,0 +1,14 @@
+/** photochemistry diagnostics module — tsb analytics library. */
+export interface PhotochemistryDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDiagnostics(data: number[], opts: PhotochemistryDiagnosticsOptions = {}): PhotochemistryDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDiagnostics };
diff --git a/src/photochemistry/differential.ts b/src/photochemistry/differential.ts
new file mode 100644
index 000000000..7d219fa61
--- /dev/null
+++ b/src/photochemistry/differential.ts
@@ -0,0 +1,14 @@
+/** photochemistry differential module — tsb analytics library. */
+export interface PhotochemistryDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDifferentialResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDifferential(data: number[], opts: PhotochemistryDifferentialOptions = {}): PhotochemistryDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDifferential };
diff --git a/src/photochemistry/discrete.ts b/src/photochemistry/discrete.ts
new file mode 100644
index 000000000..fe1925286
--- /dev/null
+++ b/src/photochemistry/discrete.ts
@@ -0,0 +1,14 @@
+/** photochemistry discrete module — tsb analytics library. */
+export interface PhotochemistryDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDiscreteResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDiscrete(data: number[], opts: PhotochemistryDiscreteOptions = {}): PhotochemistryDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDiscrete };
diff --git a/src/photochemistry/distribution.ts b/src/photochemistry/distribution.ts
new file mode 100644
index 000000000..57ae4c0b2
--- /dev/null
+++ b/src/photochemistry/distribution.ts
@@ -0,0 +1,14 @@
+/** photochemistry distribution module — tsb analytics library. */
+export interface PhotochemistryDistributionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDistributionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDistribution(data: number[], opts: PhotochemistryDistributionOptions = {}): PhotochemistryDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDistribution };
diff --git a/src/photochemistry/dynamic.ts b/src/photochemistry/dynamic.ts
new file mode 100644
index 000000000..3f06f3ced
--- /dev/null
+++ b/src/photochemistry/dynamic.ts
@@ -0,0 +1,14 @@
+/** photochemistry dynamic module — tsb analytics library. */
+export interface PhotochemistryDynamicOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryDynamicResult { values: number[]; converged: boolean; }
+export function computePhotochemistryDynamic(data: number[], opts: PhotochemistryDynamicOptions = {}): PhotochemistryDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryDynamic };
diff --git a/src/photochemistry/embedding.ts b/src/photochemistry/embedding.ts
new file mode 100644
index 000000000..55edbc2f4
--- /dev/null
+++ b/src/photochemistry/embedding.ts
@@ -0,0 +1,14 @@
+/** photochemistry embedding module — tsb analytics library. */
+export interface PhotochemistryEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryEmbeddingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryEmbedding(data: number[], opts: PhotochemistryEmbeddingOptions = {}): PhotochemistryEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryEmbedding };
diff --git a/src/photochemistry/encoding.ts b/src/photochemistry/encoding.ts
new file mode 100644
index 000000000..1016252c1
--- /dev/null
+++ b/src/photochemistry/encoding.ts
@@ -0,0 +1,14 @@
+/** photochemistry encoding module — tsb analytics library. */
+export interface PhotochemistryEncodingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryEncodingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryEncoding(data: number[], opts: PhotochemistryEncodingOptions = {}): PhotochemistryEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryEncoding };
diff --git a/src/photochemistry/ensemble.ts b/src/photochemistry/ensemble.ts
new file mode 100644
index 000000000..4a40dd32f
--- /dev/null
+++ b/src/photochemistry/ensemble.ts
@@ -0,0 +1,14 @@
+/** photochemistry ensemble module — tsb analytics library. */
+export interface PhotochemistryEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryEnsembleResult { values: number[]; converged: boolean; }
+export function computePhotochemistryEnsemble(data: number[], opts: PhotochemistryEnsembleOptions = {}): PhotochemistryEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryEnsemble };
diff --git a/src/photochemistry/estimation.ts b/src/photochemistry/estimation.ts
new file mode 100644
index 000000000..8c69d3b34
--- /dev/null
+++ b/src/photochemistry/estimation.ts
@@ -0,0 +1,14 @@
+/** photochemistry estimation module — tsb analytics library. */
+export interface PhotochemistryEstimationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryEstimationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryEstimation(data: number[], opts: PhotochemistryEstimationOptions = {}): PhotochemistryEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryEstimation };
diff --git a/src/photochemistry/evaluation.ts b/src/photochemistry/evaluation.ts
new file mode 100644
index 000000000..b4e58b919
--- /dev/null
+++ b/src/photochemistry/evaluation.ts
@@ -0,0 +1,14 @@
+/** photochemistry evaluation module — tsb analytics library. */
+export interface PhotochemistryEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryEvaluationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryEvaluation(data: number[], opts: PhotochemistryEvaluationOptions = {}): PhotochemistryEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryEvaluation };
diff --git a/src/photochemistry/extrapolation.ts b/src/photochemistry/extrapolation.ts
new file mode 100644
index 000000000..3d8054b10
--- /dev/null
+++ b/src/photochemistry/extrapolation.ts
@@ -0,0 +1,14 @@
+/** photochemistry extrapolation module — tsb analytics library. */
+export interface PhotochemistryExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryExtrapolationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryExtrapolation(data: number[], opts: PhotochemistryExtrapolationOptions = {}): PhotochemistryExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryExtrapolation };
diff --git a/src/photochemistry/features.ts b/src/photochemistry/features.ts
new file mode 100644
index 000000000..c77a61943
--- /dev/null
+++ b/src/photochemistry/features.ts
@@ -0,0 +1,14 @@
+/** photochemistry features module — tsb analytics library. */
+export interface PhotochemistryFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryFeaturesResult { values: number[]; converged: boolean; }
+export function computePhotochemistryFeatures(data: number[], opts: PhotochemistryFeaturesOptions = {}): PhotochemistryFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryFeatures };
diff --git a/src/photochemistry/feedback.ts b/src/photochemistry/feedback.ts
new file mode 100644
index 000000000..9c121a95e
--- /dev/null
+++ b/src/photochemistry/feedback.ts
@@ -0,0 +1,14 @@
+/** photochemistry feedback module — tsb analytics library. */
+export interface PhotochemistryFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryFeedbackResult { values: number[]; converged: boolean; }
+export function computePhotochemistryFeedback(data: number[], opts: PhotochemistryFeedbackOptions = {}): PhotochemistryFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryFeedback };
diff --git a/src/photochemistry/filtering.ts b/src/photochemistry/filtering.ts
new file mode 100644
index 000000000..c2df7250a
--- /dev/null
+++ b/src/photochemistry/filtering.ts
@@ -0,0 +1,14 @@
+/** photochemistry filtering module — tsb analytics library. */
+export interface PhotochemistryFilteringOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryFilteringResult { values: number[]; converged: boolean; }
+export function computePhotochemistryFiltering(data: number[], opts: PhotochemistryFilteringOptions = {}): PhotochemistryFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryFiltering };
diff --git a/src/photochemistry/fourier.ts b/src/photochemistry/fourier.ts
new file mode 100644
index 000000000..f12e3392d
--- /dev/null
+++ b/src/photochemistry/fourier.ts
@@ -0,0 +1,14 @@
+/** photochemistry fourier module — tsb analytics library. */
+export interface PhotochemistryFourierOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryFourierResult { values: number[]; converged: boolean; }
+export function computePhotochemistryFourier(data: number[], opts: PhotochemistryFourierOptions = {}): PhotochemistryFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryFourier };
diff --git a/src/photochemistry/fusion.ts b/src/photochemistry/fusion.ts
new file mode 100644
index 000000000..0bf7be503
--- /dev/null
+++ b/src/photochemistry/fusion.ts
@@ -0,0 +1,14 @@
+/** photochemistry fusion module — tsb analytics library. */
+export interface PhotochemistryFusionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryFusionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryFusion(data: number[], opts: PhotochemistryFusionOptions = {}): PhotochemistryFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryFusion };
diff --git a/src/photochemistry/generation.ts b/src/photochemistry/generation.ts
new file mode 100644
index 000000000..f33b3f3fe
--- /dev/null
+++ b/src/photochemistry/generation.ts
@@ -0,0 +1,14 @@
+/** photochemistry generation module — tsb analytics library. */
+export interface PhotochemistryGenerationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryGenerationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryGeneration(data: number[], opts: PhotochemistryGenerationOptions = {}): PhotochemistryGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryGeneration };
diff --git a/src/photochemistry/geometry.ts b/src/photochemistry/geometry.ts
new file mode 100644
index 000000000..d93c12b2a
--- /dev/null
+++ b/src/photochemistry/geometry.ts
@@ -0,0 +1,14 @@
+/** photochemistry geometry module — tsb analytics library. */
+export interface PhotochemistryGeometryOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryGeometryResult { values: number[]; converged: boolean; }
+export function computePhotochemistryGeometry(data: number[], opts: PhotochemistryGeometryOptions = {}): PhotochemistryGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryGeometry };
diff --git a/src/photochemistry/gradient.ts b/src/photochemistry/gradient.ts
new file mode 100644
index 000000000..5d5dfdc89
--- /dev/null
+++ b/src/photochemistry/gradient.ts
@@ -0,0 +1,14 @@
+/** photochemistry gradient module — tsb analytics library. */
+export interface PhotochemistryGradientOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryGradientResult { values: number[]; converged: boolean; }
+export function computePhotochemistryGradient(data: number[], opts: PhotochemistryGradientOptions = {}): PhotochemistryGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryGradient };
diff --git a/src/photochemistry/hessian.ts b/src/photochemistry/hessian.ts
new file mode 100644
index 000000000..0c321638f
--- /dev/null
+++ b/src/photochemistry/hessian.ts
@@ -0,0 +1,14 @@
+/** photochemistry hessian module — tsb analytics library. */
+export interface PhotochemistryHessianOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryHessianResult { values: number[]; converged: boolean; }
+export function computePhotochemistryHessian(data: number[], opts: PhotochemistryHessianOptions = {}): PhotochemistryHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryHessian };
diff --git a/src/photochemistry/hypothesis.ts b/src/photochemistry/hypothesis.ts
new file mode 100644
index 000000000..644c9c7f2
--- /dev/null
+++ b/src/photochemistry/hypothesis.ts
@@ -0,0 +1,14 @@
+/** photochemistry hypothesis module — tsb analytics library. */
+export interface PhotochemistryHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryHypothesisResult { values: number[]; converged: boolean; }
+export function computePhotochemistryHypothesis(data: number[], opts: PhotochemistryHypothesisOptions = {}): PhotochemistryHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryHypothesis };
diff --git a/src/photochemistry/inference.ts b/src/photochemistry/inference.ts
new file mode 100644
index 000000000..7fa34801a
--- /dev/null
+++ b/src/photochemistry/inference.ts
@@ -0,0 +1,14 @@
+/** photochemistry inference module — tsb analytics library. */
+export interface PhotochemistryInferenceOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryInferenceResult { values: number[]; converged: boolean; }
+export function computePhotochemistryInference(data: number[], opts: PhotochemistryInferenceOptions = {}): PhotochemistryInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryInference };
diff --git a/src/photochemistry/inference2.ts b/src/photochemistry/inference2.ts
new file mode 100644
index 000000000..d4b9f0054
--- /dev/null
+++ b/src/photochemistry/inference2.ts
@@ -0,0 +1,14 @@
+/** photochemistry inference2 module — tsb analytics library. */
+export interface PhotochemistryInferenceOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryInferenceResult { values: number[]; converged: boolean; }
+export function computePhotochemistryInference(data: number[], opts: PhotochemistryInferenceOptions = {}): PhotochemistryInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryInference };
diff --git a/src/photochemistry/integral.ts b/src/photochemistry/integral.ts
new file mode 100644
index 000000000..92447b060
--- /dev/null
+++ b/src/photochemistry/integral.ts
@@ -0,0 +1,14 @@
+/** photochemistry integral module — tsb analytics library. */
+export interface PhotochemistryIntegralOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryIntegralResult { values: number[]; converged: boolean; }
+export function computePhotochemistryIntegral(data: number[], opts: PhotochemistryIntegralOptions = {}): PhotochemistryIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryIntegral };
diff --git a/src/photochemistry/integration.ts b/src/photochemistry/integration.ts
new file mode 100644
index 000000000..88b832fc7
--- /dev/null
+++ b/src/photochemistry/integration.ts
@@ -0,0 +1,14 @@
+/** photochemistry integration module — tsb analytics library. */
+export interface PhotochemistryIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryIntegrationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryIntegration(data: number[], opts: PhotochemistryIntegrationOptions = {}): PhotochemistryIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryIntegration };
diff --git a/src/photochemistry/interpolation.ts b/src/photochemistry/interpolation.ts
new file mode 100644
index 000000000..02e25e548
--- /dev/null
+++ b/src/photochemistry/interpolation.ts
@@ -0,0 +1,14 @@
+/** photochemistry interpolation module — tsb analytics library. */
+export interface PhotochemistryInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryInterpolationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryInterpolation(data: number[], opts: PhotochemistryInterpolationOptions = {}): PhotochemistryInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryInterpolation };
diff --git a/src/photochemistry/jacobian.ts b/src/photochemistry/jacobian.ts
new file mode 100644
index 000000000..c6f07d551
--- /dev/null
+++ b/src/photochemistry/jacobian.ts
@@ -0,0 +1,14 @@
+/** photochemistry jacobian module — tsb analytics library. */
+export interface PhotochemistryJacobianOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryJacobianResult { values: number[]; converged: boolean; }
+export function computePhotochemistryJacobian(data: number[], opts: PhotochemistryJacobianOptions = {}): PhotochemistryJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryJacobian };
diff --git a/src/photochemistry/kernel.ts b/src/photochemistry/kernel.ts
new file mode 100644
index 000000000..af1d3fd46
--- /dev/null
+++ b/src/photochemistry/kernel.ts
@@ -0,0 +1,14 @@
+/** photochemistry kernel module — tsb analytics library. */
+export interface PhotochemistryKernelOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryKernelResult { values: number[]; converged: boolean; }
+export function computePhotochemistryKernel(data: number[], opts: PhotochemistryKernelOptions = {}): PhotochemistryKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryKernel };
diff --git a/src/photochemistry/laplacian.ts b/src/photochemistry/laplacian.ts
new file mode 100644
index 000000000..e68898692
--- /dev/null
+++ b/src/photochemistry/laplacian.ts
@@ -0,0 +1,14 @@
+/** photochemistry laplacian module — tsb analytics library. */
+export interface PhotochemistryLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryLaplacianResult { values: number[]; converged: boolean; }
+export function computePhotochemistryLaplacian(data: number[], opts: PhotochemistryLaplacianOptions = {}): PhotochemistryLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryLaplacian };
diff --git a/src/photochemistry/learning.ts b/src/photochemistry/learning.ts
new file mode 100644
index 000000000..a04f29300
--- /dev/null
+++ b/src/photochemistry/learning.ts
@@ -0,0 +1,14 @@
+/** photochemistry learning module — tsb analytics library. */
+export interface PhotochemistryLearningOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryLearningResult { values: number[]; converged: boolean; }
+export function computePhotochemistryLearning(data: number[], opts: PhotochemistryLearningOptions = {}): PhotochemistryLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryLearning };
diff --git a/src/photochemistry/linear.ts b/src/photochemistry/linear.ts
new file mode 100644
index 000000000..a8e9d1a66
--- /dev/null
+++ b/src/photochemistry/linear.ts
@@ -0,0 +1,14 @@
+/** photochemistry linear module — tsb analytics library. */
+export interface PhotochemistryLinearOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryLinearResult { values: number[]; converged: boolean; }
+export function computePhotochemistryLinear(data: number[], opts: PhotochemistryLinearOptions = {}): PhotochemistryLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryLinear };
diff --git a/src/photochemistry/manifold.ts b/src/photochemistry/manifold.ts
new file mode 100644
index 000000000..66da166d1
--- /dev/null
+++ b/src/photochemistry/manifold.ts
@@ -0,0 +1,14 @@
+/** photochemistry manifold module — tsb analytics library. */
+export interface PhotochemistryManifoldOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryManifoldResult { values: number[]; converged: boolean; }
+export function computePhotochemistryManifold(data: number[], opts: PhotochemistryManifoldOptions = {}): PhotochemistryManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryManifold };
diff --git a/src/photochemistry/matching.ts b/src/photochemistry/matching.ts
new file mode 100644
index 000000000..6989d36dc
--- /dev/null
+++ b/src/photochemistry/matching.ts
@@ -0,0 +1,14 @@
+/** photochemistry matching module — tsb analytics library. */
+export interface PhotochemistryMatchingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryMatchingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryMatching(data: number[], opts: PhotochemistryMatchingOptions = {}): PhotochemistryMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryMatching };
diff --git a/src/photochemistry/measurement.ts b/src/photochemistry/measurement.ts
new file mode 100644
index 000000000..860a2863a
--- /dev/null
+++ b/src/photochemistry/measurement.ts
@@ -0,0 +1,14 @@
+/** photochemistry measurement module — tsb analytics library. */
+export interface PhotochemistryMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryMeasurementResult { values: number[]; converged: boolean; }
+export function computePhotochemistryMeasurement(data: number[], opts: PhotochemistryMeasurementOptions = {}): PhotochemistryMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryMeasurement };
diff --git a/src/photochemistry/metrics.ts b/src/photochemistry/metrics.ts
new file mode 100644
index 000000000..26d526584
--- /dev/null
+++ b/src/photochemistry/metrics.ts
@@ -0,0 +1,14 @@
+/** photochemistry metrics module — tsb analytics library. */
+export interface PhotochemistryMetricsOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryMetricsResult { values: number[]; converged: boolean; }
+export function computePhotochemistryMetrics(data: number[], opts: PhotochemistryMetricsOptions = {}): PhotochemistryMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryMetrics };
diff --git a/src/photochemistry/modeling.ts b/src/photochemistry/modeling.ts
new file mode 100644
index 000000000..58d21f89f
--- /dev/null
+++ b/src/photochemistry/modeling.ts
@@ -0,0 +1,14 @@
+/** photochemistry modeling module — tsb analytics library. */
+export interface PhotochemistryModelingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryModelingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryModeling(data: number[], opts: PhotochemistryModelingOptions = {}): PhotochemistryModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryModeling };
diff --git a/src/photochemistry/monitoring.ts b/src/photochemistry/monitoring.ts
new file mode 100644
index 000000000..73491a2cd
--- /dev/null
+++ b/src/photochemistry/monitoring.ts
@@ -0,0 +1,14 @@
+/** photochemistry monitoring module — tsb analytics library. */
+export interface PhotochemistryMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryMonitoringResult { values: number[]; converged: boolean; }
+export function computePhotochemistryMonitoring(data: number[], opts: PhotochemistryMonitoringOptions = {}): PhotochemistryMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryMonitoring };
diff --git a/src/photochemistry/nonlinear.ts b/src/photochemistry/nonlinear.ts
new file mode 100644
index 000000000..451017263
--- /dev/null
+++ b/src/photochemistry/nonlinear.ts
@@ -0,0 +1,14 @@
+/** photochemistry nonlinear module — tsb analytics library. */
+export interface PhotochemistryNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryNonlinearResult { values: number[]; converged: boolean; }
+export function computePhotochemistryNonlinear(data: number[], opts: PhotochemistryNonlinearOptions = {}): PhotochemistryNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryNonlinear };
diff --git a/src/photochemistry/normalization.ts b/src/photochemistry/normalization.ts
new file mode 100644
index 000000000..e6fbdb721
--- /dev/null
+++ b/src/photochemistry/normalization.ts
@@ -0,0 +1,14 @@
+/** photochemistry normalization module — tsb analytics library. */
+export interface PhotochemistryNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryNormalizationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryNormalization(data: number[], opts: PhotochemistryNormalizationOptions = {}): PhotochemistryNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryNormalization };
diff --git a/src/photochemistry/optimization.ts b/src/photochemistry/optimization.ts
new file mode 100644
index 000000000..02b5fd3d2
--- /dev/null
+++ b/src/photochemistry/optimization.ts
@@ -0,0 +1,14 @@
+/** photochemistry optimization module — tsb analytics library. */
+export interface PhotochemistryOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryOptimizationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryOptimization(data: number[], opts: PhotochemistryOptimizationOptions = {}): PhotochemistryOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryOptimization };
diff --git a/src/photochemistry/patterns.ts b/src/photochemistry/patterns.ts
new file mode 100644
index 000000000..d99273a90
--- /dev/null
+++ b/src/photochemistry/patterns.ts
@@ -0,0 +1,14 @@
+/** photochemistry patterns module — tsb analytics library. */
+export interface PhotochemistryPatternsOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryPatternsResult { values: number[]; converged: boolean; }
+export function computePhotochemistryPatterns(data: number[], opts: PhotochemistryPatternsOptions = {}): PhotochemistryPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryPatterns };
diff --git a/src/photochemistry/permutation.ts b/src/photochemistry/permutation.ts
new file mode 100644
index 000000000..33ae85ca1
--- /dev/null
+++ b/src/photochemistry/permutation.ts
@@ -0,0 +1,14 @@
+/** photochemistry permutation module — tsb analytics library. */
+export interface PhotochemistryPermutationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryPermutationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryPermutation(data: number[], opts: PhotochemistryPermutationOptions = {}): PhotochemistryPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryPermutation };
diff --git a/src/photochemistry/prediction.ts b/src/photochemistry/prediction.ts
new file mode 100644
index 000000000..d3f69b0e1
--- /dev/null
+++ b/src/photochemistry/prediction.ts
@@ -0,0 +1,14 @@
+/** photochemistry prediction module — tsb analytics library. */
+export interface PhotochemistryPredictionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryPredictionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryPrediction(data: number[], opts: PhotochemistryPredictionOptions = {}): PhotochemistryPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryPrediction };
diff --git a/src/photochemistry/processing.ts b/src/photochemistry/processing.ts
new file mode 100644
index 000000000..0c477a3aa
--- /dev/null
+++ b/src/photochemistry/processing.ts
@@ -0,0 +1,14 @@
+/** photochemistry processing module — tsb analytics library. */
+export interface PhotochemistryProcessingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryProcessingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryProcessing(data: number[], opts: PhotochemistryProcessingOptions = {}): PhotochemistryProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryProcessing };
diff --git a/src/photochemistry/profiling.ts b/src/photochemistry/profiling.ts
new file mode 100644
index 000000000..b4011b783
--- /dev/null
+++ b/src/photochemistry/profiling.ts
@@ -0,0 +1,14 @@
+/** photochemistry profiling module — tsb analytics library. */
+export interface PhotochemistryProfilingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryProfilingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryProfiling(data: number[], opts: PhotochemistryProfilingOptions = {}): PhotochemistryProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryProfiling };
diff --git a/src/photochemistry/projection.ts b/src/photochemistry/projection.ts
new file mode 100644
index 000000000..942f70456
--- /dev/null
+++ b/src/photochemistry/projection.ts
@@ -0,0 +1,14 @@
+/** photochemistry projection module — tsb analytics library. */
+export interface PhotochemistryProjectionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryProjectionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryProjection(data: number[], opts: PhotochemistryProjectionOptions = {}): PhotochemistryProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryProjection };
diff --git a/src/photochemistry/ranking.ts b/src/photochemistry/ranking.ts
new file mode 100644
index 000000000..cdf8dab71
--- /dev/null
+++ b/src/photochemistry/ranking.ts
@@ -0,0 +1,14 @@
+/** photochemistry ranking module — tsb analytics library. */
+export interface PhotochemistryRankingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryRankingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryRanking(data: number[], opts: PhotochemistryRankingOptions = {}): PhotochemistryRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryRanking };
diff --git a/src/photochemistry/reconstruction.ts b/src/photochemistry/reconstruction.ts
new file mode 100644
index 000000000..eeb2e8e0c
--- /dev/null
+++ b/src/photochemistry/reconstruction.ts
@@ -0,0 +1,14 @@
+/** photochemistry reconstruction module — tsb analytics library. */
+export interface PhotochemistryReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryReconstructionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryReconstruction(data: number[], opts: PhotochemistryReconstructionOptions = {}): PhotochemistryReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryReconstruction };
diff --git a/src/photochemistry/registration.ts b/src/photochemistry/registration.ts
new file mode 100644
index 000000000..cc7c88fb9
--- /dev/null
+++ b/src/photochemistry/registration.ts
@@ -0,0 +1,14 @@
+/** photochemistry registration module — tsb analytics library. */
+export interface PhotochemistryRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryRegistrationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryRegistration(data: number[], opts: PhotochemistryRegistrationOptions = {}): PhotochemistryRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryRegistration };
diff --git a/src/photochemistry/regression.ts b/src/photochemistry/regression.ts
new file mode 100644
index 000000000..c685dee7f
--- /dev/null
+++ b/src/photochemistry/regression.ts
@@ -0,0 +1,14 @@
+/** photochemistry regression module — tsb analytics library. */
+export interface PhotochemistryRegressionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryRegressionResult { values: number[]; converged: boolean; }
+export function computePhotochemistryRegression(data: number[], opts: PhotochemistryRegressionOptions = {}): PhotochemistryRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryRegression };
diff --git a/src/photochemistry/regularization.ts b/src/photochemistry/regularization.ts
new file mode 100644
index 000000000..6f69f6498
--- /dev/null
+++ b/src/photochemistry/regularization.ts
@@ -0,0 +1,14 @@
+/** photochemistry regularization module — tsb analytics library. */
+export interface PhotochemistryRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryRegularizationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryRegularization(data: number[], opts: PhotochemistryRegularizationOptions = {}): PhotochemistryRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryRegularization };
diff --git a/src/photochemistry/robustness.ts b/src/photochemistry/robustness.ts
new file mode 100644
index 000000000..a980e0ca8
--- /dev/null
+++ b/src/photochemistry/robustness.ts
@@ -0,0 +1,14 @@
+/** photochemistry robustness module — tsb analytics library. */
+export interface PhotochemistryRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryRobustnessResult { values: number[]; converged: boolean; }
+export function computePhotochemistryRobustness(data: number[], opts: PhotochemistryRobustnessOptions = {}): PhotochemistryRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryRobustness };
diff --git a/src/photochemistry/sampling.ts b/src/photochemistry/sampling.ts
new file mode 100644
index 000000000..e6183dfd3
--- /dev/null
+++ b/src/photochemistry/sampling.ts
@@ -0,0 +1,14 @@
+/** photochemistry sampling module — tsb analytics library. */
+export interface PhotochemistrySamplingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistrySamplingResult { values: number[]; converged: boolean; }
+export function computePhotochemistrySampling(data: number[], opts: PhotochemistrySamplingOptions = {}): PhotochemistrySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistrySampling };
diff --git a/src/photochemistry/sampling2.ts b/src/photochemistry/sampling2.ts
new file mode 100644
index 000000000..291654285
--- /dev/null
+++ b/src/photochemistry/sampling2.ts
@@ -0,0 +1,14 @@
+/** photochemistry sampling2 module — tsb analytics library. */
+export interface PhotochemistrySamplingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistrySamplingResult { values: number[]; converged: boolean; }
+export function computePhotochemistrySampling(data: number[], opts: PhotochemistrySamplingOptions = {}): PhotochemistrySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistrySampling };
diff --git a/src/photochemistry/scaling.ts b/src/photochemistry/scaling.ts
new file mode 100644
index 000000000..e9555ff32
--- /dev/null
+++ b/src/photochemistry/scaling.ts
@@ -0,0 +1,14 @@
+/** photochemistry scaling module — tsb analytics library. */
+export interface PhotochemistryScalingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryScalingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryScaling(data: number[], opts: PhotochemistryScalingOptions = {}): PhotochemistryScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryScaling };
diff --git a/src/photochemistry/scoring.ts b/src/photochemistry/scoring.ts
new file mode 100644
index 000000000..17af555b1
--- /dev/null
+++ b/src/photochemistry/scoring.ts
@@ -0,0 +1,14 @@
+/** photochemistry scoring module — tsb analytics library. */
+export interface PhotochemistryScoringOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryScoringResult { values: number[]; converged: boolean; }
+export function computePhotochemistryScoring(data: number[], opts: PhotochemistryScoringOptions = {}): PhotochemistryScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryScoring };
diff --git a/src/photochemistry/segmentation.ts b/src/photochemistry/segmentation.ts
new file mode 100644
index 000000000..efb952ec5
--- /dev/null
+++ b/src/photochemistry/segmentation.ts
@@ -0,0 +1,14 @@
+/** photochemistry segmentation module — tsb analytics library. */
+export interface PhotochemistrySegmentationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistrySegmentationResult { values: number[]; converged: boolean; }
+export function computePhotochemistrySegmentation(data: number[], opts: PhotochemistrySegmentationOptions = {}): PhotochemistrySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistrySegmentation };
diff --git a/src/photochemistry/selection.ts b/src/photochemistry/selection.ts
new file mode 100644
index 000000000..790ae6a24
--- /dev/null
+++ b/src/photochemistry/selection.ts
@@ -0,0 +1,14 @@
+/** photochemistry selection module — tsb analytics library. */
+export interface PhotochemistrySelectionOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistrySelectionResult { values: number[]; converged: boolean; }
+export function computePhotochemistrySelection(data: number[], opts: PhotochemistrySelectionOptions = {}): PhotochemistrySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistrySelection };
diff --git a/src/photochemistry/sensitivity.ts b/src/photochemistry/sensitivity.ts
new file mode 100644
index 000000000..632fc6344
--- /dev/null
+++ b/src/photochemistry/sensitivity.ts
@@ -0,0 +1,14 @@
+/** photochemistry sensitivity module — tsb analytics library. */
+export interface PhotochemistrySensitivityOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistrySensitivityResult { values: number[]; converged: boolean; }
+export function computePhotochemistrySensitivity(data: number[], opts: PhotochemistrySensitivityOptions = {}): PhotochemistrySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistrySensitivity };
diff --git a/src/photochemistry/simulation.ts b/src/photochemistry/simulation.ts
new file mode 100644
index 000000000..4e32244d4
--- /dev/null
+++ b/src/photochemistry/simulation.ts
@@ -0,0 +1,14 @@
+/** photochemistry simulation module — tsb analytics library. */
+export interface PhotochemistrySimulationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistrySimulationResult { values: number[]; converged: boolean; }
+export function computePhotochemistrySimulation(data: number[], opts: PhotochemistrySimulationOptions = {}): PhotochemistrySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistrySimulation };
diff --git a/src/photochemistry/smoothing.ts b/src/photochemistry/smoothing.ts
new file mode 100644
index 000000000..d911f82c9
--- /dev/null
+++ b/src/photochemistry/smoothing.ts
@@ -0,0 +1,14 @@
+/** photochemistry smoothing module — tsb analytics library. */
+export interface PhotochemistrySmoothingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistrySmoothingResult { values: number[]; converged: boolean; }
+export function computePhotochemistrySmoothing(data: number[], opts: PhotochemistrySmoothingOptions = {}): PhotochemistrySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistrySmoothing };
diff --git a/src/photochemistry/stability.ts b/src/photochemistry/stability.ts
new file mode 100644
index 000000000..305a07921
--- /dev/null
+++ b/src/photochemistry/stability.ts
@@ -0,0 +1,14 @@
+/** photochemistry stability module — tsb analytics library. */
+export interface PhotochemistryStabilityOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryStabilityResult { values: number[]; converged: boolean; }
+export function computePhotochemistryStability(data: number[], opts: PhotochemistryStabilityOptions = {}): PhotochemistryStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryStability };
diff --git a/src/photochemistry/stacking.ts b/src/photochemistry/stacking.ts
new file mode 100644
index 000000000..538942905
--- /dev/null
+++ b/src/photochemistry/stacking.ts
@@ -0,0 +1,14 @@
+/** photochemistry stacking module — tsb analytics library. */
+export interface PhotochemistryStackingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryStackingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryStacking(data: number[], opts: PhotochemistryStackingOptions = {}): PhotochemistryStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryStacking };
diff --git a/src/photochemistry/standardization.ts b/src/photochemistry/standardization.ts
new file mode 100644
index 000000000..f72001566
--- /dev/null
+++ b/src/photochemistry/standardization.ts
@@ -0,0 +1,14 @@
+/** photochemistry standardization module — tsb analytics library. */
+export interface PhotochemistryStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryStandardizationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryStandardization(data: number[], opts: PhotochemistryStandardizationOptions = {}): PhotochemistryStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryStandardization };
diff --git a/src/photochemistry/static.ts b/src/photochemistry/static.ts
new file mode 100644
index 000000000..d4c8185e6
--- /dev/null
+++ b/src/photochemistry/static.ts
@@ -0,0 +1,14 @@
+/** photochemistry static module — tsb analytics library. */
+export interface PhotochemistryStaticOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryStaticResult { values: number[]; converged: boolean; }
+export function computePhotochemistryStatic(data: number[], opts: PhotochemistryStaticOptions = {}): PhotochemistryStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryStatic };
diff --git a/src/photochemistry/stochastic.ts b/src/photochemistry/stochastic.ts
new file mode 100644
index 000000000..82e686e45
--- /dev/null
+++ b/src/photochemistry/stochastic.ts
@@ -0,0 +1,14 @@
+/** photochemistry stochastic module — tsb analytics library. */
+export interface PhotochemistryStochasticOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryStochasticResult { values: number[]; converged: boolean; }
+export function computePhotochemistryStochastic(data: number[], opts: PhotochemistryStochasticOptions = {}): PhotochemistryStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryStochastic };
diff --git a/src/photochemistry/synthesis.ts b/src/photochemistry/synthesis.ts
new file mode 100644
index 000000000..8e06469cb
--- /dev/null
+++ b/src/photochemistry/synthesis.ts
@@ -0,0 +1,14 @@
+/** photochemistry synthesis module — tsb analytics library. */
+export interface PhotochemistrySynthesisOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistrySynthesisResult { values: number[]; converged: boolean; }
+export function computePhotochemistrySynthesis(data: number[], opts: PhotochemistrySynthesisOptions = {}): PhotochemistrySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistrySynthesis };
diff --git a/src/photochemistry/topology.ts b/src/photochemistry/topology.ts
new file mode 100644
index 000000000..37334ac61
--- /dev/null
+++ b/src/photochemistry/topology.ts
@@ -0,0 +1,14 @@
+/** photochemistry topology module — tsb analytics library. */
+export interface PhotochemistryTopologyOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryTopologyResult { values: number[]; converged: boolean; }
+export function computePhotochemistryTopology(data: number[], opts: PhotochemistryTopologyOptions = {}): PhotochemistryTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryTopology };
diff --git a/src/photochemistry/tracking.ts b/src/photochemistry/tracking.ts
new file mode 100644
index 000000000..ca04ed147
--- /dev/null
+++ b/src/photochemistry/tracking.ts
@@ -0,0 +1,14 @@
+/** photochemistry tracking module — tsb analytics library. */
+export interface PhotochemistryTrackingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryTrackingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryTracking(data: number[], opts: PhotochemistryTrackingOptions = {}): PhotochemistryTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryTracking };
diff --git a/src/photochemistry/transform.ts b/src/photochemistry/transform.ts
new file mode 100644
index 000000000..94cd81d7e
--- /dev/null
+++ b/src/photochemistry/transform.ts
@@ -0,0 +1,14 @@
+/** photochemistry transform module — tsb analytics library. */
+export interface PhotochemistryTransformOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryTransformResult { values: number[]; converged: boolean; }
+export function computePhotochemistryTransform(data: number[], opts: PhotochemistryTransformOptions = {}): PhotochemistryTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryTransform };
diff --git a/src/photochemistry/uncertainty.ts b/src/photochemistry/uncertainty.ts
new file mode 100644
index 000000000..ac42d436d
--- /dev/null
+++ b/src/photochemistry/uncertainty.ts
@@ -0,0 +1,14 @@
+/** photochemistry uncertainty module — tsb analytics library. */
+export interface PhotochemistryUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryUncertaintyResult { values: number[]; converged: boolean; }
+export function computePhotochemistryUncertainty(data: number[], opts: PhotochemistryUncertaintyOptions = {}): PhotochemistryUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryUncertainty };
diff --git a/src/photochemistry/validation.ts b/src/photochemistry/validation.ts
new file mode 100644
index 000000000..d9f36b3eb
--- /dev/null
+++ b/src/photochemistry/validation.ts
@@ -0,0 +1,14 @@
+/** photochemistry validation module — tsb analytics library. */
+export interface PhotochemistryValidationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryValidationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryValidation(data: number[], opts: PhotochemistryValidationOptions = {}): PhotochemistryValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryValidation };
diff --git a/src/photochemistry/verification.ts b/src/photochemistry/verification.ts
new file mode 100644
index 000000000..023f84e75
--- /dev/null
+++ b/src/photochemistry/verification.ts
@@ -0,0 +1,14 @@
+/** photochemistry verification module — tsb analytics library. */
+export interface PhotochemistryVerificationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryVerificationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryVerification(data: number[], opts: PhotochemistryVerificationOptions = {}): PhotochemistryVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryVerification };
diff --git a/src/photochemistry/visualization.ts b/src/photochemistry/visualization.ts
new file mode 100644
index 000000000..33aa00fb1
--- /dev/null
+++ b/src/photochemistry/visualization.ts
@@ -0,0 +1,14 @@
+/** photochemistry visualization module — tsb analytics library. */
+export interface PhotochemistryVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryVisualizationResult { values: number[]; converged: boolean; }
+export function computePhotochemistryVisualization(data: number[], opts: PhotochemistryVisualizationOptions = {}): PhotochemistryVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryVisualization };
diff --git a/src/photochemistry/voting.ts b/src/photochemistry/voting.ts
new file mode 100644
index 000000000..75a95d70b
--- /dev/null
+++ b/src/photochemistry/voting.ts
@@ -0,0 +1,14 @@
+/** photochemistry voting module — tsb analytics library. */
+export interface PhotochemistryVotingOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryVotingResult { values: number[]; converged: boolean; }
+export function computePhotochemistryVoting(data: number[], opts: PhotochemistryVotingOptions = {}): PhotochemistryVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryVoting };
diff --git a/src/photochemistry/wavelet.ts b/src/photochemistry/wavelet.ts
new file mode 100644
index 000000000..5b725345d
--- /dev/null
+++ b/src/photochemistry/wavelet.ts
@@ -0,0 +1,14 @@
+/** photochemistry wavelet module — tsb analytics library. */
+export interface PhotochemistryWaveletOptions { tol?: number; maxIter?: number; }
+export interface PhotochemistryWaveletResult { values: number[]; converged: boolean; }
+export function computePhotochemistryWavelet(data: number[], opts: PhotochemistryWaveletOptions = {}): PhotochemistryWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhotochemistryWavelet };
diff --git a/src/physics/acoustics.ts b/src/physics/acoustics.ts
new file mode 100644
index 000000000..a2bbe51ca
--- /dev/null
+++ b/src/physics/acoustics.ts
@@ -0,0 +1,22 @@
+/** Acoustics module — tsb analytics library. */
+
+/** Options for Acoustics. */
+export interface AcousticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Acoustics. */
+export interface AcousticsResult { values: number[]; converged: boolean; }
+
+/** Compute Acoustics. */
+export function computeAcoustics(data: number[], opts: AcousticsOptions = {}): AcousticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAcoustics };
diff --git a/src/physics/advanced.ts b/src/physics/advanced.ts
new file mode 100644
index 000000000..2a876915f
--- /dev/null
+++ b/src/physics/advanced.ts
@@ -0,0 +1,15 @@
+/** Physics Advanced module — tsb analytics library. */
+export interface Physics advancedOptions { tol?: number; maxIter?: number; }
+export interface Physics advancedResult { values: number[]; converged: boolean; }
+export function computePhysics advanced(data: number[], opts: Physics advancedOptions = {}): Physics advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics advanced };
diff --git a/src/physics/base2.ts b/src/physics/base2.ts
new file mode 100644
index 000000000..2d6414e4d
--- /dev/null
+++ b/src/physics/base2.ts
@@ -0,0 +1,15 @@
+/** Physics Base2 module — tsb analytics library. */
+export interface Physics base2Options { tol?: number; maxIter?: number; }
+export interface Physics base2Result { values: number[]; converged: boolean; }
+export function computePhysics base2(data: number[], opts: Physics base2Options = {}): Physics base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics base2 };
diff --git a/src/physics/batch.ts b/src/physics/batch.ts
new file mode 100644
index 000000000..73d382237
--- /dev/null
+++ b/src/physics/batch.ts
@@ -0,0 +1,15 @@
+/** Physics Batch module — tsb analytics library. */
+export interface Physics batchOptions { tol?: number; maxIter?: number; }
+export interface Physics batchResult { values: number[]; converged: boolean; }
+export function computePhysics batch(data: number[], opts: Physics batchOptions = {}): Physics batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics batch };
diff --git a/src/physics/beta.ts b/src/physics/beta.ts
new file mode 100644
index 000000000..de221eb16
--- /dev/null
+++ b/src/physics/beta.ts
@@ -0,0 +1,15 @@
+/** Physics Beta module — tsb analytics library. */
+export interface Physics betaOptions { tol?: number; maxIter?: number; }
+export interface Physics betaResult { values: number[]; converged: boolean; }
+export function computePhysics beta(data: number[], opts: Physics betaOptions = {}): Physics betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics beta };
diff --git a/src/physics/condensed_matter.ts b/src/physics/condensed_matter.ts
new file mode 100644
index 000000000..052b2abcd
--- /dev/null
+++ b/src/physics/condensed_matter.ts
@@ -0,0 +1,22 @@
+/** Condensed Matter module — tsb analytics library. */
+
+/** Options for Condensed Matter. */
+export interface CondensedMatterOptions { tol?: number; maxIter?: number; }
+
+/** Result from Condensed Matter. */
+export interface CondensedMatterResult { values: number[]; converged: boolean; }
+
+/** Compute Condensed Matter. */
+export function computeCondensedMatter(data: number[], opts: CondensedMatterOptions = {}): CondensedMatterResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCondensedMatter };
diff --git a/src/physics/cosmology.ts b/src/physics/cosmology.ts
new file mode 100644
index 000000000..5d00153bf
--- /dev/null
+++ b/src/physics/cosmology.ts
@@ -0,0 +1,22 @@
+/** Cosmology module — tsb analytics library. */
+
+/** Options for Cosmology. */
+export interface CosmologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cosmology. */
+export interface CosmologyResult { values: number[]; converged: boolean; }
+
+/** Compute Cosmology. */
+export function computeCosmology(data: number[], opts: CosmologyOptions = {}): CosmologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCosmology };
diff --git a/src/physics/cpu.ts b/src/physics/cpu.ts
new file mode 100644
index 000000000..e40d7a833
--- /dev/null
+++ b/src/physics/cpu.ts
@@ -0,0 +1,15 @@
+/** Physics Cpu module — tsb analytics library. */
+export interface Physics cpuOptions { tol?: number; maxIter?: number; }
+export interface Physics cpuResult { values: number[]; converged: boolean; }
+export function computePhysics cpu(data: number[], opts: Physics cpuOptions = {}): Physics cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics cpu };
diff --git a/src/physics/critical.ts b/src/physics/critical.ts
new file mode 100644
index 000000000..9564854b2
--- /dev/null
+++ b/src/physics/critical.ts
@@ -0,0 +1,22 @@
+/** Critical module — tsb analytics library. */
+
+/** Options for Critical. */
+export interface CriticalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Critical. */
+export interface CriticalResult { values: number[]; converged: boolean; }
+
+/** Compute Critical. */
+export function computeCritical(data: number[], opts: CriticalOptions = {}): CriticalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCritical };
diff --git a/src/physics/dense.ts b/src/physics/dense.ts
new file mode 100644
index 000000000..03b2fdf07
--- /dev/null
+++ b/src/physics/dense.ts
@@ -0,0 +1,15 @@
+/** Physics Dense module — tsb analytics library. */
+export interface Physics denseOptions { tol?: number; maxIter?: number; }
+export interface Physics denseResult { values: number[]; converged: boolean; }
+export function computePhysics dense(data: number[], opts: Physics denseOptions = {}): Physics denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics dense };
diff --git a/src/physics/density_functional.ts b/src/physics/density_functional.ts
new file mode 100644
index 000000000..60171f3c1
--- /dev/null
+++ b/src/physics/density_functional.ts
@@ -0,0 +1,22 @@
+/** Density Functional module — tsb analytics library. */
+
+/** Options for Density Functional. */
+export interface DensityFunctionalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Density Functional. */
+export interface DensityFunctionalResult { values: number[]; converged: boolean; }
+
+/** Compute Density Functional. */
+export function computeDensityFunctional(data: number[], opts: DensityFunctionalOptions = {}): DensityFunctionalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDensityFunctional };
diff --git a/src/physics/distributed.ts b/src/physics/distributed.ts
new file mode 100644
index 000000000..e5d1a53b8
--- /dev/null
+++ b/src/physics/distributed.ts
@@ -0,0 +1,15 @@
+/** Physics Distributed module — tsb analytics library. */
+export interface Physics distributedOptions { tol?: number; maxIter?: number; }
+export interface Physics distributedResult { values: number[]; converged: boolean; }
+export function computePhysics distributed(data: number[], opts: Physics distributedOptions = {}): Physics distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics distributed };
diff --git a/src/physics/electrodynamics.ts b/src/physics/electrodynamics.ts
new file mode 100644
index 000000000..e181754c3
--- /dev/null
+++ b/src/physics/electrodynamics.ts
@@ -0,0 +1,22 @@
+/** Electrodynamics module — tsb analytics library. */
+
+/** Options for Electrodynamics. */
+export interface ElectrodynamicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Electrodynamics. */
+export interface ElectrodynamicsResult { values: number[]; converged: boolean; }
+
+/** Compute Electrodynamics. */
+export function computeElectrodynamics(data: number[], opts: ElectrodynamicsOptions = {}): ElectrodynamicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeElectrodynamics };
diff --git a/src/physics/experimental.ts b/src/physics/experimental.ts
new file mode 100644
index 000000000..eb8bd45ea
--- /dev/null
+++ b/src/physics/experimental.ts
@@ -0,0 +1,15 @@
+/** Physics Experimental module — tsb analytics library. */
+export interface Physics experimentalOptions { tol?: number; maxIter?: number; }
+export interface Physics experimentalResult { values: number[]; converged: boolean; }
+export function computePhysics experimental(data: number[], opts: Physics experimentalOptions = {}): Physics experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics experimental };
diff --git a/src/physics/fast.ts b/src/physics/fast.ts
new file mode 100644
index 000000000..414812c5d
--- /dev/null
+++ b/src/physics/fast.ts
@@ -0,0 +1,15 @@
+/** Physics Fast module — tsb analytics library. */
+export interface Physics fastOptions { tol?: number; maxIter?: number; }
+export interface Physics fastResult { values: number[]; converged: boolean; }
+export function computePhysics fast(data: number[], opts: Physics fastOptions = {}): Physics fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics fast };
diff --git a/src/physics/field_theory.ts b/src/physics/field_theory.ts
new file mode 100644
index 000000000..da594bb2e
--- /dev/null
+++ b/src/physics/field_theory.ts
@@ -0,0 +1,22 @@
+/** Field Theory module — tsb analytics library. */
+
+/** Options for Field Theory. */
+export interface FieldTheoryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Field Theory. */
+export interface FieldTheoryResult { values: number[]; converged: boolean; }
+
+/** Compute Field Theory. */
+export function computeFieldTheory(data: number[], opts: FieldTheoryOptions = {}): FieldTheoryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFieldTheory };
diff --git a/src/physics/fluid_dynamics.ts b/src/physics/fluid_dynamics.ts
new file mode 100644
index 000000000..b97aa1472
--- /dev/null
+++ b/src/physics/fluid_dynamics.ts
@@ -0,0 +1,22 @@
+/** Fluid Dynamics module — tsb analytics library. */
+
+/** Options for Fluid Dynamics. */
+export interface FluidDynamicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fluid Dynamics. */
+export interface FluidDynamicsResult { values: number[]; converged: boolean; }
+
+/** Compute Fluid Dynamics. */
+export function computeFluidDynamics(data: number[], opts: FluidDynamicsOptions = {}): FluidDynamicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFluidDynamics };
diff --git a/src/physics/future.ts b/src/physics/future.ts
new file mode 100644
index 000000000..76f090f6c
--- /dev/null
+++ b/src/physics/future.ts
@@ -0,0 +1,15 @@
+/** Physics Future module — tsb analytics library. */
+export interface Physics futureOptions { tol?: number; maxIter?: number; }
+export interface Physics futureResult { values: number[]; converged: boolean; }
+export function computePhysics future(data: number[], opts: Physics futureOptions = {}): Physics futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics future };
diff --git a/src/physics/gpu.ts b/src/physics/gpu.ts
new file mode 100644
index 000000000..6589ad787
--- /dev/null
+++ b/src/physics/gpu.ts
@@ -0,0 +1,15 @@
+/** Physics Gpu module — tsb analytics library. */
+export interface Physics gpuOptions { tol?: number; maxIter?: number; }
+export interface Physics gpuResult { values: number[]; converged: boolean; }
+export function computePhysics gpu(data: number[], opts: Physics gpuOptions = {}): Physics gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics gpu };
diff --git a/src/physics/large.ts b/src/physics/large.ts
new file mode 100644
index 000000000..6d8ee025d
--- /dev/null
+++ b/src/physics/large.ts
@@ -0,0 +1,15 @@
+/** Physics Large module — tsb analytics library. */
+export interface Physics largeOptions { tol?: number; maxIter?: number; }
+export interface Physics largeResult { values: number[]; converged: boolean; }
+export function computePhysics large(data: number[], opts: Physics largeOptions = {}): Physics largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics large };
diff --git a/src/physics/lattice.ts b/src/physics/lattice.ts
new file mode 100644
index 000000000..64afadcbc
--- /dev/null
+++ b/src/physics/lattice.ts
@@ -0,0 +1,22 @@
+/** Lattice module — tsb analytics library. */
+
+/** Options for Lattice. */
+export interface LatticeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lattice. */
+export interface LatticeResult { values: number[]; converged: boolean; }
+
+/** Compute Lattice. */
+export function computeLattice(data: number[], opts: LatticeOptions = {}): LatticeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLattice };
diff --git a/src/physics/legacy.ts b/src/physics/legacy.ts
new file mode 100644
index 000000000..068b8a0ac
--- /dev/null
+++ b/src/physics/legacy.ts
@@ -0,0 +1,15 @@
+/** Physics Legacy module — tsb analytics library. */
+export interface Physics legacyOptions { tol?: number; maxIter?: number; }
+export interface Physics legacyResult { values: number[]; converged: boolean; }
+export function computePhysics legacy(data: number[], opts: Physics legacyOptions = {}): Physics legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics legacy };
diff --git a/src/physics/lite.ts b/src/physics/lite.ts
new file mode 100644
index 000000000..40ed03982
--- /dev/null
+++ b/src/physics/lite.ts
@@ -0,0 +1,15 @@
+/** Physics Lite module — tsb analytics library. */
+export interface Physics liteOptions { tol?: number; maxIter?: number; }
+export interface Physics liteResult { values: number[]; converged: boolean; }
+export function computePhysics lite(data: number[], opts: Physics liteOptions = {}): Physics liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics lite };
diff --git a/src/physics/mechanics.ts b/src/physics/mechanics.ts
new file mode 100644
index 000000000..734934fb5
--- /dev/null
+++ b/src/physics/mechanics.ts
@@ -0,0 +1,22 @@
+/** Mechanics module — tsb analytics library. */
+
+/** Options for Mechanics. */
+export interface MechanicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mechanics. */
+export interface MechanicsResult { values: number[]; converged: boolean; }
+
+/** Compute Mechanics. */
+export function computeMechanics(data: number[], opts: MechanicsOptions = {}): MechanicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMechanics };
diff --git a/src/physics/mini.ts b/src/physics/mini.ts
new file mode 100644
index 000000000..1582cfe91
--- /dev/null
+++ b/src/physics/mini.ts
@@ -0,0 +1,15 @@
+/** Physics Mini module — tsb analytics library. */
+export interface Physics miniOptions { tol?: number; maxIter?: number; }
+export interface Physics miniResult { values: number[]; converged: boolean; }
+export function computePhysics mini(data: number[], opts: Physics miniOptions = {}): Physics miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics mini };
diff --git a/src/physics/molecular_dynamics.ts b/src/physics/molecular_dynamics.ts
new file mode 100644
index 000000000..e11db597a
--- /dev/null
+++ b/src/physics/molecular_dynamics.ts
@@ -0,0 +1,22 @@
+/** Molecular Dynamics module — tsb analytics library. */
+
+/** Options for Molecular Dynamics. */
+export interface MolecularDynamicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Molecular Dynamics. */
+export interface MolecularDynamicsResult { values: number[]; converged: boolean; }
+
+/** Compute Molecular Dynamics. */
+export function computeMolecularDynamics(data: number[], opts: MolecularDynamicsOptions = {}): MolecularDynamicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMolecularDynamics };
diff --git a/src/physics/monte_carlo.ts b/src/physics/monte_carlo.ts
new file mode 100644
index 000000000..80ebf4a35
--- /dev/null
+++ b/src/physics/monte_carlo.ts
@@ -0,0 +1,22 @@
+/** Monte Carlo module — tsb analytics library. */
+
+/** Options for Monte Carlo. */
+export interface MonteCarloOptions { tol?: number; maxIter?: number; }
+
+/** Result from Monte Carlo. */
+export interface MonteCarloResult { values: number[]; converged: boolean; }
+
+/** Compute Monte Carlo. */
+export function computeMonteCarlo(data: number[], opts: MonteCarloOptions = {}): MonteCarloResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMonteCarlo };
diff --git a/src/physics/next.ts b/src/physics/next.ts
new file mode 100644
index 000000000..51771ea50
--- /dev/null
+++ b/src/physics/next.ts
@@ -0,0 +1,15 @@
+/** Physics Next module — tsb analytics library. */
+export interface Physics nextOptions { tol?: number; maxIter?: number; }
+export interface Physics nextResult { values: number[]; converged: boolean; }
+export function computePhysics next(data: number[], opts: Physics nextOptions = {}): Physics nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics next };
diff --git a/src/physics/nonequilibrium.ts b/src/physics/nonequilibrium.ts
new file mode 100644
index 000000000..29291a40f
--- /dev/null
+++ b/src/physics/nonequilibrium.ts
@@ -0,0 +1,22 @@
+/** Nonequilibrium module — tsb analytics library. */
+
+/** Options for Nonequilibrium. */
+export interface NonequilibriumOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nonequilibrium. */
+export interface NonequilibriumResult { values: number[]; converged: boolean; }
+
+/** Compute Nonequilibrium. */
+export function computeNonequilibrium(data: number[], opts: NonequilibriumOptions = {}): NonequilibriumResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNonequilibrium };
diff --git a/src/physics/nuclear.ts b/src/physics/nuclear.ts
new file mode 100644
index 000000000..1576cc3a7
--- /dev/null
+++ b/src/physics/nuclear.ts
@@ -0,0 +1,22 @@
+/** Nuclear module — tsb analytics library. */
+
+/** Options for Nuclear. */
+export interface NuclearOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nuclear. */
+export interface NuclearResult { values: number[]; converged: boolean; }
+
+/** Compute Nuclear. */
+export function computeNuclear(data: number[], opts: NuclearOptions = {}): NuclearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNuclear };
diff --git a/src/physics/online.ts b/src/physics/online.ts
new file mode 100644
index 000000000..586c017d5
--- /dev/null
+++ b/src/physics/online.ts
@@ -0,0 +1,15 @@
+/** Physics Online module — tsb analytics library. */
+export interface Physics onlineOptions { tol?: number; maxIter?: number; }
+export interface Physics onlineResult { values: number[]; converged: boolean; }
+export function computePhysics online(data: number[], opts: Physics onlineOptions = {}): Physics onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics online };
diff --git a/src/physics/optics.ts b/src/physics/optics.ts
new file mode 100644
index 000000000..90c3b1153
--- /dev/null
+++ b/src/physics/optics.ts
@@ -0,0 +1,22 @@
+/** Optics module — tsb analytics library. */
+
+/** Options for Optics. */
+export interface OpticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Optics. */
+export interface OpticsResult { values: number[]; converged: boolean; }
+
+/** Compute Optics. */
+export function computeOptics(data: number[], opts: OpticsOptions = {}): OpticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOptics };
diff --git a/src/physics/parallel.ts b/src/physics/parallel.ts
new file mode 100644
index 000000000..adcae150e
--- /dev/null
+++ b/src/physics/parallel.ts
@@ -0,0 +1,15 @@
+/** Physics Parallel module — tsb analytics library. */
+export interface Physics parallelOptions { tol?: number; maxIter?: number; }
+export interface Physics parallelResult { values: number[]; converged: boolean; }
+export function computePhysics parallel(data: number[], opts: Physics parallelOptions = {}): Physics parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics parallel };
diff --git a/src/physics/particles.ts b/src/physics/particles.ts
new file mode 100644
index 000000000..b8e7a0532
--- /dev/null
+++ b/src/physics/particles.ts
@@ -0,0 +1,22 @@
+/** Particles module — tsb analytics library. */
+
+/** Options for Particles. */
+export interface ParticlesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Particles. */
+export interface ParticlesResult { values: number[]; converged: boolean; }
+
+/** Compute Particles. */
+export function computeParticles(data: number[], opts: ParticlesOptions = {}): ParticlesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeParticles };
diff --git a/src/physics/path_integral.ts b/src/physics/path_integral.ts
new file mode 100644
index 000000000..333fac5ec
--- /dev/null
+++ b/src/physics/path_integral.ts
@@ -0,0 +1,22 @@
+/** Path Integral module — tsb analytics library. */
+
+/** Options for Path Integral. */
+export interface PathIntegralOptions { tol?: number; maxIter?: number; }
+
+/** Result from Path Integral. */
+export interface PathIntegralResult { values: number[]; converged: boolean; }
+
+/** Compute Path Integral. */
+export function computePathIntegral(data: number[], opts: PathIntegralOptions = {}): PathIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePathIntegral };
diff --git a/src/physics/perturbation.ts b/src/physics/perturbation.ts
new file mode 100644
index 000000000..f7eca34ef
--- /dev/null
+++ b/src/physics/perturbation.ts
@@ -0,0 +1,22 @@
+/** Perturbation module — tsb analytics library. */
+
+/** Options for Perturbation. */
+export interface PerturbationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Perturbation. */
+export interface PerturbationResult { values: number[]; converged: boolean; }
+
+/** Compute Perturbation. */
+export function computePerturbation(data: number[], opts: PerturbationOptions = {}): PerturbationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePerturbation };
diff --git a/src/physics/phase_transition.ts b/src/physics/phase_transition.ts
new file mode 100644
index 000000000..1d40ac294
--- /dev/null
+++ b/src/physics/phase_transition.ts
@@ -0,0 +1,22 @@
+/** Phase Transition module — tsb analytics library. */
+
+/** Options for Phase Transition. */
+export interface PhaseTransitionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Phase Transition. */
+export interface PhaseTransitionResult { values: number[]; converged: boolean; }
+
+/** Compute Phase Transition. */
+export function computePhaseTransition(data: number[], opts: PhaseTransitionOptions = {}): PhaseTransitionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhaseTransition };
diff --git a/src/physics/plasma.ts b/src/physics/plasma.ts
new file mode 100644
index 000000000..59998f5d8
--- /dev/null
+++ b/src/physics/plasma.ts
@@ -0,0 +1,22 @@
+/** Plasma module — tsb analytics library. */
+
+/** Options for Plasma. */
+export interface PlasmaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Plasma. */
+export interface PlasmaResult { values: number[]; converged: boolean; }
+
+/** Compute Plasma. */
+export function computePlasma(data: number[], opts: PlasmaOptions = {}): PlasmaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePlasma };
diff --git a/src/physics/plus.ts b/src/physics/plus.ts
new file mode 100644
index 000000000..0e972f9d1
--- /dev/null
+++ b/src/physics/plus.ts
@@ -0,0 +1,15 @@
+/** Physics Plus module — tsb analytics library. */
+export interface Physics plusOptions { tol?: number; maxIter?: number; }
+export interface Physics plusResult { values: number[]; converged: boolean; }
+export function computePhysics plus(data: number[], opts: Physics plusOptions = {}): Physics plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics plus };
diff --git a/src/physics/pro.ts b/src/physics/pro.ts
new file mode 100644
index 000000000..d6479dc67
--- /dev/null
+++ b/src/physics/pro.ts
@@ -0,0 +1,15 @@
+/** Physics Pro module — tsb analytics library. */
+export interface Physics proOptions { tol?: number; maxIter?: number; }
+export interface Physics proResult { values: number[]; converged: boolean; }
+export function computePhysics pro(data: number[], opts: Physics proOptions = {}): Physics proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics pro };
diff --git a/src/physics/quantum.ts b/src/physics/quantum.ts
new file mode 100644
index 000000000..8a7964694
--- /dev/null
+++ b/src/physics/quantum.ts
@@ -0,0 +1,22 @@
+/** Quantum module — tsb analytics library. */
+
+/** Options for Quantum. */
+export interface QuantumOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quantum. */
+export interface QuantumResult { values: number[]; converged: boolean; }
+
+/** Compute Quantum. */
+export function computeQuantum(data: number[], opts: QuantumOptions = {}): QuantumResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQuantum };
diff --git a/src/physics/relativity.ts b/src/physics/relativity.ts
new file mode 100644
index 000000000..72cc2e378
--- /dev/null
+++ b/src/physics/relativity.ts
@@ -0,0 +1,22 @@
+/** Relativity module — tsb analytics library. */
+
+/** Options for Relativity. */
+export interface RelativityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Relativity. */
+export interface RelativityResult { values: number[]; converged: boolean; }
+
+/** Compute Relativity. */
+export function computeRelativity(data: number[], opts: RelativityOptions = {}): RelativityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRelativity };
diff --git a/src/physics/renormalization.ts b/src/physics/renormalization.ts
new file mode 100644
index 000000000..c7781070c
--- /dev/null
+++ b/src/physics/renormalization.ts
@@ -0,0 +1,22 @@
+/** Renormalization module — tsb analytics library. */
+
+/** Options for Renormalization. */
+export interface RenormalizationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Renormalization. */
+export interface RenormalizationResult { values: number[]; converged: boolean; }
+
+/** Compute Renormalization. */
+export function computeRenormalization(data: number[], opts: RenormalizationOptions = {}): RenormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRenormalization };
diff --git a/src/physics/robust.ts b/src/physics/robust.ts
new file mode 100644
index 000000000..bb906e6c4
--- /dev/null
+++ b/src/physics/robust.ts
@@ -0,0 +1,15 @@
+/** Physics Robust module — tsb analytics library. */
+export interface Physics robustOptions { tol?: number; maxIter?: number; }
+export interface Physics robustResult { values: number[]; converged: boolean; }
+export function computePhysics robust(data: number[], opts: Physics robustOptions = {}): Physics robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics robust };
diff --git a/src/physics/small.ts b/src/physics/small.ts
new file mode 100644
index 000000000..f8c88fbf8
--- /dev/null
+++ b/src/physics/small.ts
@@ -0,0 +1,15 @@
+/** Physics Small module — tsb analytics library. */
+export interface Physics smallOptions { tol?: number; maxIter?: number; }
+export interface Physics smallResult { values: number[]; converged: boolean; }
+export function computePhysics small(data: number[], opts: Physics smallOptions = {}): Physics smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics small };
diff --git a/src/physics/sparse.ts b/src/physics/sparse.ts
new file mode 100644
index 000000000..fb30743d0
--- /dev/null
+++ b/src/physics/sparse.ts
@@ -0,0 +1,15 @@
+/** Physics Sparse module — tsb analytics library. */
+export interface Physics sparseOptions { tol?: number; maxIter?: number; }
+export interface Physics sparseResult { values: number[]; converged: boolean; }
+export function computePhysics sparse(data: number[], opts: Physics sparseOptions = {}): Physics sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics sparse };
diff --git a/src/physics/stable.ts b/src/physics/stable.ts
new file mode 100644
index 000000000..d61743273
--- /dev/null
+++ b/src/physics/stable.ts
@@ -0,0 +1,15 @@
+/** Physics Stable module — tsb analytics library. */
+export interface Physics stableOptions { tol?: number; maxIter?: number; }
+export interface Physics stableResult { values: number[]; converged: boolean; }
+export function computePhysics stable(data: number[], opts: Physics stableOptions = {}): Physics stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics stable };
diff --git a/src/physics/statistical_physics.ts b/src/physics/statistical_physics.ts
new file mode 100644
index 000000000..9f5e2dfe7
--- /dev/null
+++ b/src/physics/statistical_physics.ts
@@ -0,0 +1,22 @@
+/** Statistical Physics module — tsb analytics library. */
+
+/** Options for Statistical Physics. */
+export interface StatisticalPhysicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Statistical Physics. */
+export interface StatisticalPhysicsResult { values: number[]; converged: boolean; }
+
+/** Compute Statistical Physics. */
+export function computeStatisticalPhysics(data: number[], opts: StatisticalPhysicsOptions = {}): StatisticalPhysicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStatisticalPhysics };
diff --git a/src/physics/streaming.ts b/src/physics/streaming.ts
new file mode 100644
index 000000000..0d5da6c2c
--- /dev/null
+++ b/src/physics/streaming.ts
@@ -0,0 +1,15 @@
+/** Physics Streaming module — tsb analytics library. */
+export interface Physics streamingOptions { tol?: number; maxIter?: number; }
+export interface Physics streamingResult { values: number[]; converged: boolean; }
+export function computePhysics streaming(data: number[], opts: Physics streamingOptions = {}): Physics streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics streaming };
diff --git a/src/physics/thermodynamics.ts b/src/physics/thermodynamics.ts
new file mode 100644
index 000000000..23fc6c0f0
--- /dev/null
+++ b/src/physics/thermodynamics.ts
@@ -0,0 +1,22 @@
+/** Thermodynamics module — tsb analytics library. */
+
+/** Options for Thermodynamics. */
+export interface ThermodynamicsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Thermodynamics. */
+export interface ThermodynamicsResult { values: number[]; converged: boolean; }
+
+/** Compute Thermodynamics. */
+export function computeThermodynamics(data: number[], opts: ThermodynamicsOptions = {}): ThermodynamicsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeThermodynamics };
diff --git a/src/physics/tight_binding.ts b/src/physics/tight_binding.ts
new file mode 100644
index 000000000..78057b650
--- /dev/null
+++ b/src/physics/tight_binding.ts
@@ -0,0 +1,22 @@
+/** Tight Binding module — tsb analytics library. */
+
+/** Options for Tight Binding. */
+export interface TightBindingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tight Binding. */
+export interface TightBindingResult { values: number[]; converged: boolean; }
+
+/** Compute Tight Binding. */
+export function computeTightBinding(data: number[], opts: TightBindingOptions = {}): TightBindingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTightBinding };
diff --git a/src/physics/transport.ts b/src/physics/transport.ts
new file mode 100644
index 000000000..fc969aa6f
--- /dev/null
+++ b/src/physics/transport.ts
@@ -0,0 +1,22 @@
+/** Transport module — tsb analytics library. */
+
+/** Options for Transport. */
+export interface TransportOptions { tol?: number; maxIter?: number; }
+
+/** Result from Transport. */
+export interface TransportResult { values: number[]; converged: boolean; }
+
+/** Compute Transport. */
+export function computeTransport(data: number[], opts: TransportOptions = {}): TransportResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTransport };
diff --git a/src/physics/v2.ts b/src/physics/v2.ts
new file mode 100644
index 000000000..32c3c3ce8
--- /dev/null
+++ b/src/physics/v2.ts
@@ -0,0 +1,15 @@
+/** Physics V2 module — tsb analytics library. */
+export interface Physics v2Options { tol?: number; maxIter?: number; }
+export interface Physics v2Result { values: number[]; converged: boolean; }
+export function computePhysics v2(data: number[], opts: Physics v2Options = {}): Physics v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics v2 };
diff --git a/src/physics/v3.ts b/src/physics/v3.ts
new file mode 100644
index 000000000..c910fbeae
--- /dev/null
+++ b/src/physics/v3.ts
@@ -0,0 +1,15 @@
+/** Physics V3 module — tsb analytics library. */
+export interface Physics v3Options { tol?: number; maxIter?: number; }
+export interface Physics v3Result { values: number[]; converged: boolean; }
+export function computePhysics v3(data: number[], opts: Physics v3Options = {}): Physics v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics v3 };
diff --git a/src/physics/variational.ts b/src/physics/variational.ts
new file mode 100644
index 000000000..b48b6602e
--- /dev/null
+++ b/src/physics/variational.ts
@@ -0,0 +1,22 @@
+/** Variational module — tsb analytics library. */
+
+/** Options for Variational. */
+export interface VariationalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Variational. */
+export interface VariationalResult { values: number[]; converged: boolean; }
+
+/** Compute Variational. */
+export function computeVariational(data: number[], opts: VariationalOptions = {}): VariationalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVariational };
diff --git a/src/physics/wasm.ts b/src/physics/wasm.ts
new file mode 100644
index 000000000..28c427aae
--- /dev/null
+++ b/src/physics/wasm.ts
@@ -0,0 +1,15 @@
+/** Physics Wasm module — tsb analytics library. */
+export interface Physics wasmOptions { tol?: number; maxIter?: number; }
+export interface Physics wasmResult { values: number[]; converged: boolean; }
+export function computePhysics wasm(data: number[], opts: Physics wasmOptions = {}): Physics wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics wasm };
diff --git a/src/physics/wave.ts b/src/physics/wave.ts
new file mode 100644
index 000000000..d43c95282
--- /dev/null
+++ b/src/physics/wave.ts
@@ -0,0 +1,22 @@
+/** Wave module — tsb analytics library. */
+
+/** Options for Wave. */
+export interface WaveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Wave. */
+export interface WaveResult { values: number[]; converged: boolean; }
+
+/** Compute Wave. */
+export function computeWave(data: number[], opts: WaveOptions = {}): WaveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWave };
diff --git a/src/physics/xlarge.ts b/src/physics/xlarge.ts
new file mode 100644
index 000000000..67a4d31e2
--- /dev/null
+++ b/src/physics/xlarge.ts
@@ -0,0 +1,15 @@
+/** Physics Xlarge module — tsb analytics library. */
+export interface Physics xlargeOptions { tol?: number; maxIter?: number; }
+export interface Physics xlargeResult { values: number[]; converged: boolean; }
+export function computePhysics xlarge(data: number[], opts: Physics xlargeOptions = {}): Physics xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePhysics xlarge };
diff --git a/src/planetary_sci/adaptation.ts b/src/planetary_sci/adaptation.ts
new file mode 100644
index 000000000..1a732b5a7
--- /dev/null
+++ b/src/planetary_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci adaptation module — tsb analytics library. */
+export interface PlanetarySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciAdaptationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciAdaptation(data: number[], opts: PlanetarySciAdaptationOptions = {}): PlanetarySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciAdaptation };
diff --git a/src/planetary_sci/aggregation.ts b/src/planetary_sci/aggregation.ts
new file mode 100644
index 000000000..3a185ebb9
--- /dev/null
+++ b/src/planetary_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci aggregation module — tsb analytics library. */
+export interface PlanetarySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciAggregationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciAggregation(data: number[], opts: PlanetarySciAggregationOptions = {}): PlanetarySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciAggregation };
diff --git a/src/planetary_sci/algebra.ts b/src/planetary_sci/algebra.ts
new file mode 100644
index 000000000..dcb3497b0
--- /dev/null
+++ b/src/planetary_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** planetary_sci algebra module — tsb analytics library. */
+export interface PlanetarySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciAlgebraResult { values: number[]; converged: boolean; }
+export function computePlanetarySciAlgebra(data: number[], opts: PlanetarySciAlgebraOptions = {}): PlanetarySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciAlgebra };
diff --git a/src/planetary_sci/alignment.ts b/src/planetary_sci/alignment.ts
new file mode 100644
index 000000000..a9cdc3021
--- /dev/null
+++ b/src/planetary_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** planetary_sci alignment module — tsb analytics library. */
+export interface PlanetarySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciAlignmentResult { values: number[]; converged: boolean; }
+export function computePlanetarySciAlignment(data: number[], opts: PlanetarySciAlignmentOptions = {}): PlanetarySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciAlignment };
diff --git a/src/planetary_sci/analysis.ts b/src/planetary_sci/analysis.ts
new file mode 100644
index 000000000..6b14f9129
--- /dev/null
+++ b/src/planetary_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** planetary_sci analysis module — tsb analytics library. */
+export interface PlanetarySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciAnalysisResult { values: number[]; converged: boolean; }
+export function computePlanetarySciAnalysis(data: number[], opts: PlanetarySciAnalysisOptions = {}): PlanetarySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciAnalysis };
diff --git a/src/planetary_sci/augmentation.ts b/src/planetary_sci/augmentation.ts
new file mode 100644
index 000000000..ba271622d
--- /dev/null
+++ b/src/planetary_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci augmentation module — tsb analytics library. */
+export interface PlanetarySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciAugmentationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciAugmentation(data: number[], opts: PlanetarySciAugmentationOptions = {}): PlanetarySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciAugmentation };
diff --git a/src/planetary_sci/bagging.ts b/src/planetary_sci/bagging.ts
new file mode 100644
index 000000000..870ebb357
--- /dev/null
+++ b/src/planetary_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** planetary_sci bagging module — tsb analytics library. */
+export interface PlanetarySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciBaggingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciBagging(data: number[], opts: PlanetarySciBaggingOptions = {}): PlanetarySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciBagging };
diff --git a/src/planetary_sci/basis.ts b/src/planetary_sci/basis.ts
new file mode 100644
index 000000000..bded4c7ff
--- /dev/null
+++ b/src/planetary_sci/basis.ts
@@ -0,0 +1,14 @@
+/** planetary_sci basis module — tsb analytics library. */
+export interface PlanetarySciBasisOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciBasisResult { values: number[]; converged: boolean; }
+export function computePlanetarySciBasis(data: number[], opts: PlanetarySciBasisOptions = {}): PlanetarySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciBasis };
diff --git a/src/planetary_sci/benchmarking.ts b/src/planetary_sci/benchmarking.ts
new file mode 100644
index 000000000..7b628522d
--- /dev/null
+++ b/src/planetary_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** planetary_sci benchmarking module — tsb analytics library. */
+export interface PlanetarySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciBenchmarking(data: number[], opts: PlanetarySciBenchmarkingOptions = {}): PlanetarySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciBenchmarking };
diff --git a/src/planetary_sci/blending.ts b/src/planetary_sci/blending.ts
new file mode 100644
index 000000000..19748a8f5
--- /dev/null
+++ b/src/planetary_sci/blending.ts
@@ -0,0 +1,14 @@
+/** planetary_sci blending module — tsb analytics library. */
+export interface PlanetarySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciBlendingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciBlending(data: number[], opts: PlanetarySciBlendingOptions = {}): PlanetarySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciBlending };
diff --git a/src/planetary_sci/boosting.ts b/src/planetary_sci/boosting.ts
new file mode 100644
index 000000000..31305a987
--- /dev/null
+++ b/src/planetary_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** planetary_sci boosting module — tsb analytics library. */
+export interface PlanetarySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciBoostingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciBoosting(data: number[], opts: PlanetarySciBoostingOptions = {}): PlanetarySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciBoosting };
diff --git a/src/planetary_sci/bootstrap.ts b/src/planetary_sci/bootstrap.ts
new file mode 100644
index 000000000..cee71a5d8
--- /dev/null
+++ b/src/planetary_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** planetary_sci bootstrap module — tsb analytics library. */
+export interface PlanetarySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciBootstrapResult { values: number[]; converged: boolean; }
+export function computePlanetarySciBootstrap(data: number[], opts: PlanetarySciBootstrapOptions = {}): PlanetarySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciBootstrap };
diff --git a/src/planetary_sci/calculus.ts b/src/planetary_sci/calculus.ts
new file mode 100644
index 000000000..fa303a275
--- /dev/null
+++ b/src/planetary_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** planetary_sci calculus module — tsb analytics library. */
+export interface PlanetarySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciCalculusResult { values: number[]; converged: boolean; }
+export function computePlanetarySciCalculus(data: number[], opts: PlanetarySciCalculusOptions = {}): PlanetarySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciCalculus };
diff --git a/src/planetary_sci/calibration.ts b/src/planetary_sci/calibration.ts
new file mode 100644
index 000000000..ecdb78812
--- /dev/null
+++ b/src/planetary_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** planetary_sci calibration module — tsb analytics library. */
+export interface PlanetarySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciCalibrationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciCalibration(data: number[], opts: PlanetarySciCalibrationOptions = {}): PlanetarySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciCalibration };
diff --git a/src/planetary_sci/characterization.ts b/src/planetary_sci/characterization.ts
new file mode 100644
index 000000000..c20ccd5cb
--- /dev/null
+++ b/src/planetary_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** planetary_sci characterization module — tsb analytics library. */
+export interface PlanetarySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciCharacterization(data: number[], opts: PlanetarySciCharacterizationOptions = {}): PlanetarySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciCharacterization };
diff --git a/src/planetary_sci/classification.ts b/src/planetary_sci/classification.ts
new file mode 100644
index 000000000..296913bad
--- /dev/null
+++ b/src/planetary_sci/classification.ts
@@ -0,0 +1,14 @@
+/** planetary_sci classification module — tsb analytics library. */
+export interface PlanetarySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciClassificationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciClassification(data: number[], opts: PlanetarySciClassificationOptions = {}): PlanetarySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciClassification };
diff --git a/src/planetary_sci/clustering.ts b/src/planetary_sci/clustering.ts
new file mode 100644
index 000000000..2977b19d7
--- /dev/null
+++ b/src/planetary_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** planetary_sci clustering module — tsb analytics library. */
+export interface PlanetarySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciClusteringResult { values: number[]; converged: boolean; }
+export function computePlanetarySciClustering(data: number[], opts: PlanetarySciClusteringOptions = {}): PlanetarySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciClustering };
diff --git a/src/planetary_sci/compression.ts b/src/planetary_sci/compression.ts
new file mode 100644
index 000000000..ea3c6cd8d
--- /dev/null
+++ b/src/planetary_sci/compression.ts
@@ -0,0 +1,14 @@
+/** planetary_sci compression module — tsb analytics library. */
+export interface PlanetarySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciCompressionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciCompression(data: number[], opts: PlanetarySciCompressionOptions = {}): PlanetarySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciCompression };
diff --git a/src/planetary_sci/continuous.ts b/src/planetary_sci/continuous.ts
new file mode 100644
index 000000000..9dbd3c060
--- /dev/null
+++ b/src/planetary_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** planetary_sci continuous module — tsb analytics library. */
+export interface PlanetarySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciContinuousResult { values: number[]; converged: boolean; }
+export function computePlanetarySciContinuous(data: number[], opts: PlanetarySciContinuousOptions = {}): PlanetarySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciContinuous };
diff --git a/src/planetary_sci/control.ts b/src/planetary_sci/control.ts
new file mode 100644
index 000000000..a7c1f2b83
--- /dev/null
+++ b/src/planetary_sci/control.ts
@@ -0,0 +1,14 @@
+/** planetary_sci control module — tsb analytics library. */
+export interface PlanetarySciControlOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciControlResult { values: number[]; converged: boolean; }
+export function computePlanetarySciControl(data: number[], opts: PlanetarySciControlOptions = {}): PlanetarySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciControl };
diff --git a/src/planetary_sci/convergence.ts b/src/planetary_sci/convergence.ts
new file mode 100644
index 000000000..59be5d53e
--- /dev/null
+++ b/src/planetary_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** planetary_sci convergence module — tsb analytics library. */
+export interface PlanetarySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciConvergenceResult { values: number[]; converged: boolean; }
+export function computePlanetarySciConvergence(data: number[], opts: PlanetarySciConvergenceOptions = {}): PlanetarySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciConvergence };
diff --git a/src/planetary_sci/convex.ts b/src/planetary_sci/convex.ts
new file mode 100644
index 000000000..cb20bd009
--- /dev/null
+++ b/src/planetary_sci/convex.ts
@@ -0,0 +1,14 @@
+/** planetary_sci convex module — tsb analytics library. */
+export interface PlanetarySciConvexOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciConvexResult { values: number[]; converged: boolean; }
+export function computePlanetarySciConvex(data: number[], opts: PlanetarySciConvexOptions = {}): PlanetarySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciConvex };
diff --git a/src/planetary_sci/correlation.ts b/src/planetary_sci/correlation.ts
new file mode 100644
index 000000000..947fa91e2
--- /dev/null
+++ b/src/planetary_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci correlation module — tsb analytics library. */
+export interface PlanetarySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciCorrelationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciCorrelation(data: number[], opts: PlanetarySciCorrelationOptions = {}): PlanetarySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciCorrelation };
diff --git a/src/planetary_sci/covariance.ts b/src/planetary_sci/covariance.ts
new file mode 100644
index 000000000..a679f6f20
--- /dev/null
+++ b/src/planetary_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** planetary_sci covariance module — tsb analytics library. */
+export interface PlanetarySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciCovarianceResult { values: number[]; converged: boolean; }
+export function computePlanetarySciCovariance(data: number[], opts: PlanetarySciCovarianceOptions = {}): PlanetarySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciCovariance };
diff --git a/src/planetary_sci/cross_validation.ts b/src/planetary_sci/cross_validation.ts
new file mode 100644
index 000000000..0d71cb011
--- /dev/null
+++ b/src/planetary_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci cross_validation module — tsb analytics library. */
+export interface PlanetarySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciCrossValidation(data: number[], opts: PlanetarySciCrossValidationOptions = {}): PlanetarySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciCrossValidation };
diff --git a/src/planetary_sci/decoding.ts b/src/planetary_sci/decoding.ts
new file mode 100644
index 000000000..e5c3660d0
--- /dev/null
+++ b/src/planetary_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** planetary_sci decoding module — tsb analytics library. */
+export interface PlanetarySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDecodingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDecoding(data: number[], opts: PlanetarySciDecodingOptions = {}): PlanetarySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDecoding };
diff --git a/src/planetary_sci/decomposition.ts b/src/planetary_sci/decomposition.ts
new file mode 100644
index 000000000..122289f73
--- /dev/null
+++ b/src/planetary_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** planetary_sci decomposition module — tsb analytics library. */
+export interface PlanetarySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDecompositionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDecomposition(data: number[], opts: PlanetarySciDecompositionOptions = {}): PlanetarySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDecomposition };
diff --git a/src/planetary_sci/detection.ts b/src/planetary_sci/detection.ts
new file mode 100644
index 000000000..230eda5d2
--- /dev/null
+++ b/src/planetary_sci/detection.ts
@@ -0,0 +1,14 @@
+/** planetary_sci detection module — tsb analytics library. */
+export interface PlanetarySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDetectionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDetection(data: number[], opts: PlanetarySciDetectionOptions = {}): PlanetarySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDetection };
diff --git a/src/planetary_sci/deterministic.ts b/src/planetary_sci/deterministic.ts
new file mode 100644
index 000000000..0605c86ed
--- /dev/null
+++ b/src/planetary_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** planetary_sci deterministic module — tsb analytics library. */
+export interface PlanetarySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDeterministicResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDeterministic(data: number[], opts: PlanetarySciDeterministicOptions = {}): PlanetarySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDeterministic };
diff --git a/src/planetary_sci/diagnostics.ts b/src/planetary_sci/diagnostics.ts
new file mode 100644
index 000000000..7e5b4c542
--- /dev/null
+++ b/src/planetary_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** planetary_sci diagnostics module — tsb analytics library. */
+export interface PlanetarySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDiagnostics(data: number[], opts: PlanetarySciDiagnosticsOptions = {}): PlanetarySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDiagnostics };
diff --git a/src/planetary_sci/differential.ts b/src/planetary_sci/differential.ts
new file mode 100644
index 000000000..031c44d62
--- /dev/null
+++ b/src/planetary_sci/differential.ts
@@ -0,0 +1,14 @@
+/** planetary_sci differential module — tsb analytics library. */
+export interface PlanetarySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDifferentialResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDifferential(data: number[], opts: PlanetarySciDifferentialOptions = {}): PlanetarySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDifferential };
diff --git a/src/planetary_sci/discrete.ts b/src/planetary_sci/discrete.ts
new file mode 100644
index 000000000..3bda70bb8
--- /dev/null
+++ b/src/planetary_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** planetary_sci discrete module — tsb analytics library. */
+export interface PlanetarySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDiscreteResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDiscrete(data: number[], opts: PlanetarySciDiscreteOptions = {}): PlanetarySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDiscrete };
diff --git a/src/planetary_sci/distribution.ts b/src/planetary_sci/distribution.ts
new file mode 100644
index 000000000..001ed0398
--- /dev/null
+++ b/src/planetary_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** planetary_sci distribution module — tsb analytics library. */
+export interface PlanetarySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDistributionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDistribution(data: number[], opts: PlanetarySciDistributionOptions = {}): PlanetarySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDistribution };
diff --git a/src/planetary_sci/dynamic.ts b/src/planetary_sci/dynamic.ts
new file mode 100644
index 000000000..198877960
--- /dev/null
+++ b/src/planetary_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** planetary_sci dynamic module — tsb analytics library. */
+export interface PlanetarySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciDynamicResult { values: number[]; converged: boolean; }
+export function computePlanetarySciDynamic(data: number[], opts: PlanetarySciDynamicOptions = {}): PlanetarySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciDynamic };
diff --git a/src/planetary_sci/embedding.ts b/src/planetary_sci/embedding.ts
new file mode 100644
index 000000000..7d7b8232c
--- /dev/null
+++ b/src/planetary_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** planetary_sci embedding module — tsb analytics library. */
+export interface PlanetarySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciEmbedding(data: number[], opts: PlanetarySciEmbeddingOptions = {}): PlanetarySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciEmbedding };
diff --git a/src/planetary_sci/encoding.ts b/src/planetary_sci/encoding.ts
new file mode 100644
index 000000000..5f0855624
--- /dev/null
+++ b/src/planetary_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** planetary_sci encoding module — tsb analytics library. */
+export interface PlanetarySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciEncodingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciEncoding(data: number[], opts: PlanetarySciEncodingOptions = {}): PlanetarySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciEncoding };
diff --git a/src/planetary_sci/ensemble.ts b/src/planetary_sci/ensemble.ts
new file mode 100644
index 000000000..096ef95ba
--- /dev/null
+++ b/src/planetary_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** planetary_sci ensemble module — tsb analytics library. */
+export interface PlanetarySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciEnsembleResult { values: number[]; converged: boolean; }
+export function computePlanetarySciEnsemble(data: number[], opts: PlanetarySciEnsembleOptions = {}): PlanetarySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciEnsemble };
diff --git a/src/planetary_sci/estimation.ts b/src/planetary_sci/estimation.ts
new file mode 100644
index 000000000..826d266d9
--- /dev/null
+++ b/src/planetary_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci estimation module — tsb analytics library. */
+export interface PlanetarySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciEstimationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciEstimation(data: number[], opts: PlanetarySciEstimationOptions = {}): PlanetarySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciEstimation };
diff --git a/src/planetary_sci/evaluation.ts b/src/planetary_sci/evaluation.ts
new file mode 100644
index 000000000..66cd547a6
--- /dev/null
+++ b/src/planetary_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci evaluation module — tsb analytics library. */
+export interface PlanetarySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciEvaluationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciEvaluation(data: number[], opts: PlanetarySciEvaluationOptions = {}): PlanetarySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciEvaluation };
diff --git a/src/planetary_sci/extrapolation.ts b/src/planetary_sci/extrapolation.ts
new file mode 100644
index 000000000..94b8c19b6
--- /dev/null
+++ b/src/planetary_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci extrapolation module — tsb analytics library. */
+export interface PlanetarySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciExtrapolation(data: number[], opts: PlanetarySciExtrapolationOptions = {}): PlanetarySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciExtrapolation };
diff --git a/src/planetary_sci/features.ts b/src/planetary_sci/features.ts
new file mode 100644
index 000000000..4e2fba42e
--- /dev/null
+++ b/src/planetary_sci/features.ts
@@ -0,0 +1,14 @@
+/** planetary_sci features module — tsb analytics library. */
+export interface PlanetarySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciFeaturesResult { values: number[]; converged: boolean; }
+export function computePlanetarySciFeatures(data: number[], opts: PlanetarySciFeaturesOptions = {}): PlanetarySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciFeatures };
diff --git a/src/planetary_sci/feedback.ts b/src/planetary_sci/feedback.ts
new file mode 100644
index 000000000..0176091e0
--- /dev/null
+++ b/src/planetary_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** planetary_sci feedback module — tsb analytics library. */
+export interface PlanetarySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciFeedbackResult { values: number[]; converged: boolean; }
+export function computePlanetarySciFeedback(data: number[], opts: PlanetarySciFeedbackOptions = {}): PlanetarySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciFeedback };
diff --git a/src/planetary_sci/filtering.ts b/src/planetary_sci/filtering.ts
new file mode 100644
index 000000000..172d59439
--- /dev/null
+++ b/src/planetary_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** planetary_sci filtering module — tsb analytics library. */
+export interface PlanetarySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciFilteringResult { values: number[]; converged: boolean; }
+export function computePlanetarySciFiltering(data: number[], opts: PlanetarySciFilteringOptions = {}): PlanetarySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciFiltering };
diff --git a/src/planetary_sci/fourier.ts b/src/planetary_sci/fourier.ts
new file mode 100644
index 000000000..6573569ab
--- /dev/null
+++ b/src/planetary_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** planetary_sci fourier module — tsb analytics library. */
+export interface PlanetarySciFourierOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciFourierResult { values: number[]; converged: boolean; }
+export function computePlanetarySciFourier(data: number[], opts: PlanetarySciFourierOptions = {}): PlanetarySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciFourier };
diff --git a/src/planetary_sci/fusion.ts b/src/planetary_sci/fusion.ts
new file mode 100644
index 000000000..c3901ce9a
--- /dev/null
+++ b/src/planetary_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** planetary_sci fusion module — tsb analytics library. */
+export interface PlanetarySciFusionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciFusionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciFusion(data: number[], opts: PlanetarySciFusionOptions = {}): PlanetarySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciFusion };
diff --git a/src/planetary_sci/generation.ts b/src/planetary_sci/generation.ts
new file mode 100644
index 000000000..6f0e0c377
--- /dev/null
+++ b/src/planetary_sci/generation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci generation module — tsb analytics library. */
+export interface PlanetarySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciGenerationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciGeneration(data: number[], opts: PlanetarySciGenerationOptions = {}): PlanetarySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciGeneration };
diff --git a/src/planetary_sci/geometry.ts b/src/planetary_sci/geometry.ts
new file mode 100644
index 000000000..aac809300
--- /dev/null
+++ b/src/planetary_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** planetary_sci geometry module — tsb analytics library. */
+export interface PlanetarySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciGeometryResult { values: number[]; converged: boolean; }
+export function computePlanetarySciGeometry(data: number[], opts: PlanetarySciGeometryOptions = {}): PlanetarySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciGeometry };
diff --git a/src/planetary_sci/gradient.ts b/src/planetary_sci/gradient.ts
new file mode 100644
index 000000000..e8239841f
--- /dev/null
+++ b/src/planetary_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** planetary_sci gradient module — tsb analytics library. */
+export interface PlanetarySciGradientOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciGradientResult { values: number[]; converged: boolean; }
+export function computePlanetarySciGradient(data: number[], opts: PlanetarySciGradientOptions = {}): PlanetarySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciGradient };
diff --git a/src/planetary_sci/hessian.ts b/src/planetary_sci/hessian.ts
new file mode 100644
index 000000000..b5d7d6c5a
--- /dev/null
+++ b/src/planetary_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** planetary_sci hessian module — tsb analytics library. */
+export interface PlanetarySciHessianOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciHessianResult { values: number[]; converged: boolean; }
+export function computePlanetarySciHessian(data: number[], opts: PlanetarySciHessianOptions = {}): PlanetarySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciHessian };
diff --git a/src/planetary_sci/hypothesis.ts b/src/planetary_sci/hypothesis.ts
new file mode 100644
index 000000000..0d9a8fbe7
--- /dev/null
+++ b/src/planetary_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** planetary_sci hypothesis module — tsb analytics library. */
+export interface PlanetarySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciHypothesisResult { values: number[]; converged: boolean; }
+export function computePlanetarySciHypothesis(data: number[], opts: PlanetarySciHypothesisOptions = {}): PlanetarySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciHypothesis };
diff --git a/src/planetary_sci/inference.ts b/src/planetary_sci/inference.ts
new file mode 100644
index 000000000..b34edccf9
--- /dev/null
+++ b/src/planetary_sci/inference.ts
@@ -0,0 +1,14 @@
+/** planetary_sci inference module — tsb analytics library. */
+export interface PlanetarySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciInferenceResult { values: number[]; converged: boolean; }
+export function computePlanetarySciInference(data: number[], opts: PlanetarySciInferenceOptions = {}): PlanetarySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciInference };
diff --git a/src/planetary_sci/inference2.ts b/src/planetary_sci/inference2.ts
new file mode 100644
index 000000000..5d3a1284b
--- /dev/null
+++ b/src/planetary_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** planetary_sci inference2 module — tsb analytics library. */
+export interface PlanetarySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciInferenceResult { values: number[]; converged: boolean; }
+export function computePlanetarySciInference(data: number[], opts: PlanetarySciInferenceOptions = {}): PlanetarySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciInference };
diff --git a/src/planetary_sci/integral.ts b/src/planetary_sci/integral.ts
new file mode 100644
index 000000000..3f0d69977
--- /dev/null
+++ b/src/planetary_sci/integral.ts
@@ -0,0 +1,14 @@
+/** planetary_sci integral module — tsb analytics library. */
+export interface PlanetarySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciIntegralResult { values: number[]; converged: boolean; }
+export function computePlanetarySciIntegral(data: number[], opts: PlanetarySciIntegralOptions = {}): PlanetarySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciIntegral };
diff --git a/src/planetary_sci/integration.ts b/src/planetary_sci/integration.ts
new file mode 100644
index 000000000..5909376ee
--- /dev/null
+++ b/src/planetary_sci/integration.ts
@@ -0,0 +1,14 @@
+/** planetary_sci integration module — tsb analytics library. */
+export interface PlanetarySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciIntegrationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciIntegration(data: number[], opts: PlanetarySciIntegrationOptions = {}): PlanetarySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciIntegration };
diff --git a/src/planetary_sci/interpolation.ts b/src/planetary_sci/interpolation.ts
new file mode 100644
index 000000000..b86cfa3df
--- /dev/null
+++ b/src/planetary_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci interpolation module — tsb analytics library. */
+export interface PlanetarySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciInterpolationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciInterpolation(data: number[], opts: PlanetarySciInterpolationOptions = {}): PlanetarySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciInterpolation };
diff --git a/src/planetary_sci/jacobian.ts b/src/planetary_sci/jacobian.ts
new file mode 100644
index 000000000..2b0344bfc
--- /dev/null
+++ b/src/planetary_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** planetary_sci jacobian module — tsb analytics library. */
+export interface PlanetarySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciJacobianResult { values: number[]; converged: boolean; }
+export function computePlanetarySciJacobian(data: number[], opts: PlanetarySciJacobianOptions = {}): PlanetarySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciJacobian };
diff --git a/src/planetary_sci/kernel.ts b/src/planetary_sci/kernel.ts
new file mode 100644
index 000000000..e8b2090df
--- /dev/null
+++ b/src/planetary_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** planetary_sci kernel module — tsb analytics library. */
+export interface PlanetarySciKernelOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciKernelResult { values: number[]; converged: boolean; }
+export function computePlanetarySciKernel(data: number[], opts: PlanetarySciKernelOptions = {}): PlanetarySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciKernel };
diff --git a/src/planetary_sci/laplacian.ts b/src/planetary_sci/laplacian.ts
new file mode 100644
index 000000000..022d127be
--- /dev/null
+++ b/src/planetary_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** planetary_sci laplacian module — tsb analytics library. */
+export interface PlanetarySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciLaplacianResult { values: number[]; converged: boolean; }
+export function computePlanetarySciLaplacian(data: number[], opts: PlanetarySciLaplacianOptions = {}): PlanetarySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciLaplacian };
diff --git a/src/planetary_sci/learning.ts b/src/planetary_sci/learning.ts
new file mode 100644
index 000000000..bdcb41092
--- /dev/null
+++ b/src/planetary_sci/learning.ts
@@ -0,0 +1,14 @@
+/** planetary_sci learning module — tsb analytics library. */
+export interface PlanetarySciLearningOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciLearningResult { values: number[]; converged: boolean; }
+export function computePlanetarySciLearning(data: number[], opts: PlanetarySciLearningOptions = {}): PlanetarySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciLearning };
diff --git a/src/planetary_sci/linear.ts b/src/planetary_sci/linear.ts
new file mode 100644
index 000000000..e5495281f
--- /dev/null
+++ b/src/planetary_sci/linear.ts
@@ -0,0 +1,14 @@
+/** planetary_sci linear module — tsb analytics library. */
+export interface PlanetarySciLinearOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciLinearResult { values: number[]; converged: boolean; }
+export function computePlanetarySciLinear(data: number[], opts: PlanetarySciLinearOptions = {}): PlanetarySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciLinear };
diff --git a/src/planetary_sci/manifold.ts b/src/planetary_sci/manifold.ts
new file mode 100644
index 000000000..aa3488f71
--- /dev/null
+++ b/src/planetary_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** planetary_sci manifold module — tsb analytics library. */
+export interface PlanetarySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciManifoldResult { values: number[]; converged: boolean; }
+export function computePlanetarySciManifold(data: number[], opts: PlanetarySciManifoldOptions = {}): PlanetarySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciManifold };
diff --git a/src/planetary_sci/matching.ts b/src/planetary_sci/matching.ts
new file mode 100644
index 000000000..43db18838
--- /dev/null
+++ b/src/planetary_sci/matching.ts
@@ -0,0 +1,14 @@
+/** planetary_sci matching module — tsb analytics library. */
+export interface PlanetarySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciMatchingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciMatching(data: number[], opts: PlanetarySciMatchingOptions = {}): PlanetarySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciMatching };
diff --git a/src/planetary_sci/measurement.ts b/src/planetary_sci/measurement.ts
new file mode 100644
index 000000000..8b4728775
--- /dev/null
+++ b/src/planetary_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** planetary_sci measurement module — tsb analytics library. */
+export interface PlanetarySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciMeasurementResult { values: number[]; converged: boolean; }
+export function computePlanetarySciMeasurement(data: number[], opts: PlanetarySciMeasurementOptions = {}): PlanetarySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciMeasurement };
diff --git a/src/planetary_sci/metrics.ts b/src/planetary_sci/metrics.ts
new file mode 100644
index 000000000..e550c97d4
--- /dev/null
+++ b/src/planetary_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** planetary_sci metrics module — tsb analytics library. */
+export interface PlanetarySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciMetricsResult { values: number[]; converged: boolean; }
+export function computePlanetarySciMetrics(data: number[], opts: PlanetarySciMetricsOptions = {}): PlanetarySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciMetrics };
diff --git a/src/planetary_sci/modeling.ts b/src/planetary_sci/modeling.ts
new file mode 100644
index 000000000..b7a13d5f6
--- /dev/null
+++ b/src/planetary_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** planetary_sci modeling module — tsb analytics library. */
+export interface PlanetarySciModelingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciModelingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciModeling(data: number[], opts: PlanetarySciModelingOptions = {}): PlanetarySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciModeling };
diff --git a/src/planetary_sci/monitoring.ts b/src/planetary_sci/monitoring.ts
new file mode 100644
index 000000000..0bf888690
--- /dev/null
+++ b/src/planetary_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** planetary_sci monitoring module — tsb analytics library. */
+export interface PlanetarySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciMonitoringResult { values: number[]; converged: boolean; }
+export function computePlanetarySciMonitoring(data: number[], opts: PlanetarySciMonitoringOptions = {}): PlanetarySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciMonitoring };
diff --git a/src/planetary_sci/nonlinear.ts b/src/planetary_sci/nonlinear.ts
new file mode 100644
index 000000000..b40c0e47d
--- /dev/null
+++ b/src/planetary_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** planetary_sci nonlinear module — tsb analytics library. */
+export interface PlanetarySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciNonlinearResult { values: number[]; converged: boolean; }
+export function computePlanetarySciNonlinear(data: number[], opts: PlanetarySciNonlinearOptions = {}): PlanetarySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciNonlinear };
diff --git a/src/planetary_sci/normalization.ts b/src/planetary_sci/normalization.ts
new file mode 100644
index 000000000..358a0b13f
--- /dev/null
+++ b/src/planetary_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** planetary_sci normalization module — tsb analytics library. */
+export interface PlanetarySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciNormalizationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciNormalization(data: number[], opts: PlanetarySciNormalizationOptions = {}): PlanetarySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciNormalization };
diff --git a/src/planetary_sci/optimization.ts b/src/planetary_sci/optimization.ts
new file mode 100644
index 000000000..de03c3a5e
--- /dev/null
+++ b/src/planetary_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** planetary_sci optimization module — tsb analytics library. */
+export interface PlanetarySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciOptimizationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciOptimization(data: number[], opts: PlanetarySciOptimizationOptions = {}): PlanetarySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciOptimization };
diff --git a/src/planetary_sci/patterns.ts b/src/planetary_sci/patterns.ts
new file mode 100644
index 000000000..fb65bfcb1
--- /dev/null
+++ b/src/planetary_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** planetary_sci patterns module — tsb analytics library. */
+export interface PlanetarySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciPatternsResult { values: number[]; converged: boolean; }
+export function computePlanetarySciPatterns(data: number[], opts: PlanetarySciPatternsOptions = {}): PlanetarySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciPatterns };
diff --git a/src/planetary_sci/permutation.ts b/src/planetary_sci/permutation.ts
new file mode 100644
index 000000000..6cdae4b33
--- /dev/null
+++ b/src/planetary_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci permutation module — tsb analytics library. */
+export interface PlanetarySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciPermutationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciPermutation(data: number[], opts: PlanetarySciPermutationOptions = {}): PlanetarySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciPermutation };
diff --git a/src/planetary_sci/prediction.ts b/src/planetary_sci/prediction.ts
new file mode 100644
index 000000000..5837f2b93
--- /dev/null
+++ b/src/planetary_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** planetary_sci prediction module — tsb analytics library. */
+export interface PlanetarySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciPredictionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciPrediction(data: number[], opts: PlanetarySciPredictionOptions = {}): PlanetarySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciPrediction };
diff --git a/src/planetary_sci/processing.ts b/src/planetary_sci/processing.ts
new file mode 100644
index 000000000..12116d698
--- /dev/null
+++ b/src/planetary_sci/processing.ts
@@ -0,0 +1,14 @@
+/** planetary_sci processing module — tsb analytics library. */
+export interface PlanetarySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciProcessingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciProcessing(data: number[], opts: PlanetarySciProcessingOptions = {}): PlanetarySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciProcessing };
diff --git a/src/planetary_sci/profiling.ts b/src/planetary_sci/profiling.ts
new file mode 100644
index 000000000..216170aca
--- /dev/null
+++ b/src/planetary_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** planetary_sci profiling module — tsb analytics library. */
+export interface PlanetarySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciProfilingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciProfiling(data: number[], opts: PlanetarySciProfilingOptions = {}): PlanetarySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciProfiling };
diff --git a/src/planetary_sci/projection.ts b/src/planetary_sci/projection.ts
new file mode 100644
index 000000000..e4a12ccfe
--- /dev/null
+++ b/src/planetary_sci/projection.ts
@@ -0,0 +1,14 @@
+/** planetary_sci projection module — tsb analytics library. */
+export interface PlanetarySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciProjectionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciProjection(data: number[], opts: PlanetarySciProjectionOptions = {}): PlanetarySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciProjection };
diff --git a/src/planetary_sci/ranking.ts b/src/planetary_sci/ranking.ts
new file mode 100644
index 000000000..3f9b88e9c
--- /dev/null
+++ b/src/planetary_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** planetary_sci ranking module — tsb analytics library. */
+export interface PlanetarySciRankingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciRankingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciRanking(data: number[], opts: PlanetarySciRankingOptions = {}): PlanetarySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciRanking };
diff --git a/src/planetary_sci/reconstruction.ts b/src/planetary_sci/reconstruction.ts
new file mode 100644
index 000000000..bb493dc88
--- /dev/null
+++ b/src/planetary_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** planetary_sci reconstruction module — tsb analytics library. */
+export interface PlanetarySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciReconstructionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciReconstruction(data: number[], opts: PlanetarySciReconstructionOptions = {}): PlanetarySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciReconstruction };
diff --git a/src/planetary_sci/registration.ts b/src/planetary_sci/registration.ts
new file mode 100644
index 000000000..6c5ae7e96
--- /dev/null
+++ b/src/planetary_sci/registration.ts
@@ -0,0 +1,14 @@
+/** planetary_sci registration module — tsb analytics library. */
+export interface PlanetarySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciRegistrationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciRegistration(data: number[], opts: PlanetarySciRegistrationOptions = {}): PlanetarySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciRegistration };
diff --git a/src/planetary_sci/regression.ts b/src/planetary_sci/regression.ts
new file mode 100644
index 000000000..3ab3e1e16
--- /dev/null
+++ b/src/planetary_sci/regression.ts
@@ -0,0 +1,14 @@
+/** planetary_sci regression module — tsb analytics library. */
+export interface PlanetarySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciRegressionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciRegression(data: number[], opts: PlanetarySciRegressionOptions = {}): PlanetarySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciRegression };
diff --git a/src/planetary_sci/regularization.ts b/src/planetary_sci/regularization.ts
new file mode 100644
index 000000000..ab9853699
--- /dev/null
+++ b/src/planetary_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** planetary_sci regularization module — tsb analytics library. */
+export interface PlanetarySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciRegularizationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciRegularization(data: number[], opts: PlanetarySciRegularizationOptions = {}): PlanetarySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciRegularization };
diff --git a/src/planetary_sci/robustness.ts b/src/planetary_sci/robustness.ts
new file mode 100644
index 000000000..e5ae2920a
--- /dev/null
+++ b/src/planetary_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** planetary_sci robustness module — tsb analytics library. */
+export interface PlanetarySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciRobustnessResult { values: number[]; converged: boolean; }
+export function computePlanetarySciRobustness(data: number[], opts: PlanetarySciRobustnessOptions = {}): PlanetarySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciRobustness };
diff --git a/src/planetary_sci/sampling.ts b/src/planetary_sci/sampling.ts
new file mode 100644
index 000000000..023691eed
--- /dev/null
+++ b/src/planetary_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** planetary_sci sampling module — tsb analytics library. */
+export interface PlanetarySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciSamplingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciSampling(data: number[], opts: PlanetarySciSamplingOptions = {}): PlanetarySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciSampling };
diff --git a/src/planetary_sci/sampling2.ts b/src/planetary_sci/sampling2.ts
new file mode 100644
index 000000000..ef75c4a86
--- /dev/null
+++ b/src/planetary_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** planetary_sci sampling2 module — tsb analytics library. */
+export interface PlanetarySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciSamplingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciSampling(data: number[], opts: PlanetarySciSamplingOptions = {}): PlanetarySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciSampling };
diff --git a/src/planetary_sci/scaling.ts b/src/planetary_sci/scaling.ts
new file mode 100644
index 000000000..d12467354
--- /dev/null
+++ b/src/planetary_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** planetary_sci scaling module — tsb analytics library. */
+export interface PlanetarySciScalingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciScalingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciScaling(data: number[], opts: PlanetarySciScalingOptions = {}): PlanetarySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciScaling };
diff --git a/src/planetary_sci/scoring.ts b/src/planetary_sci/scoring.ts
new file mode 100644
index 000000000..f9a370e7b
--- /dev/null
+++ b/src/planetary_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** planetary_sci scoring module — tsb analytics library. */
+export interface PlanetarySciScoringOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciScoringResult { values: number[]; converged: boolean; }
+export function computePlanetarySciScoring(data: number[], opts: PlanetarySciScoringOptions = {}): PlanetarySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciScoring };
diff --git a/src/planetary_sci/segmentation.ts b/src/planetary_sci/segmentation.ts
new file mode 100644
index 000000000..939cd0ca7
--- /dev/null
+++ b/src/planetary_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci segmentation module — tsb analytics library. */
+export interface PlanetarySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciSegmentationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciSegmentation(data: number[], opts: PlanetarySciSegmentationOptions = {}): PlanetarySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciSegmentation };
diff --git a/src/planetary_sci/selection.ts b/src/planetary_sci/selection.ts
new file mode 100644
index 000000000..514bf9d9b
--- /dev/null
+++ b/src/planetary_sci/selection.ts
@@ -0,0 +1,14 @@
+/** planetary_sci selection module — tsb analytics library. */
+export interface PlanetarySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciSelectionResult { values: number[]; converged: boolean; }
+export function computePlanetarySciSelection(data: number[], opts: PlanetarySciSelectionOptions = {}): PlanetarySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciSelection };
diff --git a/src/planetary_sci/sensitivity.ts b/src/planetary_sci/sensitivity.ts
new file mode 100644
index 000000000..301723f30
--- /dev/null
+++ b/src/planetary_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** planetary_sci sensitivity module — tsb analytics library. */
+export interface PlanetarySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciSensitivityResult { values: number[]; converged: boolean; }
+export function computePlanetarySciSensitivity(data: number[], opts: PlanetarySciSensitivityOptions = {}): PlanetarySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciSensitivity };
diff --git a/src/planetary_sci/simulation.ts b/src/planetary_sci/simulation.ts
new file mode 100644
index 000000000..2e39e88cc
--- /dev/null
+++ b/src/planetary_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci simulation module — tsb analytics library. */
+export interface PlanetarySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciSimulationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciSimulation(data: number[], opts: PlanetarySciSimulationOptions = {}): PlanetarySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciSimulation };
diff --git a/src/planetary_sci/smoothing.ts b/src/planetary_sci/smoothing.ts
new file mode 100644
index 000000000..ff01e2ceb
--- /dev/null
+++ b/src/planetary_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** planetary_sci smoothing module — tsb analytics library. */
+export interface PlanetarySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciSmoothingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciSmoothing(data: number[], opts: PlanetarySciSmoothingOptions = {}): PlanetarySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciSmoothing };
diff --git a/src/planetary_sci/stability.ts b/src/planetary_sci/stability.ts
new file mode 100644
index 000000000..8afa0a866
--- /dev/null
+++ b/src/planetary_sci/stability.ts
@@ -0,0 +1,14 @@
+/** planetary_sci stability module — tsb analytics library. */
+export interface PlanetarySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciStabilityResult { values: number[]; converged: boolean; }
+export function computePlanetarySciStability(data: number[], opts: PlanetarySciStabilityOptions = {}): PlanetarySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciStability };
diff --git a/src/planetary_sci/stacking.ts b/src/planetary_sci/stacking.ts
new file mode 100644
index 000000000..4d79334e8
--- /dev/null
+++ b/src/planetary_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** planetary_sci stacking module — tsb analytics library. */
+export interface PlanetarySciStackingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciStackingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciStacking(data: number[], opts: PlanetarySciStackingOptions = {}): PlanetarySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciStacking };
diff --git a/src/planetary_sci/standardization.ts b/src/planetary_sci/standardization.ts
new file mode 100644
index 000000000..4bc0cb318
--- /dev/null
+++ b/src/planetary_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** planetary_sci standardization module — tsb analytics library. */
+export interface PlanetarySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciStandardizationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciStandardization(data: number[], opts: PlanetarySciStandardizationOptions = {}): PlanetarySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciStandardization };
diff --git a/src/planetary_sci/static.ts b/src/planetary_sci/static.ts
new file mode 100644
index 000000000..2da6c2516
--- /dev/null
+++ b/src/planetary_sci/static.ts
@@ -0,0 +1,14 @@
+/** planetary_sci static module — tsb analytics library. */
+export interface PlanetarySciStaticOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciStaticResult { values: number[]; converged: boolean; }
+export function computePlanetarySciStatic(data: number[], opts: PlanetarySciStaticOptions = {}): PlanetarySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciStatic };
diff --git a/src/planetary_sci/stochastic.ts b/src/planetary_sci/stochastic.ts
new file mode 100644
index 000000000..b04a53ed5
--- /dev/null
+++ b/src/planetary_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** planetary_sci stochastic module — tsb analytics library. */
+export interface PlanetarySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciStochasticResult { values: number[]; converged: boolean; }
+export function computePlanetarySciStochastic(data: number[], opts: PlanetarySciStochasticOptions = {}): PlanetarySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciStochastic };
diff --git a/src/planetary_sci/synthesis.ts b/src/planetary_sci/synthesis.ts
new file mode 100644
index 000000000..ca05fad42
--- /dev/null
+++ b/src/planetary_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** planetary_sci synthesis module — tsb analytics library. */
+export interface PlanetarySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciSynthesisResult { values: number[]; converged: boolean; }
+export function computePlanetarySciSynthesis(data: number[], opts: PlanetarySciSynthesisOptions = {}): PlanetarySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciSynthesis };
diff --git a/src/planetary_sci/topology.ts b/src/planetary_sci/topology.ts
new file mode 100644
index 000000000..1e27eebc1
--- /dev/null
+++ b/src/planetary_sci/topology.ts
@@ -0,0 +1,14 @@
+/** planetary_sci topology module — tsb analytics library. */
+export interface PlanetarySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciTopologyResult { values: number[]; converged: boolean; }
+export function computePlanetarySciTopology(data: number[], opts: PlanetarySciTopologyOptions = {}): PlanetarySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciTopology };
diff --git a/src/planetary_sci/tracking.ts b/src/planetary_sci/tracking.ts
new file mode 100644
index 000000000..f2d7b4e81
--- /dev/null
+++ b/src/planetary_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** planetary_sci tracking module — tsb analytics library. */
+export interface PlanetarySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciTrackingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciTracking(data: number[], opts: PlanetarySciTrackingOptions = {}): PlanetarySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciTracking };
diff --git a/src/planetary_sci/transform.ts b/src/planetary_sci/transform.ts
new file mode 100644
index 000000000..712464547
--- /dev/null
+++ b/src/planetary_sci/transform.ts
@@ -0,0 +1,14 @@
+/** planetary_sci transform module — tsb analytics library. */
+export interface PlanetarySciTransformOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciTransformResult { values: number[]; converged: boolean; }
+export function computePlanetarySciTransform(data: number[], opts: PlanetarySciTransformOptions = {}): PlanetarySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciTransform };
diff --git a/src/planetary_sci/uncertainty.ts b/src/planetary_sci/uncertainty.ts
new file mode 100644
index 000000000..09e853ac6
--- /dev/null
+++ b/src/planetary_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** planetary_sci uncertainty module — tsb analytics library. */
+export interface PlanetarySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computePlanetarySciUncertainty(data: number[], opts: PlanetarySciUncertaintyOptions = {}): PlanetarySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciUncertainty };
diff --git a/src/planetary_sci/validation.ts b/src/planetary_sci/validation.ts
new file mode 100644
index 000000000..0a35702ea
--- /dev/null
+++ b/src/planetary_sci/validation.ts
@@ -0,0 +1,14 @@
+/** planetary_sci validation module — tsb analytics library. */
+export interface PlanetarySciValidationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciValidationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciValidation(data: number[], opts: PlanetarySciValidationOptions = {}): PlanetarySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciValidation };
diff --git a/src/planetary_sci/verification.ts b/src/planetary_sci/verification.ts
new file mode 100644
index 000000000..e87e2ce2e
--- /dev/null
+++ b/src/planetary_sci/verification.ts
@@ -0,0 +1,14 @@
+/** planetary_sci verification module — tsb analytics library. */
+export interface PlanetarySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciVerificationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciVerification(data: number[], opts: PlanetarySciVerificationOptions = {}): PlanetarySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciVerification };
diff --git a/src/planetary_sci/visualization.ts b/src/planetary_sci/visualization.ts
new file mode 100644
index 000000000..daf97f7f8
--- /dev/null
+++ b/src/planetary_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** planetary_sci visualization module — tsb analytics library. */
+export interface PlanetarySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciVisualizationResult { values: number[]; converged: boolean; }
+export function computePlanetarySciVisualization(data: number[], opts: PlanetarySciVisualizationOptions = {}): PlanetarySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciVisualization };
diff --git a/src/planetary_sci/voting.ts b/src/planetary_sci/voting.ts
new file mode 100644
index 000000000..b7d5a6f24
--- /dev/null
+++ b/src/planetary_sci/voting.ts
@@ -0,0 +1,14 @@
+/** planetary_sci voting module — tsb analytics library. */
+export interface PlanetarySciVotingOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciVotingResult { values: number[]; converged: boolean; }
+export function computePlanetarySciVoting(data: number[], opts: PlanetarySciVotingOptions = {}): PlanetarySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciVoting };
diff --git a/src/planetary_sci/wavelet.ts b/src/planetary_sci/wavelet.ts
new file mode 100644
index 000000000..4ee0605c4
--- /dev/null
+++ b/src/planetary_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** planetary_sci wavelet module — tsb analytics library. */
+export interface PlanetarySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface PlanetarySciWaveletResult { values: number[]; converged: boolean; }
+export function computePlanetarySciWavelet(data: number[], opts: PlanetarySciWaveletOptions = {}): PlanetarySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePlanetarySciWavelet };
diff --git a/src/political_science/advanced.ts b/src/political_science/advanced.ts
new file mode 100644
index 000000000..a13e081fe
--- /dev/null
+++ b/src/political_science/advanced.ts
@@ -0,0 +1,15 @@
+/** Political Science Advanced module — tsb analytics library. */
+export interface PoliticalScience advancedOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience advancedResult { values: number[]; converged: boolean; }
+export function computePoliticalScience advanced(data: number[], opts: PoliticalScience advancedOptions = {}): PoliticalScience advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience advanced };
diff --git a/src/political_science/authoritarianism.ts b/src/political_science/authoritarianism.ts
new file mode 100644
index 000000000..587eadfff
--- /dev/null
+++ b/src/political_science/authoritarianism.ts
@@ -0,0 +1,22 @@
+/** Authoritarianism module — tsb analytics library. */
+
+/** Options for Authoritarianism. */
+export interface AuthoritarianismOptions { tol?: number; maxIter?: number; }
+
+/** Result from Authoritarianism. */
+export interface AuthoritarianismResult { values: number[]; converged: boolean; }
+
+/** Compute Authoritarianism. */
+export function computeAuthoritarianism(data: number[], opts: AuthoritarianismOptions = {}): AuthoritarianismResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAuthoritarianism };
diff --git a/src/political_science/base2.ts b/src/political_science/base2.ts
new file mode 100644
index 000000000..ee631195f
--- /dev/null
+++ b/src/political_science/base2.ts
@@ -0,0 +1,15 @@
+/** Political Science Base2 module — tsb analytics library. */
+export interface PoliticalScience base2Options { tol?: number; maxIter?: number; }
+export interface PoliticalScience base2Result { values: number[]; converged: boolean; }
+export function computePoliticalScience base2(data: number[], opts: PoliticalScience base2Options = {}): PoliticalScience base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience base2 };
diff --git a/src/political_science/batch.ts b/src/political_science/batch.ts
new file mode 100644
index 000000000..e8844f26d
--- /dev/null
+++ b/src/political_science/batch.ts
@@ -0,0 +1,15 @@
+/** Political Science Batch module — tsb analytics library. */
+export interface PoliticalScience batchOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience batchResult { values: number[]; converged: boolean; }
+export function computePoliticalScience batch(data: number[], opts: PoliticalScience batchOptions = {}): PoliticalScience batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience batch };
diff --git a/src/political_science/beta.ts b/src/political_science/beta.ts
new file mode 100644
index 000000000..47dc0ce02
--- /dev/null
+++ b/src/political_science/beta.ts
@@ -0,0 +1,15 @@
+/** Political Science Beta module — tsb analytics library. */
+export interface PoliticalScience betaOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience betaResult { values: number[]; converged: boolean; }
+export function computePoliticalScience beta(data: number[], opts: PoliticalScience betaOptions = {}): PoliticalScience betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience beta };
diff --git a/src/political_science/coalitions.ts b/src/political_science/coalitions.ts
new file mode 100644
index 000000000..ab865fcdc
--- /dev/null
+++ b/src/political_science/coalitions.ts
@@ -0,0 +1,22 @@
+/** Coalitions module — tsb analytics library. */
+
+/** Options for Coalitions. */
+export interface CoalitionsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coalitions. */
+export interface CoalitionsResult { values: number[]; converged: boolean; }
+
+/** Compute Coalitions. */
+export function computeCoalitions(data: number[], opts: CoalitionsOptions = {}): CoalitionsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCoalitions };
diff --git a/src/political_science/comparative.ts b/src/political_science/comparative.ts
new file mode 100644
index 000000000..8a4490aa8
--- /dev/null
+++ b/src/political_science/comparative.ts
@@ -0,0 +1,22 @@
+/** Comparative module — tsb analytics library. */
+
+/** Options for Comparative. */
+export interface ComparativeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Comparative. */
+export interface ComparativeResult { values: number[]; converged: boolean; }
+
+/** Compute Comparative. */
+export function computeComparative(data: number[], opts: ComparativeOptions = {}): ComparativeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeComparative };
diff --git a/src/political_science/conflict.ts b/src/political_science/conflict.ts
new file mode 100644
index 000000000..f20c04747
--- /dev/null
+++ b/src/political_science/conflict.ts
@@ -0,0 +1,22 @@
+/** Conflict module — tsb analytics library. */
+
+/** Options for Conflict. */
+export interface ConflictOptions { tol?: number; maxIter?: number; }
+
+/** Result from Conflict. */
+export interface ConflictResult { values: number[]; converged: boolean; }
+
+/** Compute Conflict. */
+export function computeConflict(data: number[], opts: ConflictOptions = {}): ConflictResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConflict };
diff --git a/src/political_science/cpu.ts b/src/political_science/cpu.ts
new file mode 100644
index 000000000..d3aec23fe
--- /dev/null
+++ b/src/political_science/cpu.ts
@@ -0,0 +1,15 @@
+/** Political Science Cpu module — tsb analytics library. */
+export interface PoliticalScience cpuOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience cpuResult { values: number[]; converged: boolean; }
+export function computePoliticalScience cpu(data: number[], opts: PoliticalScience cpuOptions = {}): PoliticalScience cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience cpu };
diff --git a/src/political_science/democracy.ts b/src/political_science/democracy.ts
new file mode 100644
index 000000000..d9c2dad8c
--- /dev/null
+++ b/src/political_science/democracy.ts
@@ -0,0 +1,22 @@
+/** Democracy module — tsb analytics library. */
+
+/** Options for Democracy. */
+export interface DemocracyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Democracy. */
+export interface DemocracyResult { values: number[]; converged: boolean; }
+
+/** Compute Democracy. */
+export function computeDemocracy(data: number[], opts: DemocracyOptions = {}): DemocracyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDemocracy };
diff --git a/src/political_science/dense.ts b/src/political_science/dense.ts
new file mode 100644
index 000000000..0449fdece
--- /dev/null
+++ b/src/political_science/dense.ts
@@ -0,0 +1,15 @@
+/** Political Science Dense module — tsb analytics library. */
+export interface PoliticalScience denseOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience denseResult { values: number[]; converged: boolean; }
+export function computePoliticalScience dense(data: number[], opts: PoliticalScience denseOptions = {}): PoliticalScience denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience dense };
diff --git a/src/political_science/development.ts b/src/political_science/development.ts
new file mode 100644
index 000000000..5e72e96d1
--- /dev/null
+++ b/src/political_science/development.ts
@@ -0,0 +1,22 @@
+/** Development module — tsb analytics library. */
+
+/** Options for Development. */
+export interface DevelopmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Development. */
+export interface DevelopmentResult { values: number[]; converged: boolean; }
+
+/** Compute Development. */
+export function computeDevelopment(data: number[], opts: DevelopmentOptions = {}): DevelopmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDevelopment };
diff --git a/src/political_science/distributed.ts b/src/political_science/distributed.ts
new file mode 100644
index 000000000..362b5826e
--- /dev/null
+++ b/src/political_science/distributed.ts
@@ -0,0 +1,15 @@
+/** Political Science Distributed module — tsb analytics library. */
+export interface PoliticalScience distributedOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience distributedResult { values: number[]; converged: boolean; }
+export function computePoliticalScience distributed(data: number[], opts: PoliticalScience distributedOptions = {}): PoliticalScience distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience distributed };
diff --git a/src/political_science/elections.ts b/src/political_science/elections.ts
new file mode 100644
index 000000000..7c343e294
--- /dev/null
+++ b/src/political_science/elections.ts
@@ -0,0 +1,22 @@
+/** Elections module — tsb analytics library. */
+
+/** Options for Elections. */
+export interface ElectionsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Elections. */
+export interface ElectionsResult { values: number[]; converged: boolean; }
+
+/** Compute Elections. */
+export function computeElections(data: number[], opts: ElectionsOptions = {}): ElectionsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeElections };
diff --git a/src/political_science/executive.ts b/src/political_science/executive.ts
new file mode 100644
index 000000000..af0c901d8
--- /dev/null
+++ b/src/political_science/executive.ts
@@ -0,0 +1,22 @@
+/** Executive module — tsb analytics library. */
+
+/** Options for Executive. */
+export interface ExecutiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Executive. */
+export interface ExecutiveResult { values: number[]; converged: boolean; }
+
+/** Compute Executive. */
+export function computeExecutive(data: number[], opts: ExecutiveOptions = {}): ExecutiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExecutive };
diff --git a/src/political_science/experimental.ts b/src/political_science/experimental.ts
new file mode 100644
index 000000000..161750ac4
--- /dev/null
+++ b/src/political_science/experimental.ts
@@ -0,0 +1,15 @@
+/** Political Science Experimental module — tsb analytics library. */
+export interface PoliticalScience experimentalOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience experimentalResult { values: number[]; converged: boolean; }
+export function computePoliticalScience experimental(data: number[], opts: PoliticalScience experimentalOptions = {}): PoliticalScience experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience experimental };
diff --git a/src/political_science/fast.ts b/src/political_science/fast.ts
new file mode 100644
index 000000000..7c6b7dea4
--- /dev/null
+++ b/src/political_science/fast.ts
@@ -0,0 +1,15 @@
+/** Political Science Fast module — tsb analytics library. */
+export interface PoliticalScience fastOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience fastResult { values: number[]; converged: boolean; }
+export function computePoliticalScience fast(data: number[], opts: PoliticalScience fastOptions = {}): PoliticalScience fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience fast };
diff --git a/src/political_science/federalism.ts b/src/political_science/federalism.ts
new file mode 100644
index 000000000..46d0bcab9
--- /dev/null
+++ b/src/political_science/federalism.ts
@@ -0,0 +1,22 @@
+/** Federalism module — tsb analytics library. */
+
+/** Options for Federalism. */
+export interface FederalismOptions { tol?: number; maxIter?: number; }
+
+/** Result from Federalism. */
+export interface FederalismResult { values: number[]; converged: boolean; }
+
+/** Compute Federalism. */
+export function computeFederalism(data: number[], opts: FederalismOptions = {}): FederalismResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFederalism };
diff --git a/src/political_science/future.ts b/src/political_science/future.ts
new file mode 100644
index 000000000..2ef2a2690
--- /dev/null
+++ b/src/political_science/future.ts
@@ -0,0 +1,15 @@
+/** Political Science Future module — tsb analytics library. */
+export interface PoliticalScience futureOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience futureResult { values: number[]; converged: boolean; }
+export function computePoliticalScience future(data: number[], opts: PoliticalScience futureOptions = {}): PoliticalScience futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience future };
diff --git a/src/political_science/government.ts b/src/political_science/government.ts
new file mode 100644
index 000000000..1a5eb270d
--- /dev/null
+++ b/src/political_science/government.ts
@@ -0,0 +1,22 @@
+/** Government module — tsb analytics library. */
+
+/** Options for Government. */
+export interface GovernmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Government. */
+export interface GovernmentResult { values: number[]; converged: boolean; }
+
+/** Compute Government. */
+export function computeGovernment(data: number[], opts: GovernmentOptions = {}): GovernmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGovernment };
diff --git a/src/political_science/gpu.ts b/src/political_science/gpu.ts
new file mode 100644
index 000000000..d2ae7e3e8
--- /dev/null
+++ b/src/political_science/gpu.ts
@@ -0,0 +1,15 @@
+/** Political Science Gpu module — tsb analytics library. */
+export interface PoliticalScience gpuOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience gpuResult { values: number[]; converged: boolean; }
+export function computePoliticalScience gpu(data: number[], opts: PoliticalScience gpuOptions = {}): PoliticalScience gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience gpu };
diff --git a/src/political_science/hybrid.ts b/src/political_science/hybrid.ts
new file mode 100644
index 000000000..3314ae429
--- /dev/null
+++ b/src/political_science/hybrid.ts
@@ -0,0 +1,22 @@
+/** Hybrid module — tsb analytics library. */
+
+/** Options for Hybrid. */
+export interface HybridOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hybrid. */
+export interface HybridResult { values: number[]; converged: boolean; }
+
+/** Compute Hybrid. */
+export function computeHybrid(data: number[], opts: HybridOptions = {}): HybridResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHybrid };
diff --git a/src/political_science/inequality_pol.ts b/src/political_science/inequality_pol.ts
new file mode 100644
index 000000000..3605e6c2d
--- /dev/null
+++ b/src/political_science/inequality_pol.ts
@@ -0,0 +1,22 @@
+/** Inequality Pol module — tsb analytics library. */
+
+/** Options for Inequality Pol. */
+export interface InequalityPolOptions { tol?: number; maxIter?: number; }
+
+/** Result from Inequality Pol. */
+export interface InequalityPolResult { values: number[]; converged: boolean; }
+
+/** Compute Inequality Pol. */
+export function computeInequalityPol(data: number[], opts: InequalityPolOptions = {}): InequalityPolResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInequalityPol };
diff --git a/src/political_science/institutions.ts b/src/political_science/institutions.ts
new file mode 100644
index 000000000..bcc4c0715
--- /dev/null
+++ b/src/political_science/institutions.ts
@@ -0,0 +1,22 @@
+/** Institutions module — tsb analytics library. */
+
+/** Options for Institutions. */
+export interface InstitutionsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Institutions. */
+export interface InstitutionsResult { values: number[]; converged: boolean; }
+
+/** Compute Institutions. */
+export function computeInstitutions(data: number[], opts: InstitutionsOptions = {}): InstitutionsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInstitutions };
diff --git a/src/political_science/international.ts b/src/political_science/international.ts
new file mode 100644
index 000000000..3d36bd8d0
--- /dev/null
+++ b/src/political_science/international.ts
@@ -0,0 +1,22 @@
+/** International module — tsb analytics library. */
+
+/** Options for International. */
+export interface InternationalOptions { tol?: number; maxIter?: number; }
+
+/** Result from International. */
+export interface InternationalResult { values: number[]; converged: boolean; }
+
+/** Compute International. */
+export function computeInternational(data: number[], opts: InternationalOptions = {}): InternationalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInternational };
diff --git a/src/political_science/international_law.ts b/src/political_science/international_law.ts
new file mode 100644
index 000000000..c1f3a0f13
--- /dev/null
+++ b/src/political_science/international_law.ts
@@ -0,0 +1,22 @@
+/** International Law module — tsb analytics library. */
+
+/** Options for International Law. */
+export interface InternationalLawOptions { tol?: number; maxIter?: number; }
+
+/** Result from International Law. */
+export interface InternationalLawResult { values: number[]; converged: boolean; }
+
+/** Compute International Law. */
+export function computeInternationalLaw(data: number[], opts: InternationalLawOptions = {}): InternationalLawResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInternationalLaw };
diff --git a/src/political_science/international_organization.ts b/src/political_science/international_organization.ts
new file mode 100644
index 000000000..a21941d5c
--- /dev/null
+++ b/src/political_science/international_organization.ts
@@ -0,0 +1,22 @@
+/** International Organization module — tsb analytics library. */
+
+/** Options for International Organization. */
+export interface InternationalOrganizationOptions { tol?: number; maxIter?: number; }
+
+/** Result from International Organization. */
+export interface InternationalOrganizationResult { values: number[]; converged: boolean; }
+
+/** Compute International Organization. */
+export function computeInternationalOrganization(data: number[], opts: InternationalOrganizationOptions = {}): InternationalOrganizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInternationalOrganization };
diff --git a/src/political_science/judiciary.ts b/src/political_science/judiciary.ts
new file mode 100644
index 000000000..0d836bc3b
--- /dev/null
+++ b/src/political_science/judiciary.ts
@@ -0,0 +1,22 @@
+/** Judiciary module — tsb analytics library. */
+
+/** Options for Judiciary. */
+export interface JudiciaryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Judiciary. */
+export interface JudiciaryResult { values: number[]; converged: boolean; }
+
+/** Compute Judiciary. */
+export function computeJudiciary(data: number[], opts: JudiciaryOptions = {}): JudiciaryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeJudiciary };
diff --git a/src/political_science/large.ts b/src/political_science/large.ts
new file mode 100644
index 000000000..fb1efa84f
--- /dev/null
+++ b/src/political_science/large.ts
@@ -0,0 +1,15 @@
+/** Political Science Large module — tsb analytics library. */
+export interface PoliticalScience largeOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience largeResult { values: number[]; converged: boolean; }
+export function computePoliticalScience large(data: number[], opts: PoliticalScience largeOptions = {}): PoliticalScience largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience large };
diff --git a/src/political_science/legacy.ts b/src/political_science/legacy.ts
new file mode 100644
index 000000000..4522a3751
--- /dev/null
+++ b/src/political_science/legacy.ts
@@ -0,0 +1,15 @@
+/** Political Science Legacy module — tsb analytics library. */
+export interface PoliticalScience legacyOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience legacyResult { values: number[]; converged: boolean; }
+export function computePoliticalScience legacy(data: number[], opts: PoliticalScience legacyOptions = {}): PoliticalScience legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience legacy };
diff --git a/src/political_science/legislature.ts b/src/political_science/legislature.ts
new file mode 100644
index 000000000..06cebc2ad
--- /dev/null
+++ b/src/political_science/legislature.ts
@@ -0,0 +1,22 @@
+/** Legislature module — tsb analytics library. */
+
+/** Options for Legislature. */
+export interface LegislatureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Legislature. */
+export interface LegislatureResult { values: number[]; converged: boolean; }
+
+/** Compute Legislature. */
+export function computeLegislature(data: number[], opts: LegislatureOptions = {}): LegislatureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLegislature };
diff --git a/src/political_science/lite.ts b/src/political_science/lite.ts
new file mode 100644
index 000000000..774621c1d
--- /dev/null
+++ b/src/political_science/lite.ts
@@ -0,0 +1,15 @@
+/** Political Science Lite module — tsb analytics library. */
+export interface PoliticalScience liteOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience liteResult { values: number[]; converged: boolean; }
+export function computePoliticalScience lite(data: number[], opts: PoliticalScience liteOptions = {}): PoliticalScience liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience lite };
diff --git a/src/political_science/media_pol.ts b/src/political_science/media_pol.ts
new file mode 100644
index 000000000..d39470e6b
--- /dev/null
+++ b/src/political_science/media_pol.ts
@@ -0,0 +1,22 @@
+/** Media Pol module — tsb analytics library. */
+
+/** Options for Media Pol. */
+export interface MediaPolOptions { tol?: number; maxIter?: number; }
+
+/** Result from Media Pol. */
+export interface MediaPolResult { values: number[]; converged: boolean; }
+
+/** Compute Media Pol. */
+export function computeMediaPol(data: number[], opts: MediaPolOptions = {}): MediaPolResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMediaPol };
diff --git a/src/political_science/mini.ts b/src/political_science/mini.ts
new file mode 100644
index 000000000..712ed98e6
--- /dev/null
+++ b/src/political_science/mini.ts
@@ -0,0 +1,15 @@
+/** Political Science Mini module — tsb analytics library. */
+export interface PoliticalScience miniOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience miniResult { values: number[]; converged: boolean; }
+export function computePoliticalScience mini(data: number[], opts: PoliticalScience miniOptions = {}): PoliticalScience miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience mini };
diff --git a/src/political_science/negotiation.ts b/src/political_science/negotiation.ts
new file mode 100644
index 000000000..74d18f03e
--- /dev/null
+++ b/src/political_science/negotiation.ts
@@ -0,0 +1,22 @@
+/** Negotiation module — tsb analytics library. */
+
+/** Options for Negotiation. */
+export interface NegotiationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Negotiation. */
+export interface NegotiationResult { values: number[]; converged: boolean; }
+
+/** Compute Negotiation. */
+export function computeNegotiation(data: number[], opts: NegotiationOptions = {}): NegotiationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNegotiation };
diff --git a/src/political_science/next.ts b/src/political_science/next.ts
new file mode 100644
index 000000000..dfac7d68a
--- /dev/null
+++ b/src/political_science/next.ts
@@ -0,0 +1,15 @@
+/** Political Science Next module — tsb analytics library. */
+export interface PoliticalScience nextOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience nextResult { values: number[]; converged: boolean; }
+export function computePoliticalScience next(data: number[], opts: PoliticalScience nextOptions = {}): PoliticalScience nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience next };
diff --git a/src/political_science/online.ts b/src/political_science/online.ts
new file mode 100644
index 000000000..2f9613edb
--- /dev/null
+++ b/src/political_science/online.ts
@@ -0,0 +1,15 @@
+/** Political Science Online module — tsb analytics library. */
+export interface PoliticalScience onlineOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience onlineResult { values: number[]; converged: boolean; }
+export function computePoliticalScience online(data: number[], opts: PoliticalScience onlineOptions = {}): PoliticalScience onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience online };
diff --git a/src/political_science/parallel.ts b/src/political_science/parallel.ts
new file mode 100644
index 000000000..0c5bd829f
--- /dev/null
+++ b/src/political_science/parallel.ts
@@ -0,0 +1,15 @@
+/** Political Science Parallel module — tsb analytics library. */
+export interface PoliticalScience parallelOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience parallelResult { values: number[]; converged: boolean; }
+export function computePoliticalScience parallel(data: number[], opts: PoliticalScience parallelOptions = {}): PoliticalScience parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience parallel };
diff --git a/src/political_science/parties.ts b/src/political_science/parties.ts
new file mode 100644
index 000000000..e53eb45b8
--- /dev/null
+++ b/src/political_science/parties.ts
@@ -0,0 +1,22 @@
+/** Parties module — tsb analytics library. */
+
+/** Options for Parties. */
+export interface PartiesOptions { tol?: number; maxIter?: number; }
+
+/** Result from Parties. */
+export interface PartiesResult { values: number[]; converged: boolean; }
+
+/** Compute Parties. */
+export function computeParties(data: number[], opts: PartiesOptions = {}): PartiesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeParties };
diff --git a/src/political_science/peace.ts b/src/political_science/peace.ts
new file mode 100644
index 000000000..ed170d3d8
--- /dev/null
+++ b/src/political_science/peace.ts
@@ -0,0 +1,22 @@
+/** Peace module — tsb analytics library. */
+
+/** Options for Peace. */
+export interface PeaceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Peace. */
+export interface PeaceResult { values: number[]; converged: boolean; }
+
+/** Compute Peace. */
+export function computePeace(data: number[], opts: PeaceOptions = {}): PeaceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePeace };
diff --git a/src/political_science/plus.ts b/src/political_science/plus.ts
new file mode 100644
index 000000000..507f1c6a2
--- /dev/null
+++ b/src/political_science/plus.ts
@@ -0,0 +1,15 @@
+/** Political Science Plus module — tsb analytics library. */
+export interface PoliticalScience plusOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience plusResult { values: number[]; converged: boolean; }
+export function computePoliticalScience plus(data: number[], opts: PoliticalScience plusOptions = {}): PoliticalScience plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience plus };
diff --git a/src/political_science/political_economy.ts b/src/political_science/political_economy.ts
new file mode 100644
index 000000000..4bd04a4ca
--- /dev/null
+++ b/src/political_science/political_economy.ts
@@ -0,0 +1,22 @@
+/** Political Economy module — tsb analytics library. */
+
+/** Options for Political Economy. */
+export interface PoliticalEconomyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Political Economy. */
+export interface PoliticalEconomyResult { values: number[]; converged: boolean; }
+
+/** Compute Political Economy. */
+export function computePoliticalEconomy(data: number[], opts: PoliticalEconomyOptions = {}): PoliticalEconomyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePoliticalEconomy };
diff --git a/src/political_science/pro.ts b/src/political_science/pro.ts
new file mode 100644
index 000000000..e17cc5884
--- /dev/null
+++ b/src/political_science/pro.ts
@@ -0,0 +1,15 @@
+/** Political Science Pro module — tsb analytics library. */
+export interface PoliticalScience proOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience proResult { values: number[]; converged: boolean; }
+export function computePoliticalScience pro(data: number[], opts: PoliticalScience proOptions = {}): PoliticalScience proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience pro };
diff --git a/src/political_science/public_opinion.ts b/src/political_science/public_opinion.ts
new file mode 100644
index 000000000..6927484e6
--- /dev/null
+++ b/src/political_science/public_opinion.ts
@@ -0,0 +1,22 @@
+/** Public Opinion module — tsb analytics library. */
+
+/** Options for Public Opinion. */
+export interface PublicOpinionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Public Opinion. */
+export interface PublicOpinionResult { values: number[]; converged: boolean; }
+
+/** Compute Public Opinion. */
+export function computePublicOpinion(data: number[], opts: PublicOpinionOptions = {}): PublicOpinionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePublicOpinion };
diff --git a/src/political_science/redistribution.ts b/src/political_science/redistribution.ts
new file mode 100644
index 000000000..181580757
--- /dev/null
+++ b/src/political_science/redistribution.ts
@@ -0,0 +1,22 @@
+/** Redistribution module — tsb analytics library. */
+
+/** Options for Redistribution. */
+export interface RedistributionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Redistribution. */
+export interface RedistributionResult { values: number[]; converged: boolean; }
+
+/** Compute Redistribution. */
+export function computeRedistribution(data: number[], opts: RedistributionOptions = {}): RedistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRedistribution };
diff --git a/src/political_science/robust.ts b/src/political_science/robust.ts
new file mode 100644
index 000000000..34072b23c
--- /dev/null
+++ b/src/political_science/robust.ts
@@ -0,0 +1,15 @@
+/** Political Science Robust module — tsb analytics library. */
+export interface PoliticalScience robustOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience robustResult { values: number[]; converged: boolean; }
+export function computePoliticalScience robust(data: number[], opts: PoliticalScience robustOptions = {}): PoliticalScience robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience robust };
diff --git a/src/political_science/security.ts b/src/political_science/security.ts
new file mode 100644
index 000000000..17ab85129
--- /dev/null
+++ b/src/political_science/security.ts
@@ -0,0 +1,22 @@
+/** Security module — tsb analytics library. */
+
+/** Options for Security. */
+export interface SecurityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Security. */
+export interface SecurityResult { values: number[]; converged: boolean; }
+
+/** Compute Security. */
+export function computeSecurity(data: number[], opts: SecurityOptions = {}): SecurityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSecurity };
diff --git a/src/political_science/small.ts b/src/political_science/small.ts
new file mode 100644
index 000000000..678af518c
--- /dev/null
+++ b/src/political_science/small.ts
@@ -0,0 +1,15 @@
+/** Political Science Small module — tsb analytics library. */
+export interface PoliticalScience smallOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience smallResult { values: number[]; converged: boolean; }
+export function computePoliticalScience small(data: number[], opts: PoliticalScience smallOptions = {}): PoliticalScience smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience small };
diff --git a/src/political_science/sparse.ts b/src/political_science/sparse.ts
new file mode 100644
index 000000000..9183105a2
--- /dev/null
+++ b/src/political_science/sparse.ts
@@ -0,0 +1,15 @@
+/** Political Science Sparse module — tsb analytics library. */
+export interface PoliticalScience sparseOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience sparseResult { values: number[]; converged: boolean; }
+export function computePoliticalScience sparse(data: number[], opts: PoliticalScience sparseOptions = {}): PoliticalScience sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience sparse };
diff --git a/src/political_science/stable.ts b/src/political_science/stable.ts
new file mode 100644
index 000000000..f4ce6c641
--- /dev/null
+++ b/src/political_science/stable.ts
@@ -0,0 +1,15 @@
+/** Political Science Stable module — tsb analytics library. */
+export interface PoliticalScience stableOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience stableResult { values: number[]; converged: boolean; }
+export function computePoliticalScience stable(data: number[], opts: PoliticalScience stableOptions = {}): PoliticalScience stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience stable };
diff --git a/src/political_science/streaming.ts b/src/political_science/streaming.ts
new file mode 100644
index 000000000..e626d2c2a
--- /dev/null
+++ b/src/political_science/streaming.ts
@@ -0,0 +1,15 @@
+/** Political Science Streaming module — tsb analytics library. */
+export interface PoliticalScience streamingOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience streamingResult { values: number[]; converged: boolean; }
+export function computePoliticalScience streaming(data: number[], opts: PoliticalScience streamingOptions = {}): PoliticalScience streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience streaming };
diff --git a/src/political_science/taxation.ts b/src/political_science/taxation.ts
new file mode 100644
index 000000000..08e8e3253
--- /dev/null
+++ b/src/political_science/taxation.ts
@@ -0,0 +1,22 @@
+/** Taxation module — tsb analytics library. */
+
+/** Options for Taxation. */
+export interface TaxationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Taxation. */
+export interface TaxationResult { values: number[]; converged: boolean; }
+
+/** Compute Taxation. */
+export function computeTaxation(data: number[], opts: TaxationOptions = {}): TaxationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTaxation };
diff --git a/src/political_science/v2.ts b/src/political_science/v2.ts
new file mode 100644
index 000000000..2c40e3938
--- /dev/null
+++ b/src/political_science/v2.ts
@@ -0,0 +1,15 @@
+/** Political Science V2 module — tsb analytics library. */
+export interface PoliticalScience v2Options { tol?: number; maxIter?: number; }
+export interface PoliticalScience v2Result { values: number[]; converged: boolean; }
+export function computePoliticalScience v2(data: number[], opts: PoliticalScience v2Options = {}): PoliticalScience v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience v2 };
diff --git a/src/political_science/v3.ts b/src/political_science/v3.ts
new file mode 100644
index 000000000..d7c9de4f8
--- /dev/null
+++ b/src/political_science/v3.ts
@@ -0,0 +1,15 @@
+/** Political Science V3 module — tsb analytics library. */
+export interface PoliticalScience v3Options { tol?: number; maxIter?: number; }
+export interface PoliticalScience v3Result { values: number[]; converged: boolean; }
+export function computePoliticalScience v3(data: number[], opts: PoliticalScience v3Options = {}): PoliticalScience v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience v3 };
diff --git a/src/political_science/voting.ts b/src/political_science/voting.ts
new file mode 100644
index 000000000..deab1da71
--- /dev/null
+++ b/src/political_science/voting.ts
@@ -0,0 +1,22 @@
+/** Voting module — tsb analytics library. */
+
+/** Options for Voting. */
+export interface VotingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Voting. */
+export interface VotingResult { values: number[]; converged: boolean; }
+
+/** Compute Voting. */
+export function computeVoting(data: number[], opts: VotingOptions = {}): VotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVoting };
diff --git a/src/political_science/war.ts b/src/political_science/war.ts
new file mode 100644
index 000000000..f0afd0386
--- /dev/null
+++ b/src/political_science/war.ts
@@ -0,0 +1,22 @@
+/** War module — tsb analytics library. */
+
+/** Options for War. */
+export interface WarOptions { tol?: number; maxIter?: number; }
+
+/** Result from War. */
+export interface WarResult { values: number[]; converged: boolean; }
+
+/** Compute War. */
+export function computeWar(data: number[], opts: WarOptions = {}): WarResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWar };
diff --git a/src/political_science/wasm.ts b/src/political_science/wasm.ts
new file mode 100644
index 000000000..798d9f1be
--- /dev/null
+++ b/src/political_science/wasm.ts
@@ -0,0 +1,15 @@
+/** Political Science Wasm module — tsb analytics library. */
+export interface PoliticalScience wasmOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience wasmResult { values: number[]; converged: boolean; }
+export function computePoliticalScience wasm(data: number[], opts: PoliticalScience wasmOptions = {}): PoliticalScience wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience wasm };
diff --git a/src/political_science/welfare.ts b/src/political_science/welfare.ts
new file mode 100644
index 000000000..ed9de08a0
--- /dev/null
+++ b/src/political_science/welfare.ts
@@ -0,0 +1,22 @@
+/** Welfare module — tsb analytics library. */
+
+/** Options for Welfare. */
+export interface WelfareOptions { tol?: number; maxIter?: number; }
+
+/** Result from Welfare. */
+export interface WelfareResult { values: number[]; converged: boolean; }
+
+/** Compute Welfare. */
+export function computeWelfare(data: number[], opts: WelfareOptions = {}): WelfareResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWelfare };
diff --git a/src/political_science/xlarge.ts b/src/political_science/xlarge.ts
new file mode 100644
index 000000000..0df3dbcd7
--- /dev/null
+++ b/src/political_science/xlarge.ts
@@ -0,0 +1,15 @@
+/** Political Science Xlarge module — tsb analytics library. */
+export interface PoliticalScience xlargeOptions { tol?: number; maxIter?: number; }
+export interface PoliticalScience xlargeResult { values: number[]; converged: boolean; }
+export function computePoliticalScience xlarge(data: number[], opts: PoliticalScience xlargeOptions = {}): PoliticalScience xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePoliticalScience xlarge };
diff --git a/src/polymer_sci/adaptation.ts b/src/polymer_sci/adaptation.ts
new file mode 100644
index 000000000..ef962743c
--- /dev/null
+++ b/src/polymer_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci adaptation module — tsb analytics library. */
+export interface PolymerSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciAdaptationResult { values: number[]; converged: boolean; }
+export function computePolymerSciAdaptation(data: number[], opts: PolymerSciAdaptationOptions = {}): PolymerSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciAdaptation };
diff --git a/src/polymer_sci/aggregation.ts b/src/polymer_sci/aggregation.ts
new file mode 100644
index 000000000..667968140
--- /dev/null
+++ b/src/polymer_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci aggregation module — tsb analytics library. */
+export interface PolymerSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciAggregationResult { values: number[]; converged: boolean; }
+export function computePolymerSciAggregation(data: number[], opts: PolymerSciAggregationOptions = {}): PolymerSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciAggregation };
diff --git a/src/polymer_sci/algebra.ts b/src/polymer_sci/algebra.ts
new file mode 100644
index 000000000..0dccfb487
--- /dev/null
+++ b/src/polymer_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** polymer_sci algebra module — tsb analytics library. */
+export interface PolymerSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciAlgebraResult { values: number[]; converged: boolean; }
+export function computePolymerSciAlgebra(data: number[], opts: PolymerSciAlgebraOptions = {}): PolymerSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciAlgebra };
diff --git a/src/polymer_sci/alignment.ts b/src/polymer_sci/alignment.ts
new file mode 100644
index 000000000..193203d7e
--- /dev/null
+++ b/src/polymer_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** polymer_sci alignment module — tsb analytics library. */
+export interface PolymerSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciAlignmentResult { values: number[]; converged: boolean; }
+export function computePolymerSciAlignment(data: number[], opts: PolymerSciAlignmentOptions = {}): PolymerSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciAlignment };
diff --git a/src/polymer_sci/analysis.ts b/src/polymer_sci/analysis.ts
new file mode 100644
index 000000000..ae30deca1
--- /dev/null
+++ b/src/polymer_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** polymer_sci analysis module — tsb analytics library. */
+export interface PolymerSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciAnalysisResult { values: number[]; converged: boolean; }
+export function computePolymerSciAnalysis(data: number[], opts: PolymerSciAnalysisOptions = {}): PolymerSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciAnalysis };
diff --git a/src/polymer_sci/augmentation.ts b/src/polymer_sci/augmentation.ts
new file mode 100644
index 000000000..d975521af
--- /dev/null
+++ b/src/polymer_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci augmentation module — tsb analytics library. */
+export interface PolymerSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciAugmentationResult { values: number[]; converged: boolean; }
+export function computePolymerSciAugmentation(data: number[], opts: PolymerSciAugmentationOptions = {}): PolymerSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciAugmentation };
diff --git a/src/polymer_sci/bagging.ts b/src/polymer_sci/bagging.ts
new file mode 100644
index 000000000..e2db2d5a9
--- /dev/null
+++ b/src/polymer_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** polymer_sci bagging module — tsb analytics library. */
+export interface PolymerSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciBaggingResult { values: number[]; converged: boolean; }
+export function computePolymerSciBagging(data: number[], opts: PolymerSciBaggingOptions = {}): PolymerSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciBagging };
diff --git a/src/polymer_sci/basis.ts b/src/polymer_sci/basis.ts
new file mode 100644
index 000000000..05238b52b
--- /dev/null
+++ b/src/polymer_sci/basis.ts
@@ -0,0 +1,14 @@
+/** polymer_sci basis module — tsb analytics library. */
+export interface PolymerSciBasisOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciBasisResult { values: number[]; converged: boolean; }
+export function computePolymerSciBasis(data: number[], opts: PolymerSciBasisOptions = {}): PolymerSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciBasis };
diff --git a/src/polymer_sci/benchmarking.ts b/src/polymer_sci/benchmarking.ts
new file mode 100644
index 000000000..58657a2f7
--- /dev/null
+++ b/src/polymer_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** polymer_sci benchmarking module — tsb analytics library. */
+export interface PolymerSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePolymerSciBenchmarking(data: number[], opts: PolymerSciBenchmarkingOptions = {}): PolymerSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciBenchmarking };
diff --git a/src/polymer_sci/blending.ts b/src/polymer_sci/blending.ts
new file mode 100644
index 000000000..720bbfaca
--- /dev/null
+++ b/src/polymer_sci/blending.ts
@@ -0,0 +1,14 @@
+/** polymer_sci blending module — tsb analytics library. */
+export interface PolymerSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciBlendingResult { values: number[]; converged: boolean; }
+export function computePolymerSciBlending(data: number[], opts: PolymerSciBlendingOptions = {}): PolymerSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciBlending };
diff --git a/src/polymer_sci/boosting.ts b/src/polymer_sci/boosting.ts
new file mode 100644
index 000000000..47c4e489f
--- /dev/null
+++ b/src/polymer_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** polymer_sci boosting module — tsb analytics library. */
+export interface PolymerSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciBoostingResult { values: number[]; converged: boolean; }
+export function computePolymerSciBoosting(data: number[], opts: PolymerSciBoostingOptions = {}): PolymerSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciBoosting };
diff --git a/src/polymer_sci/bootstrap.ts b/src/polymer_sci/bootstrap.ts
new file mode 100644
index 000000000..98f448efd
--- /dev/null
+++ b/src/polymer_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** polymer_sci bootstrap module — tsb analytics library. */
+export interface PolymerSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciBootstrapResult { values: number[]; converged: boolean; }
+export function computePolymerSciBootstrap(data: number[], opts: PolymerSciBootstrapOptions = {}): PolymerSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciBootstrap };
diff --git a/src/polymer_sci/calculus.ts b/src/polymer_sci/calculus.ts
new file mode 100644
index 000000000..4ce93d740
--- /dev/null
+++ b/src/polymer_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** polymer_sci calculus module — tsb analytics library. */
+export interface PolymerSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciCalculusResult { values: number[]; converged: boolean; }
+export function computePolymerSciCalculus(data: number[], opts: PolymerSciCalculusOptions = {}): PolymerSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciCalculus };
diff --git a/src/polymer_sci/calibration.ts b/src/polymer_sci/calibration.ts
new file mode 100644
index 000000000..7e57e247c
--- /dev/null
+++ b/src/polymer_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** polymer_sci calibration module — tsb analytics library. */
+export interface PolymerSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciCalibrationResult { values: number[]; converged: boolean; }
+export function computePolymerSciCalibration(data: number[], opts: PolymerSciCalibrationOptions = {}): PolymerSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciCalibration };
diff --git a/src/polymer_sci/characterization.ts b/src/polymer_sci/characterization.ts
new file mode 100644
index 000000000..7b090ed95
--- /dev/null
+++ b/src/polymer_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** polymer_sci characterization module — tsb analytics library. */
+export interface PolymerSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computePolymerSciCharacterization(data: number[], opts: PolymerSciCharacterizationOptions = {}): PolymerSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciCharacterization };
diff --git a/src/polymer_sci/classification.ts b/src/polymer_sci/classification.ts
new file mode 100644
index 000000000..428ec318e
--- /dev/null
+++ b/src/polymer_sci/classification.ts
@@ -0,0 +1,14 @@
+/** polymer_sci classification module — tsb analytics library. */
+export interface PolymerSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciClassificationResult { values: number[]; converged: boolean; }
+export function computePolymerSciClassification(data: number[], opts: PolymerSciClassificationOptions = {}): PolymerSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciClassification };
diff --git a/src/polymer_sci/clustering.ts b/src/polymer_sci/clustering.ts
new file mode 100644
index 000000000..9565665b2
--- /dev/null
+++ b/src/polymer_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** polymer_sci clustering module — tsb analytics library. */
+export interface PolymerSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciClusteringResult { values: number[]; converged: boolean; }
+export function computePolymerSciClustering(data: number[], opts: PolymerSciClusteringOptions = {}): PolymerSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciClustering };
diff --git a/src/polymer_sci/compression.ts b/src/polymer_sci/compression.ts
new file mode 100644
index 000000000..95e7c22c3
--- /dev/null
+++ b/src/polymer_sci/compression.ts
@@ -0,0 +1,14 @@
+/** polymer_sci compression module — tsb analytics library. */
+export interface PolymerSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciCompressionResult { values: number[]; converged: boolean; }
+export function computePolymerSciCompression(data: number[], opts: PolymerSciCompressionOptions = {}): PolymerSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciCompression };
diff --git a/src/polymer_sci/continuous.ts b/src/polymer_sci/continuous.ts
new file mode 100644
index 000000000..d56839b21
--- /dev/null
+++ b/src/polymer_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** polymer_sci continuous module — tsb analytics library. */
+export interface PolymerSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciContinuousResult { values: number[]; converged: boolean; }
+export function computePolymerSciContinuous(data: number[], opts: PolymerSciContinuousOptions = {}): PolymerSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciContinuous };
diff --git a/src/polymer_sci/control.ts b/src/polymer_sci/control.ts
new file mode 100644
index 000000000..464fd4ba5
--- /dev/null
+++ b/src/polymer_sci/control.ts
@@ -0,0 +1,14 @@
+/** polymer_sci control module — tsb analytics library. */
+export interface PolymerSciControlOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciControlResult { values: number[]; converged: boolean; }
+export function computePolymerSciControl(data: number[], opts: PolymerSciControlOptions = {}): PolymerSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciControl };
diff --git a/src/polymer_sci/convergence.ts b/src/polymer_sci/convergence.ts
new file mode 100644
index 000000000..465910441
--- /dev/null
+++ b/src/polymer_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** polymer_sci convergence module — tsb analytics library. */
+export interface PolymerSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciConvergenceResult { values: number[]; converged: boolean; }
+export function computePolymerSciConvergence(data: number[], opts: PolymerSciConvergenceOptions = {}): PolymerSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciConvergence };
diff --git a/src/polymer_sci/convex.ts b/src/polymer_sci/convex.ts
new file mode 100644
index 000000000..ce8aef047
--- /dev/null
+++ b/src/polymer_sci/convex.ts
@@ -0,0 +1,14 @@
+/** polymer_sci convex module — tsb analytics library. */
+export interface PolymerSciConvexOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciConvexResult { values: number[]; converged: boolean; }
+export function computePolymerSciConvex(data: number[], opts: PolymerSciConvexOptions = {}): PolymerSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciConvex };
diff --git a/src/polymer_sci/correlation.ts b/src/polymer_sci/correlation.ts
new file mode 100644
index 000000000..cfb7efbfc
--- /dev/null
+++ b/src/polymer_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci correlation module — tsb analytics library. */
+export interface PolymerSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciCorrelationResult { values: number[]; converged: boolean; }
+export function computePolymerSciCorrelation(data: number[], opts: PolymerSciCorrelationOptions = {}): PolymerSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciCorrelation };
diff --git a/src/polymer_sci/covariance.ts b/src/polymer_sci/covariance.ts
new file mode 100644
index 000000000..4004551f2
--- /dev/null
+++ b/src/polymer_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** polymer_sci covariance module — tsb analytics library. */
+export interface PolymerSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciCovarianceResult { values: number[]; converged: boolean; }
+export function computePolymerSciCovariance(data: number[], opts: PolymerSciCovarianceOptions = {}): PolymerSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciCovariance };
diff --git a/src/polymer_sci/cross_validation.ts b/src/polymer_sci/cross_validation.ts
new file mode 100644
index 000000000..67e0bd0fe
--- /dev/null
+++ b/src/polymer_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci cross_validation module — tsb analytics library. */
+export interface PolymerSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computePolymerSciCrossValidation(data: number[], opts: PolymerSciCrossValidationOptions = {}): PolymerSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciCrossValidation };
diff --git a/src/polymer_sci/decoding.ts b/src/polymer_sci/decoding.ts
new file mode 100644
index 000000000..4cd54fa2b
--- /dev/null
+++ b/src/polymer_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** polymer_sci decoding module — tsb analytics library. */
+export interface PolymerSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDecodingResult { values: number[]; converged: boolean; }
+export function computePolymerSciDecoding(data: number[], opts: PolymerSciDecodingOptions = {}): PolymerSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDecoding };
diff --git a/src/polymer_sci/decomposition.ts b/src/polymer_sci/decomposition.ts
new file mode 100644
index 000000000..7a58c3e6c
--- /dev/null
+++ b/src/polymer_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** polymer_sci decomposition module — tsb analytics library. */
+export interface PolymerSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDecompositionResult { values: number[]; converged: boolean; }
+export function computePolymerSciDecomposition(data: number[], opts: PolymerSciDecompositionOptions = {}): PolymerSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDecomposition };
diff --git a/src/polymer_sci/detection.ts b/src/polymer_sci/detection.ts
new file mode 100644
index 000000000..e64643ad9
--- /dev/null
+++ b/src/polymer_sci/detection.ts
@@ -0,0 +1,14 @@
+/** polymer_sci detection module — tsb analytics library. */
+export interface PolymerSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDetectionResult { values: number[]; converged: boolean; }
+export function computePolymerSciDetection(data: number[], opts: PolymerSciDetectionOptions = {}): PolymerSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDetection };
diff --git a/src/polymer_sci/deterministic.ts b/src/polymer_sci/deterministic.ts
new file mode 100644
index 000000000..3766e9f47
--- /dev/null
+++ b/src/polymer_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** polymer_sci deterministic module — tsb analytics library. */
+export interface PolymerSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDeterministicResult { values: number[]; converged: boolean; }
+export function computePolymerSciDeterministic(data: number[], opts: PolymerSciDeterministicOptions = {}): PolymerSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDeterministic };
diff --git a/src/polymer_sci/diagnostics.ts b/src/polymer_sci/diagnostics.ts
new file mode 100644
index 000000000..695697b6c
--- /dev/null
+++ b/src/polymer_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** polymer_sci diagnostics module — tsb analytics library. */
+export interface PolymerSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePolymerSciDiagnostics(data: number[], opts: PolymerSciDiagnosticsOptions = {}): PolymerSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDiagnostics };
diff --git a/src/polymer_sci/differential.ts b/src/polymer_sci/differential.ts
new file mode 100644
index 000000000..e773c97d3
--- /dev/null
+++ b/src/polymer_sci/differential.ts
@@ -0,0 +1,14 @@
+/** polymer_sci differential module — tsb analytics library. */
+export interface PolymerSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDifferentialResult { values: number[]; converged: boolean; }
+export function computePolymerSciDifferential(data: number[], opts: PolymerSciDifferentialOptions = {}): PolymerSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDifferential };
diff --git a/src/polymer_sci/discrete.ts b/src/polymer_sci/discrete.ts
new file mode 100644
index 000000000..c6f6718a6
--- /dev/null
+++ b/src/polymer_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** polymer_sci discrete module — tsb analytics library. */
+export interface PolymerSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDiscreteResult { values: number[]; converged: boolean; }
+export function computePolymerSciDiscrete(data: number[], opts: PolymerSciDiscreteOptions = {}): PolymerSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDiscrete };
diff --git a/src/polymer_sci/distribution.ts b/src/polymer_sci/distribution.ts
new file mode 100644
index 000000000..d86a5ee3e
--- /dev/null
+++ b/src/polymer_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** polymer_sci distribution module — tsb analytics library. */
+export interface PolymerSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDistributionResult { values: number[]; converged: boolean; }
+export function computePolymerSciDistribution(data: number[], opts: PolymerSciDistributionOptions = {}): PolymerSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDistribution };
diff --git a/src/polymer_sci/dynamic.ts b/src/polymer_sci/dynamic.ts
new file mode 100644
index 000000000..086f42131
--- /dev/null
+++ b/src/polymer_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** polymer_sci dynamic module — tsb analytics library. */
+export interface PolymerSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciDynamicResult { values: number[]; converged: boolean; }
+export function computePolymerSciDynamic(data: number[], opts: PolymerSciDynamicOptions = {}): PolymerSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciDynamic };
diff --git a/src/polymer_sci/embedding.ts b/src/polymer_sci/embedding.ts
new file mode 100644
index 000000000..357b9d175
--- /dev/null
+++ b/src/polymer_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** polymer_sci embedding module — tsb analytics library. */
+export interface PolymerSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computePolymerSciEmbedding(data: number[], opts: PolymerSciEmbeddingOptions = {}): PolymerSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciEmbedding };
diff --git a/src/polymer_sci/encoding.ts b/src/polymer_sci/encoding.ts
new file mode 100644
index 000000000..765b4ecd8
--- /dev/null
+++ b/src/polymer_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** polymer_sci encoding module — tsb analytics library. */
+export interface PolymerSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciEncodingResult { values: number[]; converged: boolean; }
+export function computePolymerSciEncoding(data: number[], opts: PolymerSciEncodingOptions = {}): PolymerSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciEncoding };
diff --git a/src/polymer_sci/ensemble.ts b/src/polymer_sci/ensemble.ts
new file mode 100644
index 000000000..c091ee6e3
--- /dev/null
+++ b/src/polymer_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** polymer_sci ensemble module — tsb analytics library. */
+export interface PolymerSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciEnsembleResult { values: number[]; converged: boolean; }
+export function computePolymerSciEnsemble(data: number[], opts: PolymerSciEnsembleOptions = {}): PolymerSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciEnsemble };
diff --git a/src/polymer_sci/estimation.ts b/src/polymer_sci/estimation.ts
new file mode 100644
index 000000000..1f11b6ad2
--- /dev/null
+++ b/src/polymer_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci estimation module — tsb analytics library. */
+export interface PolymerSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciEstimationResult { values: number[]; converged: boolean; }
+export function computePolymerSciEstimation(data: number[], opts: PolymerSciEstimationOptions = {}): PolymerSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciEstimation };
diff --git a/src/polymer_sci/evaluation.ts b/src/polymer_sci/evaluation.ts
new file mode 100644
index 000000000..bcfd24f72
--- /dev/null
+++ b/src/polymer_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci evaluation module — tsb analytics library. */
+export interface PolymerSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciEvaluationResult { values: number[]; converged: boolean; }
+export function computePolymerSciEvaluation(data: number[], opts: PolymerSciEvaluationOptions = {}): PolymerSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciEvaluation };
diff --git a/src/polymer_sci/extrapolation.ts b/src/polymer_sci/extrapolation.ts
new file mode 100644
index 000000000..3a846042f
--- /dev/null
+++ b/src/polymer_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci extrapolation module — tsb analytics library. */
+export interface PolymerSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computePolymerSciExtrapolation(data: number[], opts: PolymerSciExtrapolationOptions = {}): PolymerSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciExtrapolation };
diff --git a/src/polymer_sci/features.ts b/src/polymer_sci/features.ts
new file mode 100644
index 000000000..b94d071bc
--- /dev/null
+++ b/src/polymer_sci/features.ts
@@ -0,0 +1,14 @@
+/** polymer_sci features module — tsb analytics library. */
+export interface PolymerSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciFeaturesResult { values: number[]; converged: boolean; }
+export function computePolymerSciFeatures(data: number[], opts: PolymerSciFeaturesOptions = {}): PolymerSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciFeatures };
diff --git a/src/polymer_sci/feedback.ts b/src/polymer_sci/feedback.ts
new file mode 100644
index 000000000..8663f594e
--- /dev/null
+++ b/src/polymer_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** polymer_sci feedback module — tsb analytics library. */
+export interface PolymerSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciFeedbackResult { values: number[]; converged: boolean; }
+export function computePolymerSciFeedback(data: number[], opts: PolymerSciFeedbackOptions = {}): PolymerSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciFeedback };
diff --git a/src/polymer_sci/filtering.ts b/src/polymer_sci/filtering.ts
new file mode 100644
index 000000000..9e26ab039
--- /dev/null
+++ b/src/polymer_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** polymer_sci filtering module — tsb analytics library. */
+export interface PolymerSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciFilteringResult { values: number[]; converged: boolean; }
+export function computePolymerSciFiltering(data: number[], opts: PolymerSciFilteringOptions = {}): PolymerSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciFiltering };
diff --git a/src/polymer_sci/fourier.ts b/src/polymer_sci/fourier.ts
new file mode 100644
index 000000000..8a91202bd
--- /dev/null
+++ b/src/polymer_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** polymer_sci fourier module — tsb analytics library. */
+export interface PolymerSciFourierOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciFourierResult { values: number[]; converged: boolean; }
+export function computePolymerSciFourier(data: number[], opts: PolymerSciFourierOptions = {}): PolymerSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciFourier };
diff --git a/src/polymer_sci/fusion.ts b/src/polymer_sci/fusion.ts
new file mode 100644
index 000000000..db2d03ff2
--- /dev/null
+++ b/src/polymer_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** polymer_sci fusion module — tsb analytics library. */
+export interface PolymerSciFusionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciFusionResult { values: number[]; converged: boolean; }
+export function computePolymerSciFusion(data: number[], opts: PolymerSciFusionOptions = {}): PolymerSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciFusion };
diff --git a/src/polymer_sci/generation.ts b/src/polymer_sci/generation.ts
new file mode 100644
index 000000000..8b7ca4789
--- /dev/null
+++ b/src/polymer_sci/generation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci generation module — tsb analytics library. */
+export interface PolymerSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciGenerationResult { values: number[]; converged: boolean; }
+export function computePolymerSciGeneration(data: number[], opts: PolymerSciGenerationOptions = {}): PolymerSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciGeneration };
diff --git a/src/polymer_sci/geometry.ts b/src/polymer_sci/geometry.ts
new file mode 100644
index 000000000..766f68cd6
--- /dev/null
+++ b/src/polymer_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** polymer_sci geometry module — tsb analytics library. */
+export interface PolymerSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciGeometryResult { values: number[]; converged: boolean; }
+export function computePolymerSciGeometry(data: number[], opts: PolymerSciGeometryOptions = {}): PolymerSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciGeometry };
diff --git a/src/polymer_sci/gradient.ts b/src/polymer_sci/gradient.ts
new file mode 100644
index 000000000..a65e74693
--- /dev/null
+++ b/src/polymer_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** polymer_sci gradient module — tsb analytics library. */
+export interface PolymerSciGradientOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciGradientResult { values: number[]; converged: boolean; }
+export function computePolymerSciGradient(data: number[], opts: PolymerSciGradientOptions = {}): PolymerSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciGradient };
diff --git a/src/polymer_sci/hessian.ts b/src/polymer_sci/hessian.ts
new file mode 100644
index 000000000..68fe7f0c7
--- /dev/null
+++ b/src/polymer_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** polymer_sci hessian module — tsb analytics library. */
+export interface PolymerSciHessianOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciHessianResult { values: number[]; converged: boolean; }
+export function computePolymerSciHessian(data: number[], opts: PolymerSciHessianOptions = {}): PolymerSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciHessian };
diff --git a/src/polymer_sci/hypothesis.ts b/src/polymer_sci/hypothesis.ts
new file mode 100644
index 000000000..f277add6c
--- /dev/null
+++ b/src/polymer_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** polymer_sci hypothesis module — tsb analytics library. */
+export interface PolymerSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciHypothesisResult { values: number[]; converged: boolean; }
+export function computePolymerSciHypothesis(data: number[], opts: PolymerSciHypothesisOptions = {}): PolymerSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciHypothesis };
diff --git a/src/polymer_sci/inference.ts b/src/polymer_sci/inference.ts
new file mode 100644
index 000000000..145cdd1b4
--- /dev/null
+++ b/src/polymer_sci/inference.ts
@@ -0,0 +1,14 @@
+/** polymer_sci inference module — tsb analytics library. */
+export interface PolymerSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciInferenceResult { values: number[]; converged: boolean; }
+export function computePolymerSciInference(data: number[], opts: PolymerSciInferenceOptions = {}): PolymerSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciInference };
diff --git a/src/polymer_sci/inference2.ts b/src/polymer_sci/inference2.ts
new file mode 100644
index 000000000..d53102916
--- /dev/null
+++ b/src/polymer_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** polymer_sci inference2 module — tsb analytics library. */
+export interface PolymerSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciInferenceResult { values: number[]; converged: boolean; }
+export function computePolymerSciInference(data: number[], opts: PolymerSciInferenceOptions = {}): PolymerSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciInference };
diff --git a/src/polymer_sci/integral.ts b/src/polymer_sci/integral.ts
new file mode 100644
index 000000000..9a81fc69b
--- /dev/null
+++ b/src/polymer_sci/integral.ts
@@ -0,0 +1,14 @@
+/** polymer_sci integral module — tsb analytics library. */
+export interface PolymerSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciIntegralResult { values: number[]; converged: boolean; }
+export function computePolymerSciIntegral(data: number[], opts: PolymerSciIntegralOptions = {}): PolymerSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciIntegral };
diff --git a/src/polymer_sci/integration.ts b/src/polymer_sci/integration.ts
new file mode 100644
index 000000000..60f5f0a84
--- /dev/null
+++ b/src/polymer_sci/integration.ts
@@ -0,0 +1,14 @@
+/** polymer_sci integration module — tsb analytics library. */
+export interface PolymerSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciIntegrationResult { values: number[]; converged: boolean; }
+export function computePolymerSciIntegration(data: number[], opts: PolymerSciIntegrationOptions = {}): PolymerSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciIntegration };
diff --git a/src/polymer_sci/interpolation.ts b/src/polymer_sci/interpolation.ts
new file mode 100644
index 000000000..a404abc0b
--- /dev/null
+++ b/src/polymer_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci interpolation module — tsb analytics library. */
+export interface PolymerSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciInterpolationResult { values: number[]; converged: boolean; }
+export function computePolymerSciInterpolation(data: number[], opts: PolymerSciInterpolationOptions = {}): PolymerSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciInterpolation };
diff --git a/src/polymer_sci/jacobian.ts b/src/polymer_sci/jacobian.ts
new file mode 100644
index 000000000..34a4149c9
--- /dev/null
+++ b/src/polymer_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** polymer_sci jacobian module — tsb analytics library. */
+export interface PolymerSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciJacobianResult { values: number[]; converged: boolean; }
+export function computePolymerSciJacobian(data: number[], opts: PolymerSciJacobianOptions = {}): PolymerSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciJacobian };
diff --git a/src/polymer_sci/kernel.ts b/src/polymer_sci/kernel.ts
new file mode 100644
index 000000000..1421516e9
--- /dev/null
+++ b/src/polymer_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** polymer_sci kernel module — tsb analytics library. */
+export interface PolymerSciKernelOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciKernelResult { values: number[]; converged: boolean; }
+export function computePolymerSciKernel(data: number[], opts: PolymerSciKernelOptions = {}): PolymerSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciKernel };
diff --git a/src/polymer_sci/laplacian.ts b/src/polymer_sci/laplacian.ts
new file mode 100644
index 000000000..d56821bfa
--- /dev/null
+++ b/src/polymer_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** polymer_sci laplacian module — tsb analytics library. */
+export interface PolymerSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciLaplacianResult { values: number[]; converged: boolean; }
+export function computePolymerSciLaplacian(data: number[], opts: PolymerSciLaplacianOptions = {}): PolymerSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciLaplacian };
diff --git a/src/polymer_sci/learning.ts b/src/polymer_sci/learning.ts
new file mode 100644
index 000000000..5d34e15cf
--- /dev/null
+++ b/src/polymer_sci/learning.ts
@@ -0,0 +1,14 @@
+/** polymer_sci learning module — tsb analytics library. */
+export interface PolymerSciLearningOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciLearningResult { values: number[]; converged: boolean; }
+export function computePolymerSciLearning(data: number[], opts: PolymerSciLearningOptions = {}): PolymerSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciLearning };
diff --git a/src/polymer_sci/linear.ts b/src/polymer_sci/linear.ts
new file mode 100644
index 000000000..e9bb35286
--- /dev/null
+++ b/src/polymer_sci/linear.ts
@@ -0,0 +1,14 @@
+/** polymer_sci linear module — tsb analytics library. */
+export interface PolymerSciLinearOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciLinearResult { values: number[]; converged: boolean; }
+export function computePolymerSciLinear(data: number[], opts: PolymerSciLinearOptions = {}): PolymerSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciLinear };
diff --git a/src/polymer_sci/manifold.ts b/src/polymer_sci/manifold.ts
new file mode 100644
index 000000000..8802f8691
--- /dev/null
+++ b/src/polymer_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** polymer_sci manifold module — tsb analytics library. */
+export interface PolymerSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciManifoldResult { values: number[]; converged: boolean; }
+export function computePolymerSciManifold(data: number[], opts: PolymerSciManifoldOptions = {}): PolymerSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciManifold };
diff --git a/src/polymer_sci/matching.ts b/src/polymer_sci/matching.ts
new file mode 100644
index 000000000..aec2ed7fe
--- /dev/null
+++ b/src/polymer_sci/matching.ts
@@ -0,0 +1,14 @@
+/** polymer_sci matching module — tsb analytics library. */
+export interface PolymerSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciMatchingResult { values: number[]; converged: boolean; }
+export function computePolymerSciMatching(data: number[], opts: PolymerSciMatchingOptions = {}): PolymerSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciMatching };
diff --git a/src/polymer_sci/measurement.ts b/src/polymer_sci/measurement.ts
new file mode 100644
index 000000000..fc6b6a3cb
--- /dev/null
+++ b/src/polymer_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** polymer_sci measurement module — tsb analytics library. */
+export interface PolymerSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciMeasurementResult { values: number[]; converged: boolean; }
+export function computePolymerSciMeasurement(data: number[], opts: PolymerSciMeasurementOptions = {}): PolymerSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciMeasurement };
diff --git a/src/polymer_sci/metrics.ts b/src/polymer_sci/metrics.ts
new file mode 100644
index 000000000..d3548908e
--- /dev/null
+++ b/src/polymer_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** polymer_sci metrics module — tsb analytics library. */
+export interface PolymerSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciMetricsResult { values: number[]; converged: boolean; }
+export function computePolymerSciMetrics(data: number[], opts: PolymerSciMetricsOptions = {}): PolymerSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciMetrics };
diff --git a/src/polymer_sci/modeling.ts b/src/polymer_sci/modeling.ts
new file mode 100644
index 000000000..3897954d6
--- /dev/null
+++ b/src/polymer_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** polymer_sci modeling module — tsb analytics library. */
+export interface PolymerSciModelingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciModelingResult { values: number[]; converged: boolean; }
+export function computePolymerSciModeling(data: number[], opts: PolymerSciModelingOptions = {}): PolymerSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciModeling };
diff --git a/src/polymer_sci/monitoring.ts b/src/polymer_sci/monitoring.ts
new file mode 100644
index 000000000..82c52ad0f
--- /dev/null
+++ b/src/polymer_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** polymer_sci monitoring module — tsb analytics library. */
+export interface PolymerSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciMonitoringResult { values: number[]; converged: boolean; }
+export function computePolymerSciMonitoring(data: number[], opts: PolymerSciMonitoringOptions = {}): PolymerSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciMonitoring };
diff --git a/src/polymer_sci/nonlinear.ts b/src/polymer_sci/nonlinear.ts
new file mode 100644
index 000000000..af7f84a41
--- /dev/null
+++ b/src/polymer_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** polymer_sci nonlinear module — tsb analytics library. */
+export interface PolymerSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciNonlinearResult { values: number[]; converged: boolean; }
+export function computePolymerSciNonlinear(data: number[], opts: PolymerSciNonlinearOptions = {}): PolymerSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciNonlinear };
diff --git a/src/polymer_sci/normalization.ts b/src/polymer_sci/normalization.ts
new file mode 100644
index 000000000..c82e75188
--- /dev/null
+++ b/src/polymer_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** polymer_sci normalization module — tsb analytics library. */
+export interface PolymerSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciNormalizationResult { values: number[]; converged: boolean; }
+export function computePolymerSciNormalization(data: number[], opts: PolymerSciNormalizationOptions = {}): PolymerSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciNormalization };
diff --git a/src/polymer_sci/optimization.ts b/src/polymer_sci/optimization.ts
new file mode 100644
index 000000000..84c0ca002
--- /dev/null
+++ b/src/polymer_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** polymer_sci optimization module — tsb analytics library. */
+export interface PolymerSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciOptimizationResult { values: number[]; converged: boolean; }
+export function computePolymerSciOptimization(data: number[], opts: PolymerSciOptimizationOptions = {}): PolymerSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciOptimization };
diff --git a/src/polymer_sci/patterns.ts b/src/polymer_sci/patterns.ts
new file mode 100644
index 000000000..abeb635e8
--- /dev/null
+++ b/src/polymer_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** polymer_sci patterns module — tsb analytics library. */
+export interface PolymerSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciPatternsResult { values: number[]; converged: boolean; }
+export function computePolymerSciPatterns(data: number[], opts: PolymerSciPatternsOptions = {}): PolymerSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciPatterns };
diff --git a/src/polymer_sci/permutation.ts b/src/polymer_sci/permutation.ts
new file mode 100644
index 000000000..f134b4141
--- /dev/null
+++ b/src/polymer_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci permutation module — tsb analytics library. */
+export interface PolymerSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciPermutationResult { values: number[]; converged: boolean; }
+export function computePolymerSciPermutation(data: number[], opts: PolymerSciPermutationOptions = {}): PolymerSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciPermutation };
diff --git a/src/polymer_sci/prediction.ts b/src/polymer_sci/prediction.ts
new file mode 100644
index 000000000..1bb155ef7
--- /dev/null
+++ b/src/polymer_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** polymer_sci prediction module — tsb analytics library. */
+export interface PolymerSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciPredictionResult { values: number[]; converged: boolean; }
+export function computePolymerSciPrediction(data: number[], opts: PolymerSciPredictionOptions = {}): PolymerSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciPrediction };
diff --git a/src/polymer_sci/processing.ts b/src/polymer_sci/processing.ts
new file mode 100644
index 000000000..d8104366f
--- /dev/null
+++ b/src/polymer_sci/processing.ts
@@ -0,0 +1,14 @@
+/** polymer_sci processing module — tsb analytics library. */
+export interface PolymerSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciProcessingResult { values: number[]; converged: boolean; }
+export function computePolymerSciProcessing(data: number[], opts: PolymerSciProcessingOptions = {}): PolymerSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciProcessing };
diff --git a/src/polymer_sci/profiling.ts b/src/polymer_sci/profiling.ts
new file mode 100644
index 000000000..f80750e4a
--- /dev/null
+++ b/src/polymer_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** polymer_sci profiling module — tsb analytics library. */
+export interface PolymerSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciProfilingResult { values: number[]; converged: boolean; }
+export function computePolymerSciProfiling(data: number[], opts: PolymerSciProfilingOptions = {}): PolymerSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciProfiling };
diff --git a/src/polymer_sci/projection.ts b/src/polymer_sci/projection.ts
new file mode 100644
index 000000000..90b32347c
--- /dev/null
+++ b/src/polymer_sci/projection.ts
@@ -0,0 +1,14 @@
+/** polymer_sci projection module — tsb analytics library. */
+export interface PolymerSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciProjectionResult { values: number[]; converged: boolean; }
+export function computePolymerSciProjection(data: number[], opts: PolymerSciProjectionOptions = {}): PolymerSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciProjection };
diff --git a/src/polymer_sci/ranking.ts b/src/polymer_sci/ranking.ts
new file mode 100644
index 000000000..6fb118512
--- /dev/null
+++ b/src/polymer_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** polymer_sci ranking module — tsb analytics library. */
+export interface PolymerSciRankingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciRankingResult { values: number[]; converged: boolean; }
+export function computePolymerSciRanking(data: number[], opts: PolymerSciRankingOptions = {}): PolymerSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciRanking };
diff --git a/src/polymer_sci/reconstruction.ts b/src/polymer_sci/reconstruction.ts
new file mode 100644
index 000000000..57f90cdc0
--- /dev/null
+++ b/src/polymer_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** polymer_sci reconstruction module — tsb analytics library. */
+export interface PolymerSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciReconstructionResult { values: number[]; converged: boolean; }
+export function computePolymerSciReconstruction(data: number[], opts: PolymerSciReconstructionOptions = {}): PolymerSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciReconstruction };
diff --git a/src/polymer_sci/registration.ts b/src/polymer_sci/registration.ts
new file mode 100644
index 000000000..5899f7070
--- /dev/null
+++ b/src/polymer_sci/registration.ts
@@ -0,0 +1,14 @@
+/** polymer_sci registration module — tsb analytics library. */
+export interface PolymerSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciRegistrationResult { values: number[]; converged: boolean; }
+export function computePolymerSciRegistration(data: number[], opts: PolymerSciRegistrationOptions = {}): PolymerSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciRegistration };
diff --git a/src/polymer_sci/regression.ts b/src/polymer_sci/regression.ts
new file mode 100644
index 000000000..f37beb13e
--- /dev/null
+++ b/src/polymer_sci/regression.ts
@@ -0,0 +1,14 @@
+/** polymer_sci regression module — tsb analytics library. */
+export interface PolymerSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciRegressionResult { values: number[]; converged: boolean; }
+export function computePolymerSciRegression(data: number[], opts: PolymerSciRegressionOptions = {}): PolymerSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciRegression };
diff --git a/src/polymer_sci/regularization.ts b/src/polymer_sci/regularization.ts
new file mode 100644
index 000000000..0db2e9a80
--- /dev/null
+++ b/src/polymer_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** polymer_sci regularization module — tsb analytics library. */
+export interface PolymerSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciRegularizationResult { values: number[]; converged: boolean; }
+export function computePolymerSciRegularization(data: number[], opts: PolymerSciRegularizationOptions = {}): PolymerSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciRegularization };
diff --git a/src/polymer_sci/robustness.ts b/src/polymer_sci/robustness.ts
new file mode 100644
index 000000000..c6b964610
--- /dev/null
+++ b/src/polymer_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** polymer_sci robustness module — tsb analytics library. */
+export interface PolymerSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciRobustnessResult { values: number[]; converged: boolean; }
+export function computePolymerSciRobustness(data: number[], opts: PolymerSciRobustnessOptions = {}): PolymerSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciRobustness };
diff --git a/src/polymer_sci/sampling.ts b/src/polymer_sci/sampling.ts
new file mode 100644
index 000000000..81bcec56f
--- /dev/null
+++ b/src/polymer_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** polymer_sci sampling module — tsb analytics library. */
+export interface PolymerSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciSamplingResult { values: number[]; converged: boolean; }
+export function computePolymerSciSampling(data: number[], opts: PolymerSciSamplingOptions = {}): PolymerSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciSampling };
diff --git a/src/polymer_sci/sampling2.ts b/src/polymer_sci/sampling2.ts
new file mode 100644
index 000000000..ed69c6545
--- /dev/null
+++ b/src/polymer_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** polymer_sci sampling2 module — tsb analytics library. */
+export interface PolymerSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciSamplingResult { values: number[]; converged: boolean; }
+export function computePolymerSciSampling(data: number[], opts: PolymerSciSamplingOptions = {}): PolymerSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciSampling };
diff --git a/src/polymer_sci/scaling.ts b/src/polymer_sci/scaling.ts
new file mode 100644
index 000000000..417ea3588
--- /dev/null
+++ b/src/polymer_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** polymer_sci scaling module — tsb analytics library. */
+export interface PolymerSciScalingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciScalingResult { values: number[]; converged: boolean; }
+export function computePolymerSciScaling(data: number[], opts: PolymerSciScalingOptions = {}): PolymerSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciScaling };
diff --git a/src/polymer_sci/scoring.ts b/src/polymer_sci/scoring.ts
new file mode 100644
index 000000000..aa7d66cea
--- /dev/null
+++ b/src/polymer_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** polymer_sci scoring module — tsb analytics library. */
+export interface PolymerSciScoringOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciScoringResult { values: number[]; converged: boolean; }
+export function computePolymerSciScoring(data: number[], opts: PolymerSciScoringOptions = {}): PolymerSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciScoring };
diff --git a/src/polymer_sci/segmentation.ts b/src/polymer_sci/segmentation.ts
new file mode 100644
index 000000000..a7496c2fb
--- /dev/null
+++ b/src/polymer_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci segmentation module — tsb analytics library. */
+export interface PolymerSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciSegmentationResult { values: number[]; converged: boolean; }
+export function computePolymerSciSegmentation(data: number[], opts: PolymerSciSegmentationOptions = {}): PolymerSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciSegmentation };
diff --git a/src/polymer_sci/selection.ts b/src/polymer_sci/selection.ts
new file mode 100644
index 000000000..5f11d7cb5
--- /dev/null
+++ b/src/polymer_sci/selection.ts
@@ -0,0 +1,14 @@
+/** polymer_sci selection module — tsb analytics library. */
+export interface PolymerSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciSelectionResult { values: number[]; converged: boolean; }
+export function computePolymerSciSelection(data: number[], opts: PolymerSciSelectionOptions = {}): PolymerSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciSelection };
diff --git a/src/polymer_sci/sensitivity.ts b/src/polymer_sci/sensitivity.ts
new file mode 100644
index 000000000..58e593807
--- /dev/null
+++ b/src/polymer_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** polymer_sci sensitivity module — tsb analytics library. */
+export interface PolymerSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciSensitivityResult { values: number[]; converged: boolean; }
+export function computePolymerSciSensitivity(data: number[], opts: PolymerSciSensitivityOptions = {}): PolymerSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciSensitivity };
diff --git a/src/polymer_sci/simulation.ts b/src/polymer_sci/simulation.ts
new file mode 100644
index 000000000..41ea2d203
--- /dev/null
+++ b/src/polymer_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci simulation module — tsb analytics library. */
+export interface PolymerSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciSimulationResult { values: number[]; converged: boolean; }
+export function computePolymerSciSimulation(data: number[], opts: PolymerSciSimulationOptions = {}): PolymerSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciSimulation };
diff --git a/src/polymer_sci/smoothing.ts b/src/polymer_sci/smoothing.ts
new file mode 100644
index 000000000..10fe36dc1
--- /dev/null
+++ b/src/polymer_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** polymer_sci smoothing module — tsb analytics library. */
+export interface PolymerSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciSmoothingResult { values: number[]; converged: boolean; }
+export function computePolymerSciSmoothing(data: number[], opts: PolymerSciSmoothingOptions = {}): PolymerSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciSmoothing };
diff --git a/src/polymer_sci/stability.ts b/src/polymer_sci/stability.ts
new file mode 100644
index 000000000..9a5ee4d3d
--- /dev/null
+++ b/src/polymer_sci/stability.ts
@@ -0,0 +1,14 @@
+/** polymer_sci stability module — tsb analytics library. */
+export interface PolymerSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciStabilityResult { values: number[]; converged: boolean; }
+export function computePolymerSciStability(data: number[], opts: PolymerSciStabilityOptions = {}): PolymerSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciStability };
diff --git a/src/polymer_sci/stacking.ts b/src/polymer_sci/stacking.ts
new file mode 100644
index 000000000..1b2f105e1
--- /dev/null
+++ b/src/polymer_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** polymer_sci stacking module — tsb analytics library. */
+export interface PolymerSciStackingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciStackingResult { values: number[]; converged: boolean; }
+export function computePolymerSciStacking(data: number[], opts: PolymerSciStackingOptions = {}): PolymerSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciStacking };
diff --git a/src/polymer_sci/standardization.ts b/src/polymer_sci/standardization.ts
new file mode 100644
index 000000000..3d7440855
--- /dev/null
+++ b/src/polymer_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** polymer_sci standardization module — tsb analytics library. */
+export interface PolymerSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciStandardizationResult { values: number[]; converged: boolean; }
+export function computePolymerSciStandardization(data: number[], opts: PolymerSciStandardizationOptions = {}): PolymerSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciStandardization };
diff --git a/src/polymer_sci/static.ts b/src/polymer_sci/static.ts
new file mode 100644
index 000000000..5a7b9e141
--- /dev/null
+++ b/src/polymer_sci/static.ts
@@ -0,0 +1,14 @@
+/** polymer_sci static module — tsb analytics library. */
+export interface PolymerSciStaticOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciStaticResult { values: number[]; converged: boolean; }
+export function computePolymerSciStatic(data: number[], opts: PolymerSciStaticOptions = {}): PolymerSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciStatic };
diff --git a/src/polymer_sci/stochastic.ts b/src/polymer_sci/stochastic.ts
new file mode 100644
index 000000000..738a18932
--- /dev/null
+++ b/src/polymer_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** polymer_sci stochastic module — tsb analytics library. */
+export interface PolymerSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciStochasticResult { values: number[]; converged: boolean; }
+export function computePolymerSciStochastic(data: number[], opts: PolymerSciStochasticOptions = {}): PolymerSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciStochastic };
diff --git a/src/polymer_sci/synthesis.ts b/src/polymer_sci/synthesis.ts
new file mode 100644
index 000000000..6efac5d51
--- /dev/null
+++ b/src/polymer_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** polymer_sci synthesis module — tsb analytics library. */
+export interface PolymerSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciSynthesisResult { values: number[]; converged: boolean; }
+export function computePolymerSciSynthesis(data: number[], opts: PolymerSciSynthesisOptions = {}): PolymerSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciSynthesis };
diff --git a/src/polymer_sci/topology.ts b/src/polymer_sci/topology.ts
new file mode 100644
index 000000000..7102d6233
--- /dev/null
+++ b/src/polymer_sci/topology.ts
@@ -0,0 +1,14 @@
+/** polymer_sci topology module — tsb analytics library. */
+export interface PolymerSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciTopologyResult { values: number[]; converged: boolean; }
+export function computePolymerSciTopology(data: number[], opts: PolymerSciTopologyOptions = {}): PolymerSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciTopology };
diff --git a/src/polymer_sci/tracking.ts b/src/polymer_sci/tracking.ts
new file mode 100644
index 000000000..0e84a1a19
--- /dev/null
+++ b/src/polymer_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** polymer_sci tracking module — tsb analytics library. */
+export interface PolymerSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciTrackingResult { values: number[]; converged: boolean; }
+export function computePolymerSciTracking(data: number[], opts: PolymerSciTrackingOptions = {}): PolymerSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciTracking };
diff --git a/src/polymer_sci/transform.ts b/src/polymer_sci/transform.ts
new file mode 100644
index 000000000..5670a4c63
--- /dev/null
+++ b/src/polymer_sci/transform.ts
@@ -0,0 +1,14 @@
+/** polymer_sci transform module — tsb analytics library. */
+export interface PolymerSciTransformOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciTransformResult { values: number[]; converged: boolean; }
+export function computePolymerSciTransform(data: number[], opts: PolymerSciTransformOptions = {}): PolymerSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciTransform };
diff --git a/src/polymer_sci/uncertainty.ts b/src/polymer_sci/uncertainty.ts
new file mode 100644
index 000000000..f56adaae1
--- /dev/null
+++ b/src/polymer_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** polymer_sci uncertainty module — tsb analytics library. */
+export interface PolymerSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computePolymerSciUncertainty(data: number[], opts: PolymerSciUncertaintyOptions = {}): PolymerSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciUncertainty };
diff --git a/src/polymer_sci/validation.ts b/src/polymer_sci/validation.ts
new file mode 100644
index 000000000..cc031e02c
--- /dev/null
+++ b/src/polymer_sci/validation.ts
@@ -0,0 +1,14 @@
+/** polymer_sci validation module — tsb analytics library. */
+export interface PolymerSciValidationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciValidationResult { values: number[]; converged: boolean; }
+export function computePolymerSciValidation(data: number[], opts: PolymerSciValidationOptions = {}): PolymerSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciValidation };
diff --git a/src/polymer_sci/verification.ts b/src/polymer_sci/verification.ts
new file mode 100644
index 000000000..a4006cc80
--- /dev/null
+++ b/src/polymer_sci/verification.ts
@@ -0,0 +1,14 @@
+/** polymer_sci verification module — tsb analytics library. */
+export interface PolymerSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciVerificationResult { values: number[]; converged: boolean; }
+export function computePolymerSciVerification(data: number[], opts: PolymerSciVerificationOptions = {}): PolymerSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciVerification };
diff --git a/src/polymer_sci/visualization.ts b/src/polymer_sci/visualization.ts
new file mode 100644
index 000000000..d49fc33c4
--- /dev/null
+++ b/src/polymer_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** polymer_sci visualization module — tsb analytics library. */
+export interface PolymerSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciVisualizationResult { values: number[]; converged: boolean; }
+export function computePolymerSciVisualization(data: number[], opts: PolymerSciVisualizationOptions = {}): PolymerSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciVisualization };
diff --git a/src/polymer_sci/voting.ts b/src/polymer_sci/voting.ts
new file mode 100644
index 000000000..f1aa0b7a4
--- /dev/null
+++ b/src/polymer_sci/voting.ts
@@ -0,0 +1,14 @@
+/** polymer_sci voting module — tsb analytics library. */
+export interface PolymerSciVotingOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciVotingResult { values: number[]; converged: boolean; }
+export function computePolymerSciVoting(data: number[], opts: PolymerSciVotingOptions = {}): PolymerSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciVoting };
diff --git a/src/polymer_sci/wavelet.ts b/src/polymer_sci/wavelet.ts
new file mode 100644
index 000000000..ade1a4586
--- /dev/null
+++ b/src/polymer_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** polymer_sci wavelet module — tsb analytics library. */
+export interface PolymerSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface PolymerSciWaveletResult { values: number[]; converged: boolean; }
+export function computePolymerSciWavelet(data: number[], opts: PolymerSciWaveletOptions = {}): PolymerSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePolymerSciWavelet };
diff --git a/src/population_bio/adaptation.ts b/src/population_bio/adaptation.ts
new file mode 100644
index 000000000..f534c2968
--- /dev/null
+++ b/src/population_bio/adaptation.ts
@@ -0,0 +1,14 @@
+/** population_bio adaptation module — tsb analytics library. */
+export interface PopulationBioAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioAdaptationResult { values: number[]; converged: boolean; }
+export function computePopulationBioAdaptation(data: number[], opts: PopulationBioAdaptationOptions = {}): PopulationBioAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioAdaptation };
diff --git a/src/population_bio/aggregation.ts b/src/population_bio/aggregation.ts
new file mode 100644
index 000000000..db4a14e7a
--- /dev/null
+++ b/src/population_bio/aggregation.ts
@@ -0,0 +1,14 @@
+/** population_bio aggregation module — tsb analytics library. */
+export interface PopulationBioAggregationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioAggregationResult { values: number[]; converged: boolean; }
+export function computePopulationBioAggregation(data: number[], opts: PopulationBioAggregationOptions = {}): PopulationBioAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioAggregation };
diff --git a/src/population_bio/algebra.ts b/src/population_bio/algebra.ts
new file mode 100644
index 000000000..64a73e492
--- /dev/null
+++ b/src/population_bio/algebra.ts
@@ -0,0 +1,14 @@
+/** population_bio algebra module — tsb analytics library. */
+export interface PopulationBioAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioAlgebraResult { values: number[]; converged: boolean; }
+export function computePopulationBioAlgebra(data: number[], opts: PopulationBioAlgebraOptions = {}): PopulationBioAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioAlgebra };
diff --git a/src/population_bio/alignment.ts b/src/population_bio/alignment.ts
new file mode 100644
index 000000000..7bb2f2401
--- /dev/null
+++ b/src/population_bio/alignment.ts
@@ -0,0 +1,14 @@
+/** population_bio alignment module — tsb analytics library. */
+export interface PopulationBioAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioAlignmentResult { values: number[]; converged: boolean; }
+export function computePopulationBioAlignment(data: number[], opts: PopulationBioAlignmentOptions = {}): PopulationBioAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioAlignment };
diff --git a/src/population_bio/analysis.ts b/src/population_bio/analysis.ts
new file mode 100644
index 000000000..209a35ff2
--- /dev/null
+++ b/src/population_bio/analysis.ts
@@ -0,0 +1,14 @@
+/** population_bio analysis module — tsb analytics library. */
+export interface PopulationBioAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioAnalysisResult { values: number[]; converged: boolean; }
+export function computePopulationBioAnalysis(data: number[], opts: PopulationBioAnalysisOptions = {}): PopulationBioAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioAnalysis };
diff --git a/src/population_bio/augmentation.ts b/src/population_bio/augmentation.ts
new file mode 100644
index 000000000..b8c8df895
--- /dev/null
+++ b/src/population_bio/augmentation.ts
@@ -0,0 +1,14 @@
+/** population_bio augmentation module — tsb analytics library. */
+export interface PopulationBioAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioAugmentationResult { values: number[]; converged: boolean; }
+export function computePopulationBioAugmentation(data: number[], opts: PopulationBioAugmentationOptions = {}): PopulationBioAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioAugmentation };
diff --git a/src/population_bio/bagging.ts b/src/population_bio/bagging.ts
new file mode 100644
index 000000000..324b408b7
--- /dev/null
+++ b/src/population_bio/bagging.ts
@@ -0,0 +1,14 @@
+/** population_bio bagging module — tsb analytics library. */
+export interface PopulationBioBaggingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioBaggingResult { values: number[]; converged: boolean; }
+export function computePopulationBioBagging(data: number[], opts: PopulationBioBaggingOptions = {}): PopulationBioBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioBagging };
diff --git a/src/population_bio/basis.ts b/src/population_bio/basis.ts
new file mode 100644
index 000000000..cf623b0e4
--- /dev/null
+++ b/src/population_bio/basis.ts
@@ -0,0 +1,14 @@
+/** population_bio basis module — tsb analytics library. */
+export interface PopulationBioBasisOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioBasisResult { values: number[]; converged: boolean; }
+export function computePopulationBioBasis(data: number[], opts: PopulationBioBasisOptions = {}): PopulationBioBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioBasis };
diff --git a/src/population_bio/benchmarking.ts b/src/population_bio/benchmarking.ts
new file mode 100644
index 000000000..09243016c
--- /dev/null
+++ b/src/population_bio/benchmarking.ts
@@ -0,0 +1,14 @@
+/** population_bio benchmarking module — tsb analytics library. */
+export interface PopulationBioBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePopulationBioBenchmarking(data: number[], opts: PopulationBioBenchmarkingOptions = {}): PopulationBioBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioBenchmarking };
diff --git a/src/population_bio/blending.ts b/src/population_bio/blending.ts
new file mode 100644
index 000000000..9d65cd9d7
--- /dev/null
+++ b/src/population_bio/blending.ts
@@ -0,0 +1,14 @@
+/** population_bio blending module — tsb analytics library. */
+export interface PopulationBioBlendingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioBlendingResult { values: number[]; converged: boolean; }
+export function computePopulationBioBlending(data: number[], opts: PopulationBioBlendingOptions = {}): PopulationBioBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioBlending };
diff --git a/src/population_bio/boosting.ts b/src/population_bio/boosting.ts
new file mode 100644
index 000000000..9410fa2a1
--- /dev/null
+++ b/src/population_bio/boosting.ts
@@ -0,0 +1,14 @@
+/** population_bio boosting module — tsb analytics library. */
+export interface PopulationBioBoostingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioBoostingResult { values: number[]; converged: boolean; }
+export function computePopulationBioBoosting(data: number[], opts: PopulationBioBoostingOptions = {}): PopulationBioBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioBoosting };
diff --git a/src/population_bio/bootstrap.ts b/src/population_bio/bootstrap.ts
new file mode 100644
index 000000000..9ea413530
--- /dev/null
+++ b/src/population_bio/bootstrap.ts
@@ -0,0 +1,14 @@
+/** population_bio bootstrap module — tsb analytics library. */
+export interface PopulationBioBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioBootstrapResult { values: number[]; converged: boolean; }
+export function computePopulationBioBootstrap(data: number[], opts: PopulationBioBootstrapOptions = {}): PopulationBioBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioBootstrap };
diff --git a/src/population_bio/calculus.ts b/src/population_bio/calculus.ts
new file mode 100644
index 000000000..b21826e6c
--- /dev/null
+++ b/src/population_bio/calculus.ts
@@ -0,0 +1,14 @@
+/** population_bio calculus module — tsb analytics library. */
+export interface PopulationBioCalculusOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioCalculusResult { values: number[]; converged: boolean; }
+export function computePopulationBioCalculus(data: number[], opts: PopulationBioCalculusOptions = {}): PopulationBioCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioCalculus };
diff --git a/src/population_bio/calibration.ts b/src/population_bio/calibration.ts
new file mode 100644
index 000000000..b42bb31b9
--- /dev/null
+++ b/src/population_bio/calibration.ts
@@ -0,0 +1,14 @@
+/** population_bio calibration module — tsb analytics library. */
+export interface PopulationBioCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioCalibrationResult { values: number[]; converged: boolean; }
+export function computePopulationBioCalibration(data: number[], opts: PopulationBioCalibrationOptions = {}): PopulationBioCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioCalibration };
diff --git a/src/population_bio/characterization.ts b/src/population_bio/characterization.ts
new file mode 100644
index 000000000..4072e157f
--- /dev/null
+++ b/src/population_bio/characterization.ts
@@ -0,0 +1,14 @@
+/** population_bio characterization module — tsb analytics library. */
+export interface PopulationBioCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioCharacterizationResult { values: number[]; converged: boolean; }
+export function computePopulationBioCharacterization(data: number[], opts: PopulationBioCharacterizationOptions = {}): PopulationBioCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioCharacterization };
diff --git a/src/population_bio/classification.ts b/src/population_bio/classification.ts
new file mode 100644
index 000000000..09106e570
--- /dev/null
+++ b/src/population_bio/classification.ts
@@ -0,0 +1,14 @@
+/** population_bio classification module — tsb analytics library. */
+export interface PopulationBioClassificationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioClassificationResult { values: number[]; converged: boolean; }
+export function computePopulationBioClassification(data: number[], opts: PopulationBioClassificationOptions = {}): PopulationBioClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioClassification };
diff --git a/src/population_bio/clustering.ts b/src/population_bio/clustering.ts
new file mode 100644
index 000000000..738f91dd8
--- /dev/null
+++ b/src/population_bio/clustering.ts
@@ -0,0 +1,14 @@
+/** population_bio clustering module — tsb analytics library. */
+export interface PopulationBioClusteringOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioClusteringResult { values: number[]; converged: boolean; }
+export function computePopulationBioClustering(data: number[], opts: PopulationBioClusteringOptions = {}): PopulationBioClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioClustering };
diff --git a/src/population_bio/compression.ts b/src/population_bio/compression.ts
new file mode 100644
index 000000000..1a12ecbd3
--- /dev/null
+++ b/src/population_bio/compression.ts
@@ -0,0 +1,14 @@
+/** population_bio compression module — tsb analytics library. */
+export interface PopulationBioCompressionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioCompressionResult { values: number[]; converged: boolean; }
+export function computePopulationBioCompression(data: number[], opts: PopulationBioCompressionOptions = {}): PopulationBioCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioCompression };
diff --git a/src/population_bio/continuous.ts b/src/population_bio/continuous.ts
new file mode 100644
index 000000000..d19812a6c
--- /dev/null
+++ b/src/population_bio/continuous.ts
@@ -0,0 +1,14 @@
+/** population_bio continuous module — tsb analytics library. */
+export interface PopulationBioContinuousOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioContinuousResult { values: number[]; converged: boolean; }
+export function computePopulationBioContinuous(data: number[], opts: PopulationBioContinuousOptions = {}): PopulationBioContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioContinuous };
diff --git a/src/population_bio/control.ts b/src/population_bio/control.ts
new file mode 100644
index 000000000..c61b1309e
--- /dev/null
+++ b/src/population_bio/control.ts
@@ -0,0 +1,14 @@
+/** population_bio control module — tsb analytics library. */
+export interface PopulationBioControlOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioControlResult { values: number[]; converged: boolean; }
+export function computePopulationBioControl(data: number[], opts: PopulationBioControlOptions = {}): PopulationBioControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioControl };
diff --git a/src/population_bio/convergence.ts b/src/population_bio/convergence.ts
new file mode 100644
index 000000000..22a13eab1
--- /dev/null
+++ b/src/population_bio/convergence.ts
@@ -0,0 +1,14 @@
+/** population_bio convergence module — tsb analytics library. */
+export interface PopulationBioConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioConvergenceResult { values: number[]; converged: boolean; }
+export function computePopulationBioConvergence(data: number[], opts: PopulationBioConvergenceOptions = {}): PopulationBioConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioConvergence };
diff --git a/src/population_bio/convex.ts b/src/population_bio/convex.ts
new file mode 100644
index 000000000..e0413bb55
--- /dev/null
+++ b/src/population_bio/convex.ts
@@ -0,0 +1,14 @@
+/** population_bio convex module — tsb analytics library. */
+export interface PopulationBioConvexOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioConvexResult { values: number[]; converged: boolean; }
+export function computePopulationBioConvex(data: number[], opts: PopulationBioConvexOptions = {}): PopulationBioConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioConvex };
diff --git a/src/population_bio/correlation.ts b/src/population_bio/correlation.ts
new file mode 100644
index 000000000..f0e151f7f
--- /dev/null
+++ b/src/population_bio/correlation.ts
@@ -0,0 +1,14 @@
+/** population_bio correlation module — tsb analytics library. */
+export interface PopulationBioCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioCorrelationResult { values: number[]; converged: boolean; }
+export function computePopulationBioCorrelation(data: number[], opts: PopulationBioCorrelationOptions = {}): PopulationBioCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioCorrelation };
diff --git a/src/population_bio/covariance.ts b/src/population_bio/covariance.ts
new file mode 100644
index 000000000..3802de3b8
--- /dev/null
+++ b/src/population_bio/covariance.ts
@@ -0,0 +1,14 @@
+/** population_bio covariance module — tsb analytics library. */
+export interface PopulationBioCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioCovarianceResult { values: number[]; converged: boolean; }
+export function computePopulationBioCovariance(data: number[], opts: PopulationBioCovarianceOptions = {}): PopulationBioCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioCovariance };
diff --git a/src/population_bio/cross_validation.ts b/src/population_bio/cross_validation.ts
new file mode 100644
index 000000000..38e6a01cb
--- /dev/null
+++ b/src/population_bio/cross_validation.ts
@@ -0,0 +1,14 @@
+/** population_bio cross_validation module — tsb analytics library. */
+export interface PopulationBioCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioCrossValidationResult { values: number[]; converged: boolean; }
+export function computePopulationBioCrossValidation(data: number[], opts: PopulationBioCrossValidationOptions = {}): PopulationBioCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioCrossValidation };
diff --git a/src/population_bio/decoding.ts b/src/population_bio/decoding.ts
new file mode 100644
index 000000000..ea1c74cef
--- /dev/null
+++ b/src/population_bio/decoding.ts
@@ -0,0 +1,14 @@
+/** population_bio decoding module — tsb analytics library. */
+export interface PopulationBioDecodingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDecodingResult { values: number[]; converged: boolean; }
+export function computePopulationBioDecoding(data: number[], opts: PopulationBioDecodingOptions = {}): PopulationBioDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDecoding };
diff --git a/src/population_bio/decomposition.ts b/src/population_bio/decomposition.ts
new file mode 100644
index 000000000..6521fa1e7
--- /dev/null
+++ b/src/population_bio/decomposition.ts
@@ -0,0 +1,14 @@
+/** population_bio decomposition module — tsb analytics library. */
+export interface PopulationBioDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDecompositionResult { values: number[]; converged: boolean; }
+export function computePopulationBioDecomposition(data: number[], opts: PopulationBioDecompositionOptions = {}): PopulationBioDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDecomposition };
diff --git a/src/population_bio/detection.ts b/src/population_bio/detection.ts
new file mode 100644
index 000000000..a87ebef53
--- /dev/null
+++ b/src/population_bio/detection.ts
@@ -0,0 +1,14 @@
+/** population_bio detection module — tsb analytics library. */
+export interface PopulationBioDetectionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDetectionResult { values: number[]; converged: boolean; }
+export function computePopulationBioDetection(data: number[], opts: PopulationBioDetectionOptions = {}): PopulationBioDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDetection };
diff --git a/src/population_bio/deterministic.ts b/src/population_bio/deterministic.ts
new file mode 100644
index 000000000..776e339a0
--- /dev/null
+++ b/src/population_bio/deterministic.ts
@@ -0,0 +1,14 @@
+/** population_bio deterministic module — tsb analytics library. */
+export interface PopulationBioDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDeterministicResult { values: number[]; converged: boolean; }
+export function computePopulationBioDeterministic(data: number[], opts: PopulationBioDeterministicOptions = {}): PopulationBioDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDeterministic };
diff --git a/src/population_bio/diagnostics.ts b/src/population_bio/diagnostics.ts
new file mode 100644
index 000000000..c32bb398c
--- /dev/null
+++ b/src/population_bio/diagnostics.ts
@@ -0,0 +1,14 @@
+/** population_bio diagnostics module — tsb analytics library. */
+export interface PopulationBioDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePopulationBioDiagnostics(data: number[], opts: PopulationBioDiagnosticsOptions = {}): PopulationBioDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDiagnostics };
diff --git a/src/population_bio/differential.ts b/src/population_bio/differential.ts
new file mode 100644
index 000000000..8aa7b3952
--- /dev/null
+++ b/src/population_bio/differential.ts
@@ -0,0 +1,14 @@
+/** population_bio differential module — tsb analytics library. */
+export interface PopulationBioDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDifferentialResult { values: number[]; converged: boolean; }
+export function computePopulationBioDifferential(data: number[], opts: PopulationBioDifferentialOptions = {}): PopulationBioDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDifferential };
diff --git a/src/population_bio/discrete.ts b/src/population_bio/discrete.ts
new file mode 100644
index 000000000..bb55285a1
--- /dev/null
+++ b/src/population_bio/discrete.ts
@@ -0,0 +1,14 @@
+/** population_bio discrete module — tsb analytics library. */
+export interface PopulationBioDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDiscreteResult { values: number[]; converged: boolean; }
+export function computePopulationBioDiscrete(data: number[], opts: PopulationBioDiscreteOptions = {}): PopulationBioDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDiscrete };
diff --git a/src/population_bio/distribution.ts b/src/population_bio/distribution.ts
new file mode 100644
index 000000000..186144595
--- /dev/null
+++ b/src/population_bio/distribution.ts
@@ -0,0 +1,14 @@
+/** population_bio distribution module — tsb analytics library. */
+export interface PopulationBioDistributionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDistributionResult { values: number[]; converged: boolean; }
+export function computePopulationBioDistribution(data: number[], opts: PopulationBioDistributionOptions = {}): PopulationBioDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDistribution };
diff --git a/src/population_bio/dynamic.ts b/src/population_bio/dynamic.ts
new file mode 100644
index 000000000..ad1a01184
--- /dev/null
+++ b/src/population_bio/dynamic.ts
@@ -0,0 +1,14 @@
+/** population_bio dynamic module — tsb analytics library. */
+export interface PopulationBioDynamicOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioDynamicResult { values: number[]; converged: boolean; }
+export function computePopulationBioDynamic(data: number[], opts: PopulationBioDynamicOptions = {}): PopulationBioDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioDynamic };
diff --git a/src/population_bio/embedding.ts b/src/population_bio/embedding.ts
new file mode 100644
index 000000000..3c09c16ce
--- /dev/null
+++ b/src/population_bio/embedding.ts
@@ -0,0 +1,14 @@
+/** population_bio embedding module — tsb analytics library. */
+export interface PopulationBioEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioEmbeddingResult { values: number[]; converged: boolean; }
+export function computePopulationBioEmbedding(data: number[], opts: PopulationBioEmbeddingOptions = {}): PopulationBioEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioEmbedding };
diff --git a/src/population_bio/encoding.ts b/src/population_bio/encoding.ts
new file mode 100644
index 000000000..05f489c1c
--- /dev/null
+++ b/src/population_bio/encoding.ts
@@ -0,0 +1,14 @@
+/** population_bio encoding module — tsb analytics library. */
+export interface PopulationBioEncodingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioEncodingResult { values: number[]; converged: boolean; }
+export function computePopulationBioEncoding(data: number[], opts: PopulationBioEncodingOptions = {}): PopulationBioEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioEncoding };
diff --git a/src/population_bio/ensemble.ts b/src/population_bio/ensemble.ts
new file mode 100644
index 000000000..5a1e90d75
--- /dev/null
+++ b/src/population_bio/ensemble.ts
@@ -0,0 +1,14 @@
+/** population_bio ensemble module — tsb analytics library. */
+export interface PopulationBioEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioEnsembleResult { values: number[]; converged: boolean; }
+export function computePopulationBioEnsemble(data: number[], opts: PopulationBioEnsembleOptions = {}): PopulationBioEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioEnsemble };
diff --git a/src/population_bio/estimation.ts b/src/population_bio/estimation.ts
new file mode 100644
index 000000000..435e435bf
--- /dev/null
+++ b/src/population_bio/estimation.ts
@@ -0,0 +1,14 @@
+/** population_bio estimation module — tsb analytics library. */
+export interface PopulationBioEstimationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioEstimationResult { values: number[]; converged: boolean; }
+export function computePopulationBioEstimation(data: number[], opts: PopulationBioEstimationOptions = {}): PopulationBioEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioEstimation };
diff --git a/src/population_bio/evaluation.ts b/src/population_bio/evaluation.ts
new file mode 100644
index 000000000..131fd720c
--- /dev/null
+++ b/src/population_bio/evaluation.ts
@@ -0,0 +1,14 @@
+/** population_bio evaluation module — tsb analytics library. */
+export interface PopulationBioEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioEvaluationResult { values: number[]; converged: boolean; }
+export function computePopulationBioEvaluation(data: number[], opts: PopulationBioEvaluationOptions = {}): PopulationBioEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioEvaluation };
diff --git a/src/population_bio/extrapolation.ts b/src/population_bio/extrapolation.ts
new file mode 100644
index 000000000..dc8afab78
--- /dev/null
+++ b/src/population_bio/extrapolation.ts
@@ -0,0 +1,14 @@
+/** population_bio extrapolation module — tsb analytics library. */
+export interface PopulationBioExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioExtrapolationResult { values: number[]; converged: boolean; }
+export function computePopulationBioExtrapolation(data: number[], opts: PopulationBioExtrapolationOptions = {}): PopulationBioExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioExtrapolation };
diff --git a/src/population_bio/features.ts b/src/population_bio/features.ts
new file mode 100644
index 000000000..38093b086
--- /dev/null
+++ b/src/population_bio/features.ts
@@ -0,0 +1,14 @@
+/** population_bio features module — tsb analytics library. */
+export interface PopulationBioFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioFeaturesResult { values: number[]; converged: boolean; }
+export function computePopulationBioFeatures(data: number[], opts: PopulationBioFeaturesOptions = {}): PopulationBioFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioFeatures };
diff --git a/src/population_bio/feedback.ts b/src/population_bio/feedback.ts
new file mode 100644
index 000000000..d0e2c44c7
--- /dev/null
+++ b/src/population_bio/feedback.ts
@@ -0,0 +1,14 @@
+/** population_bio feedback module — tsb analytics library. */
+export interface PopulationBioFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioFeedbackResult { values: number[]; converged: boolean; }
+export function computePopulationBioFeedback(data: number[], opts: PopulationBioFeedbackOptions = {}): PopulationBioFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioFeedback };
diff --git a/src/population_bio/filtering.ts b/src/population_bio/filtering.ts
new file mode 100644
index 000000000..af812f5f9
--- /dev/null
+++ b/src/population_bio/filtering.ts
@@ -0,0 +1,14 @@
+/** population_bio filtering module — tsb analytics library. */
+export interface PopulationBioFilteringOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioFilteringResult { values: number[]; converged: boolean; }
+export function computePopulationBioFiltering(data: number[], opts: PopulationBioFilteringOptions = {}): PopulationBioFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioFiltering };
diff --git a/src/population_bio/fourier.ts b/src/population_bio/fourier.ts
new file mode 100644
index 000000000..c50e5bb9b
--- /dev/null
+++ b/src/population_bio/fourier.ts
@@ -0,0 +1,14 @@
+/** population_bio fourier module — tsb analytics library. */
+export interface PopulationBioFourierOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioFourierResult { values: number[]; converged: boolean; }
+export function computePopulationBioFourier(data: number[], opts: PopulationBioFourierOptions = {}): PopulationBioFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioFourier };
diff --git a/src/population_bio/fusion.ts b/src/population_bio/fusion.ts
new file mode 100644
index 000000000..7a36f8223
--- /dev/null
+++ b/src/population_bio/fusion.ts
@@ -0,0 +1,14 @@
+/** population_bio fusion module — tsb analytics library. */
+export interface PopulationBioFusionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioFusionResult { values: number[]; converged: boolean; }
+export function computePopulationBioFusion(data: number[], opts: PopulationBioFusionOptions = {}): PopulationBioFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioFusion };
diff --git a/src/population_bio/generation.ts b/src/population_bio/generation.ts
new file mode 100644
index 000000000..fab764f44
--- /dev/null
+++ b/src/population_bio/generation.ts
@@ -0,0 +1,14 @@
+/** population_bio generation module — tsb analytics library. */
+export interface PopulationBioGenerationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioGenerationResult { values: number[]; converged: boolean; }
+export function computePopulationBioGeneration(data: number[], opts: PopulationBioGenerationOptions = {}): PopulationBioGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioGeneration };
diff --git a/src/population_bio/geometry.ts b/src/population_bio/geometry.ts
new file mode 100644
index 000000000..0604b82cc
--- /dev/null
+++ b/src/population_bio/geometry.ts
@@ -0,0 +1,14 @@
+/** population_bio geometry module — tsb analytics library. */
+export interface PopulationBioGeometryOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioGeometryResult { values: number[]; converged: boolean; }
+export function computePopulationBioGeometry(data: number[], opts: PopulationBioGeometryOptions = {}): PopulationBioGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioGeometry };
diff --git a/src/population_bio/gradient.ts b/src/population_bio/gradient.ts
new file mode 100644
index 000000000..7e7efd7ac
--- /dev/null
+++ b/src/population_bio/gradient.ts
@@ -0,0 +1,14 @@
+/** population_bio gradient module — tsb analytics library. */
+export interface PopulationBioGradientOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioGradientResult { values: number[]; converged: boolean; }
+export function computePopulationBioGradient(data: number[], opts: PopulationBioGradientOptions = {}): PopulationBioGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioGradient };
diff --git a/src/population_bio/hessian.ts b/src/population_bio/hessian.ts
new file mode 100644
index 000000000..e547b19cf
--- /dev/null
+++ b/src/population_bio/hessian.ts
@@ -0,0 +1,14 @@
+/** population_bio hessian module — tsb analytics library. */
+export interface PopulationBioHessianOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioHessianResult { values: number[]; converged: boolean; }
+export function computePopulationBioHessian(data: number[], opts: PopulationBioHessianOptions = {}): PopulationBioHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioHessian };
diff --git a/src/population_bio/hypothesis.ts b/src/population_bio/hypothesis.ts
new file mode 100644
index 000000000..160d34038
--- /dev/null
+++ b/src/population_bio/hypothesis.ts
@@ -0,0 +1,14 @@
+/** population_bio hypothesis module — tsb analytics library. */
+export interface PopulationBioHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioHypothesisResult { values: number[]; converged: boolean; }
+export function computePopulationBioHypothesis(data: number[], opts: PopulationBioHypothesisOptions = {}): PopulationBioHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioHypothesis };
diff --git a/src/population_bio/inference.ts b/src/population_bio/inference.ts
new file mode 100644
index 000000000..6a2d13c50
--- /dev/null
+++ b/src/population_bio/inference.ts
@@ -0,0 +1,14 @@
+/** population_bio inference module — tsb analytics library. */
+export interface PopulationBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioInferenceResult { values: number[]; converged: boolean; }
+export function computePopulationBioInference(data: number[], opts: PopulationBioInferenceOptions = {}): PopulationBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioInference };
diff --git a/src/population_bio/inference2.ts b/src/population_bio/inference2.ts
new file mode 100644
index 000000000..68c43a415
--- /dev/null
+++ b/src/population_bio/inference2.ts
@@ -0,0 +1,14 @@
+/** population_bio inference2 module — tsb analytics library. */
+export interface PopulationBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioInferenceResult { values: number[]; converged: boolean; }
+export function computePopulationBioInference(data: number[], opts: PopulationBioInferenceOptions = {}): PopulationBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioInference };
diff --git a/src/population_bio/integral.ts b/src/population_bio/integral.ts
new file mode 100644
index 000000000..5be34cae4
--- /dev/null
+++ b/src/population_bio/integral.ts
@@ -0,0 +1,14 @@
+/** population_bio integral module — tsb analytics library. */
+export interface PopulationBioIntegralOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioIntegralResult { values: number[]; converged: boolean; }
+export function computePopulationBioIntegral(data: number[], opts: PopulationBioIntegralOptions = {}): PopulationBioIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioIntegral };
diff --git a/src/population_bio/integration.ts b/src/population_bio/integration.ts
new file mode 100644
index 000000000..7e4150156
--- /dev/null
+++ b/src/population_bio/integration.ts
@@ -0,0 +1,14 @@
+/** population_bio integration module — tsb analytics library. */
+export interface PopulationBioIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioIntegrationResult { values: number[]; converged: boolean; }
+export function computePopulationBioIntegration(data: number[], opts: PopulationBioIntegrationOptions = {}): PopulationBioIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioIntegration };
diff --git a/src/population_bio/interpolation.ts b/src/population_bio/interpolation.ts
new file mode 100644
index 000000000..e38a82852
--- /dev/null
+++ b/src/population_bio/interpolation.ts
@@ -0,0 +1,14 @@
+/** population_bio interpolation module — tsb analytics library. */
+export interface PopulationBioInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioInterpolationResult { values: number[]; converged: boolean; }
+export function computePopulationBioInterpolation(data: number[], opts: PopulationBioInterpolationOptions = {}): PopulationBioInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioInterpolation };
diff --git a/src/population_bio/jacobian.ts b/src/population_bio/jacobian.ts
new file mode 100644
index 000000000..a381c5ab5
--- /dev/null
+++ b/src/population_bio/jacobian.ts
@@ -0,0 +1,14 @@
+/** population_bio jacobian module — tsb analytics library. */
+export interface PopulationBioJacobianOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioJacobianResult { values: number[]; converged: boolean; }
+export function computePopulationBioJacobian(data: number[], opts: PopulationBioJacobianOptions = {}): PopulationBioJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioJacobian };
diff --git a/src/population_bio/kernel.ts b/src/population_bio/kernel.ts
new file mode 100644
index 000000000..073789c53
--- /dev/null
+++ b/src/population_bio/kernel.ts
@@ -0,0 +1,14 @@
+/** population_bio kernel module — tsb analytics library. */
+export interface PopulationBioKernelOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioKernelResult { values: number[]; converged: boolean; }
+export function computePopulationBioKernel(data: number[], opts: PopulationBioKernelOptions = {}): PopulationBioKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioKernel };
diff --git a/src/population_bio/laplacian.ts b/src/population_bio/laplacian.ts
new file mode 100644
index 000000000..74bf8b2c9
--- /dev/null
+++ b/src/population_bio/laplacian.ts
@@ -0,0 +1,14 @@
+/** population_bio laplacian module — tsb analytics library. */
+export interface PopulationBioLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioLaplacianResult { values: number[]; converged: boolean; }
+export function computePopulationBioLaplacian(data: number[], opts: PopulationBioLaplacianOptions = {}): PopulationBioLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioLaplacian };
diff --git a/src/population_bio/learning.ts b/src/population_bio/learning.ts
new file mode 100644
index 000000000..2d33fbc3a
--- /dev/null
+++ b/src/population_bio/learning.ts
@@ -0,0 +1,14 @@
+/** population_bio learning module — tsb analytics library. */
+export interface PopulationBioLearningOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioLearningResult { values: number[]; converged: boolean; }
+export function computePopulationBioLearning(data: number[], opts: PopulationBioLearningOptions = {}): PopulationBioLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioLearning };
diff --git a/src/population_bio/linear.ts b/src/population_bio/linear.ts
new file mode 100644
index 000000000..412ec908e
--- /dev/null
+++ b/src/population_bio/linear.ts
@@ -0,0 +1,14 @@
+/** population_bio linear module — tsb analytics library. */
+export interface PopulationBioLinearOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioLinearResult { values: number[]; converged: boolean; }
+export function computePopulationBioLinear(data: number[], opts: PopulationBioLinearOptions = {}): PopulationBioLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioLinear };
diff --git a/src/population_bio/manifold.ts b/src/population_bio/manifold.ts
new file mode 100644
index 000000000..95bc7e9d3
--- /dev/null
+++ b/src/population_bio/manifold.ts
@@ -0,0 +1,14 @@
+/** population_bio manifold module — tsb analytics library. */
+export interface PopulationBioManifoldOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioManifoldResult { values: number[]; converged: boolean; }
+export function computePopulationBioManifold(data: number[], opts: PopulationBioManifoldOptions = {}): PopulationBioManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioManifold };
diff --git a/src/population_bio/matching.ts b/src/population_bio/matching.ts
new file mode 100644
index 000000000..e07807c9e
--- /dev/null
+++ b/src/population_bio/matching.ts
@@ -0,0 +1,14 @@
+/** population_bio matching module — tsb analytics library. */
+export interface PopulationBioMatchingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioMatchingResult { values: number[]; converged: boolean; }
+export function computePopulationBioMatching(data: number[], opts: PopulationBioMatchingOptions = {}): PopulationBioMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioMatching };
diff --git a/src/population_bio/measurement.ts b/src/population_bio/measurement.ts
new file mode 100644
index 000000000..8cd39e1ba
--- /dev/null
+++ b/src/population_bio/measurement.ts
@@ -0,0 +1,14 @@
+/** population_bio measurement module — tsb analytics library. */
+export interface PopulationBioMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioMeasurementResult { values: number[]; converged: boolean; }
+export function computePopulationBioMeasurement(data: number[], opts: PopulationBioMeasurementOptions = {}): PopulationBioMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioMeasurement };
diff --git a/src/population_bio/metrics.ts b/src/population_bio/metrics.ts
new file mode 100644
index 000000000..dbba3a066
--- /dev/null
+++ b/src/population_bio/metrics.ts
@@ -0,0 +1,14 @@
+/** population_bio metrics module — tsb analytics library. */
+export interface PopulationBioMetricsOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioMetricsResult { values: number[]; converged: boolean; }
+export function computePopulationBioMetrics(data: number[], opts: PopulationBioMetricsOptions = {}): PopulationBioMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioMetrics };
diff --git a/src/population_bio/modeling.ts b/src/population_bio/modeling.ts
new file mode 100644
index 000000000..fe3c61286
--- /dev/null
+++ b/src/population_bio/modeling.ts
@@ -0,0 +1,14 @@
+/** population_bio modeling module — tsb analytics library. */
+export interface PopulationBioModelingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioModelingResult { values: number[]; converged: boolean; }
+export function computePopulationBioModeling(data: number[], opts: PopulationBioModelingOptions = {}): PopulationBioModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioModeling };
diff --git a/src/population_bio/monitoring.ts b/src/population_bio/monitoring.ts
new file mode 100644
index 000000000..2c335c4f0
--- /dev/null
+++ b/src/population_bio/monitoring.ts
@@ -0,0 +1,14 @@
+/** population_bio monitoring module — tsb analytics library. */
+export interface PopulationBioMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioMonitoringResult { values: number[]; converged: boolean; }
+export function computePopulationBioMonitoring(data: number[], opts: PopulationBioMonitoringOptions = {}): PopulationBioMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioMonitoring };
diff --git a/src/population_bio/nonlinear.ts b/src/population_bio/nonlinear.ts
new file mode 100644
index 000000000..b5067e23a
--- /dev/null
+++ b/src/population_bio/nonlinear.ts
@@ -0,0 +1,14 @@
+/** population_bio nonlinear module — tsb analytics library. */
+export interface PopulationBioNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioNonlinearResult { values: number[]; converged: boolean; }
+export function computePopulationBioNonlinear(data: number[], opts: PopulationBioNonlinearOptions = {}): PopulationBioNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioNonlinear };
diff --git a/src/population_bio/normalization.ts b/src/population_bio/normalization.ts
new file mode 100644
index 000000000..596bf0345
--- /dev/null
+++ b/src/population_bio/normalization.ts
@@ -0,0 +1,14 @@
+/** population_bio normalization module — tsb analytics library. */
+export interface PopulationBioNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioNormalizationResult { values: number[]; converged: boolean; }
+export function computePopulationBioNormalization(data: number[], opts: PopulationBioNormalizationOptions = {}): PopulationBioNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioNormalization };
diff --git a/src/population_bio/optimization.ts b/src/population_bio/optimization.ts
new file mode 100644
index 000000000..fb6150ddb
--- /dev/null
+++ b/src/population_bio/optimization.ts
@@ -0,0 +1,14 @@
+/** population_bio optimization module — tsb analytics library. */
+export interface PopulationBioOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioOptimizationResult { values: number[]; converged: boolean; }
+export function computePopulationBioOptimization(data: number[], opts: PopulationBioOptimizationOptions = {}): PopulationBioOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioOptimization };
diff --git a/src/population_bio/patterns.ts b/src/population_bio/patterns.ts
new file mode 100644
index 000000000..1a8402cca
--- /dev/null
+++ b/src/population_bio/patterns.ts
@@ -0,0 +1,14 @@
+/** population_bio patterns module — tsb analytics library. */
+export interface PopulationBioPatternsOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioPatternsResult { values: number[]; converged: boolean; }
+export function computePopulationBioPatterns(data: number[], opts: PopulationBioPatternsOptions = {}): PopulationBioPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioPatterns };
diff --git a/src/population_bio/permutation.ts b/src/population_bio/permutation.ts
new file mode 100644
index 000000000..912e9d8a1
--- /dev/null
+++ b/src/population_bio/permutation.ts
@@ -0,0 +1,14 @@
+/** population_bio permutation module — tsb analytics library. */
+export interface PopulationBioPermutationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioPermutationResult { values: number[]; converged: boolean; }
+export function computePopulationBioPermutation(data: number[], opts: PopulationBioPermutationOptions = {}): PopulationBioPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioPermutation };
diff --git a/src/population_bio/prediction.ts b/src/population_bio/prediction.ts
new file mode 100644
index 000000000..4a2d9c9ec
--- /dev/null
+++ b/src/population_bio/prediction.ts
@@ -0,0 +1,14 @@
+/** population_bio prediction module — tsb analytics library. */
+export interface PopulationBioPredictionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioPredictionResult { values: number[]; converged: boolean; }
+export function computePopulationBioPrediction(data: number[], opts: PopulationBioPredictionOptions = {}): PopulationBioPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioPrediction };
diff --git a/src/population_bio/processing.ts b/src/population_bio/processing.ts
new file mode 100644
index 000000000..7c3714bc2
--- /dev/null
+++ b/src/population_bio/processing.ts
@@ -0,0 +1,14 @@
+/** population_bio processing module — tsb analytics library. */
+export interface PopulationBioProcessingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioProcessingResult { values: number[]; converged: boolean; }
+export function computePopulationBioProcessing(data: number[], opts: PopulationBioProcessingOptions = {}): PopulationBioProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioProcessing };
diff --git a/src/population_bio/profiling.ts b/src/population_bio/profiling.ts
new file mode 100644
index 000000000..667db2f34
--- /dev/null
+++ b/src/population_bio/profiling.ts
@@ -0,0 +1,14 @@
+/** population_bio profiling module — tsb analytics library. */
+export interface PopulationBioProfilingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioProfilingResult { values: number[]; converged: boolean; }
+export function computePopulationBioProfiling(data: number[], opts: PopulationBioProfilingOptions = {}): PopulationBioProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioProfiling };
diff --git a/src/population_bio/projection.ts b/src/population_bio/projection.ts
new file mode 100644
index 000000000..f23f5c72d
--- /dev/null
+++ b/src/population_bio/projection.ts
@@ -0,0 +1,14 @@
+/** population_bio projection module — tsb analytics library. */
+export interface PopulationBioProjectionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioProjectionResult { values: number[]; converged: boolean; }
+export function computePopulationBioProjection(data: number[], opts: PopulationBioProjectionOptions = {}): PopulationBioProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioProjection };
diff --git a/src/population_bio/ranking.ts b/src/population_bio/ranking.ts
new file mode 100644
index 000000000..e6dfe1d5b
--- /dev/null
+++ b/src/population_bio/ranking.ts
@@ -0,0 +1,14 @@
+/** population_bio ranking module — tsb analytics library. */
+export interface PopulationBioRankingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioRankingResult { values: number[]; converged: boolean; }
+export function computePopulationBioRanking(data: number[], opts: PopulationBioRankingOptions = {}): PopulationBioRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioRanking };
diff --git a/src/population_bio/reconstruction.ts b/src/population_bio/reconstruction.ts
new file mode 100644
index 000000000..a9ab85656
--- /dev/null
+++ b/src/population_bio/reconstruction.ts
@@ -0,0 +1,14 @@
+/** population_bio reconstruction module — tsb analytics library. */
+export interface PopulationBioReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioReconstructionResult { values: number[]; converged: boolean; }
+export function computePopulationBioReconstruction(data: number[], opts: PopulationBioReconstructionOptions = {}): PopulationBioReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioReconstruction };
diff --git a/src/population_bio/registration.ts b/src/population_bio/registration.ts
new file mode 100644
index 000000000..a2bd706f8
--- /dev/null
+++ b/src/population_bio/registration.ts
@@ -0,0 +1,14 @@
+/** population_bio registration module — tsb analytics library. */
+export interface PopulationBioRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioRegistrationResult { values: number[]; converged: boolean; }
+export function computePopulationBioRegistration(data: number[], opts: PopulationBioRegistrationOptions = {}): PopulationBioRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioRegistration };
diff --git a/src/population_bio/regression.ts b/src/population_bio/regression.ts
new file mode 100644
index 000000000..16d0097ae
--- /dev/null
+++ b/src/population_bio/regression.ts
@@ -0,0 +1,14 @@
+/** population_bio regression module — tsb analytics library. */
+export interface PopulationBioRegressionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioRegressionResult { values: number[]; converged: boolean; }
+export function computePopulationBioRegression(data: number[], opts: PopulationBioRegressionOptions = {}): PopulationBioRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioRegression };
diff --git a/src/population_bio/regularization.ts b/src/population_bio/regularization.ts
new file mode 100644
index 000000000..be6a986e4
--- /dev/null
+++ b/src/population_bio/regularization.ts
@@ -0,0 +1,14 @@
+/** population_bio regularization module — tsb analytics library. */
+export interface PopulationBioRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioRegularizationResult { values: number[]; converged: boolean; }
+export function computePopulationBioRegularization(data: number[], opts: PopulationBioRegularizationOptions = {}): PopulationBioRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioRegularization };
diff --git a/src/population_bio/robustness.ts b/src/population_bio/robustness.ts
new file mode 100644
index 000000000..c3a6ec800
--- /dev/null
+++ b/src/population_bio/robustness.ts
@@ -0,0 +1,14 @@
+/** population_bio robustness module — tsb analytics library. */
+export interface PopulationBioRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioRobustnessResult { values: number[]; converged: boolean; }
+export function computePopulationBioRobustness(data: number[], opts: PopulationBioRobustnessOptions = {}): PopulationBioRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioRobustness };
diff --git a/src/population_bio/sampling.ts b/src/population_bio/sampling.ts
new file mode 100644
index 000000000..9f8db2ebc
--- /dev/null
+++ b/src/population_bio/sampling.ts
@@ -0,0 +1,14 @@
+/** population_bio sampling module — tsb analytics library. */
+export interface PopulationBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioSamplingResult { values: number[]; converged: boolean; }
+export function computePopulationBioSampling(data: number[], opts: PopulationBioSamplingOptions = {}): PopulationBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioSampling };
diff --git a/src/population_bio/sampling2.ts b/src/population_bio/sampling2.ts
new file mode 100644
index 000000000..8e7381e93
--- /dev/null
+++ b/src/population_bio/sampling2.ts
@@ -0,0 +1,14 @@
+/** population_bio sampling2 module — tsb analytics library. */
+export interface PopulationBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioSamplingResult { values: number[]; converged: boolean; }
+export function computePopulationBioSampling(data: number[], opts: PopulationBioSamplingOptions = {}): PopulationBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioSampling };
diff --git a/src/population_bio/scaling.ts b/src/population_bio/scaling.ts
new file mode 100644
index 000000000..6cbbbd7a1
--- /dev/null
+++ b/src/population_bio/scaling.ts
@@ -0,0 +1,14 @@
+/** population_bio scaling module — tsb analytics library. */
+export interface PopulationBioScalingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioScalingResult { values: number[]; converged: boolean; }
+export function computePopulationBioScaling(data: number[], opts: PopulationBioScalingOptions = {}): PopulationBioScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioScaling };
diff --git a/src/population_bio/scoring.ts b/src/population_bio/scoring.ts
new file mode 100644
index 000000000..f585dc893
--- /dev/null
+++ b/src/population_bio/scoring.ts
@@ -0,0 +1,14 @@
+/** population_bio scoring module — tsb analytics library. */
+export interface PopulationBioScoringOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioScoringResult { values: number[]; converged: boolean; }
+export function computePopulationBioScoring(data: number[], opts: PopulationBioScoringOptions = {}): PopulationBioScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioScoring };
diff --git a/src/population_bio/segmentation.ts b/src/population_bio/segmentation.ts
new file mode 100644
index 000000000..624c169b8
--- /dev/null
+++ b/src/population_bio/segmentation.ts
@@ -0,0 +1,14 @@
+/** population_bio segmentation module — tsb analytics library. */
+export interface PopulationBioSegmentationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioSegmentationResult { values: number[]; converged: boolean; }
+export function computePopulationBioSegmentation(data: number[], opts: PopulationBioSegmentationOptions = {}): PopulationBioSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioSegmentation };
diff --git a/src/population_bio/selection.ts b/src/population_bio/selection.ts
new file mode 100644
index 000000000..1d77ee611
--- /dev/null
+++ b/src/population_bio/selection.ts
@@ -0,0 +1,14 @@
+/** population_bio selection module — tsb analytics library. */
+export interface PopulationBioSelectionOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioSelectionResult { values: number[]; converged: boolean; }
+export function computePopulationBioSelection(data: number[], opts: PopulationBioSelectionOptions = {}): PopulationBioSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioSelection };
diff --git a/src/population_bio/sensitivity.ts b/src/population_bio/sensitivity.ts
new file mode 100644
index 000000000..cce3ca3b1
--- /dev/null
+++ b/src/population_bio/sensitivity.ts
@@ -0,0 +1,14 @@
+/** population_bio sensitivity module — tsb analytics library. */
+export interface PopulationBioSensitivityOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioSensitivityResult { values: number[]; converged: boolean; }
+export function computePopulationBioSensitivity(data: number[], opts: PopulationBioSensitivityOptions = {}): PopulationBioSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioSensitivity };
diff --git a/src/population_bio/simulation.ts b/src/population_bio/simulation.ts
new file mode 100644
index 000000000..a7952340c
--- /dev/null
+++ b/src/population_bio/simulation.ts
@@ -0,0 +1,14 @@
+/** population_bio simulation module — tsb analytics library. */
+export interface PopulationBioSimulationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioSimulationResult { values: number[]; converged: boolean; }
+export function computePopulationBioSimulation(data: number[], opts: PopulationBioSimulationOptions = {}): PopulationBioSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioSimulation };
diff --git a/src/population_bio/smoothing.ts b/src/population_bio/smoothing.ts
new file mode 100644
index 000000000..f9a21fd51
--- /dev/null
+++ b/src/population_bio/smoothing.ts
@@ -0,0 +1,14 @@
+/** population_bio smoothing module — tsb analytics library. */
+export interface PopulationBioSmoothingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioSmoothingResult { values: number[]; converged: boolean; }
+export function computePopulationBioSmoothing(data: number[], opts: PopulationBioSmoothingOptions = {}): PopulationBioSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioSmoothing };
diff --git a/src/population_bio/stability.ts b/src/population_bio/stability.ts
new file mode 100644
index 000000000..487da0314
--- /dev/null
+++ b/src/population_bio/stability.ts
@@ -0,0 +1,14 @@
+/** population_bio stability module — tsb analytics library. */
+export interface PopulationBioStabilityOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioStabilityResult { values: number[]; converged: boolean; }
+export function computePopulationBioStability(data: number[], opts: PopulationBioStabilityOptions = {}): PopulationBioStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioStability };
diff --git a/src/population_bio/stacking.ts b/src/population_bio/stacking.ts
new file mode 100644
index 000000000..6be7aba01
--- /dev/null
+++ b/src/population_bio/stacking.ts
@@ -0,0 +1,14 @@
+/** population_bio stacking module — tsb analytics library. */
+export interface PopulationBioStackingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioStackingResult { values: number[]; converged: boolean; }
+export function computePopulationBioStacking(data: number[], opts: PopulationBioStackingOptions = {}): PopulationBioStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioStacking };
diff --git a/src/population_bio/standardization.ts b/src/population_bio/standardization.ts
new file mode 100644
index 000000000..7c853a7e7
--- /dev/null
+++ b/src/population_bio/standardization.ts
@@ -0,0 +1,14 @@
+/** population_bio standardization module — tsb analytics library. */
+export interface PopulationBioStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioStandardizationResult { values: number[]; converged: boolean; }
+export function computePopulationBioStandardization(data: number[], opts: PopulationBioStandardizationOptions = {}): PopulationBioStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioStandardization };
diff --git a/src/population_bio/static.ts b/src/population_bio/static.ts
new file mode 100644
index 000000000..dd779c23d
--- /dev/null
+++ b/src/population_bio/static.ts
@@ -0,0 +1,14 @@
+/** population_bio static module — tsb analytics library. */
+export interface PopulationBioStaticOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioStaticResult { values: number[]; converged: boolean; }
+export function computePopulationBioStatic(data: number[], opts: PopulationBioStaticOptions = {}): PopulationBioStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioStatic };
diff --git a/src/population_bio/stochastic.ts b/src/population_bio/stochastic.ts
new file mode 100644
index 000000000..693229746
--- /dev/null
+++ b/src/population_bio/stochastic.ts
@@ -0,0 +1,14 @@
+/** population_bio stochastic module — tsb analytics library. */
+export interface PopulationBioStochasticOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioStochasticResult { values: number[]; converged: boolean; }
+export function computePopulationBioStochastic(data: number[], opts: PopulationBioStochasticOptions = {}): PopulationBioStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioStochastic };
diff --git a/src/population_bio/synthesis.ts b/src/population_bio/synthesis.ts
new file mode 100644
index 000000000..2ee97c451
--- /dev/null
+++ b/src/population_bio/synthesis.ts
@@ -0,0 +1,14 @@
+/** population_bio synthesis module — tsb analytics library. */
+export interface PopulationBioSynthesisOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioSynthesisResult { values: number[]; converged: boolean; }
+export function computePopulationBioSynthesis(data: number[], opts: PopulationBioSynthesisOptions = {}): PopulationBioSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioSynthesis };
diff --git a/src/population_bio/topology.ts b/src/population_bio/topology.ts
new file mode 100644
index 000000000..910b1fe33
--- /dev/null
+++ b/src/population_bio/topology.ts
@@ -0,0 +1,14 @@
+/** population_bio topology module — tsb analytics library. */
+export interface PopulationBioTopologyOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioTopologyResult { values: number[]; converged: boolean; }
+export function computePopulationBioTopology(data: number[], opts: PopulationBioTopologyOptions = {}): PopulationBioTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioTopology };
diff --git a/src/population_bio/tracking.ts b/src/population_bio/tracking.ts
new file mode 100644
index 000000000..f8a9b665c
--- /dev/null
+++ b/src/population_bio/tracking.ts
@@ -0,0 +1,14 @@
+/** population_bio tracking module — tsb analytics library. */
+export interface PopulationBioTrackingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioTrackingResult { values: number[]; converged: boolean; }
+export function computePopulationBioTracking(data: number[], opts: PopulationBioTrackingOptions = {}): PopulationBioTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioTracking };
diff --git a/src/population_bio/transform.ts b/src/population_bio/transform.ts
new file mode 100644
index 000000000..147b4029d
--- /dev/null
+++ b/src/population_bio/transform.ts
@@ -0,0 +1,14 @@
+/** population_bio transform module — tsb analytics library. */
+export interface PopulationBioTransformOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioTransformResult { values: number[]; converged: boolean; }
+export function computePopulationBioTransform(data: number[], opts: PopulationBioTransformOptions = {}): PopulationBioTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioTransform };
diff --git a/src/population_bio/uncertainty.ts b/src/population_bio/uncertainty.ts
new file mode 100644
index 000000000..b73b7d12d
--- /dev/null
+++ b/src/population_bio/uncertainty.ts
@@ -0,0 +1,14 @@
+/** population_bio uncertainty module — tsb analytics library. */
+export interface PopulationBioUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioUncertaintyResult { values: number[]; converged: boolean; }
+export function computePopulationBioUncertainty(data: number[], opts: PopulationBioUncertaintyOptions = {}): PopulationBioUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioUncertainty };
diff --git a/src/population_bio/validation.ts b/src/population_bio/validation.ts
new file mode 100644
index 000000000..805094127
--- /dev/null
+++ b/src/population_bio/validation.ts
@@ -0,0 +1,14 @@
+/** population_bio validation module — tsb analytics library. */
+export interface PopulationBioValidationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioValidationResult { values: number[]; converged: boolean; }
+export function computePopulationBioValidation(data: number[], opts: PopulationBioValidationOptions = {}): PopulationBioValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioValidation };
diff --git a/src/population_bio/verification.ts b/src/population_bio/verification.ts
new file mode 100644
index 000000000..3bf0c465e
--- /dev/null
+++ b/src/population_bio/verification.ts
@@ -0,0 +1,14 @@
+/** population_bio verification module — tsb analytics library. */
+export interface PopulationBioVerificationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioVerificationResult { values: number[]; converged: boolean; }
+export function computePopulationBioVerification(data: number[], opts: PopulationBioVerificationOptions = {}): PopulationBioVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioVerification };
diff --git a/src/population_bio/visualization.ts b/src/population_bio/visualization.ts
new file mode 100644
index 000000000..69cc037a2
--- /dev/null
+++ b/src/population_bio/visualization.ts
@@ -0,0 +1,14 @@
+/** population_bio visualization module — tsb analytics library. */
+export interface PopulationBioVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioVisualizationResult { values: number[]; converged: boolean; }
+export function computePopulationBioVisualization(data: number[], opts: PopulationBioVisualizationOptions = {}): PopulationBioVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioVisualization };
diff --git a/src/population_bio/voting.ts b/src/population_bio/voting.ts
new file mode 100644
index 000000000..b2560ebe8
--- /dev/null
+++ b/src/population_bio/voting.ts
@@ -0,0 +1,14 @@
+/** population_bio voting module — tsb analytics library. */
+export interface PopulationBioVotingOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioVotingResult { values: number[]; converged: boolean; }
+export function computePopulationBioVoting(data: number[], opts: PopulationBioVotingOptions = {}): PopulationBioVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioVoting };
diff --git a/src/population_bio/wavelet.ts b/src/population_bio/wavelet.ts
new file mode 100644
index 000000000..93b993487
--- /dev/null
+++ b/src/population_bio/wavelet.ts
@@ -0,0 +1,14 @@
+/** population_bio wavelet module — tsb analytics library. */
+export interface PopulationBioWaveletOptions { tol?: number; maxIter?: number; }
+export interface PopulationBioWaveletResult { values: number[]; converged: boolean; }
+export function computePopulationBioWavelet(data: number[], opts: PopulationBioWaveletOptions = {}): PopulationBioWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePopulationBioWavelet };
diff --git a/src/proteomics_sci/adaptation.ts b/src/proteomics_sci/adaptation.ts
new file mode 100644
index 000000000..13da19c83
--- /dev/null
+++ b/src/proteomics_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci adaptation module — tsb analytics library. */
+export interface ProteomicsSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciAdaptation(data: number[], opts: ProteomicsSciAdaptationOptions = {}): ProteomicsSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciAdaptation };
diff --git a/src/proteomics_sci/aggregation.ts b/src/proteomics_sci/aggregation.ts
new file mode 100644
index 000000000..e5709fc73
--- /dev/null
+++ b/src/proteomics_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci aggregation module — tsb analytics library. */
+export interface ProteomicsSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciAggregationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciAggregation(data: number[], opts: ProteomicsSciAggregationOptions = {}): ProteomicsSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciAggregation };
diff --git a/src/proteomics_sci/algebra.ts b/src/proteomics_sci/algebra.ts
new file mode 100644
index 000000000..fa8f4e2a8
--- /dev/null
+++ b/src/proteomics_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci algebra module — tsb analytics library. */
+export interface ProteomicsSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciAlgebra(data: number[], opts: ProteomicsSciAlgebraOptions = {}): ProteomicsSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciAlgebra };
diff --git a/src/proteomics_sci/alignment.ts b/src/proteomics_sci/alignment.ts
new file mode 100644
index 000000000..b1fbdd65c
--- /dev/null
+++ b/src/proteomics_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci alignment module — tsb analytics library. */
+export interface ProteomicsSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciAlignment(data: number[], opts: ProteomicsSciAlignmentOptions = {}): ProteomicsSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciAlignment };
diff --git a/src/proteomics_sci/analysis.ts b/src/proteomics_sci/analysis.ts
new file mode 100644
index 000000000..6824fc637
--- /dev/null
+++ b/src/proteomics_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci analysis module — tsb analytics library. */
+export interface ProteomicsSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciAnalysis(data: number[], opts: ProteomicsSciAnalysisOptions = {}): ProteomicsSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciAnalysis };
diff --git a/src/proteomics_sci/augmentation.ts b/src/proteomics_sci/augmentation.ts
new file mode 100644
index 000000000..5121d46df
--- /dev/null
+++ b/src/proteomics_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci augmentation module — tsb analytics library. */
+export interface ProteomicsSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciAugmentation(data: number[], opts: ProteomicsSciAugmentationOptions = {}): ProteomicsSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciAugmentation };
diff --git a/src/proteomics_sci/bagging.ts b/src/proteomics_sci/bagging.ts
new file mode 100644
index 000000000..266d4379e
--- /dev/null
+++ b/src/proteomics_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci bagging module — tsb analytics library. */
+export interface ProteomicsSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciBaggingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciBagging(data: number[], opts: ProteomicsSciBaggingOptions = {}): ProteomicsSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciBagging };
diff --git a/src/proteomics_sci/basis.ts b/src/proteomics_sci/basis.ts
new file mode 100644
index 000000000..1464a1dba
--- /dev/null
+++ b/src/proteomics_sci/basis.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci basis module — tsb analytics library. */
+export interface ProteomicsSciBasisOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciBasisResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciBasis(data: number[], opts: ProteomicsSciBasisOptions = {}): ProteomicsSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciBasis };
diff --git a/src/proteomics_sci/benchmarking.ts b/src/proteomics_sci/benchmarking.ts
new file mode 100644
index 000000000..8940a73cd
--- /dev/null
+++ b/src/proteomics_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci benchmarking module — tsb analytics library. */
+export interface ProteomicsSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciBenchmarking(data: number[], opts: ProteomicsSciBenchmarkingOptions = {}): ProteomicsSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciBenchmarking };
diff --git a/src/proteomics_sci/blending.ts b/src/proteomics_sci/blending.ts
new file mode 100644
index 000000000..06eb643cd
--- /dev/null
+++ b/src/proteomics_sci/blending.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci blending module — tsb analytics library. */
+export interface ProteomicsSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciBlendingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciBlending(data: number[], opts: ProteomicsSciBlendingOptions = {}): ProteomicsSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciBlending };
diff --git a/src/proteomics_sci/boosting.ts b/src/proteomics_sci/boosting.ts
new file mode 100644
index 000000000..d92f1caf3
--- /dev/null
+++ b/src/proteomics_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci boosting module — tsb analytics library. */
+export interface ProteomicsSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciBoostingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciBoosting(data: number[], opts: ProteomicsSciBoostingOptions = {}): ProteomicsSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciBoosting };
diff --git a/src/proteomics_sci/bootstrap.ts b/src/proteomics_sci/bootstrap.ts
new file mode 100644
index 000000000..b69d32a3e
--- /dev/null
+++ b/src/proteomics_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci bootstrap module — tsb analytics library. */
+export interface ProteomicsSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciBootstrap(data: number[], opts: ProteomicsSciBootstrapOptions = {}): ProteomicsSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciBootstrap };
diff --git a/src/proteomics_sci/calculus.ts b/src/proteomics_sci/calculus.ts
new file mode 100644
index 000000000..27eaa455a
--- /dev/null
+++ b/src/proteomics_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci calculus module — tsb analytics library. */
+export interface ProteomicsSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciCalculusResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciCalculus(data: number[], opts: ProteomicsSciCalculusOptions = {}): ProteomicsSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciCalculus };
diff --git a/src/proteomics_sci/calibration.ts b/src/proteomics_sci/calibration.ts
new file mode 100644
index 000000000..ce11f3c31
--- /dev/null
+++ b/src/proteomics_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci calibration module — tsb analytics library. */
+export interface ProteomicsSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciCalibration(data: number[], opts: ProteomicsSciCalibrationOptions = {}): ProteomicsSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciCalibration };
diff --git a/src/proteomics_sci/characterization.ts b/src/proteomics_sci/characterization.ts
new file mode 100644
index 000000000..be8711f0c
--- /dev/null
+++ b/src/proteomics_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci characterization module — tsb analytics library. */
+export interface ProteomicsSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciCharacterization(data: number[], opts: ProteomicsSciCharacterizationOptions = {}): ProteomicsSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciCharacterization };
diff --git a/src/proteomics_sci/classification.ts b/src/proteomics_sci/classification.ts
new file mode 100644
index 000000000..68612e6f5
--- /dev/null
+++ b/src/proteomics_sci/classification.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci classification module — tsb analytics library. */
+export interface ProteomicsSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciClassificationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciClassification(data: number[], opts: ProteomicsSciClassificationOptions = {}): ProteomicsSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciClassification };
diff --git a/src/proteomics_sci/clustering.ts b/src/proteomics_sci/clustering.ts
new file mode 100644
index 000000000..7b03b6107
--- /dev/null
+++ b/src/proteomics_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci clustering module — tsb analytics library. */
+export interface ProteomicsSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciClusteringResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciClustering(data: number[], opts: ProteomicsSciClusteringOptions = {}): ProteomicsSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciClustering };
diff --git a/src/proteomics_sci/compression.ts b/src/proteomics_sci/compression.ts
new file mode 100644
index 000000000..f492b37db
--- /dev/null
+++ b/src/proteomics_sci/compression.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci compression module — tsb analytics library. */
+export interface ProteomicsSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciCompressionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciCompression(data: number[], opts: ProteomicsSciCompressionOptions = {}): ProteomicsSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciCompression };
diff --git a/src/proteomics_sci/continuous.ts b/src/proteomics_sci/continuous.ts
new file mode 100644
index 000000000..91cbc391d
--- /dev/null
+++ b/src/proteomics_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci continuous module — tsb analytics library. */
+export interface ProteomicsSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciContinuousResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciContinuous(data: number[], opts: ProteomicsSciContinuousOptions = {}): ProteomicsSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciContinuous };
diff --git a/src/proteomics_sci/control.ts b/src/proteomics_sci/control.ts
new file mode 100644
index 000000000..7504a3787
--- /dev/null
+++ b/src/proteomics_sci/control.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci control module — tsb analytics library. */
+export interface ProteomicsSciControlOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciControlResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciControl(data: number[], opts: ProteomicsSciControlOptions = {}): ProteomicsSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciControl };
diff --git a/src/proteomics_sci/convergence.ts b/src/proteomics_sci/convergence.ts
new file mode 100644
index 000000000..a1d5442a8
--- /dev/null
+++ b/src/proteomics_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci convergence module — tsb analytics library. */
+export interface ProteomicsSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciConvergence(data: number[], opts: ProteomicsSciConvergenceOptions = {}): ProteomicsSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciConvergence };
diff --git a/src/proteomics_sci/convex.ts b/src/proteomics_sci/convex.ts
new file mode 100644
index 000000000..622878a9c
--- /dev/null
+++ b/src/proteomics_sci/convex.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci convex module — tsb analytics library. */
+export interface ProteomicsSciConvexOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciConvexResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciConvex(data: number[], opts: ProteomicsSciConvexOptions = {}): ProteomicsSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciConvex };
diff --git a/src/proteomics_sci/correlation.ts b/src/proteomics_sci/correlation.ts
new file mode 100644
index 000000000..88eb3003b
--- /dev/null
+++ b/src/proteomics_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci correlation module — tsb analytics library. */
+export interface ProteomicsSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciCorrelation(data: number[], opts: ProteomicsSciCorrelationOptions = {}): ProteomicsSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciCorrelation };
diff --git a/src/proteomics_sci/covariance.ts b/src/proteomics_sci/covariance.ts
new file mode 100644
index 000000000..da171740c
--- /dev/null
+++ b/src/proteomics_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci covariance module — tsb analytics library. */
+export interface ProteomicsSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciCovariance(data: number[], opts: ProteomicsSciCovarianceOptions = {}): ProteomicsSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciCovariance };
diff --git a/src/proteomics_sci/cross_validation.ts b/src/proteomics_sci/cross_validation.ts
new file mode 100644
index 000000000..7e30531ee
--- /dev/null
+++ b/src/proteomics_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci cross_validation module — tsb analytics library. */
+export interface ProteomicsSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciCrossValidation(data: number[], opts: ProteomicsSciCrossValidationOptions = {}): ProteomicsSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciCrossValidation };
diff --git a/src/proteomics_sci/decoding.ts b/src/proteomics_sci/decoding.ts
new file mode 100644
index 000000000..a681ba84a
--- /dev/null
+++ b/src/proteomics_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci decoding module — tsb analytics library. */
+export interface ProteomicsSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDecodingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDecoding(data: number[], opts: ProteomicsSciDecodingOptions = {}): ProteomicsSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDecoding };
diff --git a/src/proteomics_sci/decomposition.ts b/src/proteomics_sci/decomposition.ts
new file mode 100644
index 000000000..9d1b4cfd6
--- /dev/null
+++ b/src/proteomics_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci decomposition module — tsb analytics library. */
+export interface ProteomicsSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDecomposition(data: number[], opts: ProteomicsSciDecompositionOptions = {}): ProteomicsSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDecomposition };
diff --git a/src/proteomics_sci/detection.ts b/src/proteomics_sci/detection.ts
new file mode 100644
index 000000000..ab94da3e3
--- /dev/null
+++ b/src/proteomics_sci/detection.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci detection module — tsb analytics library. */
+export interface ProteomicsSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDetectionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDetection(data: number[], opts: ProteomicsSciDetectionOptions = {}): ProteomicsSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDetection };
diff --git a/src/proteomics_sci/deterministic.ts b/src/proteomics_sci/deterministic.ts
new file mode 100644
index 000000000..8b4c44379
--- /dev/null
+++ b/src/proteomics_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci deterministic module — tsb analytics library. */
+export interface ProteomicsSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDeterministic(data: number[], opts: ProteomicsSciDeterministicOptions = {}): ProteomicsSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDeterministic };
diff --git a/src/proteomics_sci/diagnostics.ts b/src/proteomics_sci/diagnostics.ts
new file mode 100644
index 000000000..cff7b1528
--- /dev/null
+++ b/src/proteomics_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci diagnostics module — tsb analytics library. */
+export interface ProteomicsSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDiagnostics(data: number[], opts: ProteomicsSciDiagnosticsOptions = {}): ProteomicsSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDiagnostics };
diff --git a/src/proteomics_sci/differential.ts b/src/proteomics_sci/differential.ts
new file mode 100644
index 000000000..2bb80af97
--- /dev/null
+++ b/src/proteomics_sci/differential.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci differential module — tsb analytics library. */
+export interface ProteomicsSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDifferential(data: number[], opts: ProteomicsSciDifferentialOptions = {}): ProteomicsSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDifferential };
diff --git a/src/proteomics_sci/discrete.ts b/src/proteomics_sci/discrete.ts
new file mode 100644
index 000000000..d1200af15
--- /dev/null
+++ b/src/proteomics_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci discrete module — tsb analytics library. */
+export interface ProteomicsSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDiscrete(data: number[], opts: ProteomicsSciDiscreteOptions = {}): ProteomicsSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDiscrete };
diff --git a/src/proteomics_sci/distribution.ts b/src/proteomics_sci/distribution.ts
new file mode 100644
index 000000000..a4997cb40
--- /dev/null
+++ b/src/proteomics_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci distribution module — tsb analytics library. */
+export interface ProteomicsSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDistributionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDistribution(data: number[], opts: ProteomicsSciDistributionOptions = {}): ProteomicsSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDistribution };
diff --git a/src/proteomics_sci/dynamic.ts b/src/proteomics_sci/dynamic.ts
new file mode 100644
index 000000000..5763070ea
--- /dev/null
+++ b/src/proteomics_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci dynamic module — tsb analytics library. */
+export interface ProteomicsSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciDynamicResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciDynamic(data: number[], opts: ProteomicsSciDynamicOptions = {}): ProteomicsSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciDynamic };
diff --git a/src/proteomics_sci/embedding.ts b/src/proteomics_sci/embedding.ts
new file mode 100644
index 000000000..c184e3663
--- /dev/null
+++ b/src/proteomics_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci embedding module — tsb analytics library. */
+export interface ProteomicsSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciEmbedding(data: number[], opts: ProteomicsSciEmbeddingOptions = {}): ProteomicsSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciEmbedding };
diff --git a/src/proteomics_sci/encoding.ts b/src/proteomics_sci/encoding.ts
new file mode 100644
index 000000000..de863dc14
--- /dev/null
+++ b/src/proteomics_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci encoding module — tsb analytics library. */
+export interface ProteomicsSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciEncodingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciEncoding(data: number[], opts: ProteomicsSciEncodingOptions = {}): ProteomicsSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciEncoding };
diff --git a/src/proteomics_sci/ensemble.ts b/src/proteomics_sci/ensemble.ts
new file mode 100644
index 000000000..f019416bf
--- /dev/null
+++ b/src/proteomics_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci ensemble module — tsb analytics library. */
+export interface ProteomicsSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciEnsemble(data: number[], opts: ProteomicsSciEnsembleOptions = {}): ProteomicsSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciEnsemble };
diff --git a/src/proteomics_sci/estimation.ts b/src/proteomics_sci/estimation.ts
new file mode 100644
index 000000000..ec25b0a7e
--- /dev/null
+++ b/src/proteomics_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci estimation module — tsb analytics library. */
+export interface ProteomicsSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciEstimationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciEstimation(data: number[], opts: ProteomicsSciEstimationOptions = {}): ProteomicsSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciEstimation };
diff --git a/src/proteomics_sci/evaluation.ts b/src/proteomics_sci/evaluation.ts
new file mode 100644
index 000000000..6d2ffcab0
--- /dev/null
+++ b/src/proteomics_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci evaluation module — tsb analytics library. */
+export interface ProteomicsSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciEvaluation(data: number[], opts: ProteomicsSciEvaluationOptions = {}): ProteomicsSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciEvaluation };
diff --git a/src/proteomics_sci/extrapolation.ts b/src/proteomics_sci/extrapolation.ts
new file mode 100644
index 000000000..b966c011f
--- /dev/null
+++ b/src/proteomics_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci extrapolation module — tsb analytics library. */
+export interface ProteomicsSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciExtrapolation(data: number[], opts: ProteomicsSciExtrapolationOptions = {}): ProteomicsSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciExtrapolation };
diff --git a/src/proteomics_sci/features.ts b/src/proteomics_sci/features.ts
new file mode 100644
index 000000000..b74e16ee8
--- /dev/null
+++ b/src/proteomics_sci/features.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci features module — tsb analytics library. */
+export interface ProteomicsSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciFeatures(data: number[], opts: ProteomicsSciFeaturesOptions = {}): ProteomicsSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciFeatures };
diff --git a/src/proteomics_sci/feedback.ts b/src/proteomics_sci/feedback.ts
new file mode 100644
index 000000000..443812310
--- /dev/null
+++ b/src/proteomics_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci feedback module — tsb analytics library. */
+export interface ProteomicsSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciFeedback(data: number[], opts: ProteomicsSciFeedbackOptions = {}): ProteomicsSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciFeedback };
diff --git a/src/proteomics_sci/filtering.ts b/src/proteomics_sci/filtering.ts
new file mode 100644
index 000000000..790542606
--- /dev/null
+++ b/src/proteomics_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci filtering module — tsb analytics library. */
+export interface ProteomicsSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciFilteringResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciFiltering(data: number[], opts: ProteomicsSciFilteringOptions = {}): ProteomicsSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciFiltering };
diff --git a/src/proteomics_sci/fourier.ts b/src/proteomics_sci/fourier.ts
new file mode 100644
index 000000000..455bb759d
--- /dev/null
+++ b/src/proteomics_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci fourier module — tsb analytics library. */
+export interface ProteomicsSciFourierOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciFourierResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciFourier(data: number[], opts: ProteomicsSciFourierOptions = {}): ProteomicsSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciFourier };
diff --git a/src/proteomics_sci/fusion.ts b/src/proteomics_sci/fusion.ts
new file mode 100644
index 000000000..7ff864269
--- /dev/null
+++ b/src/proteomics_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci fusion module — tsb analytics library. */
+export interface ProteomicsSciFusionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciFusionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciFusion(data: number[], opts: ProteomicsSciFusionOptions = {}): ProteomicsSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciFusion };
diff --git a/src/proteomics_sci/generation.ts b/src/proteomics_sci/generation.ts
new file mode 100644
index 000000000..5eb151746
--- /dev/null
+++ b/src/proteomics_sci/generation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci generation module — tsb analytics library. */
+export interface ProteomicsSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciGenerationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciGeneration(data: number[], opts: ProteomicsSciGenerationOptions = {}): ProteomicsSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciGeneration };
diff --git a/src/proteomics_sci/geometry.ts b/src/proteomics_sci/geometry.ts
new file mode 100644
index 000000000..0cb68cfce
--- /dev/null
+++ b/src/proteomics_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci geometry module — tsb analytics library. */
+export interface ProteomicsSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciGeometryResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciGeometry(data: number[], opts: ProteomicsSciGeometryOptions = {}): ProteomicsSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciGeometry };
diff --git a/src/proteomics_sci/gradient.ts b/src/proteomics_sci/gradient.ts
new file mode 100644
index 000000000..c3406ed65
--- /dev/null
+++ b/src/proteomics_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci gradient module — tsb analytics library. */
+export interface ProteomicsSciGradientOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciGradientResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciGradient(data: number[], opts: ProteomicsSciGradientOptions = {}): ProteomicsSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciGradient };
diff --git a/src/proteomics_sci/hessian.ts b/src/proteomics_sci/hessian.ts
new file mode 100644
index 000000000..1c3bb0839
--- /dev/null
+++ b/src/proteomics_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci hessian module — tsb analytics library. */
+export interface ProteomicsSciHessianOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciHessianResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciHessian(data: number[], opts: ProteomicsSciHessianOptions = {}): ProteomicsSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciHessian };
diff --git a/src/proteomics_sci/hypothesis.ts b/src/proteomics_sci/hypothesis.ts
new file mode 100644
index 000000000..23a99c15b
--- /dev/null
+++ b/src/proteomics_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci hypothesis module — tsb analytics library. */
+export interface ProteomicsSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciHypothesis(data: number[], opts: ProteomicsSciHypothesisOptions = {}): ProteomicsSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciHypothesis };
diff --git a/src/proteomics_sci/inference.ts b/src/proteomics_sci/inference.ts
new file mode 100644
index 000000000..c50363d88
--- /dev/null
+++ b/src/proteomics_sci/inference.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci inference module — tsb analytics library. */
+export interface ProteomicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciInference(data: number[], opts: ProteomicsSciInferenceOptions = {}): ProteomicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciInference };
diff --git a/src/proteomics_sci/inference2.ts b/src/proteomics_sci/inference2.ts
new file mode 100644
index 000000000..808f2e7ed
--- /dev/null
+++ b/src/proteomics_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci inference2 module — tsb analytics library. */
+export interface ProteomicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciInference(data: number[], opts: ProteomicsSciInferenceOptions = {}): ProteomicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciInference };
diff --git a/src/proteomics_sci/integral.ts b/src/proteomics_sci/integral.ts
new file mode 100644
index 000000000..d9f397fb9
--- /dev/null
+++ b/src/proteomics_sci/integral.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci integral module — tsb analytics library. */
+export interface ProteomicsSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciIntegralResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciIntegral(data: number[], opts: ProteomicsSciIntegralOptions = {}): ProteomicsSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciIntegral };
diff --git a/src/proteomics_sci/integration.ts b/src/proteomics_sci/integration.ts
new file mode 100644
index 000000000..bc9c48779
--- /dev/null
+++ b/src/proteomics_sci/integration.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci integration module — tsb analytics library. */
+export interface ProteomicsSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciIntegration(data: number[], opts: ProteomicsSciIntegrationOptions = {}): ProteomicsSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciIntegration };
diff --git a/src/proteomics_sci/interpolation.ts b/src/proteomics_sci/interpolation.ts
new file mode 100644
index 000000000..b710d3957
--- /dev/null
+++ b/src/proteomics_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci interpolation module — tsb analytics library. */
+export interface ProteomicsSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciInterpolation(data: number[], opts: ProteomicsSciInterpolationOptions = {}): ProteomicsSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciInterpolation };
diff --git a/src/proteomics_sci/jacobian.ts b/src/proteomics_sci/jacobian.ts
new file mode 100644
index 000000000..86a3d1c8b
--- /dev/null
+++ b/src/proteomics_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci jacobian module — tsb analytics library. */
+export interface ProteomicsSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciJacobianResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciJacobian(data: number[], opts: ProteomicsSciJacobianOptions = {}): ProteomicsSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciJacobian };
diff --git a/src/proteomics_sci/kernel.ts b/src/proteomics_sci/kernel.ts
new file mode 100644
index 000000000..e7c78a207
--- /dev/null
+++ b/src/proteomics_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci kernel module — tsb analytics library. */
+export interface ProteomicsSciKernelOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciKernelResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciKernel(data: number[], opts: ProteomicsSciKernelOptions = {}): ProteomicsSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciKernel };
diff --git a/src/proteomics_sci/laplacian.ts b/src/proteomics_sci/laplacian.ts
new file mode 100644
index 000000000..9c15739d2
--- /dev/null
+++ b/src/proteomics_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci laplacian module — tsb analytics library. */
+export interface ProteomicsSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciLaplacian(data: number[], opts: ProteomicsSciLaplacianOptions = {}): ProteomicsSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciLaplacian };
diff --git a/src/proteomics_sci/learning.ts b/src/proteomics_sci/learning.ts
new file mode 100644
index 000000000..5df36e849
--- /dev/null
+++ b/src/proteomics_sci/learning.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci learning module — tsb analytics library. */
+export interface ProteomicsSciLearningOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciLearningResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciLearning(data: number[], opts: ProteomicsSciLearningOptions = {}): ProteomicsSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciLearning };
diff --git a/src/proteomics_sci/linear.ts b/src/proteomics_sci/linear.ts
new file mode 100644
index 000000000..9a9e19f03
--- /dev/null
+++ b/src/proteomics_sci/linear.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci linear module — tsb analytics library. */
+export interface ProteomicsSciLinearOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciLinearResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciLinear(data: number[], opts: ProteomicsSciLinearOptions = {}): ProteomicsSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciLinear };
diff --git a/src/proteomics_sci/manifold.ts b/src/proteomics_sci/manifold.ts
new file mode 100644
index 000000000..4e20e85cc
--- /dev/null
+++ b/src/proteomics_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci manifold module — tsb analytics library. */
+export interface ProteomicsSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciManifoldResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciManifold(data: number[], opts: ProteomicsSciManifoldOptions = {}): ProteomicsSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciManifold };
diff --git a/src/proteomics_sci/matching.ts b/src/proteomics_sci/matching.ts
new file mode 100644
index 000000000..c701b223e
--- /dev/null
+++ b/src/proteomics_sci/matching.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci matching module — tsb analytics library. */
+export interface ProteomicsSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciMatchingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciMatching(data: number[], opts: ProteomicsSciMatchingOptions = {}): ProteomicsSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciMatching };
diff --git a/src/proteomics_sci/measurement.ts b/src/proteomics_sci/measurement.ts
new file mode 100644
index 000000000..c4a4ffb09
--- /dev/null
+++ b/src/proteomics_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci measurement module — tsb analytics library. */
+export interface ProteomicsSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciMeasurement(data: number[], opts: ProteomicsSciMeasurementOptions = {}): ProteomicsSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciMeasurement };
diff --git a/src/proteomics_sci/metrics.ts b/src/proteomics_sci/metrics.ts
new file mode 100644
index 000000000..b720f0752
--- /dev/null
+++ b/src/proteomics_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci metrics module — tsb analytics library. */
+export interface ProteomicsSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciMetricsResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciMetrics(data: number[], opts: ProteomicsSciMetricsOptions = {}): ProteomicsSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciMetrics };
diff --git a/src/proteomics_sci/modeling.ts b/src/proteomics_sci/modeling.ts
new file mode 100644
index 000000000..e54e515d0
--- /dev/null
+++ b/src/proteomics_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci modeling module — tsb analytics library. */
+export interface ProteomicsSciModelingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciModelingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciModeling(data: number[], opts: ProteomicsSciModelingOptions = {}): ProteomicsSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciModeling };
diff --git a/src/proteomics_sci/monitoring.ts b/src/proteomics_sci/monitoring.ts
new file mode 100644
index 000000000..b5ea587c4
--- /dev/null
+++ b/src/proteomics_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci monitoring module — tsb analytics library. */
+export interface ProteomicsSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciMonitoring(data: number[], opts: ProteomicsSciMonitoringOptions = {}): ProteomicsSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciMonitoring };
diff --git a/src/proteomics_sci/nonlinear.ts b/src/proteomics_sci/nonlinear.ts
new file mode 100644
index 000000000..76871a4ee
--- /dev/null
+++ b/src/proteomics_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci nonlinear module — tsb analytics library. */
+export interface ProteomicsSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciNonlinear(data: number[], opts: ProteomicsSciNonlinearOptions = {}): ProteomicsSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciNonlinear };
diff --git a/src/proteomics_sci/normalization.ts b/src/proteomics_sci/normalization.ts
new file mode 100644
index 000000000..291a54dc0
--- /dev/null
+++ b/src/proteomics_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci normalization module — tsb analytics library. */
+export interface ProteomicsSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciNormalization(data: number[], opts: ProteomicsSciNormalizationOptions = {}): ProteomicsSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciNormalization };
diff --git a/src/proteomics_sci/optimization.ts b/src/proteomics_sci/optimization.ts
new file mode 100644
index 000000000..1a52ce975
--- /dev/null
+++ b/src/proteomics_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci optimization module — tsb analytics library. */
+export interface ProteomicsSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciOptimization(data: number[], opts: ProteomicsSciOptimizationOptions = {}): ProteomicsSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciOptimization };
diff --git a/src/proteomics_sci/patterns.ts b/src/proteomics_sci/patterns.ts
new file mode 100644
index 000000000..15f56715a
--- /dev/null
+++ b/src/proteomics_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci patterns module — tsb analytics library. */
+export interface ProteomicsSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciPatternsResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciPatterns(data: number[], opts: ProteomicsSciPatternsOptions = {}): ProteomicsSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciPatterns };
diff --git a/src/proteomics_sci/permutation.ts b/src/proteomics_sci/permutation.ts
new file mode 100644
index 000000000..bfbec980d
--- /dev/null
+++ b/src/proteomics_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci permutation module — tsb analytics library. */
+export interface ProteomicsSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciPermutationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciPermutation(data: number[], opts: ProteomicsSciPermutationOptions = {}): ProteomicsSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciPermutation };
diff --git a/src/proteomics_sci/prediction.ts b/src/proteomics_sci/prediction.ts
new file mode 100644
index 000000000..9a097d6f4
--- /dev/null
+++ b/src/proteomics_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci prediction module — tsb analytics library. */
+export interface ProteomicsSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciPredictionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciPrediction(data: number[], opts: ProteomicsSciPredictionOptions = {}): ProteomicsSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciPrediction };
diff --git a/src/proteomics_sci/processing.ts b/src/proteomics_sci/processing.ts
new file mode 100644
index 000000000..f3f078db4
--- /dev/null
+++ b/src/proteomics_sci/processing.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci processing module — tsb analytics library. */
+export interface ProteomicsSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciProcessingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciProcessing(data: number[], opts: ProteomicsSciProcessingOptions = {}): ProteomicsSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciProcessing };
diff --git a/src/proteomics_sci/profiling.ts b/src/proteomics_sci/profiling.ts
new file mode 100644
index 000000000..a2ce1aeea
--- /dev/null
+++ b/src/proteomics_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci profiling module — tsb analytics library. */
+export interface ProteomicsSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciProfilingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciProfiling(data: number[], opts: ProteomicsSciProfilingOptions = {}): ProteomicsSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciProfiling };
diff --git a/src/proteomics_sci/projection.ts b/src/proteomics_sci/projection.ts
new file mode 100644
index 000000000..cb91e010a
--- /dev/null
+++ b/src/proteomics_sci/projection.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci projection module — tsb analytics library. */
+export interface ProteomicsSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciProjectionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciProjection(data: number[], opts: ProteomicsSciProjectionOptions = {}): ProteomicsSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciProjection };
diff --git a/src/proteomics_sci/ranking.ts b/src/proteomics_sci/ranking.ts
new file mode 100644
index 000000000..01ca76176
--- /dev/null
+++ b/src/proteomics_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci ranking module — tsb analytics library. */
+export interface ProteomicsSciRankingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciRankingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciRanking(data: number[], opts: ProteomicsSciRankingOptions = {}): ProteomicsSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciRanking };
diff --git a/src/proteomics_sci/reconstruction.ts b/src/proteomics_sci/reconstruction.ts
new file mode 100644
index 000000000..a5b021315
--- /dev/null
+++ b/src/proteomics_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci reconstruction module — tsb analytics library. */
+export interface ProteomicsSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciReconstruction(data: number[], opts: ProteomicsSciReconstructionOptions = {}): ProteomicsSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciReconstruction };
diff --git a/src/proteomics_sci/registration.ts b/src/proteomics_sci/registration.ts
new file mode 100644
index 000000000..bbc96464d
--- /dev/null
+++ b/src/proteomics_sci/registration.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci registration module — tsb analytics library. */
+export interface ProteomicsSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciRegistration(data: number[], opts: ProteomicsSciRegistrationOptions = {}): ProteomicsSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciRegistration };
diff --git a/src/proteomics_sci/regression.ts b/src/proteomics_sci/regression.ts
new file mode 100644
index 000000000..484514bf5
--- /dev/null
+++ b/src/proteomics_sci/regression.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci regression module — tsb analytics library. */
+export interface ProteomicsSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciRegressionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciRegression(data: number[], opts: ProteomicsSciRegressionOptions = {}): ProteomicsSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciRegression };
diff --git a/src/proteomics_sci/regularization.ts b/src/proteomics_sci/regularization.ts
new file mode 100644
index 000000000..3aa180c1f
--- /dev/null
+++ b/src/proteomics_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci regularization module — tsb analytics library. */
+export interface ProteomicsSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciRegularization(data: number[], opts: ProteomicsSciRegularizationOptions = {}): ProteomicsSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciRegularization };
diff --git a/src/proteomics_sci/robustness.ts b/src/proteomics_sci/robustness.ts
new file mode 100644
index 000000000..df83bb3ae
--- /dev/null
+++ b/src/proteomics_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci robustness module — tsb analytics library. */
+export interface ProteomicsSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciRobustness(data: number[], opts: ProteomicsSciRobustnessOptions = {}): ProteomicsSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciRobustness };
diff --git a/src/proteomics_sci/sampling.ts b/src/proteomics_sci/sampling.ts
new file mode 100644
index 000000000..dc3d5ca5d
--- /dev/null
+++ b/src/proteomics_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci sampling module — tsb analytics library. */
+export interface ProteomicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciSampling(data: number[], opts: ProteomicsSciSamplingOptions = {}): ProteomicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciSampling };
diff --git a/src/proteomics_sci/sampling2.ts b/src/proteomics_sci/sampling2.ts
new file mode 100644
index 000000000..baa43e1c0
--- /dev/null
+++ b/src/proteomics_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci sampling2 module — tsb analytics library. */
+export interface ProteomicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciSampling(data: number[], opts: ProteomicsSciSamplingOptions = {}): ProteomicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciSampling };
diff --git a/src/proteomics_sci/scaling.ts b/src/proteomics_sci/scaling.ts
new file mode 100644
index 000000000..1195e9c81
--- /dev/null
+++ b/src/proteomics_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci scaling module — tsb analytics library. */
+export interface ProteomicsSciScalingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciScalingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciScaling(data: number[], opts: ProteomicsSciScalingOptions = {}): ProteomicsSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciScaling };
diff --git a/src/proteomics_sci/scoring.ts b/src/proteomics_sci/scoring.ts
new file mode 100644
index 000000000..91f8fb022
--- /dev/null
+++ b/src/proteomics_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci scoring module — tsb analytics library. */
+export interface ProteomicsSciScoringOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciScoringResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciScoring(data: number[], opts: ProteomicsSciScoringOptions = {}): ProteomicsSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciScoring };
diff --git a/src/proteomics_sci/segmentation.ts b/src/proteomics_sci/segmentation.ts
new file mode 100644
index 000000000..90dafa3a0
--- /dev/null
+++ b/src/proteomics_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci segmentation module — tsb analytics library. */
+export interface ProteomicsSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciSegmentation(data: number[], opts: ProteomicsSciSegmentationOptions = {}): ProteomicsSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciSegmentation };
diff --git a/src/proteomics_sci/selection.ts b/src/proteomics_sci/selection.ts
new file mode 100644
index 000000000..a25f36786
--- /dev/null
+++ b/src/proteomics_sci/selection.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci selection module — tsb analytics library. */
+export interface ProteomicsSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciSelectionResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciSelection(data: number[], opts: ProteomicsSciSelectionOptions = {}): ProteomicsSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciSelection };
diff --git a/src/proteomics_sci/sensitivity.ts b/src/proteomics_sci/sensitivity.ts
new file mode 100644
index 000000000..d466eb6d8
--- /dev/null
+++ b/src/proteomics_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci sensitivity module — tsb analytics library. */
+export interface ProteomicsSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciSensitivity(data: number[], opts: ProteomicsSciSensitivityOptions = {}): ProteomicsSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciSensitivity };
diff --git a/src/proteomics_sci/simulation.ts b/src/proteomics_sci/simulation.ts
new file mode 100644
index 000000000..948e2b8ec
--- /dev/null
+++ b/src/proteomics_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci simulation module — tsb analytics library. */
+export interface ProteomicsSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciSimulationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciSimulation(data: number[], opts: ProteomicsSciSimulationOptions = {}): ProteomicsSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciSimulation };
diff --git a/src/proteomics_sci/smoothing.ts b/src/proteomics_sci/smoothing.ts
new file mode 100644
index 000000000..d9bc7988b
--- /dev/null
+++ b/src/proteomics_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci smoothing module — tsb analytics library. */
+export interface ProteomicsSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciSmoothing(data: number[], opts: ProteomicsSciSmoothingOptions = {}): ProteomicsSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciSmoothing };
diff --git a/src/proteomics_sci/stability.ts b/src/proteomics_sci/stability.ts
new file mode 100644
index 000000000..bc14cc2bf
--- /dev/null
+++ b/src/proteomics_sci/stability.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci stability module — tsb analytics library. */
+export interface ProteomicsSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciStabilityResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciStability(data: number[], opts: ProteomicsSciStabilityOptions = {}): ProteomicsSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciStability };
diff --git a/src/proteomics_sci/stacking.ts b/src/proteomics_sci/stacking.ts
new file mode 100644
index 000000000..888c6241b
--- /dev/null
+++ b/src/proteomics_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci stacking module — tsb analytics library. */
+export interface ProteomicsSciStackingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciStackingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciStacking(data: number[], opts: ProteomicsSciStackingOptions = {}): ProteomicsSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciStacking };
diff --git a/src/proteomics_sci/standardization.ts b/src/proteomics_sci/standardization.ts
new file mode 100644
index 000000000..6a6884e6c
--- /dev/null
+++ b/src/proteomics_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci standardization module — tsb analytics library. */
+export interface ProteomicsSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciStandardization(data: number[], opts: ProteomicsSciStandardizationOptions = {}): ProteomicsSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciStandardization };
diff --git a/src/proteomics_sci/static.ts b/src/proteomics_sci/static.ts
new file mode 100644
index 000000000..1824077c9
--- /dev/null
+++ b/src/proteomics_sci/static.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci static module — tsb analytics library. */
+export interface ProteomicsSciStaticOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciStaticResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciStatic(data: number[], opts: ProteomicsSciStaticOptions = {}): ProteomicsSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciStatic };
diff --git a/src/proteomics_sci/stochastic.ts b/src/proteomics_sci/stochastic.ts
new file mode 100644
index 000000000..509c7374b
--- /dev/null
+++ b/src/proteomics_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci stochastic module — tsb analytics library. */
+export interface ProteomicsSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciStochasticResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciStochastic(data: number[], opts: ProteomicsSciStochasticOptions = {}): ProteomicsSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciStochastic };
diff --git a/src/proteomics_sci/synthesis.ts b/src/proteomics_sci/synthesis.ts
new file mode 100644
index 000000000..0e5218079
--- /dev/null
+++ b/src/proteomics_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci synthesis module — tsb analytics library. */
+export interface ProteomicsSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciSynthesis(data: number[], opts: ProteomicsSciSynthesisOptions = {}): ProteomicsSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciSynthesis };
diff --git a/src/proteomics_sci/topology.ts b/src/proteomics_sci/topology.ts
new file mode 100644
index 000000000..33fc7c9fd
--- /dev/null
+++ b/src/proteomics_sci/topology.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci topology module — tsb analytics library. */
+export interface ProteomicsSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciTopologyResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciTopology(data: number[], opts: ProteomicsSciTopologyOptions = {}): ProteomicsSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciTopology };
diff --git a/src/proteomics_sci/tracking.ts b/src/proteomics_sci/tracking.ts
new file mode 100644
index 000000000..b58ffb3ec
--- /dev/null
+++ b/src/proteomics_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci tracking module — tsb analytics library. */
+export interface ProteomicsSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciTrackingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciTracking(data: number[], opts: ProteomicsSciTrackingOptions = {}): ProteomicsSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciTracking };
diff --git a/src/proteomics_sci/transform.ts b/src/proteomics_sci/transform.ts
new file mode 100644
index 000000000..1a2b9e500
--- /dev/null
+++ b/src/proteomics_sci/transform.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci transform module — tsb analytics library. */
+export interface ProteomicsSciTransformOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciTransformResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciTransform(data: number[], opts: ProteomicsSciTransformOptions = {}): ProteomicsSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciTransform };
diff --git a/src/proteomics_sci/uncertainty.ts b/src/proteomics_sci/uncertainty.ts
new file mode 100644
index 000000000..b6d742c08
--- /dev/null
+++ b/src/proteomics_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci uncertainty module — tsb analytics library. */
+export interface ProteomicsSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciUncertainty(data: number[], opts: ProteomicsSciUncertaintyOptions = {}): ProteomicsSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciUncertainty };
diff --git a/src/proteomics_sci/validation.ts b/src/proteomics_sci/validation.ts
new file mode 100644
index 000000000..186cec2c4
--- /dev/null
+++ b/src/proteomics_sci/validation.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci validation module — tsb analytics library. */
+export interface ProteomicsSciValidationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciValidationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciValidation(data: number[], opts: ProteomicsSciValidationOptions = {}): ProteomicsSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciValidation };
diff --git a/src/proteomics_sci/verification.ts b/src/proteomics_sci/verification.ts
new file mode 100644
index 000000000..940b1b3ac
--- /dev/null
+++ b/src/proteomics_sci/verification.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci verification module — tsb analytics library. */
+export interface ProteomicsSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciVerificationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciVerification(data: number[], opts: ProteomicsSciVerificationOptions = {}): ProteomicsSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciVerification };
diff --git a/src/proteomics_sci/visualization.ts b/src/proteomics_sci/visualization.ts
new file mode 100644
index 000000000..8beca8de9
--- /dev/null
+++ b/src/proteomics_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci visualization module — tsb analytics library. */
+export interface ProteomicsSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciVisualization(data: number[], opts: ProteomicsSciVisualizationOptions = {}): ProteomicsSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciVisualization };
diff --git a/src/proteomics_sci/voting.ts b/src/proteomics_sci/voting.ts
new file mode 100644
index 000000000..0183f255c
--- /dev/null
+++ b/src/proteomics_sci/voting.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci voting module — tsb analytics library. */
+export interface ProteomicsSciVotingOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciVotingResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciVoting(data: number[], opts: ProteomicsSciVotingOptions = {}): ProteomicsSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciVoting };
diff --git a/src/proteomics_sci/wavelet.ts b/src/proteomics_sci/wavelet.ts
new file mode 100644
index 000000000..5d1301c31
--- /dev/null
+++ b/src/proteomics_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** proteomics_sci wavelet module — tsb analytics library. */
+export interface ProteomicsSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface ProteomicsSciWaveletResult { values: number[]; converged: boolean; }
+export function computeProteomicsSciWavelet(data: number[], opts: ProteomicsSciWaveletOptions = {}): ProteomicsSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeProteomicsSciWavelet };
diff --git a/src/psychology/advanced.ts b/src/psychology/advanced.ts
new file mode 100644
index 000000000..88edc94f6
--- /dev/null
+++ b/src/psychology/advanced.ts
@@ -0,0 +1,15 @@
+/** Psychology Advanced module — tsb analytics library. */
+export interface Psychology advancedOptions { tol?: number; maxIter?: number; }
+export interface Psychology advancedResult { values: number[]; converged: boolean; }
+export function computePsychology advanced(data: number[], opts: Psychology advancedOptions = {}): Psychology advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology advanced };
diff --git a/src/psychology/attention_psych.ts b/src/psychology/attention_psych.ts
new file mode 100644
index 000000000..e16988b07
--- /dev/null
+++ b/src/psychology/attention_psych.ts
@@ -0,0 +1,22 @@
+/** Attention Psych module — tsb analytics library. */
+
+/** Options for Attention Psych. */
+export interface AttentionPsychOptions { tol?: number; maxIter?: number; }
+
+/** Result from Attention Psych. */
+export interface AttentionPsychResult { values: number[]; converged: boolean; }
+
+/** Compute Attention Psych. */
+export function computeAttentionPsych(data: number[], opts: AttentionPsychOptions = {}): AttentionPsychResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAttentionPsych };
diff --git a/src/psychology/attitude.ts b/src/psychology/attitude.ts
new file mode 100644
index 000000000..c8f80be0e
--- /dev/null
+++ b/src/psychology/attitude.ts
@@ -0,0 +1,22 @@
+/** Attitude module — tsb analytics library. */
+
+/** Options for Attitude. */
+export interface AttitudeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Attitude. */
+export interface AttitudeResult { values: number[]; converged: boolean; }
+
+/** Compute Attitude. */
+export function computeAttitude(data: number[], opts: AttitudeOptions = {}): AttitudeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAttitude };
diff --git a/src/psychology/base2.ts b/src/psychology/base2.ts
new file mode 100644
index 000000000..5f233fb3e
--- /dev/null
+++ b/src/psychology/base2.ts
@@ -0,0 +1,15 @@
+/** Psychology Base2 module — tsb analytics library. */
+export interface Psychology base2Options { tol?: number; maxIter?: number; }
+export interface Psychology base2Result { values: number[]; converged: boolean; }
+export function computePsychology base2(data: number[], opts: Psychology base2Options = {}): Psychology base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology base2 };
diff --git a/src/psychology/batch.ts b/src/psychology/batch.ts
new file mode 100644
index 000000000..b2e124999
--- /dev/null
+++ b/src/psychology/batch.ts
@@ -0,0 +1,15 @@
+/** Psychology Batch module — tsb analytics library. */
+export interface Psychology batchOptions { tol?: number; maxIter?: number; }
+export interface Psychology batchResult { values: number[]; converged: boolean; }
+export function computePsychology batch(data: number[], opts: Psychology batchOptions = {}): Psychology batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology batch };
diff --git a/src/psychology/behavioral.ts b/src/psychology/behavioral.ts
new file mode 100644
index 000000000..2a3f6e1a8
--- /dev/null
+++ b/src/psychology/behavioral.ts
@@ -0,0 +1,22 @@
+/** Behavioral module — tsb analytics library. */
+
+/** Options for Behavioral. */
+export interface BehavioralOptions { tol?: number; maxIter?: number; }
+
+/** Result from Behavioral. */
+export interface BehavioralResult { values: number[]; converged: boolean; }
+
+/** Compute Behavioral. */
+export function computeBehavioral(data: number[], opts: BehavioralOptions = {}): BehavioralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBehavioral };
diff --git a/src/psychology/beta.ts b/src/psychology/beta.ts
new file mode 100644
index 000000000..57e489ef4
--- /dev/null
+++ b/src/psychology/beta.ts
@@ -0,0 +1,15 @@
+/** Psychology Beta module — tsb analytics library. */
+export interface Psychology betaOptions { tol?: number; maxIter?: number; }
+export interface Psychology betaResult { values: number[]; converged: boolean; }
+export function computePsychology beta(data: number[], opts: Psychology betaOptions = {}): Psychology betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology beta };
diff --git a/src/psychology/clinical.ts b/src/psychology/clinical.ts
new file mode 100644
index 000000000..da2616728
--- /dev/null
+++ b/src/psychology/clinical.ts
@@ -0,0 +1,22 @@
+/** Clinical module — tsb analytics library. */
+
+/** Options for Clinical. */
+export interface ClinicalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Clinical. */
+export interface ClinicalResult { values: number[]; converged: boolean; }
+
+/** Compute Clinical. */
+export function computeClinical(data: number[], opts: ClinicalOptions = {}): ClinicalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClinical };
diff --git a/src/psychology/cognitive.ts b/src/psychology/cognitive.ts
new file mode 100644
index 000000000..ab547fa2c
--- /dev/null
+++ b/src/psychology/cognitive.ts
@@ -0,0 +1,22 @@
+/** Cognitive module — tsb analytics library. */
+
+/** Options for Cognitive. */
+export interface CognitiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cognitive. */
+export interface CognitiveResult { values: number[]; converged: boolean; }
+
+/** Compute Cognitive. */
+export function computeCognitive(data: number[], opts: CognitiveOptions = {}): CognitiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCognitive };
diff --git a/src/psychology/conformity.ts b/src/psychology/conformity.ts
new file mode 100644
index 000000000..93de132b3
--- /dev/null
+++ b/src/psychology/conformity.ts
@@ -0,0 +1,22 @@
+/** Conformity module — tsb analytics library. */
+
+/** Options for Conformity. */
+export interface ConformityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Conformity. */
+export interface ConformityResult { values: number[]; converged: boolean; }
+
+/** Compute Conformity. */
+export function computeConformity(data: number[], opts: ConformityOptions = {}): ConformityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConformity };
diff --git a/src/psychology/cpu.ts b/src/psychology/cpu.ts
new file mode 100644
index 000000000..6f99e3228
--- /dev/null
+++ b/src/psychology/cpu.ts
@@ -0,0 +1,15 @@
+/** Psychology Cpu module — tsb analytics library. */
+export interface Psychology cpuOptions { tol?: number; maxIter?: number; }
+export interface Psychology cpuResult { values: number[]; converged: boolean; }
+export function computePsychology cpu(data: number[], opts: Psychology cpuOptions = {}): Psychology cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology cpu };
diff --git a/src/psychology/cross_cultural.ts b/src/psychology/cross_cultural.ts
new file mode 100644
index 000000000..680bdd136
--- /dev/null
+++ b/src/psychology/cross_cultural.ts
@@ -0,0 +1,22 @@
+/** Cross Cultural module — tsb analytics library. */
+
+/** Options for Cross Cultural. */
+export interface CrossCulturalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cross Cultural. */
+export interface CrossCulturalResult { values: number[]; converged: boolean; }
+
+/** Compute Cross Cultural. */
+export function computeCrossCultural(data: number[], opts: CrossCulturalOptions = {}): CrossCulturalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCrossCultural };
diff --git a/src/psychology/decision.ts b/src/psychology/decision.ts
new file mode 100644
index 000000000..d53c8d4ba
--- /dev/null
+++ b/src/psychology/decision.ts
@@ -0,0 +1,22 @@
+/** Decision module — tsb analytics library. */
+
+/** Options for Decision. */
+export interface DecisionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Decision. */
+export interface DecisionResult { values: number[]; converged: boolean; }
+
+/** Compute Decision. */
+export function computeDecision(data: number[], opts: DecisionOptions = {}): DecisionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDecision };
diff --git a/src/psychology/dense.ts b/src/psychology/dense.ts
new file mode 100644
index 000000000..f6f03793a
--- /dev/null
+++ b/src/psychology/dense.ts
@@ -0,0 +1,15 @@
+/** Psychology Dense module — tsb analytics library. */
+export interface Psychology denseOptions { tol?: number; maxIter?: number; }
+export interface Psychology denseResult { values: number[]; converged: boolean; }
+export function computePsychology dense(data: number[], opts: Psychology denseOptions = {}): Psychology denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology dense };
diff --git a/src/psychology/developmental.ts b/src/psychology/developmental.ts
new file mode 100644
index 000000000..66e3377e7
--- /dev/null
+++ b/src/psychology/developmental.ts
@@ -0,0 +1,22 @@
+/** Developmental module — tsb analytics library. */
+
+/** Options for Developmental. */
+export interface DevelopmentalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Developmental. */
+export interface DevelopmentalResult { values: number[]; converged: boolean; }
+
+/** Compute Developmental. */
+export function computeDevelopmental(data: number[], opts: DevelopmentalOptions = {}): DevelopmentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDevelopmental };
diff --git a/src/psychology/distributed.ts b/src/psychology/distributed.ts
new file mode 100644
index 000000000..d552a0506
--- /dev/null
+++ b/src/psychology/distributed.ts
@@ -0,0 +1,15 @@
+/** Psychology Distributed module — tsb analytics library. */
+export interface Psychology distributedOptions { tol?: number; maxIter?: number; }
+export interface Psychology distributedResult { values: number[]; converged: boolean; }
+export function computePsychology distributed(data: number[], opts: Psychology distributedOptions = {}): Psychology distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology distributed };
diff --git a/src/psychology/educational_psych.ts b/src/psychology/educational_psych.ts
new file mode 100644
index 000000000..739d410ff
--- /dev/null
+++ b/src/psychology/educational_psych.ts
@@ -0,0 +1,22 @@
+/** Educational Psych module — tsb analytics library. */
+
+/** Options for Educational Psych. */
+export interface EducationalPsychOptions { tol?: number; maxIter?: number; }
+
+/** Result from Educational Psych. */
+export interface EducationalPsychResult { values: number[]; converged: boolean; }
+
+/** Compute Educational Psych. */
+export function computeEducationalPsych(data: number[], opts: EducationalPsychOptions = {}): EducationalPsychResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEducationalPsych };
diff --git a/src/psychology/emotion.ts b/src/psychology/emotion.ts
new file mode 100644
index 000000000..922279b9f
--- /dev/null
+++ b/src/psychology/emotion.ts
@@ -0,0 +1,22 @@
+/** Emotion module — tsb analytics library. */
+
+/** Options for Emotion. */
+export interface EmotionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Emotion. */
+export interface EmotionResult { values: number[]; converged: boolean; }
+
+/** Compute Emotion. */
+export function computeEmotion(data: number[], opts: EmotionOptions = {}): EmotionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEmotion };
diff --git a/src/psychology/environmental_psych.ts b/src/psychology/environmental_psych.ts
new file mode 100644
index 000000000..d434db457
--- /dev/null
+++ b/src/psychology/environmental_psych.ts
@@ -0,0 +1,22 @@
+/** Environmental Psych module — tsb analytics library. */
+
+/** Options for Environmental Psych. */
+export interface EnvironmentalPsychOptions { tol?: number; maxIter?: number; }
+
+/** Result from Environmental Psych. */
+export interface EnvironmentalPsychResult { values: number[]; converged: boolean; }
+
+/** Compute Environmental Psych. */
+export function computeEnvironmentalPsych(data: number[], opts: EnvironmentalPsychOptions = {}): EnvironmentalPsychResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEnvironmentalPsych };
diff --git a/src/psychology/evolutionary.ts b/src/psychology/evolutionary.ts
new file mode 100644
index 000000000..4fddc3bbe
--- /dev/null
+++ b/src/psychology/evolutionary.ts
@@ -0,0 +1,22 @@
+/** Evolutionary module — tsb analytics library. */
+
+/** Options for Evolutionary. */
+export interface EvolutionaryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Evolutionary. */
+export interface EvolutionaryResult { values: number[]; converged: boolean; }
+
+/** Compute Evolutionary. */
+export function computeEvolutionary(data: number[], opts: EvolutionaryOptions = {}): EvolutionaryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEvolutionary };
diff --git a/src/psychology/experimental.ts b/src/psychology/experimental.ts
new file mode 100644
index 000000000..76d4d64b7
--- /dev/null
+++ b/src/psychology/experimental.ts
@@ -0,0 +1,15 @@
+/** Psychology Experimental module — tsb analytics library. */
+export interface Psychology experimentalOptions { tol?: number; maxIter?: number; }
+export interface Psychology experimentalResult { values: number[]; converged: boolean; }
+export function computePsychology experimental(data: number[], opts: Psychology experimentalOptions = {}): Psychology experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology experimental };
diff --git a/src/psychology/fast.ts b/src/psychology/fast.ts
new file mode 100644
index 000000000..ea001f01c
--- /dev/null
+++ b/src/psychology/fast.ts
@@ -0,0 +1,15 @@
+/** Psychology Fast module — tsb analytics library. */
+export interface Psychology fastOptions { tol?: number; maxIter?: number; }
+export interface Psychology fastResult { values: number[]; converged: boolean; }
+export function computePsychology fast(data: number[], opts: Psychology fastOptions = {}): Psychology fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology fast };
diff --git a/src/psychology/forensic.ts b/src/psychology/forensic.ts
new file mode 100644
index 000000000..5ce904d82
--- /dev/null
+++ b/src/psychology/forensic.ts
@@ -0,0 +1,22 @@
+/** Forensic module — tsb analytics library. */
+
+/** Options for Forensic. */
+export interface ForensicOptions { tol?: number; maxIter?: number; }
+
+/** Result from Forensic. */
+export interface ForensicResult { values: number[]; converged: boolean; }
+
+/** Compute Forensic. */
+export function computeForensic(data: number[], opts: ForensicOptions = {}): ForensicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeForensic };
diff --git a/src/psychology/future.ts b/src/psychology/future.ts
new file mode 100644
index 000000000..513c06a2d
--- /dev/null
+++ b/src/psychology/future.ts
@@ -0,0 +1,15 @@
+/** Psychology Future module — tsb analytics library. */
+export interface Psychology futureOptions { tol?: number; maxIter?: number; }
+export interface Psychology futureResult { values: number[]; converged: boolean; }
+export function computePsychology future(data: number[], opts: Psychology futureOptions = {}): Psychology futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology future };
diff --git a/src/psychology/gpu.ts b/src/psychology/gpu.ts
new file mode 100644
index 000000000..b04ffc22f
--- /dev/null
+++ b/src/psychology/gpu.ts
@@ -0,0 +1,15 @@
+/** Psychology Gpu module — tsb analytics library. */
+export interface Psychology gpuOptions { tol?: number; maxIter?: number; }
+export interface Psychology gpuResult { values: number[]; converged: boolean; }
+export function computePsychology gpu(data: number[], opts: Psychology gpuOptions = {}): Psychology gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology gpu };
diff --git a/src/psychology/health_psych.ts b/src/psychology/health_psych.ts
new file mode 100644
index 000000000..6bcd615e2
--- /dev/null
+++ b/src/psychology/health_psych.ts
@@ -0,0 +1,22 @@
+/** Health Psych module — tsb analytics library. */
+
+/** Options for Health Psych. */
+export interface HealthPsychOptions { tol?: number; maxIter?: number; }
+
+/** Result from Health Psych. */
+export interface HealthPsychResult { values: number[]; converged: boolean; }
+
+/** Compute Health Psych. */
+export function computeHealthPsych(data: number[], opts: HealthPsychOptions = {}): HealthPsychResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHealthPsych };
diff --git a/src/psychology/judgment.ts b/src/psychology/judgment.ts
new file mode 100644
index 000000000..fc6493530
--- /dev/null
+++ b/src/psychology/judgment.ts
@@ -0,0 +1,22 @@
+/** Judgment module — tsb analytics library. */
+
+/** Options for Judgment. */
+export interface JudgmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Judgment. */
+export interface JudgmentResult { values: number[]; converged: boolean; }
+
+/** Compute Judgment. */
+export function computeJudgment(data: number[], opts: JudgmentOptions = {}): JudgmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeJudgment };
diff --git a/src/psychology/language_psych.ts b/src/psychology/language_psych.ts
new file mode 100644
index 000000000..1f48be3e3
--- /dev/null
+++ b/src/psychology/language_psych.ts
@@ -0,0 +1,22 @@
+/** Language Psych module — tsb analytics library. */
+
+/** Options for Language Psych. */
+export interface LanguagePsychOptions { tol?: number; maxIter?: number; }
+
+/** Result from Language Psych. */
+export interface LanguagePsychResult { values: number[]; converged: boolean; }
+
+/** Compute Language Psych. */
+export function computeLanguagePsych(data: number[], opts: LanguagePsychOptions = {}): LanguagePsychResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLanguagePsych };
diff --git a/src/psychology/large.ts b/src/psychology/large.ts
new file mode 100644
index 000000000..c58e2c9c3
--- /dev/null
+++ b/src/psychology/large.ts
@@ -0,0 +1,15 @@
+/** Psychology Large module — tsb analytics library. */
+export interface Psychology largeOptions { tol?: number; maxIter?: number; }
+export interface Psychology largeResult { values: number[]; converged: boolean; }
+export function computePsychology large(data: number[], opts: Psychology largeOptions = {}): Psychology largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology large };
diff --git a/src/psychology/legacy.ts b/src/psychology/legacy.ts
new file mode 100644
index 000000000..fce96b0e6
--- /dev/null
+++ b/src/psychology/legacy.ts
@@ -0,0 +1,15 @@
+/** Psychology Legacy module — tsb analytics library. */
+export interface Psychology legacyOptions { tol?: number; maxIter?: number; }
+export interface Psychology legacyResult { values: number[]; converged: boolean; }
+export function computePsychology legacy(data: number[], opts: Psychology legacyOptions = {}): Psychology legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology legacy };
diff --git a/src/psychology/lifespan.ts b/src/psychology/lifespan.ts
new file mode 100644
index 000000000..41939b65e
--- /dev/null
+++ b/src/psychology/lifespan.ts
@@ -0,0 +1,22 @@
+/** Lifespan module — tsb analytics library. */
+
+/** Options for Lifespan. */
+export interface LifespanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lifespan. */
+export interface LifespanResult { values: number[]; converged: boolean; }
+
+/** Compute Lifespan. */
+export function computeLifespan(data: number[], opts: LifespanOptions = {}): LifespanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLifespan };
diff --git a/src/psychology/lite.ts b/src/psychology/lite.ts
new file mode 100644
index 000000000..4e06688b8
--- /dev/null
+++ b/src/psychology/lite.ts
@@ -0,0 +1,15 @@
+/** Psychology Lite module — tsb analytics library. */
+export interface Psychology liteOptions { tol?: number; maxIter?: number; }
+export interface Psychology liteResult { values: number[]; converged: boolean; }
+export function computePsychology lite(data: number[], opts: Psychology liteOptions = {}): Psychology liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology lite };
diff --git a/src/psychology/memory.ts b/src/psychology/memory.ts
new file mode 100644
index 000000000..b8374e4f7
--- /dev/null
+++ b/src/psychology/memory.ts
@@ -0,0 +1,22 @@
+/** Memory module — tsb analytics library. */
+
+/** Options for Memory. */
+export interface MemoryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Memory. */
+export interface MemoryResult { values: number[]; converged: boolean; }
+
+/** Compute Memory. */
+export function computeMemory(data: number[], opts: MemoryOptions = {}): MemoryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMemory };
diff --git a/src/psychology/mini.ts b/src/psychology/mini.ts
new file mode 100644
index 000000000..df6cc44b3
--- /dev/null
+++ b/src/psychology/mini.ts
@@ -0,0 +1,15 @@
+/** Psychology Mini module — tsb analytics library. */
+export interface Psychology miniOptions { tol?: number; maxIter?: number; }
+export interface Psychology miniResult { values: number[]; converged: boolean; }
+export function computePsychology mini(data: number[], opts: Psychology miniOptions = {}): Psychology miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology mini };
diff --git a/src/psychology/motivation.ts b/src/psychology/motivation.ts
new file mode 100644
index 000000000..5d716b088
--- /dev/null
+++ b/src/psychology/motivation.ts
@@ -0,0 +1,22 @@
+/** Motivation module — tsb analytics library. */
+
+/** Options for Motivation. */
+export interface MotivationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Motivation. */
+export interface MotivationResult { values: number[]; converged: boolean; }
+
+/** Compute Motivation. */
+export function computeMotivation(data: number[], opts: MotivationOptions = {}): MotivationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMotivation };
diff --git a/src/psychology/neuropsychology.ts b/src/psychology/neuropsychology.ts
new file mode 100644
index 000000000..eb43fabe1
--- /dev/null
+++ b/src/psychology/neuropsychology.ts
@@ -0,0 +1,22 @@
+/** Neuropsychology module — tsb analytics library. */
+
+/** Options for Neuropsychology. */
+export interface NeuropsychologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Neuropsychology. */
+export interface NeuropsychologyResult { values: number[]; converged: boolean; }
+
+/** Compute Neuropsychology. */
+export function computeNeuropsychology(data: number[], opts: NeuropsychologyOptions = {}): NeuropsychologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNeuropsychology };
diff --git a/src/psychology/next.ts b/src/psychology/next.ts
new file mode 100644
index 000000000..5db0838cb
--- /dev/null
+++ b/src/psychology/next.ts
@@ -0,0 +1,15 @@
+/** Psychology Next module — tsb analytics library. */
+export interface Psychology nextOptions { tol?: number; maxIter?: number; }
+export interface Psychology nextResult { values: number[]; converged: boolean; }
+export function computePsychology next(data: number[], opts: Psychology nextOptions = {}): Psychology nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology next };
diff --git a/src/psychology/obedience.ts b/src/psychology/obedience.ts
new file mode 100644
index 000000000..fcec51360
--- /dev/null
+++ b/src/psychology/obedience.ts
@@ -0,0 +1,22 @@
+/** Obedience module — tsb analytics library. */
+
+/** Options for Obedience. */
+export interface ObedienceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Obedience. */
+export interface ObedienceResult { values: number[]; converged: boolean; }
+
+/** Compute Obedience. */
+export function computeObedience(data: number[], opts: ObedienceOptions = {}): ObedienceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeObedience };
diff --git a/src/psychology/online.ts b/src/psychology/online.ts
new file mode 100644
index 000000000..716b5953b
--- /dev/null
+++ b/src/psychology/online.ts
@@ -0,0 +1,15 @@
+/** Psychology Online module — tsb analytics library. */
+export interface Psychology onlineOptions { tol?: number; maxIter?: number; }
+export interface Psychology onlineResult { values: number[]; converged: boolean; }
+export function computePsychology online(data: number[], opts: Psychology onlineOptions = {}): Psychology onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology online };
diff --git a/src/psychology/organizational.ts b/src/psychology/organizational.ts
new file mode 100644
index 000000000..daf551f57
--- /dev/null
+++ b/src/psychology/organizational.ts
@@ -0,0 +1,22 @@
+/** Organizational module — tsb analytics library. */
+
+/** Options for Organizational. */
+export interface OrganizationalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Organizational. */
+export interface OrganizationalResult { values: number[]; converged: boolean; }
+
+/** Compute Organizational. */
+export function computeOrganizational(data: number[], opts: OrganizationalOptions = {}): OrganizationalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOrganizational };
diff --git a/src/psychology/parallel.ts b/src/psychology/parallel.ts
new file mode 100644
index 000000000..7cc2fadee
--- /dev/null
+++ b/src/psychology/parallel.ts
@@ -0,0 +1,15 @@
+/** Psychology Parallel module — tsb analytics library. */
+export interface Psychology parallelOptions { tol?: number; maxIter?: number; }
+export interface Psychology parallelResult { values: number[]; converged: boolean; }
+export function computePsychology parallel(data: number[], opts: Psychology parallelOptions = {}): Psychology parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology parallel };
diff --git a/src/psychology/perception.ts b/src/psychology/perception.ts
new file mode 100644
index 000000000..e2e04ea88
--- /dev/null
+++ b/src/psychology/perception.ts
@@ -0,0 +1,22 @@
+/** Perception module — tsb analytics library. */
+
+/** Options for Perception. */
+export interface PerceptionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Perception. */
+export interface PerceptionResult { values: number[]; converged: boolean; }
+
+/** Compute Perception. */
+export function computePerception(data: number[], opts: PerceptionOptions = {}): PerceptionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePerception };
diff --git a/src/psychology/personality.ts b/src/psychology/personality.ts
new file mode 100644
index 000000000..4018756b1
--- /dev/null
+++ b/src/psychology/personality.ts
@@ -0,0 +1,22 @@
+/** Personality module — tsb analytics library. */
+
+/** Options for Personality. */
+export interface PersonalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Personality. */
+export interface PersonalityResult { values: number[]; converged: boolean; }
+
+/** Compute Personality. */
+export function computePersonality(data: number[], opts: PersonalityOptions = {}): PersonalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePersonality };
diff --git a/src/psychology/persuasion.ts b/src/psychology/persuasion.ts
new file mode 100644
index 000000000..e446ae416
--- /dev/null
+++ b/src/psychology/persuasion.ts
@@ -0,0 +1,22 @@
+/** Persuasion module — tsb analytics library. */
+
+/** Options for Persuasion. */
+export interface PersuasionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Persuasion. */
+export interface PersuasionResult { values: number[]; converged: boolean; }
+
+/** Compute Persuasion. */
+export function computePersuasion(data: number[], opts: PersuasionOptions = {}): PersuasionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePersuasion };
diff --git a/src/psychology/plus.ts b/src/psychology/plus.ts
new file mode 100644
index 000000000..79745d164
--- /dev/null
+++ b/src/psychology/plus.ts
@@ -0,0 +1,15 @@
+/** Psychology Plus module — tsb analytics library. */
+export interface Psychology plusOptions { tol?: number; maxIter?: number; }
+export interface Psychology plusResult { values: number[]; converged: boolean; }
+export function computePsychology plus(data: number[], opts: Psychology plusOptions = {}): Psychology plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology plus };
diff --git a/src/psychology/positive.ts b/src/psychology/positive.ts
new file mode 100644
index 000000000..c7c1d76ab
--- /dev/null
+++ b/src/psychology/positive.ts
@@ -0,0 +1,22 @@
+/** Positive module — tsb analytics library. */
+
+/** Options for Positive. */
+export interface PositiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Positive. */
+export interface PositiveResult { values: number[]; converged: boolean; }
+
+/** Compute Positive. */
+export function computePositive(data: number[], opts: PositiveOptions = {}): PositiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePositive };
diff --git a/src/psychology/pro.ts b/src/psychology/pro.ts
new file mode 100644
index 000000000..c076cfd2c
--- /dev/null
+++ b/src/psychology/pro.ts
@@ -0,0 +1,15 @@
+/** Psychology Pro module — tsb analytics library. */
+export interface Psychology proOptions { tol?: number; maxIter?: number; }
+export interface Psychology proResult { values: number[]; converged: boolean; }
+export function computePsychology pro(data: number[], opts: Psychology proOptions = {}): Psychology proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology pro };
diff --git a/src/psychology/psychophysiology.ts b/src/psychology/psychophysiology.ts
new file mode 100644
index 000000000..c6544425e
--- /dev/null
+++ b/src/psychology/psychophysiology.ts
@@ -0,0 +1,22 @@
+/** Psychophysiology module — tsb analytics library. */
+
+/** Options for Psychophysiology. */
+export interface PsychophysiologyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Psychophysiology. */
+export interface PsychophysiologyResult { values: number[]; converged: boolean; }
+
+/** Compute Psychophysiology. */
+export function computePsychophysiology(data: number[], opts: PsychophysiologyOptions = {}): PsychophysiologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePsychophysiology };
diff --git a/src/psychology/robust.ts b/src/psychology/robust.ts
new file mode 100644
index 000000000..0e66402b3
--- /dev/null
+++ b/src/psychology/robust.ts
@@ -0,0 +1,15 @@
+/** Psychology Robust module — tsb analytics library. */
+export interface Psychology robustOptions { tol?: number; maxIter?: number; }
+export interface Psychology robustResult { values: number[]; converged: boolean; }
+export function computePsychology robust(data: number[], opts: Psychology robustOptions = {}): Psychology robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology robust };
diff --git a/src/psychology/small.ts b/src/psychology/small.ts
new file mode 100644
index 000000000..c3e31a1eb
--- /dev/null
+++ b/src/psychology/small.ts
@@ -0,0 +1,15 @@
+/** Psychology Small module — tsb analytics library. */
+export interface Psychology smallOptions { tol?: number; maxIter?: number; }
+export interface Psychology smallResult { values: number[]; converged: boolean; }
+export function computePsychology small(data: number[], opts: Psychology smallOptions = {}): Psychology smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology small };
diff --git a/src/psychology/social.ts b/src/psychology/social.ts
new file mode 100644
index 000000000..6804cb4a4
--- /dev/null
+++ b/src/psychology/social.ts
@@ -0,0 +1,22 @@
+/** Social module — tsb analytics library. */
+
+/** Options for Social. */
+export interface SocialOptions { tol?: number; maxIter?: number; }
+
+/** Result from Social. */
+export interface SocialResult { values: number[]; converged: boolean; }
+
+/** Compute Social. */
+export function computeSocial(data: number[], opts: SocialOptions = {}): SocialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSocial };
diff --git a/src/psychology/sparse.ts b/src/psychology/sparse.ts
new file mode 100644
index 000000000..a85f87f09
--- /dev/null
+++ b/src/psychology/sparse.ts
@@ -0,0 +1,15 @@
+/** Psychology Sparse module — tsb analytics library. */
+export interface Psychology sparseOptions { tol?: number; maxIter?: number; }
+export interface Psychology sparseResult { values: number[]; converged: boolean; }
+export function computePsychology sparse(data: number[], opts: Psychology sparseOptions = {}): Psychology sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology sparse };
diff --git a/src/psychology/sport.ts b/src/psychology/sport.ts
new file mode 100644
index 000000000..d354760c3
--- /dev/null
+++ b/src/psychology/sport.ts
@@ -0,0 +1,22 @@
+/** Sport module — tsb analytics library. */
+
+/** Options for Sport. */
+export interface SportOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sport. */
+export interface SportResult { values: number[]; converged: boolean; }
+
+/** Compute Sport. */
+export function computeSport(data: number[], opts: SportOptions = {}): SportResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSport };
diff --git a/src/psychology/stable.ts b/src/psychology/stable.ts
new file mode 100644
index 000000000..f94f59068
--- /dev/null
+++ b/src/psychology/stable.ts
@@ -0,0 +1,15 @@
+/** Psychology Stable module — tsb analytics library. */
+export interface Psychology stableOptions { tol?: number; maxIter?: number; }
+export interface Psychology stableResult { values: number[]; converged: boolean; }
+export function computePsychology stable(data: number[], opts: Psychology stableOptions = {}): Psychology stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology stable };
diff --git a/src/psychology/streaming.ts b/src/psychology/streaming.ts
new file mode 100644
index 000000000..963a813c1
--- /dev/null
+++ b/src/psychology/streaming.ts
@@ -0,0 +1,15 @@
+/** Psychology Streaming module — tsb analytics library. */
+export interface Psychology streamingOptions { tol?: number; maxIter?: number; }
+export interface Psychology streamingResult { values: number[]; converged: boolean; }
+export function computePsychology streaming(data: number[], opts: Psychology streamingOptions = {}): Psychology streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology streaming };
diff --git a/src/psychology/v2.ts b/src/psychology/v2.ts
new file mode 100644
index 000000000..6263f6ab6
--- /dev/null
+++ b/src/psychology/v2.ts
@@ -0,0 +1,15 @@
+/** Psychology V2 module — tsb analytics library. */
+export interface Psychology v2Options { tol?: number; maxIter?: number; }
+export interface Psychology v2Result { values: number[]; converged: boolean; }
+export function computePsychology v2(data: number[], opts: Psychology v2Options = {}): Psychology v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology v2 };
diff --git a/src/psychology/v3.ts b/src/psychology/v3.ts
new file mode 100644
index 000000000..21bb6033f
--- /dev/null
+++ b/src/psychology/v3.ts
@@ -0,0 +1,15 @@
+/** Psychology V3 module — tsb analytics library. */
+export interface Psychology v3Options { tol?: number; maxIter?: number; }
+export interface Psychology v3Result { values: number[]; converged: boolean; }
+export function computePsychology v3(data: number[], opts: Psychology v3Options = {}): Psychology v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology v3 };
diff --git a/src/psychology/wasm.ts b/src/psychology/wasm.ts
new file mode 100644
index 000000000..d72f34e10
--- /dev/null
+++ b/src/psychology/wasm.ts
@@ -0,0 +1,15 @@
+/** Psychology Wasm module — tsb analytics library. */
+export interface Psychology wasmOptions { tol?: number; maxIter?: number; }
+export interface Psychology wasmResult { values: number[]; converged: boolean; }
+export function computePsychology wasm(data: number[], opts: Psychology wasmOptions = {}): Psychology wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology wasm };
diff --git a/src/psychology/xlarge.ts b/src/psychology/xlarge.ts
new file mode 100644
index 000000000..2f8fb8968
--- /dev/null
+++ b/src/psychology/xlarge.ts
@@ -0,0 +1,15 @@
+/** Psychology Xlarge module — tsb analytics library. */
+export interface Psychology xlargeOptions { tol?: number; maxIter?: number; }
+export interface Psychology xlargeResult { values: number[]; converged: boolean; }
+export function computePsychology xlarge(data: number[], opts: Psychology xlargeOptions = {}): Psychology xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePsychology xlarge };
diff --git a/src/pulmonology_sci/adaptation.ts b/src/pulmonology_sci/adaptation.ts
new file mode 100644
index 000000000..f258f32e3
--- /dev/null
+++ b/src/pulmonology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci adaptation module — tsb analytics library. */
+export interface PulmonologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciAdaptation(data: number[], opts: PulmonologySciAdaptationOptions = {}): PulmonologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciAdaptation };
diff --git a/src/pulmonology_sci/aggregation.ts b/src/pulmonology_sci/aggregation.ts
new file mode 100644
index 000000000..f67074022
--- /dev/null
+++ b/src/pulmonology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci aggregation module — tsb analytics library. */
+export interface PulmonologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciAggregationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciAggregation(data: number[], opts: PulmonologySciAggregationOptions = {}): PulmonologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciAggregation };
diff --git a/src/pulmonology_sci/algebra.ts b/src/pulmonology_sci/algebra.ts
new file mode 100644
index 000000000..616dd4d03
--- /dev/null
+++ b/src/pulmonology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci algebra module — tsb analytics library. */
+export interface PulmonologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computePulmonologySciAlgebra(data: number[], opts: PulmonologySciAlgebraOptions = {}): PulmonologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciAlgebra };
diff --git a/src/pulmonology_sci/alignment.ts b/src/pulmonology_sci/alignment.ts
new file mode 100644
index 000000000..4984b75b2
--- /dev/null
+++ b/src/pulmonology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci alignment module — tsb analytics library. */
+export interface PulmonologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computePulmonologySciAlignment(data: number[], opts: PulmonologySciAlignmentOptions = {}): PulmonologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciAlignment };
diff --git a/src/pulmonology_sci/analysis.ts b/src/pulmonology_sci/analysis.ts
new file mode 100644
index 000000000..00752a358
--- /dev/null
+++ b/src/pulmonology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci analysis module — tsb analytics library. */
+export interface PulmonologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computePulmonologySciAnalysis(data: number[], opts: PulmonologySciAnalysisOptions = {}): PulmonologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciAnalysis };
diff --git a/src/pulmonology_sci/augmentation.ts b/src/pulmonology_sci/augmentation.ts
new file mode 100644
index 000000000..56297f4a1
--- /dev/null
+++ b/src/pulmonology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci augmentation module — tsb analytics library. */
+export interface PulmonologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciAugmentation(data: number[], opts: PulmonologySciAugmentationOptions = {}): PulmonologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciAugmentation };
diff --git a/src/pulmonology_sci/bagging.ts b/src/pulmonology_sci/bagging.ts
new file mode 100644
index 000000000..b2108eb1f
--- /dev/null
+++ b/src/pulmonology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci bagging module — tsb analytics library. */
+export interface PulmonologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciBaggingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciBagging(data: number[], opts: PulmonologySciBaggingOptions = {}): PulmonologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciBagging };
diff --git a/src/pulmonology_sci/basis.ts b/src/pulmonology_sci/basis.ts
new file mode 100644
index 000000000..331a2c812
--- /dev/null
+++ b/src/pulmonology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci basis module — tsb analytics library. */
+export interface PulmonologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciBasisResult { values: number[]; converged: boolean; }
+export function computePulmonologySciBasis(data: number[], opts: PulmonologySciBasisOptions = {}): PulmonologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciBasis };
diff --git a/src/pulmonology_sci/benchmarking.ts b/src/pulmonology_sci/benchmarking.ts
new file mode 100644
index 000000000..7aa84ae08
--- /dev/null
+++ b/src/pulmonology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci benchmarking module — tsb analytics library. */
+export interface PulmonologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciBenchmarking(data: number[], opts: PulmonologySciBenchmarkingOptions = {}): PulmonologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciBenchmarking };
diff --git a/src/pulmonology_sci/blending.ts b/src/pulmonology_sci/blending.ts
new file mode 100644
index 000000000..947ebfc03
--- /dev/null
+++ b/src/pulmonology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci blending module — tsb analytics library. */
+export interface PulmonologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciBlendingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciBlending(data: number[], opts: PulmonologySciBlendingOptions = {}): PulmonologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciBlending };
diff --git a/src/pulmonology_sci/boosting.ts b/src/pulmonology_sci/boosting.ts
new file mode 100644
index 000000000..38468af86
--- /dev/null
+++ b/src/pulmonology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci boosting module — tsb analytics library. */
+export interface PulmonologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciBoostingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciBoosting(data: number[], opts: PulmonologySciBoostingOptions = {}): PulmonologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciBoosting };
diff --git a/src/pulmonology_sci/bootstrap.ts b/src/pulmonology_sci/bootstrap.ts
new file mode 100644
index 000000000..323eb0272
--- /dev/null
+++ b/src/pulmonology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci bootstrap module — tsb analytics library. */
+export interface PulmonologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computePulmonologySciBootstrap(data: number[], opts: PulmonologySciBootstrapOptions = {}): PulmonologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciBootstrap };
diff --git a/src/pulmonology_sci/calculus.ts b/src/pulmonology_sci/calculus.ts
new file mode 100644
index 000000000..6f60dccdc
--- /dev/null
+++ b/src/pulmonology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci calculus module — tsb analytics library. */
+export interface PulmonologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciCalculusResult { values: number[]; converged: boolean; }
+export function computePulmonologySciCalculus(data: number[], opts: PulmonologySciCalculusOptions = {}): PulmonologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciCalculus };
diff --git a/src/pulmonology_sci/calibration.ts b/src/pulmonology_sci/calibration.ts
new file mode 100644
index 000000000..941521b1a
--- /dev/null
+++ b/src/pulmonology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci calibration module — tsb analytics library. */
+export interface PulmonologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciCalibration(data: number[], opts: PulmonologySciCalibrationOptions = {}): PulmonologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciCalibration };
diff --git a/src/pulmonology_sci/characterization.ts b/src/pulmonology_sci/characterization.ts
new file mode 100644
index 000000000..52b87a392
--- /dev/null
+++ b/src/pulmonology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci characterization module — tsb analytics library. */
+export interface PulmonologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciCharacterization(data: number[], opts: PulmonologySciCharacterizationOptions = {}): PulmonologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciCharacterization };
diff --git a/src/pulmonology_sci/classification.ts b/src/pulmonology_sci/classification.ts
new file mode 100644
index 000000000..c02a06d5c
--- /dev/null
+++ b/src/pulmonology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci classification module — tsb analytics library. */
+export interface PulmonologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciClassificationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciClassification(data: number[], opts: PulmonologySciClassificationOptions = {}): PulmonologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciClassification };
diff --git a/src/pulmonology_sci/clustering.ts b/src/pulmonology_sci/clustering.ts
new file mode 100644
index 000000000..fcdec92de
--- /dev/null
+++ b/src/pulmonology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci clustering module — tsb analytics library. */
+export interface PulmonologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciClusteringResult { values: number[]; converged: boolean; }
+export function computePulmonologySciClustering(data: number[], opts: PulmonologySciClusteringOptions = {}): PulmonologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciClustering };
diff --git a/src/pulmonology_sci/compression.ts b/src/pulmonology_sci/compression.ts
new file mode 100644
index 000000000..ac1681ff7
--- /dev/null
+++ b/src/pulmonology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci compression module — tsb analytics library. */
+export interface PulmonologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciCompressionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciCompression(data: number[], opts: PulmonologySciCompressionOptions = {}): PulmonologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciCompression };
diff --git a/src/pulmonology_sci/continuous.ts b/src/pulmonology_sci/continuous.ts
new file mode 100644
index 000000000..5fb1fc1c3
--- /dev/null
+++ b/src/pulmonology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci continuous module — tsb analytics library. */
+export interface PulmonologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciContinuousResult { values: number[]; converged: boolean; }
+export function computePulmonologySciContinuous(data: number[], opts: PulmonologySciContinuousOptions = {}): PulmonologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciContinuous };
diff --git a/src/pulmonology_sci/control.ts b/src/pulmonology_sci/control.ts
new file mode 100644
index 000000000..d298e3bc5
--- /dev/null
+++ b/src/pulmonology_sci/control.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci control module — tsb analytics library. */
+export interface PulmonologySciControlOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciControlResult { values: number[]; converged: boolean; }
+export function computePulmonologySciControl(data: number[], opts: PulmonologySciControlOptions = {}): PulmonologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciControl };
diff --git a/src/pulmonology_sci/convergence.ts b/src/pulmonology_sci/convergence.ts
new file mode 100644
index 000000000..890669880
--- /dev/null
+++ b/src/pulmonology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci convergence module — tsb analytics library. */
+export interface PulmonologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computePulmonologySciConvergence(data: number[], opts: PulmonologySciConvergenceOptions = {}): PulmonologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciConvergence };
diff --git a/src/pulmonology_sci/convex.ts b/src/pulmonology_sci/convex.ts
new file mode 100644
index 000000000..1c85622a7
--- /dev/null
+++ b/src/pulmonology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci convex module — tsb analytics library. */
+export interface PulmonologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciConvexResult { values: number[]; converged: boolean; }
+export function computePulmonologySciConvex(data: number[], opts: PulmonologySciConvexOptions = {}): PulmonologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciConvex };
diff --git a/src/pulmonology_sci/correlation.ts b/src/pulmonology_sci/correlation.ts
new file mode 100644
index 000000000..fc1deb002
--- /dev/null
+++ b/src/pulmonology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci correlation module — tsb analytics library. */
+export interface PulmonologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciCorrelation(data: number[], opts: PulmonologySciCorrelationOptions = {}): PulmonologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciCorrelation };
diff --git a/src/pulmonology_sci/covariance.ts b/src/pulmonology_sci/covariance.ts
new file mode 100644
index 000000000..e988b65d3
--- /dev/null
+++ b/src/pulmonology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci covariance module — tsb analytics library. */
+export interface PulmonologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computePulmonologySciCovariance(data: number[], opts: PulmonologySciCovarianceOptions = {}): PulmonologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciCovariance };
diff --git a/src/pulmonology_sci/cross_validation.ts b/src/pulmonology_sci/cross_validation.ts
new file mode 100644
index 000000000..54d1a198c
--- /dev/null
+++ b/src/pulmonology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci cross_validation module — tsb analytics library. */
+export interface PulmonologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciCrossValidation(data: number[], opts: PulmonologySciCrossValidationOptions = {}): PulmonologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciCrossValidation };
diff --git a/src/pulmonology_sci/decoding.ts b/src/pulmonology_sci/decoding.ts
new file mode 100644
index 000000000..18fb494c3
--- /dev/null
+++ b/src/pulmonology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci decoding module — tsb analytics library. */
+export interface PulmonologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDecodingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDecoding(data: number[], opts: PulmonologySciDecodingOptions = {}): PulmonologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDecoding };
diff --git a/src/pulmonology_sci/decomposition.ts b/src/pulmonology_sci/decomposition.ts
new file mode 100644
index 000000000..e128b5284
--- /dev/null
+++ b/src/pulmonology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci decomposition module — tsb analytics library. */
+export interface PulmonologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDecomposition(data: number[], opts: PulmonologySciDecompositionOptions = {}): PulmonologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDecomposition };
diff --git a/src/pulmonology_sci/detection.ts b/src/pulmonology_sci/detection.ts
new file mode 100644
index 000000000..e090cd5c0
--- /dev/null
+++ b/src/pulmonology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci detection module — tsb analytics library. */
+export interface PulmonologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDetectionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDetection(data: number[], opts: PulmonologySciDetectionOptions = {}): PulmonologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDetection };
diff --git a/src/pulmonology_sci/deterministic.ts b/src/pulmonology_sci/deterministic.ts
new file mode 100644
index 000000000..b1d45cdf3
--- /dev/null
+++ b/src/pulmonology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci deterministic module — tsb analytics library. */
+export interface PulmonologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDeterministic(data: number[], opts: PulmonologySciDeterministicOptions = {}): PulmonologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDeterministic };
diff --git a/src/pulmonology_sci/diagnostics.ts b/src/pulmonology_sci/diagnostics.ts
new file mode 100644
index 000000000..37059ccf0
--- /dev/null
+++ b/src/pulmonology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci diagnostics module — tsb analytics library. */
+export interface PulmonologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDiagnostics(data: number[], opts: PulmonologySciDiagnosticsOptions = {}): PulmonologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDiagnostics };
diff --git a/src/pulmonology_sci/differential.ts b/src/pulmonology_sci/differential.ts
new file mode 100644
index 000000000..0be56947b
--- /dev/null
+++ b/src/pulmonology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci differential module — tsb analytics library. */
+export interface PulmonologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDifferential(data: number[], opts: PulmonologySciDifferentialOptions = {}): PulmonologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDifferential };
diff --git a/src/pulmonology_sci/discrete.ts b/src/pulmonology_sci/discrete.ts
new file mode 100644
index 000000000..e4eeba3ef
--- /dev/null
+++ b/src/pulmonology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci discrete module — tsb analytics library. */
+export interface PulmonologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDiscrete(data: number[], opts: PulmonologySciDiscreteOptions = {}): PulmonologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDiscrete };
diff --git a/src/pulmonology_sci/distribution.ts b/src/pulmonology_sci/distribution.ts
new file mode 100644
index 000000000..d5ce2dd7d
--- /dev/null
+++ b/src/pulmonology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci distribution module — tsb analytics library. */
+export interface PulmonologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDistributionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDistribution(data: number[], opts: PulmonologySciDistributionOptions = {}): PulmonologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDistribution };
diff --git a/src/pulmonology_sci/dynamic.ts b/src/pulmonology_sci/dynamic.ts
new file mode 100644
index 000000000..b8f014803
--- /dev/null
+++ b/src/pulmonology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci dynamic module — tsb analytics library. */
+export interface PulmonologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciDynamicResult { values: number[]; converged: boolean; }
+export function computePulmonologySciDynamic(data: number[], opts: PulmonologySciDynamicOptions = {}): PulmonologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciDynamic };
diff --git a/src/pulmonology_sci/embedding.ts b/src/pulmonology_sci/embedding.ts
new file mode 100644
index 000000000..0ed6921c9
--- /dev/null
+++ b/src/pulmonology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci embedding module — tsb analytics library. */
+export interface PulmonologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciEmbedding(data: number[], opts: PulmonologySciEmbeddingOptions = {}): PulmonologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciEmbedding };
diff --git a/src/pulmonology_sci/encoding.ts b/src/pulmonology_sci/encoding.ts
new file mode 100644
index 000000000..475b726aa
--- /dev/null
+++ b/src/pulmonology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci encoding module — tsb analytics library. */
+export interface PulmonologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciEncodingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciEncoding(data: number[], opts: PulmonologySciEncodingOptions = {}): PulmonologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciEncoding };
diff --git a/src/pulmonology_sci/ensemble.ts b/src/pulmonology_sci/ensemble.ts
new file mode 100644
index 000000000..5a51efa76
--- /dev/null
+++ b/src/pulmonology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci ensemble module — tsb analytics library. */
+export interface PulmonologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computePulmonologySciEnsemble(data: number[], opts: PulmonologySciEnsembleOptions = {}): PulmonologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciEnsemble };
diff --git a/src/pulmonology_sci/estimation.ts b/src/pulmonology_sci/estimation.ts
new file mode 100644
index 000000000..de960a022
--- /dev/null
+++ b/src/pulmonology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci estimation module — tsb analytics library. */
+export interface PulmonologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciEstimationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciEstimation(data: number[], opts: PulmonologySciEstimationOptions = {}): PulmonologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciEstimation };
diff --git a/src/pulmonology_sci/evaluation.ts b/src/pulmonology_sci/evaluation.ts
new file mode 100644
index 000000000..7bb6fe32f
--- /dev/null
+++ b/src/pulmonology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci evaluation module — tsb analytics library. */
+export interface PulmonologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciEvaluation(data: number[], opts: PulmonologySciEvaluationOptions = {}): PulmonologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciEvaluation };
diff --git a/src/pulmonology_sci/extrapolation.ts b/src/pulmonology_sci/extrapolation.ts
new file mode 100644
index 000000000..9961d1a7e
--- /dev/null
+++ b/src/pulmonology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci extrapolation module — tsb analytics library. */
+export interface PulmonologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciExtrapolation(data: number[], opts: PulmonologySciExtrapolationOptions = {}): PulmonologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciExtrapolation };
diff --git a/src/pulmonology_sci/features.ts b/src/pulmonology_sci/features.ts
new file mode 100644
index 000000000..44f53dc24
--- /dev/null
+++ b/src/pulmonology_sci/features.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci features module — tsb analytics library. */
+export interface PulmonologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computePulmonologySciFeatures(data: number[], opts: PulmonologySciFeaturesOptions = {}): PulmonologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciFeatures };
diff --git a/src/pulmonology_sci/feedback.ts b/src/pulmonology_sci/feedback.ts
new file mode 100644
index 000000000..fc4c69302
--- /dev/null
+++ b/src/pulmonology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci feedback module — tsb analytics library. */
+export interface PulmonologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computePulmonologySciFeedback(data: number[], opts: PulmonologySciFeedbackOptions = {}): PulmonologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciFeedback };
diff --git a/src/pulmonology_sci/filtering.ts b/src/pulmonology_sci/filtering.ts
new file mode 100644
index 000000000..8ad0fa2a3
--- /dev/null
+++ b/src/pulmonology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci filtering module — tsb analytics library. */
+export interface PulmonologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciFilteringResult { values: number[]; converged: boolean; }
+export function computePulmonologySciFiltering(data: number[], opts: PulmonologySciFilteringOptions = {}): PulmonologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciFiltering };
diff --git a/src/pulmonology_sci/fourier.ts b/src/pulmonology_sci/fourier.ts
new file mode 100644
index 000000000..63c55da05
--- /dev/null
+++ b/src/pulmonology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci fourier module — tsb analytics library. */
+export interface PulmonologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciFourierResult { values: number[]; converged: boolean; }
+export function computePulmonologySciFourier(data: number[], opts: PulmonologySciFourierOptions = {}): PulmonologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciFourier };
diff --git a/src/pulmonology_sci/fusion.ts b/src/pulmonology_sci/fusion.ts
new file mode 100644
index 000000000..65d55b78d
--- /dev/null
+++ b/src/pulmonology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci fusion module — tsb analytics library. */
+export interface PulmonologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciFusionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciFusion(data: number[], opts: PulmonologySciFusionOptions = {}): PulmonologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciFusion };
diff --git a/src/pulmonology_sci/generation.ts b/src/pulmonology_sci/generation.ts
new file mode 100644
index 000000000..f0494674c
--- /dev/null
+++ b/src/pulmonology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci generation module — tsb analytics library. */
+export interface PulmonologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciGenerationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciGeneration(data: number[], opts: PulmonologySciGenerationOptions = {}): PulmonologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciGeneration };
diff --git a/src/pulmonology_sci/geometry.ts b/src/pulmonology_sci/geometry.ts
new file mode 100644
index 000000000..17599bba2
--- /dev/null
+++ b/src/pulmonology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci geometry module — tsb analytics library. */
+export interface PulmonologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciGeometryResult { values: number[]; converged: boolean; }
+export function computePulmonologySciGeometry(data: number[], opts: PulmonologySciGeometryOptions = {}): PulmonologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciGeometry };
diff --git a/src/pulmonology_sci/gradient.ts b/src/pulmonology_sci/gradient.ts
new file mode 100644
index 000000000..66a6a6d6b
--- /dev/null
+++ b/src/pulmonology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci gradient module — tsb analytics library. */
+export interface PulmonologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciGradientResult { values: number[]; converged: boolean; }
+export function computePulmonologySciGradient(data: number[], opts: PulmonologySciGradientOptions = {}): PulmonologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciGradient };
diff --git a/src/pulmonology_sci/hessian.ts b/src/pulmonology_sci/hessian.ts
new file mode 100644
index 000000000..3b6ab13be
--- /dev/null
+++ b/src/pulmonology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci hessian module — tsb analytics library. */
+export interface PulmonologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciHessianResult { values: number[]; converged: boolean; }
+export function computePulmonologySciHessian(data: number[], opts: PulmonologySciHessianOptions = {}): PulmonologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciHessian };
diff --git a/src/pulmonology_sci/hypothesis.ts b/src/pulmonology_sci/hypothesis.ts
new file mode 100644
index 000000000..98cb2a7eb
--- /dev/null
+++ b/src/pulmonology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci hypothesis module — tsb analytics library. */
+export interface PulmonologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computePulmonologySciHypothesis(data: number[], opts: PulmonologySciHypothesisOptions = {}): PulmonologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciHypothesis };
diff --git a/src/pulmonology_sci/inference.ts b/src/pulmonology_sci/inference.ts
new file mode 100644
index 000000000..ca0940954
--- /dev/null
+++ b/src/pulmonology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci inference module — tsb analytics library. */
+export interface PulmonologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciInferenceResult { values: number[]; converged: boolean; }
+export function computePulmonologySciInference(data: number[], opts: PulmonologySciInferenceOptions = {}): PulmonologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciInference };
diff --git a/src/pulmonology_sci/inference2.ts b/src/pulmonology_sci/inference2.ts
new file mode 100644
index 000000000..c7c5dc8f0
--- /dev/null
+++ b/src/pulmonology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci inference2 module — tsb analytics library. */
+export interface PulmonologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciInferenceResult { values: number[]; converged: boolean; }
+export function computePulmonologySciInference(data: number[], opts: PulmonologySciInferenceOptions = {}): PulmonologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciInference };
diff --git a/src/pulmonology_sci/integral.ts b/src/pulmonology_sci/integral.ts
new file mode 100644
index 000000000..2964f1aa9
--- /dev/null
+++ b/src/pulmonology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci integral module — tsb analytics library. */
+export interface PulmonologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciIntegralResult { values: number[]; converged: boolean; }
+export function computePulmonologySciIntegral(data: number[], opts: PulmonologySciIntegralOptions = {}): PulmonologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciIntegral };
diff --git a/src/pulmonology_sci/integration.ts b/src/pulmonology_sci/integration.ts
new file mode 100644
index 000000000..55e8264f4
--- /dev/null
+++ b/src/pulmonology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci integration module — tsb analytics library. */
+export interface PulmonologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciIntegration(data: number[], opts: PulmonologySciIntegrationOptions = {}): PulmonologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciIntegration };
diff --git a/src/pulmonology_sci/interpolation.ts b/src/pulmonology_sci/interpolation.ts
new file mode 100644
index 000000000..7b9b7394b
--- /dev/null
+++ b/src/pulmonology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci interpolation module — tsb analytics library. */
+export interface PulmonologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciInterpolation(data: number[], opts: PulmonologySciInterpolationOptions = {}): PulmonologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciInterpolation };
diff --git a/src/pulmonology_sci/jacobian.ts b/src/pulmonology_sci/jacobian.ts
new file mode 100644
index 000000000..5a6015740
--- /dev/null
+++ b/src/pulmonology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci jacobian module — tsb analytics library. */
+export interface PulmonologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciJacobianResult { values: number[]; converged: boolean; }
+export function computePulmonologySciJacobian(data: number[], opts: PulmonologySciJacobianOptions = {}): PulmonologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciJacobian };
diff --git a/src/pulmonology_sci/kernel.ts b/src/pulmonology_sci/kernel.ts
new file mode 100644
index 000000000..4932f9340
--- /dev/null
+++ b/src/pulmonology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci kernel module — tsb analytics library. */
+export interface PulmonologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciKernelResult { values: number[]; converged: boolean; }
+export function computePulmonologySciKernel(data: number[], opts: PulmonologySciKernelOptions = {}): PulmonologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciKernel };
diff --git a/src/pulmonology_sci/laplacian.ts b/src/pulmonology_sci/laplacian.ts
new file mode 100644
index 000000000..7e5d9dba1
--- /dev/null
+++ b/src/pulmonology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci laplacian module — tsb analytics library. */
+export interface PulmonologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computePulmonologySciLaplacian(data: number[], opts: PulmonologySciLaplacianOptions = {}): PulmonologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciLaplacian };
diff --git a/src/pulmonology_sci/learning.ts b/src/pulmonology_sci/learning.ts
new file mode 100644
index 000000000..fcf8b59e6
--- /dev/null
+++ b/src/pulmonology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci learning module — tsb analytics library. */
+export interface PulmonologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciLearningResult { values: number[]; converged: boolean; }
+export function computePulmonologySciLearning(data: number[], opts: PulmonologySciLearningOptions = {}): PulmonologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciLearning };
diff --git a/src/pulmonology_sci/linear.ts b/src/pulmonology_sci/linear.ts
new file mode 100644
index 000000000..a2f8069b3
--- /dev/null
+++ b/src/pulmonology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci linear module — tsb analytics library. */
+export interface PulmonologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciLinearResult { values: number[]; converged: boolean; }
+export function computePulmonologySciLinear(data: number[], opts: PulmonologySciLinearOptions = {}): PulmonologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciLinear };
diff --git a/src/pulmonology_sci/manifold.ts b/src/pulmonology_sci/manifold.ts
new file mode 100644
index 000000000..4d86c965a
--- /dev/null
+++ b/src/pulmonology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci manifold module — tsb analytics library. */
+export interface PulmonologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciManifoldResult { values: number[]; converged: boolean; }
+export function computePulmonologySciManifold(data: number[], opts: PulmonologySciManifoldOptions = {}): PulmonologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciManifold };
diff --git a/src/pulmonology_sci/matching.ts b/src/pulmonology_sci/matching.ts
new file mode 100644
index 000000000..c19c88412
--- /dev/null
+++ b/src/pulmonology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci matching module — tsb analytics library. */
+export interface PulmonologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciMatchingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciMatching(data: number[], opts: PulmonologySciMatchingOptions = {}): PulmonologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciMatching };
diff --git a/src/pulmonology_sci/measurement.ts b/src/pulmonology_sci/measurement.ts
new file mode 100644
index 000000000..870b59534
--- /dev/null
+++ b/src/pulmonology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci measurement module — tsb analytics library. */
+export interface PulmonologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computePulmonologySciMeasurement(data: number[], opts: PulmonologySciMeasurementOptions = {}): PulmonologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciMeasurement };
diff --git a/src/pulmonology_sci/metrics.ts b/src/pulmonology_sci/metrics.ts
new file mode 100644
index 000000000..15824085b
--- /dev/null
+++ b/src/pulmonology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci metrics module — tsb analytics library. */
+export interface PulmonologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciMetricsResult { values: number[]; converged: boolean; }
+export function computePulmonologySciMetrics(data: number[], opts: PulmonologySciMetricsOptions = {}): PulmonologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciMetrics };
diff --git a/src/pulmonology_sci/modeling.ts b/src/pulmonology_sci/modeling.ts
new file mode 100644
index 000000000..748c2dbbb
--- /dev/null
+++ b/src/pulmonology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci modeling module — tsb analytics library. */
+export interface PulmonologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciModelingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciModeling(data: number[], opts: PulmonologySciModelingOptions = {}): PulmonologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciModeling };
diff --git a/src/pulmonology_sci/monitoring.ts b/src/pulmonology_sci/monitoring.ts
new file mode 100644
index 000000000..ef508942f
--- /dev/null
+++ b/src/pulmonology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci monitoring module — tsb analytics library. */
+export interface PulmonologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computePulmonologySciMonitoring(data: number[], opts: PulmonologySciMonitoringOptions = {}): PulmonologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciMonitoring };
diff --git a/src/pulmonology_sci/nonlinear.ts b/src/pulmonology_sci/nonlinear.ts
new file mode 100644
index 000000000..ae868dfda
--- /dev/null
+++ b/src/pulmonology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci nonlinear module — tsb analytics library. */
+export interface PulmonologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computePulmonologySciNonlinear(data: number[], opts: PulmonologySciNonlinearOptions = {}): PulmonologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciNonlinear };
diff --git a/src/pulmonology_sci/normalization.ts b/src/pulmonology_sci/normalization.ts
new file mode 100644
index 000000000..f255af6c2
--- /dev/null
+++ b/src/pulmonology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci normalization module — tsb analytics library. */
+export interface PulmonologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciNormalization(data: number[], opts: PulmonologySciNormalizationOptions = {}): PulmonologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciNormalization };
diff --git a/src/pulmonology_sci/optimization.ts b/src/pulmonology_sci/optimization.ts
new file mode 100644
index 000000000..e5fc4ca4c
--- /dev/null
+++ b/src/pulmonology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci optimization module — tsb analytics library. */
+export interface PulmonologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciOptimization(data: number[], opts: PulmonologySciOptimizationOptions = {}): PulmonologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciOptimization };
diff --git a/src/pulmonology_sci/patterns.ts b/src/pulmonology_sci/patterns.ts
new file mode 100644
index 000000000..03aecd695
--- /dev/null
+++ b/src/pulmonology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci patterns module — tsb analytics library. */
+export interface PulmonologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciPatternsResult { values: number[]; converged: boolean; }
+export function computePulmonologySciPatterns(data: number[], opts: PulmonologySciPatternsOptions = {}): PulmonologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciPatterns };
diff --git a/src/pulmonology_sci/permutation.ts b/src/pulmonology_sci/permutation.ts
new file mode 100644
index 000000000..13fa604b6
--- /dev/null
+++ b/src/pulmonology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci permutation module — tsb analytics library. */
+export interface PulmonologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciPermutationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciPermutation(data: number[], opts: PulmonologySciPermutationOptions = {}): PulmonologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciPermutation };
diff --git a/src/pulmonology_sci/prediction.ts b/src/pulmonology_sci/prediction.ts
new file mode 100644
index 000000000..58970c096
--- /dev/null
+++ b/src/pulmonology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci prediction module — tsb analytics library. */
+export interface PulmonologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciPredictionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciPrediction(data: number[], opts: PulmonologySciPredictionOptions = {}): PulmonologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciPrediction };
diff --git a/src/pulmonology_sci/processing.ts b/src/pulmonology_sci/processing.ts
new file mode 100644
index 000000000..167ba419c
--- /dev/null
+++ b/src/pulmonology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci processing module — tsb analytics library. */
+export interface PulmonologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciProcessingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciProcessing(data: number[], opts: PulmonologySciProcessingOptions = {}): PulmonologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciProcessing };
diff --git a/src/pulmonology_sci/profiling.ts b/src/pulmonology_sci/profiling.ts
new file mode 100644
index 000000000..853c735ab
--- /dev/null
+++ b/src/pulmonology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci profiling module — tsb analytics library. */
+export interface PulmonologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciProfilingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciProfiling(data: number[], opts: PulmonologySciProfilingOptions = {}): PulmonologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciProfiling };
diff --git a/src/pulmonology_sci/projection.ts b/src/pulmonology_sci/projection.ts
new file mode 100644
index 000000000..76bffa266
--- /dev/null
+++ b/src/pulmonology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci projection module — tsb analytics library. */
+export interface PulmonologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciProjectionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciProjection(data: number[], opts: PulmonologySciProjectionOptions = {}): PulmonologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciProjection };
diff --git a/src/pulmonology_sci/ranking.ts b/src/pulmonology_sci/ranking.ts
new file mode 100644
index 000000000..2e15dfae2
--- /dev/null
+++ b/src/pulmonology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci ranking module — tsb analytics library. */
+export interface PulmonologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciRankingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciRanking(data: number[], opts: PulmonologySciRankingOptions = {}): PulmonologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciRanking };
diff --git a/src/pulmonology_sci/reconstruction.ts b/src/pulmonology_sci/reconstruction.ts
new file mode 100644
index 000000000..9c40ab627
--- /dev/null
+++ b/src/pulmonology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci reconstruction module — tsb analytics library. */
+export interface PulmonologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciReconstruction(data: number[], opts: PulmonologySciReconstructionOptions = {}): PulmonologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciReconstruction };
diff --git a/src/pulmonology_sci/registration.ts b/src/pulmonology_sci/registration.ts
new file mode 100644
index 000000000..4eae9bbce
--- /dev/null
+++ b/src/pulmonology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci registration module — tsb analytics library. */
+export interface PulmonologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciRegistration(data: number[], opts: PulmonologySciRegistrationOptions = {}): PulmonologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciRegistration };
diff --git a/src/pulmonology_sci/regression.ts b/src/pulmonology_sci/regression.ts
new file mode 100644
index 000000000..8954b8272
--- /dev/null
+++ b/src/pulmonology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci regression module — tsb analytics library. */
+export interface PulmonologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciRegressionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciRegression(data: number[], opts: PulmonologySciRegressionOptions = {}): PulmonologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciRegression };
diff --git a/src/pulmonology_sci/regularization.ts b/src/pulmonology_sci/regularization.ts
new file mode 100644
index 000000000..d235dbe96
--- /dev/null
+++ b/src/pulmonology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci regularization module — tsb analytics library. */
+export interface PulmonologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciRegularization(data: number[], opts: PulmonologySciRegularizationOptions = {}): PulmonologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciRegularization };
diff --git a/src/pulmonology_sci/robustness.ts b/src/pulmonology_sci/robustness.ts
new file mode 100644
index 000000000..b0f24aec9
--- /dev/null
+++ b/src/pulmonology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci robustness module — tsb analytics library. */
+export interface PulmonologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computePulmonologySciRobustness(data: number[], opts: PulmonologySciRobustnessOptions = {}): PulmonologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciRobustness };
diff --git a/src/pulmonology_sci/sampling.ts b/src/pulmonology_sci/sampling.ts
new file mode 100644
index 000000000..40a2b04d4
--- /dev/null
+++ b/src/pulmonology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci sampling module — tsb analytics library. */
+export interface PulmonologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciSamplingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciSampling(data: number[], opts: PulmonologySciSamplingOptions = {}): PulmonologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciSampling };
diff --git a/src/pulmonology_sci/sampling2.ts b/src/pulmonology_sci/sampling2.ts
new file mode 100644
index 000000000..a03998217
--- /dev/null
+++ b/src/pulmonology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci sampling2 module — tsb analytics library. */
+export interface PulmonologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciSamplingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciSampling(data: number[], opts: PulmonologySciSamplingOptions = {}): PulmonologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciSampling };
diff --git a/src/pulmonology_sci/scaling.ts b/src/pulmonology_sci/scaling.ts
new file mode 100644
index 000000000..fc0f0c9bb
--- /dev/null
+++ b/src/pulmonology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci scaling module — tsb analytics library. */
+export interface PulmonologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciScalingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciScaling(data: number[], opts: PulmonologySciScalingOptions = {}): PulmonologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciScaling };
diff --git a/src/pulmonology_sci/scoring.ts b/src/pulmonology_sci/scoring.ts
new file mode 100644
index 000000000..12c7986dc
--- /dev/null
+++ b/src/pulmonology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci scoring module — tsb analytics library. */
+export interface PulmonologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciScoringResult { values: number[]; converged: boolean; }
+export function computePulmonologySciScoring(data: number[], opts: PulmonologySciScoringOptions = {}): PulmonologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciScoring };
diff --git a/src/pulmonology_sci/segmentation.ts b/src/pulmonology_sci/segmentation.ts
new file mode 100644
index 000000000..ec5711540
--- /dev/null
+++ b/src/pulmonology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci segmentation module — tsb analytics library. */
+export interface PulmonologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciSegmentation(data: number[], opts: PulmonologySciSegmentationOptions = {}): PulmonologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciSegmentation };
diff --git a/src/pulmonology_sci/selection.ts b/src/pulmonology_sci/selection.ts
new file mode 100644
index 000000000..bff09a62b
--- /dev/null
+++ b/src/pulmonology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci selection module — tsb analytics library. */
+export interface PulmonologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciSelectionResult { values: number[]; converged: boolean; }
+export function computePulmonologySciSelection(data: number[], opts: PulmonologySciSelectionOptions = {}): PulmonologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciSelection };
diff --git a/src/pulmonology_sci/sensitivity.ts b/src/pulmonology_sci/sensitivity.ts
new file mode 100644
index 000000000..28fcd3ae0
--- /dev/null
+++ b/src/pulmonology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci sensitivity module — tsb analytics library. */
+export interface PulmonologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computePulmonologySciSensitivity(data: number[], opts: PulmonologySciSensitivityOptions = {}): PulmonologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciSensitivity };
diff --git a/src/pulmonology_sci/simulation.ts b/src/pulmonology_sci/simulation.ts
new file mode 100644
index 000000000..607bc30f2
--- /dev/null
+++ b/src/pulmonology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci simulation module — tsb analytics library. */
+export interface PulmonologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciSimulationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciSimulation(data: number[], opts: PulmonologySciSimulationOptions = {}): PulmonologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciSimulation };
diff --git a/src/pulmonology_sci/smoothing.ts b/src/pulmonology_sci/smoothing.ts
new file mode 100644
index 000000000..074966946
--- /dev/null
+++ b/src/pulmonology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci smoothing module — tsb analytics library. */
+export interface PulmonologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciSmoothing(data: number[], opts: PulmonologySciSmoothingOptions = {}): PulmonologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciSmoothing };
diff --git a/src/pulmonology_sci/stability.ts b/src/pulmonology_sci/stability.ts
new file mode 100644
index 000000000..0236f49a9
--- /dev/null
+++ b/src/pulmonology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci stability module — tsb analytics library. */
+export interface PulmonologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciStabilityResult { values: number[]; converged: boolean; }
+export function computePulmonologySciStability(data: number[], opts: PulmonologySciStabilityOptions = {}): PulmonologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciStability };
diff --git a/src/pulmonology_sci/stacking.ts b/src/pulmonology_sci/stacking.ts
new file mode 100644
index 000000000..ca1795385
--- /dev/null
+++ b/src/pulmonology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci stacking module — tsb analytics library. */
+export interface PulmonologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciStackingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciStacking(data: number[], opts: PulmonologySciStackingOptions = {}): PulmonologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciStacking };
diff --git a/src/pulmonology_sci/standardization.ts b/src/pulmonology_sci/standardization.ts
new file mode 100644
index 000000000..da68f2241
--- /dev/null
+++ b/src/pulmonology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci standardization module — tsb analytics library. */
+export interface PulmonologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciStandardization(data: number[], opts: PulmonologySciStandardizationOptions = {}): PulmonologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciStandardization };
diff --git a/src/pulmonology_sci/static.ts b/src/pulmonology_sci/static.ts
new file mode 100644
index 000000000..b8a0b783a
--- /dev/null
+++ b/src/pulmonology_sci/static.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci static module — tsb analytics library. */
+export interface PulmonologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciStaticResult { values: number[]; converged: boolean; }
+export function computePulmonologySciStatic(data: number[], opts: PulmonologySciStaticOptions = {}): PulmonologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciStatic };
diff --git a/src/pulmonology_sci/stochastic.ts b/src/pulmonology_sci/stochastic.ts
new file mode 100644
index 000000000..8d1ae8726
--- /dev/null
+++ b/src/pulmonology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci stochastic module — tsb analytics library. */
+export interface PulmonologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciStochasticResult { values: number[]; converged: boolean; }
+export function computePulmonologySciStochastic(data: number[], opts: PulmonologySciStochasticOptions = {}): PulmonologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciStochastic };
diff --git a/src/pulmonology_sci/synthesis.ts b/src/pulmonology_sci/synthesis.ts
new file mode 100644
index 000000000..8deb4d0d2
--- /dev/null
+++ b/src/pulmonology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci synthesis module — tsb analytics library. */
+export interface PulmonologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computePulmonologySciSynthesis(data: number[], opts: PulmonologySciSynthesisOptions = {}): PulmonologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciSynthesis };
diff --git a/src/pulmonology_sci/topology.ts b/src/pulmonology_sci/topology.ts
new file mode 100644
index 000000000..43e9a95a5
--- /dev/null
+++ b/src/pulmonology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci topology module — tsb analytics library. */
+export interface PulmonologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciTopologyResult { values: number[]; converged: boolean; }
+export function computePulmonologySciTopology(data: number[], opts: PulmonologySciTopologyOptions = {}): PulmonologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciTopology };
diff --git a/src/pulmonology_sci/tracking.ts b/src/pulmonology_sci/tracking.ts
new file mode 100644
index 000000000..f422af7fb
--- /dev/null
+++ b/src/pulmonology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci tracking module — tsb analytics library. */
+export interface PulmonologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciTrackingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciTracking(data: number[], opts: PulmonologySciTrackingOptions = {}): PulmonologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciTracking };
diff --git a/src/pulmonology_sci/transform.ts b/src/pulmonology_sci/transform.ts
new file mode 100644
index 000000000..c5dc8e2ae
--- /dev/null
+++ b/src/pulmonology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci transform module — tsb analytics library. */
+export interface PulmonologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciTransformResult { values: number[]; converged: boolean; }
+export function computePulmonologySciTransform(data: number[], opts: PulmonologySciTransformOptions = {}): PulmonologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciTransform };
diff --git a/src/pulmonology_sci/uncertainty.ts b/src/pulmonology_sci/uncertainty.ts
new file mode 100644
index 000000000..468ec7b00
--- /dev/null
+++ b/src/pulmonology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci uncertainty module — tsb analytics library. */
+export interface PulmonologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computePulmonologySciUncertainty(data: number[], opts: PulmonologySciUncertaintyOptions = {}): PulmonologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciUncertainty };
diff --git a/src/pulmonology_sci/validation.ts b/src/pulmonology_sci/validation.ts
new file mode 100644
index 000000000..9e270b66e
--- /dev/null
+++ b/src/pulmonology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci validation module — tsb analytics library. */
+export interface PulmonologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciValidationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciValidation(data: number[], opts: PulmonologySciValidationOptions = {}): PulmonologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciValidation };
diff --git a/src/pulmonology_sci/verification.ts b/src/pulmonology_sci/verification.ts
new file mode 100644
index 000000000..409c74142
--- /dev/null
+++ b/src/pulmonology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci verification module — tsb analytics library. */
+export interface PulmonologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciVerificationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciVerification(data: number[], opts: PulmonologySciVerificationOptions = {}): PulmonologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciVerification };
diff --git a/src/pulmonology_sci/visualization.ts b/src/pulmonology_sci/visualization.ts
new file mode 100644
index 000000000..b1c7fee05
--- /dev/null
+++ b/src/pulmonology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci visualization module — tsb analytics library. */
+export interface PulmonologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computePulmonologySciVisualization(data: number[], opts: PulmonologySciVisualizationOptions = {}): PulmonologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciVisualization };
diff --git a/src/pulmonology_sci/voting.ts b/src/pulmonology_sci/voting.ts
new file mode 100644
index 000000000..32189bc0b
--- /dev/null
+++ b/src/pulmonology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci voting module — tsb analytics library. */
+export interface PulmonologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciVotingResult { values: number[]; converged: boolean; }
+export function computePulmonologySciVoting(data: number[], opts: PulmonologySciVotingOptions = {}): PulmonologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciVoting };
diff --git a/src/pulmonology_sci/wavelet.ts b/src/pulmonology_sci/wavelet.ts
new file mode 100644
index 000000000..507552eb6
--- /dev/null
+++ b/src/pulmonology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** pulmonology_sci wavelet module — tsb analytics library. */
+export interface PulmonologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface PulmonologySciWaveletResult { values: number[]; converged: boolean; }
+export function computePulmonologySciWavelet(data: number[], opts: PulmonologySciWaveletOptions = {}): PulmonologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computePulmonologySciWavelet };
diff --git a/src/quant/accruals.ts b/src/quant/accruals.ts
new file mode 100644
index 000000000..6e24ed026
--- /dev/null
+++ b/src/quant/accruals.ts
@@ -0,0 +1,22 @@
+/** Accruals module — tsb analytics library. */
+
+/** Options for Accruals. */
+export interface AccrualsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Accruals. */
+export interface AccrualsResult { values: number[]; converged: boolean; }
+
+/** Compute Accruals. */
+export function computeAccruals(data: number[], opts: AccrualsOptions = {}): AccrualsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAccruals };
diff --git a/src/quant/advanced.ts b/src/quant/advanced.ts
new file mode 100644
index 000000000..b79f2fc56
--- /dev/null
+++ b/src/quant/advanced.ts
@@ -0,0 +1,15 @@
+/** Quant Advanced module — tsb analytics library. */
+export interface Quant advancedOptions { tol?: number; maxIter?: number; }
+export interface Quant advancedResult { values: number[]; converged: boolean; }
+export function computeQuant advanced(data: number[], opts: Quant advancedOptions = {}): Quant advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant advanced };
diff --git a/src/quant/alpha_model.ts b/src/quant/alpha_model.ts
new file mode 100644
index 000000000..0c88297fb
--- /dev/null
+++ b/src/quant/alpha_model.ts
@@ -0,0 +1,22 @@
+/** Alpha Model module — tsb analytics library. */
+
+/** Options for Alpha Model. */
+export interface AlphaModelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Alpha Model. */
+export interface AlphaModelResult { values: number[]; converged: boolean; }
+
+/** Compute Alpha Model. */
+export function computeAlphaModel(data: number[], opts: AlphaModelOptions = {}): AlphaModelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAlphaModel };
diff --git a/src/quant/analyst.ts b/src/quant/analyst.ts
new file mode 100644
index 000000000..7d4b0dd8e
--- /dev/null
+++ b/src/quant/analyst.ts
@@ -0,0 +1,22 @@
+/** Analyst module — tsb analytics library. */
+
+/** Options for Analyst. */
+export interface AnalystOptions { tol?: number; maxIter?: number; }
+
+/** Result from Analyst. */
+export interface AnalystResult { values: number[]; converged: boolean; }
+
+/** Compute Analyst. */
+export function computeAnalyst(data: number[], opts: AnalystOptions = {}): AnalystResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAnalyst };
diff --git a/src/quant/base2.ts b/src/quant/base2.ts
new file mode 100644
index 000000000..2fddcd9bd
--- /dev/null
+++ b/src/quant/base2.ts
@@ -0,0 +1,15 @@
+/** Quant Base2 module — tsb analytics library. */
+export interface Quant base2Options { tol?: number; maxIter?: number; }
+export interface Quant base2Result { values: number[]; converged: boolean; }
+export function computeQuant base2(data: number[], opts: Quant base2Options = {}): Quant base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant base2 };
diff --git a/src/quant/batch.ts b/src/quant/batch.ts
new file mode 100644
index 000000000..a73ce5c22
--- /dev/null
+++ b/src/quant/batch.ts
@@ -0,0 +1,15 @@
+/** Quant Batch module — tsb analytics library. */
+export interface Quant batchOptions { tol?: number; maxIter?: number; }
+export interface Quant batchResult { values: number[]; converged: boolean; }
+export function computeQuant batch(data: number[], opts: Quant batchOptions = {}): Quant batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant batch };
diff --git a/src/quant/beta.ts b/src/quant/beta.ts
new file mode 100644
index 000000000..b7378f563
--- /dev/null
+++ b/src/quant/beta.ts
@@ -0,0 +1,15 @@
+/** Quant Beta module — tsb analytics library. */
+export interface Quant betaOptions { tol?: number; maxIter?: number; }
+export interface Quant betaResult { values: number[]; converged: boolean; }
+export function computeQuant beta(data: number[], opts: Quant betaOptions = {}): Quant betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant beta };
diff --git a/src/quant/book_to_market.ts b/src/quant/book_to_market.ts
new file mode 100644
index 000000000..2ce2cbd59
--- /dev/null
+++ b/src/quant/book_to_market.ts
@@ -0,0 +1,22 @@
+/** Book To Market module — tsb analytics library. */
+
+/** Options for Book To Market. */
+export interface BookToMarketOptions { tol?: number; maxIter?: number; }
+
+/** Result from Book To Market. */
+export interface BookToMarketResult { values: number[]; converged: boolean; }
+
+/** Compute Book To Market. */
+export function computeBookToMarket(data: number[], opts: BookToMarketOptions = {}): BookToMarketResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBookToMarket };
diff --git a/src/quant/carry.ts b/src/quant/carry.ts
new file mode 100644
index 000000000..2722a38e0
--- /dev/null
+++ b/src/quant/carry.ts
@@ -0,0 +1,22 @@
+/** Carry module — tsb analytics library. */
+
+/** Options for Carry. */
+export interface CarryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Carry. */
+export interface CarryResult { values: number[]; converged: boolean; }
+
+/** Compute Carry. */
+export function computeCarry(data: number[], opts: CarryOptions = {}): CarryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCarry };
diff --git a/src/quant/cpu.ts b/src/quant/cpu.ts
new file mode 100644
index 000000000..dbc445b5c
--- /dev/null
+++ b/src/quant/cpu.ts
@@ -0,0 +1,15 @@
+/** Quant Cpu module — tsb analytics library. */
+export interface Quant cpuOptions { tol?: number; maxIter?: number; }
+export interface Quant cpuResult { values: number[]; converged: boolean; }
+export function computeQuant cpu(data: number[], opts: Quant cpuOptions = {}): Quant cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant cpu };
diff --git a/src/quant/dense.ts b/src/quant/dense.ts
new file mode 100644
index 000000000..d37d8c482
--- /dev/null
+++ b/src/quant/dense.ts
@@ -0,0 +1,15 @@
+/** Quant Dense module — tsb analytics library. */
+export interface Quant denseOptions { tol?: number; maxIter?: number; }
+export interface Quant denseResult { values: number[]; converged: boolean; }
+export function computeQuant dense(data: number[], opts: Quant denseOptions = {}): Quant denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant dense };
diff --git a/src/quant/distributed.ts b/src/quant/distributed.ts
new file mode 100644
index 000000000..380bee6db
--- /dev/null
+++ b/src/quant/distributed.ts
@@ -0,0 +1,15 @@
+/** Quant Distributed module — tsb analytics library. */
+export interface Quant distributedOptions { tol?: number; maxIter?: number; }
+export interface Quant distributedResult { values: number[]; converged: boolean; }
+export function computeQuant distributed(data: number[], opts: Quant distributedOptions = {}): Quant distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant distributed };
diff --git a/src/quant/earnings.ts b/src/quant/earnings.ts
new file mode 100644
index 000000000..f37164821
--- /dev/null
+++ b/src/quant/earnings.ts
@@ -0,0 +1,22 @@
+/** Earnings module — tsb analytics library. */
+
+/** Options for Earnings. */
+export interface EarningsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Earnings. */
+export interface EarningsResult { values: number[]; converged: boolean; }
+
+/** Compute Earnings. */
+export function computeEarnings(data: number[], opts: EarningsOptions = {}): EarningsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEarnings };
diff --git a/src/quant/execution_model.ts b/src/quant/execution_model.ts
new file mode 100644
index 000000000..3b3e8fdeb
--- /dev/null
+++ b/src/quant/execution_model.ts
@@ -0,0 +1,22 @@
+/** Execution Model module — tsb analytics library. */
+
+/** Options for Execution Model. */
+export interface ExecutionModelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Execution Model. */
+export interface ExecutionModelResult { values: number[]; converged: boolean; }
+
+/** Compute Execution Model. */
+export function computeExecutionModel(data: number[], opts: ExecutionModelOptions = {}): ExecutionModelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExecutionModel };
diff --git a/src/quant/experimental.ts b/src/quant/experimental.ts
new file mode 100644
index 000000000..ccd574b76
--- /dev/null
+++ b/src/quant/experimental.ts
@@ -0,0 +1,15 @@
+/** Quant Experimental module — tsb analytics library. */
+export interface Quant experimentalOptions { tol?: number; maxIter?: number; }
+export interface Quant experimentalResult { values: number[]; converged: boolean; }
+export function computeQuant experimental(data: number[], opts: Quant experimentalOptions = {}): Quant experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant experimental };
diff --git a/src/quant/factor_model.ts b/src/quant/factor_model.ts
new file mode 100644
index 000000000..b82fad829
--- /dev/null
+++ b/src/quant/factor_model.ts
@@ -0,0 +1,22 @@
+/** Factor Model module — tsb analytics library. */
+
+/** Options for Factor Model. */
+export interface FactorModelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Factor Model. */
+export interface FactorModelResult { values: number[]; converged: boolean; }
+
+/** Compute Factor Model. */
+export function computeFactorModel(data: number[], opts: FactorModelOptions = {}): FactorModelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFactorModel };
diff --git a/src/quant/fast.ts b/src/quant/fast.ts
new file mode 100644
index 000000000..f63c0c852
--- /dev/null
+++ b/src/quant/fast.ts
@@ -0,0 +1,15 @@
+/** Quant Fast module — tsb analytics library. */
+export interface Quant fastOptions { tol?: number; maxIter?: number; }
+export interface Quant fastResult { values: number[]; converged: boolean; }
+export function computeQuant fast(data: number[], opts: Quant fastOptions = {}): Quant fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant fast };
diff --git a/src/quant/fill_rate.ts b/src/quant/fill_rate.ts
new file mode 100644
index 000000000..699b0f60d
--- /dev/null
+++ b/src/quant/fill_rate.ts
@@ -0,0 +1,22 @@
+/** Fill Rate module — tsb analytics library. */
+
+/** Options for Fill Rate. */
+export interface FillRateOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fill Rate. */
+export interface FillRateResult { values: number[]; converged: boolean; }
+
+/** Compute Fill Rate. */
+export function computeFillRate(data: number[], opts: FillRateOptions = {}): FillRateResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFillRate };
diff --git a/src/quant/future.ts b/src/quant/future.ts
new file mode 100644
index 000000000..380af0d2e
--- /dev/null
+++ b/src/quant/future.ts
@@ -0,0 +1,15 @@
+/** Quant Future module — tsb analytics library. */
+export interface Quant futureOptions { tol?: number; maxIter?: number; }
+export interface Quant futureResult { values: number[]; converged: boolean; }
+export function computeQuant future(data: number[], opts: Quant futureOptions = {}): Quant futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant future };
diff --git a/src/quant/gpu.ts b/src/quant/gpu.ts
new file mode 100644
index 000000000..5d3b69515
--- /dev/null
+++ b/src/quant/gpu.ts
@@ -0,0 +1,15 @@
+/** Quant Gpu module — tsb analytics library. */
+export interface Quant gpuOptions { tol?: number; maxIter?: number; }
+export interface Quant gpuResult { values: number[]; converged: boolean; }
+export function computeQuant gpu(data: number[], opts: Quant gpuOptions = {}): Quant gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant gpu };
diff --git a/src/quant/intraday.ts b/src/quant/intraday.ts
new file mode 100644
index 000000000..69e10f85d
--- /dev/null
+++ b/src/quant/intraday.ts
@@ -0,0 +1,22 @@
+/** Intraday module — tsb analytics library. */
+
+/** Options for Intraday. */
+export interface IntradayOptions { tol?: number; maxIter?: number; }
+
+/** Result from Intraday. */
+export interface IntradayResult { values: number[]; converged: boolean; }
+
+/** Compute Intraday. */
+export function computeIntraday(data: number[], opts: IntradayOptions = {}): IntradayResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIntraday };
diff --git a/src/quant/investment.ts b/src/quant/investment.ts
new file mode 100644
index 000000000..bc0d0cbd9
--- /dev/null
+++ b/src/quant/investment.ts
@@ -0,0 +1,22 @@
+/** Investment module — tsb analytics library. */
+
+/** Options for Investment. */
+export interface InvestmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Investment. */
+export interface InvestmentResult { values: number[]; converged: boolean; }
+
+/** Compute Investment. */
+export function computeInvestment(data: number[], opts: InvestmentOptions = {}): InvestmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInvestment };
diff --git a/src/quant/large.ts b/src/quant/large.ts
new file mode 100644
index 000000000..8fd465023
--- /dev/null
+++ b/src/quant/large.ts
@@ -0,0 +1,15 @@
+/** Quant Large module — tsb analytics library. */
+export interface Quant largeOptions { tol?: number; maxIter?: number; }
+export interface Quant largeResult { values: number[]; converged: boolean; }
+export function computeQuant large(data: number[], opts: Quant largeOptions = {}): Quant largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant large };
diff --git a/src/quant/legacy.ts b/src/quant/legacy.ts
new file mode 100644
index 000000000..30feae82c
--- /dev/null
+++ b/src/quant/legacy.ts
@@ -0,0 +1,15 @@
+/** Quant Legacy module — tsb analytics library. */
+export interface Quant legacyOptions { tol?: number; maxIter?: number; }
+export interface Quant legacyResult { values: number[]; converged: boolean; }
+export function computeQuant legacy(data: number[], opts: Quant legacyOptions = {}): Quant legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant legacy };
diff --git a/src/quant/lite.ts b/src/quant/lite.ts
new file mode 100644
index 000000000..851dd2437
--- /dev/null
+++ b/src/quant/lite.ts
@@ -0,0 +1,15 @@
+/** Quant Lite module — tsb analytics library. */
+export interface Quant liteOptions { tol?: number; maxIter?: number; }
+export interface Quant liteResult { values: number[]; converged: boolean; }
+export function computeQuant lite(data: number[], opts: Quant liteOptions = {}): Quant liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant lite };
diff --git a/src/quant/low_vol.ts b/src/quant/low_vol.ts
new file mode 100644
index 000000000..6ccabe92f
--- /dev/null
+++ b/src/quant/low_vol.ts
@@ -0,0 +1,22 @@
+/** Low Vol module — tsb analytics library. */
+
+/** Options for Low Vol. */
+export interface LowVolOptions { tol?: number; maxIter?: number; }
+
+/** Result from Low Vol. */
+export interface LowVolResult { values: number[]; converged: boolean; }
+
+/** Compute Low Vol. */
+export function computeLowVol(data: number[], opts: LowVolOptions = {}): LowVolResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLowVol };
diff --git a/src/quant/market_impact.ts b/src/quant/market_impact.ts
new file mode 100644
index 000000000..dee0eb91a
--- /dev/null
+++ b/src/quant/market_impact.ts
@@ -0,0 +1,22 @@
+/** Market Impact module — tsb analytics library. */
+
+/** Options for Market Impact. */
+export interface MarketImpactOptions { tol?: number; maxIter?: number; }
+
+/** Result from Market Impact. */
+export interface MarketImpactResult { values: number[]; converged: boolean; }
+
+/** Compute Market Impact. */
+export function computeMarketImpact(data: number[], opts: MarketImpactOptions = {}): MarketImpactResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMarketImpact };
diff --git a/src/quant/mini.ts b/src/quant/mini.ts
new file mode 100644
index 000000000..cb396f590
--- /dev/null
+++ b/src/quant/mini.ts
@@ -0,0 +1,15 @@
+/** Quant Mini module — tsb analytics library. */
+export interface Quant miniOptions { tol?: number; maxIter?: number; }
+export interface Quant miniResult { values: number[]; converged: boolean; }
+export function computeQuant mini(data: number[], opts: Quant miniOptions = {}): Quant miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant mini };
diff --git a/src/quant/momentum_quant.ts b/src/quant/momentum_quant.ts
new file mode 100644
index 000000000..52880b357
--- /dev/null
+++ b/src/quant/momentum_quant.ts
@@ -0,0 +1,22 @@
+/** Momentum Quant module — tsb analytics library. */
+
+/** Options for Momentum Quant. */
+export interface MomentumQuantOptions { tol?: number; maxIter?: number; }
+
+/** Result from Momentum Quant. */
+export interface MomentumQuantResult { values: number[]; converged: boolean; }
+
+/** Compute Momentum Quant. */
+export function computeMomentumQuant(data: number[], opts: MomentumQuantOptions = {}): MomentumQuantResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMomentumQuant };
diff --git a/src/quant/next.ts b/src/quant/next.ts
new file mode 100644
index 000000000..174974305
--- /dev/null
+++ b/src/quant/next.ts
@@ -0,0 +1,15 @@
+/** Quant Next module — tsb analytics library. */
+export interface Quant nextOptions { tol?: number; maxIter?: number; }
+export interface Quant nextResult { values: number[]; converged: boolean; }
+export function computeQuant next(data: number[], opts: Quant nextOptions = {}): Quant nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant next };
diff --git a/src/quant/online.ts b/src/quant/online.ts
new file mode 100644
index 000000000..df0377535
--- /dev/null
+++ b/src/quant/online.ts
@@ -0,0 +1,15 @@
+/** Quant Online module — tsb analytics library. */
+export interface Quant onlineOptions { tol?: number; maxIter?: number; }
+export interface Quant onlineResult { values: number[]; converged: boolean; }
+export function computeQuant online(data: number[], opts: Quant onlineOptions = {}): Quant onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant online };
diff --git a/src/quant/overnight.ts b/src/quant/overnight.ts
new file mode 100644
index 000000000..2098594ac
--- /dev/null
+++ b/src/quant/overnight.ts
@@ -0,0 +1,22 @@
+/** Overnight module — tsb analytics library. */
+
+/** Options for Overnight. */
+export interface OvernightOptions { tol?: number; maxIter?: number; }
+
+/** Result from Overnight. */
+export interface OvernightResult { values: number[]; converged: boolean; }
+
+/** Compute Overnight. */
+export function computeOvernight(data: number[], opts: OvernightOptions = {}): OvernightResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOvernight };
diff --git a/src/quant/parallel.ts b/src/quant/parallel.ts
new file mode 100644
index 000000000..98d2eaac3
--- /dev/null
+++ b/src/quant/parallel.ts
@@ -0,0 +1,15 @@
+/** Quant Parallel module — tsb analytics library. */
+export interface Quant parallelOptions { tol?: number; maxIter?: number; }
+export interface Quant parallelResult { values: number[]; converged: boolean; }
+export function computeQuant parallel(data: number[], opts: Quant parallelOptions = {}): Quant parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant parallel };
diff --git a/src/quant/plus.ts b/src/quant/plus.ts
new file mode 100644
index 000000000..f74ecc33d
--- /dev/null
+++ b/src/quant/plus.ts
@@ -0,0 +1,15 @@
+/** Quant Plus module — tsb analytics library. */
+export interface Quant plusOptions { tol?: number; maxIter?: number; }
+export interface Quant plusResult { values: number[]; converged: boolean; }
+export function computeQuant plus(data: number[], opts: Quant plusOptions = {}): Quant plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant plus };
diff --git a/src/quant/portfolio_opt.ts b/src/quant/portfolio_opt.ts
new file mode 100644
index 000000000..dc7e7ce1a
--- /dev/null
+++ b/src/quant/portfolio_opt.ts
@@ -0,0 +1,22 @@
+/** Portfolio Opt module — tsb analytics library. */
+
+/** Options for Portfolio Opt. */
+export interface PortfolioOptOptions { tol?: number; maxIter?: number; }
+
+/** Result from Portfolio Opt. */
+export interface PortfolioOptResult { values: number[]; converged: boolean; }
+
+/** Compute Portfolio Opt. */
+export function computePortfolioOpt(data: number[], opts: PortfolioOptOptions = {}): PortfolioOptResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePortfolioOpt };
diff --git a/src/quant/position_sizing.ts b/src/quant/position_sizing.ts
new file mode 100644
index 000000000..219af2a27
--- /dev/null
+++ b/src/quant/position_sizing.ts
@@ -0,0 +1,22 @@
+/** Position Sizing module — tsb analytics library. */
+
+/** Options for Position Sizing. */
+export interface PositionSizingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Position Sizing. */
+export interface PositionSizingResult { values: number[]; converged: boolean; }
+
+/** Compute Position Sizing. */
+export function computePositionSizing(data: number[], opts: PositionSizingOptions = {}): PositionSizingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePositionSizing };
diff --git a/src/quant/pro.ts b/src/quant/pro.ts
new file mode 100644
index 000000000..8874b87ba
--- /dev/null
+++ b/src/quant/pro.ts
@@ -0,0 +1,15 @@
+/** Quant Pro module — tsb analytics library. */
+export interface Quant proOptions { tol?: number; maxIter?: number; }
+export interface Quant proResult { values: number[]; converged: boolean; }
+export function computeQuant pro(data: number[], opts: Quant proOptions = {}): Quant proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant pro };
diff --git a/src/quant/profitability.ts b/src/quant/profitability.ts
new file mode 100644
index 000000000..982df22a7
--- /dev/null
+++ b/src/quant/profitability.ts
@@ -0,0 +1,22 @@
+/** Profitability module — tsb analytics library. */
+
+/** Options for Profitability. */
+export interface ProfitabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Profitability. */
+export interface ProfitabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Profitability. */
+export function computeProfitability(data: number[], opts: ProfitabilityOptions = {}): ProfitabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProfitability };
diff --git a/src/quant/quality.ts b/src/quant/quality.ts
new file mode 100644
index 000000000..bf7f8c234
--- /dev/null
+++ b/src/quant/quality.ts
@@ -0,0 +1,22 @@
+/** Quality module — tsb analytics library. */
+
+/** Options for Quality. */
+export interface QualityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quality. */
+export interface QualityResult { values: number[]; converged: boolean; }
+
+/** Compute Quality. */
+export function computeQuality(data: number[], opts: QualityOptions = {}): QualityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQuality };
diff --git a/src/quant/rebalancing.ts b/src/quant/rebalancing.ts
new file mode 100644
index 000000000..ade20b4a4
--- /dev/null
+++ b/src/quant/rebalancing.ts
@@ -0,0 +1,22 @@
+/** Rebalancing module — tsb analytics library. */
+
+/** Options for Rebalancing. */
+export interface RebalancingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rebalancing. */
+export interface RebalancingResult { values: number[]; converged: boolean; }
+
+/** Compute Rebalancing. */
+export function computeRebalancing(data: number[], opts: RebalancingOptions = {}): RebalancingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRebalancing };
diff --git a/src/quant/risk_model.ts b/src/quant/risk_model.ts
new file mode 100644
index 000000000..71859c532
--- /dev/null
+++ b/src/quant/risk_model.ts
@@ -0,0 +1,22 @@
+/** Risk Model module — tsb analytics library. */
+
+/** Options for Risk Model. */
+export interface RiskModelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Risk Model. */
+export interface RiskModelResult { values: number[]; converged: boolean; }
+
+/** Compute Risk Model. */
+export function computeRiskModel(data: number[], opts: RiskModelOptions = {}): RiskModelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRiskModel };
diff --git a/src/quant/robust.ts b/src/quant/robust.ts
new file mode 100644
index 000000000..6e1eed54d
--- /dev/null
+++ b/src/quant/robust.ts
@@ -0,0 +1,15 @@
+/** Quant Robust module — tsb analytics library. */
+export interface Quant robustOptions { tol?: number; maxIter?: number; }
+export interface Quant robustResult { values: number[]; converged: boolean; }
+export function computeQuant robust(data: number[], opts: Quant robustOptions = {}): Quant robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant robust };
diff --git a/src/quant/sentiment_quant.ts b/src/quant/sentiment_quant.ts
new file mode 100644
index 000000000..12e04dc84
--- /dev/null
+++ b/src/quant/sentiment_quant.ts
@@ -0,0 +1,22 @@
+/** Sentiment Quant module — tsb analytics library. */
+
+/** Options for Sentiment Quant. */
+export interface SentimentQuantOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sentiment Quant. */
+export interface SentimentQuantResult { values: number[]; converged: boolean; }
+
+/** Compute Sentiment Quant. */
+export function computeSentimentQuant(data: number[], opts: SentimentQuantOptions = {}): SentimentQuantResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSentimentQuant };
diff --git a/src/quant/signal_combination.ts b/src/quant/signal_combination.ts
new file mode 100644
index 000000000..1057bf0e5
--- /dev/null
+++ b/src/quant/signal_combination.ts
@@ -0,0 +1,22 @@
+/** Signal Combination module — tsb analytics library. */
+
+/** Options for Signal Combination. */
+export interface SignalCombinationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Signal Combination. */
+export interface SignalCombinationResult { values: number[]; converged: boolean; }
+
+/** Compute Signal Combination. */
+export function computeSignalCombination(data: number[], opts: SignalCombinationOptions = {}): SignalCombinationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSignalCombination };
diff --git a/src/quant/signal_generation.ts b/src/quant/signal_generation.ts
new file mode 100644
index 000000000..4c9f03bd3
--- /dev/null
+++ b/src/quant/signal_generation.ts
@@ -0,0 +1,22 @@
+/** Signal Generation module — tsb analytics library. */
+
+/** Options for Signal Generation. */
+export interface SignalGenerationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Signal Generation. */
+export interface SignalGenerationResult { values: number[]; converged: boolean; }
+
+/** Compute Signal Generation. */
+export function computeSignalGeneration(data: number[], opts: SignalGenerationOptions = {}): SignalGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSignalGeneration };
diff --git a/src/quant/size.ts b/src/quant/size.ts
new file mode 100644
index 000000000..1cadc0979
--- /dev/null
+++ b/src/quant/size.ts
@@ -0,0 +1,22 @@
+/** Size module — tsb analytics library. */
+
+/** Options for Size. */
+export interface SizeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Size. */
+export interface SizeResult { values: number[]; converged: boolean; }
+
+/** Compute Size. */
+export function computeSize(data: number[], opts: SizeOptions = {}): SizeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSize };
diff --git a/src/quant/slippage.ts b/src/quant/slippage.ts
new file mode 100644
index 000000000..7012f595d
--- /dev/null
+++ b/src/quant/slippage.ts
@@ -0,0 +1,22 @@
+/** Slippage module — tsb analytics library. */
+
+/** Options for Slippage. */
+export interface SlippageOptions { tol?: number; maxIter?: number; }
+
+/** Result from Slippage. */
+export interface SlippageResult { values: number[]; converged: boolean; }
+
+/** Compute Slippage. */
+export function computeSlippage(data: number[], opts: SlippageOptions = {}): SlippageResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSlippage };
diff --git a/src/quant/small.ts b/src/quant/small.ts
new file mode 100644
index 000000000..477583a80
--- /dev/null
+++ b/src/quant/small.ts
@@ -0,0 +1,15 @@
+/** Quant Small module — tsb analytics library. */
+export interface Quant smallOptions { tol?: number; maxIter?: number; }
+export interface Quant smallResult { values: number[]; converged: boolean; }
+export function computeQuant small(data: number[], opts: Quant smallOptions = {}): Quant smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant small };
diff --git a/src/quant/sparse.ts b/src/quant/sparse.ts
new file mode 100644
index 000000000..6109c4c7c
--- /dev/null
+++ b/src/quant/sparse.ts
@@ -0,0 +1,15 @@
+/** Quant Sparse module — tsb analytics library. */
+export interface Quant sparseOptions { tol?: number; maxIter?: number; }
+export interface Quant sparseResult { values: number[]; converged: boolean; }
+export function computeQuant sparse(data: number[], opts: Quant sparseOptions = {}): Quant sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant sparse };
diff --git a/src/quant/stable.ts b/src/quant/stable.ts
new file mode 100644
index 000000000..5961257ce
--- /dev/null
+++ b/src/quant/stable.ts
@@ -0,0 +1,15 @@
+/** Quant Stable module — tsb analytics library. */
+export interface Quant stableOptions { tol?: number; maxIter?: number; }
+export interface Quant stableResult { values: number[]; converged: boolean; }
+export function computeQuant stable(data: number[], opts: Quant stableOptions = {}): Quant stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant stable };
diff --git a/src/quant/streaming.ts b/src/quant/streaming.ts
new file mode 100644
index 000000000..9ebed750a
--- /dev/null
+++ b/src/quant/streaming.ts
@@ -0,0 +1,15 @@
+/** Quant Streaming module — tsb analytics library. */
+export interface Quant streamingOptions { tol?: number; maxIter?: number; }
+export interface Quant streamingResult { values: number[]; converged: boolean; }
+export function computeQuant streaming(data: number[], opts: Quant streamingOptions = {}): Quant streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant streaming };
diff --git a/src/quant/transaction_cost.ts b/src/quant/transaction_cost.ts
new file mode 100644
index 000000000..fb2c79d88
--- /dev/null
+++ b/src/quant/transaction_cost.ts
@@ -0,0 +1,22 @@
+/** Transaction Cost module — tsb analytics library. */
+
+/** Options for Transaction Cost. */
+export interface TransactionCostOptions { tol?: number; maxIter?: number; }
+
+/** Result from Transaction Cost. */
+export interface TransactionCostResult { values: number[]; converged: boolean; }
+
+/** Compute Transaction Cost. */
+export function computeTransactionCost(data: number[], opts: TransactionCostOptions = {}): TransactionCostResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTransactionCost };
diff --git a/src/quant/turnover.ts b/src/quant/turnover.ts
new file mode 100644
index 000000000..123f1a695
--- /dev/null
+++ b/src/quant/turnover.ts
@@ -0,0 +1,22 @@
+/** Turnover module — tsb analytics library. */
+
+/** Options for Turnover. */
+export interface TurnoverOptions { tol?: number; maxIter?: number; }
+
+/** Result from Turnover. */
+export interface TurnoverResult { values: number[]; converged: boolean; }
+
+/** Compute Turnover. */
+export function computeTurnover(data: number[], opts: TurnoverOptions = {}): TurnoverResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTurnover };
diff --git a/src/quant/v2.ts b/src/quant/v2.ts
new file mode 100644
index 000000000..8b0f8d09c
--- /dev/null
+++ b/src/quant/v2.ts
@@ -0,0 +1,15 @@
+/** Quant V2 module — tsb analytics library. */
+export interface Quant v2Options { tol?: number; maxIter?: number; }
+export interface Quant v2Result { values: number[]; converged: boolean; }
+export function computeQuant v2(data: number[], opts: Quant v2Options = {}): Quant v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant v2 };
diff --git a/src/quant/v3.ts b/src/quant/v3.ts
new file mode 100644
index 000000000..4a4cbb2d9
--- /dev/null
+++ b/src/quant/v3.ts
@@ -0,0 +1,15 @@
+/** Quant V3 module — tsb analytics library. */
+export interface Quant v3Options { tol?: number; maxIter?: number; }
+export interface Quant v3Result { values: number[]; converged: boolean; }
+export function computeQuant v3(data: number[], opts: Quant v3Options = {}): Quant v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant v3 };
diff --git a/src/quant/value.ts b/src/quant/value.ts
new file mode 100644
index 000000000..d3aa702d7
--- /dev/null
+++ b/src/quant/value.ts
@@ -0,0 +1,22 @@
+/** Value module — tsb analytics library. */
+
+/** Options for Value. */
+export interface ValueOptions { tol?: number; maxIter?: number; }
+
+/** Result from Value. */
+export interface ValueResult { values: number[]; converged: boolean; }
+
+/** Compute Value. */
+export function computeValue(data: number[], opts: ValueOptions = {}): ValueResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeValue };
diff --git a/src/quant/wasm.ts b/src/quant/wasm.ts
new file mode 100644
index 000000000..0436a8d8f
--- /dev/null
+++ b/src/quant/wasm.ts
@@ -0,0 +1,15 @@
+/** Quant Wasm module — tsb analytics library. */
+export interface Quant wasmOptions { tol?: number; maxIter?: number; }
+export interface Quant wasmResult { values: number[]; converged: boolean; }
+export function computeQuant wasm(data: number[], opts: Quant wasmOptions = {}): Quant wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant wasm };
diff --git a/src/quant/xlarge.ts b/src/quant/xlarge.ts
new file mode 100644
index 000000000..b43150c08
--- /dev/null
+++ b/src/quant/xlarge.ts
@@ -0,0 +1,15 @@
+/** Quant Xlarge module — tsb analytics library. */
+export interface Quant xlargeOptions { tol?: number; maxIter?: number; }
+export interface Quant xlargeResult { values: number[]; converged: boolean; }
+export function computeQuant xlarge(data: number[], opts: Quant xlargeOptions = {}): Quant xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeQuant xlarge };
diff --git a/src/radiochemistry/adaptation.ts b/src/radiochemistry/adaptation.ts
new file mode 100644
index 000000000..599cf01c0
--- /dev/null
+++ b/src/radiochemistry/adaptation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry adaptation module — tsb analytics library. */
+export interface RadiochemistryAdaptationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryAdaptationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryAdaptation(data: number[], opts: RadiochemistryAdaptationOptions = {}): RadiochemistryAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryAdaptation };
diff --git a/src/radiochemistry/aggregation.ts b/src/radiochemistry/aggregation.ts
new file mode 100644
index 000000000..816c0f431
--- /dev/null
+++ b/src/radiochemistry/aggregation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry aggregation module — tsb analytics library. */
+export interface RadiochemistryAggregationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryAggregationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryAggregation(data: number[], opts: RadiochemistryAggregationOptions = {}): RadiochemistryAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryAggregation };
diff --git a/src/radiochemistry/algebra.ts b/src/radiochemistry/algebra.ts
new file mode 100644
index 000000000..fec0f2eb9
--- /dev/null
+++ b/src/radiochemistry/algebra.ts
@@ -0,0 +1,14 @@
+/** radiochemistry algebra module — tsb analytics library. */
+export interface RadiochemistryAlgebraOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryAlgebraResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryAlgebra(data: number[], opts: RadiochemistryAlgebraOptions = {}): RadiochemistryAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryAlgebra };
diff --git a/src/radiochemistry/alignment.ts b/src/radiochemistry/alignment.ts
new file mode 100644
index 000000000..32b9b2856
--- /dev/null
+++ b/src/radiochemistry/alignment.ts
@@ -0,0 +1,14 @@
+/** radiochemistry alignment module — tsb analytics library. */
+export interface RadiochemistryAlignmentOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryAlignmentResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryAlignment(data: number[], opts: RadiochemistryAlignmentOptions = {}): RadiochemistryAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryAlignment };
diff --git a/src/radiochemistry/analysis.ts b/src/radiochemistry/analysis.ts
new file mode 100644
index 000000000..ac3c0d705
--- /dev/null
+++ b/src/radiochemistry/analysis.ts
@@ -0,0 +1,14 @@
+/** radiochemistry analysis module — tsb analytics library. */
+export interface RadiochemistryAnalysisOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryAnalysisResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryAnalysis(data: number[], opts: RadiochemistryAnalysisOptions = {}): RadiochemistryAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryAnalysis };
diff --git a/src/radiochemistry/augmentation.ts b/src/radiochemistry/augmentation.ts
new file mode 100644
index 000000000..bf2c88dfd
--- /dev/null
+++ b/src/radiochemistry/augmentation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry augmentation module — tsb analytics library. */
+export interface RadiochemistryAugmentationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryAugmentationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryAugmentation(data: number[], opts: RadiochemistryAugmentationOptions = {}): RadiochemistryAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryAugmentation };
diff --git a/src/radiochemistry/bagging.ts b/src/radiochemistry/bagging.ts
new file mode 100644
index 000000000..6f87bdc88
--- /dev/null
+++ b/src/radiochemistry/bagging.ts
@@ -0,0 +1,14 @@
+/** radiochemistry bagging module — tsb analytics library. */
+export interface RadiochemistryBaggingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryBaggingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryBagging(data: number[], opts: RadiochemistryBaggingOptions = {}): RadiochemistryBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryBagging };
diff --git a/src/radiochemistry/basis.ts b/src/radiochemistry/basis.ts
new file mode 100644
index 000000000..f6d17bb80
--- /dev/null
+++ b/src/radiochemistry/basis.ts
@@ -0,0 +1,14 @@
+/** radiochemistry basis module — tsb analytics library. */
+export interface RadiochemistryBasisOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryBasisResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryBasis(data: number[], opts: RadiochemistryBasisOptions = {}): RadiochemistryBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryBasis };
diff --git a/src/radiochemistry/benchmarking.ts b/src/radiochemistry/benchmarking.ts
new file mode 100644
index 000000000..192467c48
--- /dev/null
+++ b/src/radiochemistry/benchmarking.ts
@@ -0,0 +1,14 @@
+/** radiochemistry benchmarking module — tsb analytics library. */
+export interface RadiochemistryBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryBenchmarking(data: number[], opts: RadiochemistryBenchmarkingOptions = {}): RadiochemistryBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryBenchmarking };
diff --git a/src/radiochemistry/blending.ts b/src/radiochemistry/blending.ts
new file mode 100644
index 000000000..b12f5616c
--- /dev/null
+++ b/src/radiochemistry/blending.ts
@@ -0,0 +1,14 @@
+/** radiochemistry blending module — tsb analytics library. */
+export interface RadiochemistryBlendingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryBlendingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryBlending(data: number[], opts: RadiochemistryBlendingOptions = {}): RadiochemistryBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryBlending };
diff --git a/src/radiochemistry/boosting.ts b/src/radiochemistry/boosting.ts
new file mode 100644
index 000000000..9ee3b302c
--- /dev/null
+++ b/src/radiochemistry/boosting.ts
@@ -0,0 +1,14 @@
+/** radiochemistry boosting module — tsb analytics library. */
+export interface RadiochemistryBoostingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryBoostingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryBoosting(data: number[], opts: RadiochemistryBoostingOptions = {}): RadiochemistryBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryBoosting };
diff --git a/src/radiochemistry/bootstrap.ts b/src/radiochemistry/bootstrap.ts
new file mode 100644
index 000000000..699c118f6
--- /dev/null
+++ b/src/radiochemistry/bootstrap.ts
@@ -0,0 +1,14 @@
+/** radiochemistry bootstrap module — tsb analytics library. */
+export interface RadiochemistryBootstrapOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryBootstrapResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryBootstrap(data: number[], opts: RadiochemistryBootstrapOptions = {}): RadiochemistryBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryBootstrap };
diff --git a/src/radiochemistry/calculus.ts b/src/radiochemistry/calculus.ts
new file mode 100644
index 000000000..865cb7637
--- /dev/null
+++ b/src/radiochemistry/calculus.ts
@@ -0,0 +1,14 @@
+/** radiochemistry calculus module — tsb analytics library. */
+export interface RadiochemistryCalculusOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryCalculusResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryCalculus(data: number[], opts: RadiochemistryCalculusOptions = {}): RadiochemistryCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryCalculus };
diff --git a/src/radiochemistry/calibration.ts b/src/radiochemistry/calibration.ts
new file mode 100644
index 000000000..1b5e3700c
--- /dev/null
+++ b/src/radiochemistry/calibration.ts
@@ -0,0 +1,14 @@
+/** radiochemistry calibration module — tsb analytics library. */
+export interface RadiochemistryCalibrationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryCalibrationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryCalibration(data: number[], opts: RadiochemistryCalibrationOptions = {}): RadiochemistryCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryCalibration };
diff --git a/src/radiochemistry/characterization.ts b/src/radiochemistry/characterization.ts
new file mode 100644
index 000000000..78bd1365a
--- /dev/null
+++ b/src/radiochemistry/characterization.ts
@@ -0,0 +1,14 @@
+/** radiochemistry characterization module — tsb analytics library. */
+export interface RadiochemistryCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryCharacterizationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryCharacterization(data: number[], opts: RadiochemistryCharacterizationOptions = {}): RadiochemistryCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryCharacterization };
diff --git a/src/radiochemistry/classification.ts b/src/radiochemistry/classification.ts
new file mode 100644
index 000000000..d9ad3bbda
--- /dev/null
+++ b/src/radiochemistry/classification.ts
@@ -0,0 +1,14 @@
+/** radiochemistry classification module — tsb analytics library. */
+export interface RadiochemistryClassificationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryClassificationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryClassification(data: number[], opts: RadiochemistryClassificationOptions = {}): RadiochemistryClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryClassification };
diff --git a/src/radiochemistry/clustering.ts b/src/radiochemistry/clustering.ts
new file mode 100644
index 000000000..7a3193754
--- /dev/null
+++ b/src/radiochemistry/clustering.ts
@@ -0,0 +1,14 @@
+/** radiochemistry clustering module — tsb analytics library. */
+export interface RadiochemistryClusteringOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryClusteringResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryClustering(data: number[], opts: RadiochemistryClusteringOptions = {}): RadiochemistryClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryClustering };
diff --git a/src/radiochemistry/compression.ts b/src/radiochemistry/compression.ts
new file mode 100644
index 000000000..0f8c08701
--- /dev/null
+++ b/src/radiochemistry/compression.ts
@@ -0,0 +1,14 @@
+/** radiochemistry compression module — tsb analytics library. */
+export interface RadiochemistryCompressionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryCompressionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryCompression(data: number[], opts: RadiochemistryCompressionOptions = {}): RadiochemistryCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryCompression };
diff --git a/src/radiochemistry/continuous.ts b/src/radiochemistry/continuous.ts
new file mode 100644
index 000000000..a959aa1d3
--- /dev/null
+++ b/src/radiochemistry/continuous.ts
@@ -0,0 +1,14 @@
+/** radiochemistry continuous module — tsb analytics library. */
+export interface RadiochemistryContinuousOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryContinuousResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryContinuous(data: number[], opts: RadiochemistryContinuousOptions = {}): RadiochemistryContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryContinuous };
diff --git a/src/radiochemistry/control.ts b/src/radiochemistry/control.ts
new file mode 100644
index 000000000..c43b42265
--- /dev/null
+++ b/src/radiochemistry/control.ts
@@ -0,0 +1,14 @@
+/** radiochemistry control module — tsb analytics library. */
+export interface RadiochemistryControlOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryControlResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryControl(data: number[], opts: RadiochemistryControlOptions = {}): RadiochemistryControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryControl };
diff --git a/src/radiochemistry/convergence.ts b/src/radiochemistry/convergence.ts
new file mode 100644
index 000000000..feadbcbd1
--- /dev/null
+++ b/src/radiochemistry/convergence.ts
@@ -0,0 +1,14 @@
+/** radiochemistry convergence module — tsb analytics library. */
+export interface RadiochemistryConvergenceOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryConvergenceResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryConvergence(data: number[], opts: RadiochemistryConvergenceOptions = {}): RadiochemistryConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryConvergence };
diff --git a/src/radiochemistry/convex.ts b/src/radiochemistry/convex.ts
new file mode 100644
index 000000000..bfdfc9f86
--- /dev/null
+++ b/src/radiochemistry/convex.ts
@@ -0,0 +1,14 @@
+/** radiochemistry convex module — tsb analytics library. */
+export interface RadiochemistryConvexOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryConvexResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryConvex(data: number[], opts: RadiochemistryConvexOptions = {}): RadiochemistryConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryConvex };
diff --git a/src/radiochemistry/correlation.ts b/src/radiochemistry/correlation.ts
new file mode 100644
index 000000000..f7cb6efac
--- /dev/null
+++ b/src/radiochemistry/correlation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry correlation module — tsb analytics library. */
+export interface RadiochemistryCorrelationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryCorrelationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryCorrelation(data: number[], opts: RadiochemistryCorrelationOptions = {}): RadiochemistryCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryCorrelation };
diff --git a/src/radiochemistry/covariance.ts b/src/radiochemistry/covariance.ts
new file mode 100644
index 000000000..833420fab
--- /dev/null
+++ b/src/radiochemistry/covariance.ts
@@ -0,0 +1,14 @@
+/** radiochemistry covariance module — tsb analytics library. */
+export interface RadiochemistryCovarianceOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryCovarianceResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryCovariance(data: number[], opts: RadiochemistryCovarianceOptions = {}): RadiochemistryCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryCovariance };
diff --git a/src/radiochemistry/cross_validation.ts b/src/radiochemistry/cross_validation.ts
new file mode 100644
index 000000000..806a6f9aa
--- /dev/null
+++ b/src/radiochemistry/cross_validation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry cross_validation module — tsb analytics library. */
+export interface RadiochemistryCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryCrossValidationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryCrossValidation(data: number[], opts: RadiochemistryCrossValidationOptions = {}): RadiochemistryCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryCrossValidation };
diff --git a/src/radiochemistry/decoding.ts b/src/radiochemistry/decoding.ts
new file mode 100644
index 000000000..d242a173f
--- /dev/null
+++ b/src/radiochemistry/decoding.ts
@@ -0,0 +1,14 @@
+/** radiochemistry decoding module — tsb analytics library. */
+export interface RadiochemistryDecodingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDecodingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDecoding(data: number[], opts: RadiochemistryDecodingOptions = {}): RadiochemistryDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDecoding };
diff --git a/src/radiochemistry/decomposition.ts b/src/radiochemistry/decomposition.ts
new file mode 100644
index 000000000..221c5c8b6
--- /dev/null
+++ b/src/radiochemistry/decomposition.ts
@@ -0,0 +1,14 @@
+/** radiochemistry decomposition module — tsb analytics library. */
+export interface RadiochemistryDecompositionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDecompositionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDecomposition(data: number[], opts: RadiochemistryDecompositionOptions = {}): RadiochemistryDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDecomposition };
diff --git a/src/radiochemistry/detection.ts b/src/radiochemistry/detection.ts
new file mode 100644
index 000000000..8b5644018
--- /dev/null
+++ b/src/radiochemistry/detection.ts
@@ -0,0 +1,14 @@
+/** radiochemistry detection module — tsb analytics library. */
+export interface RadiochemistryDetectionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDetectionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDetection(data: number[], opts: RadiochemistryDetectionOptions = {}): RadiochemistryDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDetection };
diff --git a/src/radiochemistry/deterministic.ts b/src/radiochemistry/deterministic.ts
new file mode 100644
index 000000000..141232cb6
--- /dev/null
+++ b/src/radiochemistry/deterministic.ts
@@ -0,0 +1,14 @@
+/** radiochemistry deterministic module — tsb analytics library. */
+export interface RadiochemistryDeterministicOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDeterministicResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDeterministic(data: number[], opts: RadiochemistryDeterministicOptions = {}): RadiochemistryDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDeterministic };
diff --git a/src/radiochemistry/diagnostics.ts b/src/radiochemistry/diagnostics.ts
new file mode 100644
index 000000000..05c155e31
--- /dev/null
+++ b/src/radiochemistry/diagnostics.ts
@@ -0,0 +1,14 @@
+/** radiochemistry diagnostics module — tsb analytics library. */
+export interface RadiochemistryDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDiagnostics(data: number[], opts: RadiochemistryDiagnosticsOptions = {}): RadiochemistryDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDiagnostics };
diff --git a/src/radiochemistry/differential.ts b/src/radiochemistry/differential.ts
new file mode 100644
index 000000000..4226b13c5
--- /dev/null
+++ b/src/radiochemistry/differential.ts
@@ -0,0 +1,14 @@
+/** radiochemistry differential module — tsb analytics library. */
+export interface RadiochemistryDifferentialOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDifferentialResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDifferential(data: number[], opts: RadiochemistryDifferentialOptions = {}): RadiochemistryDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDifferential };
diff --git a/src/radiochemistry/discrete.ts b/src/radiochemistry/discrete.ts
new file mode 100644
index 000000000..995126370
--- /dev/null
+++ b/src/radiochemistry/discrete.ts
@@ -0,0 +1,14 @@
+/** radiochemistry discrete module — tsb analytics library. */
+export interface RadiochemistryDiscreteOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDiscreteResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDiscrete(data: number[], opts: RadiochemistryDiscreteOptions = {}): RadiochemistryDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDiscrete };
diff --git a/src/radiochemistry/distribution.ts b/src/radiochemistry/distribution.ts
new file mode 100644
index 000000000..54487ef97
--- /dev/null
+++ b/src/radiochemistry/distribution.ts
@@ -0,0 +1,14 @@
+/** radiochemistry distribution module — tsb analytics library. */
+export interface RadiochemistryDistributionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDistributionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDistribution(data: number[], opts: RadiochemistryDistributionOptions = {}): RadiochemistryDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDistribution };
diff --git a/src/radiochemistry/dynamic.ts b/src/radiochemistry/dynamic.ts
new file mode 100644
index 000000000..1693a1486
--- /dev/null
+++ b/src/radiochemistry/dynamic.ts
@@ -0,0 +1,14 @@
+/** radiochemistry dynamic module — tsb analytics library. */
+export interface RadiochemistryDynamicOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryDynamicResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryDynamic(data: number[], opts: RadiochemistryDynamicOptions = {}): RadiochemistryDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryDynamic };
diff --git a/src/radiochemistry/embedding.ts b/src/radiochemistry/embedding.ts
new file mode 100644
index 000000000..9498c407d
--- /dev/null
+++ b/src/radiochemistry/embedding.ts
@@ -0,0 +1,14 @@
+/** radiochemistry embedding module — tsb analytics library. */
+export interface RadiochemistryEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryEmbeddingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryEmbedding(data: number[], opts: RadiochemistryEmbeddingOptions = {}): RadiochemistryEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryEmbedding };
diff --git a/src/radiochemistry/encoding.ts b/src/radiochemistry/encoding.ts
new file mode 100644
index 000000000..4fa5a8d3b
--- /dev/null
+++ b/src/radiochemistry/encoding.ts
@@ -0,0 +1,14 @@
+/** radiochemistry encoding module — tsb analytics library. */
+export interface RadiochemistryEncodingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryEncodingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryEncoding(data: number[], opts: RadiochemistryEncodingOptions = {}): RadiochemistryEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryEncoding };
diff --git a/src/radiochemistry/ensemble.ts b/src/radiochemistry/ensemble.ts
new file mode 100644
index 000000000..b96fb2c67
--- /dev/null
+++ b/src/radiochemistry/ensemble.ts
@@ -0,0 +1,14 @@
+/** radiochemistry ensemble module — tsb analytics library. */
+export interface RadiochemistryEnsembleOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryEnsembleResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryEnsemble(data: number[], opts: RadiochemistryEnsembleOptions = {}): RadiochemistryEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryEnsemble };
diff --git a/src/radiochemistry/estimation.ts b/src/radiochemistry/estimation.ts
new file mode 100644
index 000000000..f643c90de
--- /dev/null
+++ b/src/radiochemistry/estimation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry estimation module — tsb analytics library. */
+export interface RadiochemistryEstimationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryEstimationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryEstimation(data: number[], opts: RadiochemistryEstimationOptions = {}): RadiochemistryEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryEstimation };
diff --git a/src/radiochemistry/evaluation.ts b/src/radiochemistry/evaluation.ts
new file mode 100644
index 000000000..cff3e843c
--- /dev/null
+++ b/src/radiochemistry/evaluation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry evaluation module — tsb analytics library. */
+export interface RadiochemistryEvaluationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryEvaluationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryEvaluation(data: number[], opts: RadiochemistryEvaluationOptions = {}): RadiochemistryEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryEvaluation };
diff --git a/src/radiochemistry/extrapolation.ts b/src/radiochemistry/extrapolation.ts
new file mode 100644
index 000000000..09d3f4e00
--- /dev/null
+++ b/src/radiochemistry/extrapolation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry extrapolation module — tsb analytics library. */
+export interface RadiochemistryExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryExtrapolationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryExtrapolation(data: number[], opts: RadiochemistryExtrapolationOptions = {}): RadiochemistryExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryExtrapolation };
diff --git a/src/radiochemistry/features.ts b/src/radiochemistry/features.ts
new file mode 100644
index 000000000..6eaec3b52
--- /dev/null
+++ b/src/radiochemistry/features.ts
@@ -0,0 +1,14 @@
+/** radiochemistry features module — tsb analytics library. */
+export interface RadiochemistryFeaturesOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryFeaturesResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryFeatures(data: number[], opts: RadiochemistryFeaturesOptions = {}): RadiochemistryFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryFeatures };
diff --git a/src/radiochemistry/feedback.ts b/src/radiochemistry/feedback.ts
new file mode 100644
index 000000000..0b71cb12b
--- /dev/null
+++ b/src/radiochemistry/feedback.ts
@@ -0,0 +1,14 @@
+/** radiochemistry feedback module — tsb analytics library. */
+export interface RadiochemistryFeedbackOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryFeedbackResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryFeedback(data: number[], opts: RadiochemistryFeedbackOptions = {}): RadiochemistryFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryFeedback };
diff --git a/src/radiochemistry/filtering.ts b/src/radiochemistry/filtering.ts
new file mode 100644
index 000000000..efd5ccaf6
--- /dev/null
+++ b/src/radiochemistry/filtering.ts
@@ -0,0 +1,14 @@
+/** radiochemistry filtering module — tsb analytics library. */
+export interface RadiochemistryFilteringOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryFilteringResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryFiltering(data: number[], opts: RadiochemistryFilteringOptions = {}): RadiochemistryFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryFiltering };
diff --git a/src/radiochemistry/fourier.ts b/src/radiochemistry/fourier.ts
new file mode 100644
index 000000000..3fd5446c0
--- /dev/null
+++ b/src/radiochemistry/fourier.ts
@@ -0,0 +1,14 @@
+/** radiochemistry fourier module — tsb analytics library. */
+export interface RadiochemistryFourierOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryFourierResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryFourier(data: number[], opts: RadiochemistryFourierOptions = {}): RadiochemistryFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryFourier };
diff --git a/src/radiochemistry/fusion.ts b/src/radiochemistry/fusion.ts
new file mode 100644
index 000000000..c2687c38a
--- /dev/null
+++ b/src/radiochemistry/fusion.ts
@@ -0,0 +1,14 @@
+/** radiochemistry fusion module — tsb analytics library. */
+export interface RadiochemistryFusionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryFusionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryFusion(data: number[], opts: RadiochemistryFusionOptions = {}): RadiochemistryFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryFusion };
diff --git a/src/radiochemistry/generation.ts b/src/radiochemistry/generation.ts
new file mode 100644
index 000000000..ed4cea92a
--- /dev/null
+++ b/src/radiochemistry/generation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry generation module — tsb analytics library. */
+export interface RadiochemistryGenerationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryGenerationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryGeneration(data: number[], opts: RadiochemistryGenerationOptions = {}): RadiochemistryGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryGeneration };
diff --git a/src/radiochemistry/geometry.ts b/src/radiochemistry/geometry.ts
new file mode 100644
index 000000000..be63d83cd
--- /dev/null
+++ b/src/radiochemistry/geometry.ts
@@ -0,0 +1,14 @@
+/** radiochemistry geometry module — tsb analytics library. */
+export interface RadiochemistryGeometryOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryGeometryResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryGeometry(data: number[], opts: RadiochemistryGeometryOptions = {}): RadiochemistryGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryGeometry };
diff --git a/src/radiochemistry/gradient.ts b/src/radiochemistry/gradient.ts
new file mode 100644
index 000000000..4b251de10
--- /dev/null
+++ b/src/radiochemistry/gradient.ts
@@ -0,0 +1,14 @@
+/** radiochemistry gradient module — tsb analytics library. */
+export interface RadiochemistryGradientOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryGradientResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryGradient(data: number[], opts: RadiochemistryGradientOptions = {}): RadiochemistryGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryGradient };
diff --git a/src/radiochemistry/hessian.ts b/src/radiochemistry/hessian.ts
new file mode 100644
index 000000000..66cca5ddc
--- /dev/null
+++ b/src/radiochemistry/hessian.ts
@@ -0,0 +1,14 @@
+/** radiochemistry hessian module — tsb analytics library. */
+export interface RadiochemistryHessianOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryHessianResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryHessian(data: number[], opts: RadiochemistryHessianOptions = {}): RadiochemistryHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryHessian };
diff --git a/src/radiochemistry/hypothesis.ts b/src/radiochemistry/hypothesis.ts
new file mode 100644
index 000000000..c9f7de0c9
--- /dev/null
+++ b/src/radiochemistry/hypothesis.ts
@@ -0,0 +1,14 @@
+/** radiochemistry hypothesis module — tsb analytics library. */
+export interface RadiochemistryHypothesisOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryHypothesisResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryHypothesis(data: number[], opts: RadiochemistryHypothesisOptions = {}): RadiochemistryHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryHypothesis };
diff --git a/src/radiochemistry/inference.ts b/src/radiochemistry/inference.ts
new file mode 100644
index 000000000..f7a1bf3f5
--- /dev/null
+++ b/src/radiochemistry/inference.ts
@@ -0,0 +1,14 @@
+/** radiochemistry inference module — tsb analytics library. */
+export interface RadiochemistryInferenceOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryInferenceResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryInference(data: number[], opts: RadiochemistryInferenceOptions = {}): RadiochemistryInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryInference };
diff --git a/src/radiochemistry/inference2.ts b/src/radiochemistry/inference2.ts
new file mode 100644
index 000000000..5a259e452
--- /dev/null
+++ b/src/radiochemistry/inference2.ts
@@ -0,0 +1,14 @@
+/** radiochemistry inference2 module — tsb analytics library. */
+export interface RadiochemistryInferenceOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryInferenceResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryInference(data: number[], opts: RadiochemistryInferenceOptions = {}): RadiochemistryInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryInference };
diff --git a/src/radiochemistry/integral.ts b/src/radiochemistry/integral.ts
new file mode 100644
index 000000000..580f28da6
--- /dev/null
+++ b/src/radiochemistry/integral.ts
@@ -0,0 +1,14 @@
+/** radiochemistry integral module — tsb analytics library. */
+export interface RadiochemistryIntegralOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryIntegralResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryIntegral(data: number[], opts: RadiochemistryIntegralOptions = {}): RadiochemistryIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryIntegral };
diff --git a/src/radiochemistry/integration.ts b/src/radiochemistry/integration.ts
new file mode 100644
index 000000000..cfe349398
--- /dev/null
+++ b/src/radiochemistry/integration.ts
@@ -0,0 +1,14 @@
+/** radiochemistry integration module — tsb analytics library. */
+export interface RadiochemistryIntegrationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryIntegrationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryIntegration(data: number[], opts: RadiochemistryIntegrationOptions = {}): RadiochemistryIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryIntegration };
diff --git a/src/radiochemistry/interpolation.ts b/src/radiochemistry/interpolation.ts
new file mode 100644
index 000000000..9ecf8a261
--- /dev/null
+++ b/src/radiochemistry/interpolation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry interpolation module — tsb analytics library. */
+export interface RadiochemistryInterpolationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryInterpolationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryInterpolation(data: number[], opts: RadiochemistryInterpolationOptions = {}): RadiochemistryInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryInterpolation };
diff --git a/src/radiochemistry/jacobian.ts b/src/radiochemistry/jacobian.ts
new file mode 100644
index 000000000..02e63a33a
--- /dev/null
+++ b/src/radiochemistry/jacobian.ts
@@ -0,0 +1,14 @@
+/** radiochemistry jacobian module — tsb analytics library. */
+export interface RadiochemistryJacobianOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryJacobianResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryJacobian(data: number[], opts: RadiochemistryJacobianOptions = {}): RadiochemistryJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryJacobian };
diff --git a/src/radiochemistry/kernel.ts b/src/radiochemistry/kernel.ts
new file mode 100644
index 000000000..e4cb89299
--- /dev/null
+++ b/src/radiochemistry/kernel.ts
@@ -0,0 +1,14 @@
+/** radiochemistry kernel module — tsb analytics library. */
+export interface RadiochemistryKernelOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryKernelResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryKernel(data: number[], opts: RadiochemistryKernelOptions = {}): RadiochemistryKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryKernel };
diff --git a/src/radiochemistry/laplacian.ts b/src/radiochemistry/laplacian.ts
new file mode 100644
index 000000000..a69c12d9b
--- /dev/null
+++ b/src/radiochemistry/laplacian.ts
@@ -0,0 +1,14 @@
+/** radiochemistry laplacian module — tsb analytics library. */
+export interface RadiochemistryLaplacianOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryLaplacianResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryLaplacian(data: number[], opts: RadiochemistryLaplacianOptions = {}): RadiochemistryLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryLaplacian };
diff --git a/src/radiochemistry/learning.ts b/src/radiochemistry/learning.ts
new file mode 100644
index 000000000..4130d1b69
--- /dev/null
+++ b/src/radiochemistry/learning.ts
@@ -0,0 +1,14 @@
+/** radiochemistry learning module — tsb analytics library. */
+export interface RadiochemistryLearningOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryLearningResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryLearning(data: number[], opts: RadiochemistryLearningOptions = {}): RadiochemistryLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryLearning };
diff --git a/src/radiochemistry/linear.ts b/src/radiochemistry/linear.ts
new file mode 100644
index 000000000..11fed1c07
--- /dev/null
+++ b/src/radiochemistry/linear.ts
@@ -0,0 +1,14 @@
+/** radiochemistry linear module — tsb analytics library. */
+export interface RadiochemistryLinearOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryLinearResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryLinear(data: number[], opts: RadiochemistryLinearOptions = {}): RadiochemistryLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryLinear };
diff --git a/src/radiochemistry/manifold.ts b/src/radiochemistry/manifold.ts
new file mode 100644
index 000000000..2291ed686
--- /dev/null
+++ b/src/radiochemistry/manifold.ts
@@ -0,0 +1,14 @@
+/** radiochemistry manifold module — tsb analytics library. */
+export interface RadiochemistryManifoldOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryManifoldResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryManifold(data: number[], opts: RadiochemistryManifoldOptions = {}): RadiochemistryManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryManifold };
diff --git a/src/radiochemistry/matching.ts b/src/radiochemistry/matching.ts
new file mode 100644
index 000000000..4b8bce14d
--- /dev/null
+++ b/src/radiochemistry/matching.ts
@@ -0,0 +1,14 @@
+/** radiochemistry matching module — tsb analytics library. */
+export interface RadiochemistryMatchingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryMatchingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryMatching(data: number[], opts: RadiochemistryMatchingOptions = {}): RadiochemistryMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryMatching };
diff --git a/src/radiochemistry/measurement.ts b/src/radiochemistry/measurement.ts
new file mode 100644
index 000000000..c4690c9af
--- /dev/null
+++ b/src/radiochemistry/measurement.ts
@@ -0,0 +1,14 @@
+/** radiochemistry measurement module — tsb analytics library. */
+export interface RadiochemistryMeasurementOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryMeasurementResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryMeasurement(data: number[], opts: RadiochemistryMeasurementOptions = {}): RadiochemistryMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryMeasurement };
diff --git a/src/radiochemistry/metrics.ts b/src/radiochemistry/metrics.ts
new file mode 100644
index 000000000..2e21d08d5
--- /dev/null
+++ b/src/radiochemistry/metrics.ts
@@ -0,0 +1,14 @@
+/** radiochemistry metrics module — tsb analytics library. */
+export interface RadiochemistryMetricsOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryMetricsResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryMetrics(data: number[], opts: RadiochemistryMetricsOptions = {}): RadiochemistryMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryMetrics };
diff --git a/src/radiochemistry/modeling.ts b/src/radiochemistry/modeling.ts
new file mode 100644
index 000000000..e3485ca34
--- /dev/null
+++ b/src/radiochemistry/modeling.ts
@@ -0,0 +1,14 @@
+/** radiochemistry modeling module — tsb analytics library. */
+export interface RadiochemistryModelingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryModelingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryModeling(data: number[], opts: RadiochemistryModelingOptions = {}): RadiochemistryModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryModeling };
diff --git a/src/radiochemistry/monitoring.ts b/src/radiochemistry/monitoring.ts
new file mode 100644
index 000000000..c3cc8dacd
--- /dev/null
+++ b/src/radiochemistry/monitoring.ts
@@ -0,0 +1,14 @@
+/** radiochemistry monitoring module — tsb analytics library. */
+export interface RadiochemistryMonitoringOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryMonitoringResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryMonitoring(data: number[], opts: RadiochemistryMonitoringOptions = {}): RadiochemistryMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryMonitoring };
diff --git a/src/radiochemistry/nonlinear.ts b/src/radiochemistry/nonlinear.ts
new file mode 100644
index 000000000..c4c25dd08
--- /dev/null
+++ b/src/radiochemistry/nonlinear.ts
@@ -0,0 +1,14 @@
+/** radiochemistry nonlinear module — tsb analytics library. */
+export interface RadiochemistryNonlinearOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryNonlinearResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryNonlinear(data: number[], opts: RadiochemistryNonlinearOptions = {}): RadiochemistryNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryNonlinear };
diff --git a/src/radiochemistry/normalization.ts b/src/radiochemistry/normalization.ts
new file mode 100644
index 000000000..0a7a9eaa1
--- /dev/null
+++ b/src/radiochemistry/normalization.ts
@@ -0,0 +1,14 @@
+/** radiochemistry normalization module — tsb analytics library. */
+export interface RadiochemistryNormalizationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryNormalizationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryNormalization(data: number[], opts: RadiochemistryNormalizationOptions = {}): RadiochemistryNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryNormalization };
diff --git a/src/radiochemistry/optimization.ts b/src/radiochemistry/optimization.ts
new file mode 100644
index 000000000..b0a15b491
--- /dev/null
+++ b/src/radiochemistry/optimization.ts
@@ -0,0 +1,14 @@
+/** radiochemistry optimization module — tsb analytics library. */
+export interface RadiochemistryOptimizationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryOptimizationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryOptimization(data: number[], opts: RadiochemistryOptimizationOptions = {}): RadiochemistryOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryOptimization };
diff --git a/src/radiochemistry/patterns.ts b/src/radiochemistry/patterns.ts
new file mode 100644
index 000000000..b6ffcbc54
--- /dev/null
+++ b/src/radiochemistry/patterns.ts
@@ -0,0 +1,14 @@
+/** radiochemistry patterns module — tsb analytics library. */
+export interface RadiochemistryPatternsOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryPatternsResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryPatterns(data: number[], opts: RadiochemistryPatternsOptions = {}): RadiochemistryPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryPatterns };
diff --git a/src/radiochemistry/permutation.ts b/src/radiochemistry/permutation.ts
new file mode 100644
index 000000000..0b6e8950a
--- /dev/null
+++ b/src/radiochemistry/permutation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry permutation module — tsb analytics library. */
+export interface RadiochemistryPermutationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryPermutationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryPermutation(data: number[], opts: RadiochemistryPermutationOptions = {}): RadiochemistryPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryPermutation };
diff --git a/src/radiochemistry/prediction.ts b/src/radiochemistry/prediction.ts
new file mode 100644
index 000000000..1de112ccc
--- /dev/null
+++ b/src/radiochemistry/prediction.ts
@@ -0,0 +1,14 @@
+/** radiochemistry prediction module — tsb analytics library. */
+export interface RadiochemistryPredictionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryPredictionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryPrediction(data: number[], opts: RadiochemistryPredictionOptions = {}): RadiochemistryPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryPrediction };
diff --git a/src/radiochemistry/processing.ts b/src/radiochemistry/processing.ts
new file mode 100644
index 000000000..1027f609b
--- /dev/null
+++ b/src/radiochemistry/processing.ts
@@ -0,0 +1,14 @@
+/** radiochemistry processing module — tsb analytics library. */
+export interface RadiochemistryProcessingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryProcessingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryProcessing(data: number[], opts: RadiochemistryProcessingOptions = {}): RadiochemistryProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryProcessing };
diff --git a/src/radiochemistry/profiling.ts b/src/radiochemistry/profiling.ts
new file mode 100644
index 000000000..68abf353e
--- /dev/null
+++ b/src/radiochemistry/profiling.ts
@@ -0,0 +1,14 @@
+/** radiochemistry profiling module — tsb analytics library. */
+export interface RadiochemistryProfilingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryProfilingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryProfiling(data: number[], opts: RadiochemistryProfilingOptions = {}): RadiochemistryProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryProfiling };
diff --git a/src/radiochemistry/projection.ts b/src/radiochemistry/projection.ts
new file mode 100644
index 000000000..4ab856ca3
--- /dev/null
+++ b/src/radiochemistry/projection.ts
@@ -0,0 +1,14 @@
+/** radiochemistry projection module — tsb analytics library. */
+export interface RadiochemistryProjectionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryProjectionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryProjection(data: number[], opts: RadiochemistryProjectionOptions = {}): RadiochemistryProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryProjection };
diff --git a/src/radiochemistry/ranking.ts b/src/radiochemistry/ranking.ts
new file mode 100644
index 000000000..07a34fdb2
--- /dev/null
+++ b/src/radiochemistry/ranking.ts
@@ -0,0 +1,14 @@
+/** radiochemistry ranking module — tsb analytics library. */
+export interface RadiochemistryRankingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryRankingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryRanking(data: number[], opts: RadiochemistryRankingOptions = {}): RadiochemistryRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryRanking };
diff --git a/src/radiochemistry/reconstruction.ts b/src/radiochemistry/reconstruction.ts
new file mode 100644
index 000000000..78dc9cbf8
--- /dev/null
+++ b/src/radiochemistry/reconstruction.ts
@@ -0,0 +1,14 @@
+/** radiochemistry reconstruction module — tsb analytics library. */
+export interface RadiochemistryReconstructionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryReconstructionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryReconstruction(data: number[], opts: RadiochemistryReconstructionOptions = {}): RadiochemistryReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryReconstruction };
diff --git a/src/radiochemistry/registration.ts b/src/radiochemistry/registration.ts
new file mode 100644
index 000000000..d940769b7
--- /dev/null
+++ b/src/radiochemistry/registration.ts
@@ -0,0 +1,14 @@
+/** radiochemistry registration module — tsb analytics library. */
+export interface RadiochemistryRegistrationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryRegistrationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryRegistration(data: number[], opts: RadiochemistryRegistrationOptions = {}): RadiochemistryRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryRegistration };
diff --git a/src/radiochemistry/regression.ts b/src/radiochemistry/regression.ts
new file mode 100644
index 000000000..6fc208522
--- /dev/null
+++ b/src/radiochemistry/regression.ts
@@ -0,0 +1,14 @@
+/** radiochemistry regression module — tsb analytics library. */
+export interface RadiochemistryRegressionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryRegressionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryRegression(data: number[], opts: RadiochemistryRegressionOptions = {}): RadiochemistryRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryRegression };
diff --git a/src/radiochemistry/regularization.ts b/src/radiochemistry/regularization.ts
new file mode 100644
index 000000000..6f706ad5e
--- /dev/null
+++ b/src/radiochemistry/regularization.ts
@@ -0,0 +1,14 @@
+/** radiochemistry regularization module — tsb analytics library. */
+export interface RadiochemistryRegularizationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryRegularizationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryRegularization(data: number[], opts: RadiochemistryRegularizationOptions = {}): RadiochemistryRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryRegularization };
diff --git a/src/radiochemistry/robustness.ts b/src/radiochemistry/robustness.ts
new file mode 100644
index 000000000..74307c083
--- /dev/null
+++ b/src/radiochemistry/robustness.ts
@@ -0,0 +1,14 @@
+/** radiochemistry robustness module — tsb analytics library. */
+export interface RadiochemistryRobustnessOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryRobustnessResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryRobustness(data: number[], opts: RadiochemistryRobustnessOptions = {}): RadiochemistryRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryRobustness };
diff --git a/src/radiochemistry/sampling.ts b/src/radiochemistry/sampling.ts
new file mode 100644
index 000000000..94bd4ac4f
--- /dev/null
+++ b/src/radiochemistry/sampling.ts
@@ -0,0 +1,14 @@
+/** radiochemistry sampling module — tsb analytics library. */
+export interface RadiochemistrySamplingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistrySamplingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistrySampling(data: number[], opts: RadiochemistrySamplingOptions = {}): RadiochemistrySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistrySampling };
diff --git a/src/radiochemistry/sampling2.ts b/src/radiochemistry/sampling2.ts
new file mode 100644
index 000000000..071a9a29a
--- /dev/null
+++ b/src/radiochemistry/sampling2.ts
@@ -0,0 +1,14 @@
+/** radiochemistry sampling2 module — tsb analytics library. */
+export interface RadiochemistrySamplingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistrySamplingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistrySampling(data: number[], opts: RadiochemistrySamplingOptions = {}): RadiochemistrySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistrySampling };
diff --git a/src/radiochemistry/scaling.ts b/src/radiochemistry/scaling.ts
new file mode 100644
index 000000000..361d958ba
--- /dev/null
+++ b/src/radiochemistry/scaling.ts
@@ -0,0 +1,14 @@
+/** radiochemistry scaling module — tsb analytics library. */
+export interface RadiochemistryScalingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryScalingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryScaling(data: number[], opts: RadiochemistryScalingOptions = {}): RadiochemistryScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryScaling };
diff --git a/src/radiochemistry/scoring.ts b/src/radiochemistry/scoring.ts
new file mode 100644
index 000000000..245a80d8c
--- /dev/null
+++ b/src/radiochemistry/scoring.ts
@@ -0,0 +1,14 @@
+/** radiochemistry scoring module — tsb analytics library. */
+export interface RadiochemistryScoringOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryScoringResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryScoring(data: number[], opts: RadiochemistryScoringOptions = {}): RadiochemistryScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryScoring };
diff --git a/src/radiochemistry/segmentation.ts b/src/radiochemistry/segmentation.ts
new file mode 100644
index 000000000..d3889b520
--- /dev/null
+++ b/src/radiochemistry/segmentation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry segmentation module — tsb analytics library. */
+export interface RadiochemistrySegmentationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistrySegmentationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistrySegmentation(data: number[], opts: RadiochemistrySegmentationOptions = {}): RadiochemistrySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistrySegmentation };
diff --git a/src/radiochemistry/selection.ts b/src/radiochemistry/selection.ts
new file mode 100644
index 000000000..8a2ac2339
--- /dev/null
+++ b/src/radiochemistry/selection.ts
@@ -0,0 +1,14 @@
+/** radiochemistry selection module — tsb analytics library. */
+export interface RadiochemistrySelectionOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistrySelectionResult { values: number[]; converged: boolean; }
+export function computeRadiochemistrySelection(data: number[], opts: RadiochemistrySelectionOptions = {}): RadiochemistrySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistrySelection };
diff --git a/src/radiochemistry/sensitivity.ts b/src/radiochemistry/sensitivity.ts
new file mode 100644
index 000000000..be1d925ba
--- /dev/null
+++ b/src/radiochemistry/sensitivity.ts
@@ -0,0 +1,14 @@
+/** radiochemistry sensitivity module — tsb analytics library. */
+export interface RadiochemistrySensitivityOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistrySensitivityResult { values: number[]; converged: boolean; }
+export function computeRadiochemistrySensitivity(data: number[], opts: RadiochemistrySensitivityOptions = {}): RadiochemistrySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistrySensitivity };
diff --git a/src/radiochemistry/simulation.ts b/src/radiochemistry/simulation.ts
new file mode 100644
index 000000000..b1b0e13e0
--- /dev/null
+++ b/src/radiochemistry/simulation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry simulation module — tsb analytics library. */
+export interface RadiochemistrySimulationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistrySimulationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistrySimulation(data: number[], opts: RadiochemistrySimulationOptions = {}): RadiochemistrySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistrySimulation };
diff --git a/src/radiochemistry/smoothing.ts b/src/radiochemistry/smoothing.ts
new file mode 100644
index 000000000..09aa0cff1
--- /dev/null
+++ b/src/radiochemistry/smoothing.ts
@@ -0,0 +1,14 @@
+/** radiochemistry smoothing module — tsb analytics library. */
+export interface RadiochemistrySmoothingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistrySmoothingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistrySmoothing(data: number[], opts: RadiochemistrySmoothingOptions = {}): RadiochemistrySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistrySmoothing };
diff --git a/src/radiochemistry/stability.ts b/src/radiochemistry/stability.ts
new file mode 100644
index 000000000..3f15cc657
--- /dev/null
+++ b/src/radiochemistry/stability.ts
@@ -0,0 +1,14 @@
+/** radiochemistry stability module — tsb analytics library. */
+export interface RadiochemistryStabilityOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryStabilityResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryStability(data: number[], opts: RadiochemistryStabilityOptions = {}): RadiochemistryStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryStability };
diff --git a/src/radiochemistry/stacking.ts b/src/radiochemistry/stacking.ts
new file mode 100644
index 000000000..6d76aa424
--- /dev/null
+++ b/src/radiochemistry/stacking.ts
@@ -0,0 +1,14 @@
+/** radiochemistry stacking module — tsb analytics library. */
+export interface RadiochemistryStackingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryStackingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryStacking(data: number[], opts: RadiochemistryStackingOptions = {}): RadiochemistryStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryStacking };
diff --git a/src/radiochemistry/standardization.ts b/src/radiochemistry/standardization.ts
new file mode 100644
index 000000000..ed0b7624a
--- /dev/null
+++ b/src/radiochemistry/standardization.ts
@@ -0,0 +1,14 @@
+/** radiochemistry standardization module — tsb analytics library. */
+export interface RadiochemistryStandardizationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryStandardizationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryStandardization(data: number[], opts: RadiochemistryStandardizationOptions = {}): RadiochemistryStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryStandardization };
diff --git a/src/radiochemistry/static.ts b/src/radiochemistry/static.ts
new file mode 100644
index 000000000..854bf3cb8
--- /dev/null
+++ b/src/radiochemistry/static.ts
@@ -0,0 +1,14 @@
+/** radiochemistry static module — tsb analytics library. */
+export interface RadiochemistryStaticOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryStaticResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryStatic(data: number[], opts: RadiochemistryStaticOptions = {}): RadiochemistryStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryStatic };
diff --git a/src/radiochemistry/stochastic.ts b/src/radiochemistry/stochastic.ts
new file mode 100644
index 000000000..45f64f952
--- /dev/null
+++ b/src/radiochemistry/stochastic.ts
@@ -0,0 +1,14 @@
+/** radiochemistry stochastic module — tsb analytics library. */
+export interface RadiochemistryStochasticOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryStochasticResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryStochastic(data: number[], opts: RadiochemistryStochasticOptions = {}): RadiochemistryStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryStochastic };
diff --git a/src/radiochemistry/synthesis.ts b/src/radiochemistry/synthesis.ts
new file mode 100644
index 000000000..ce47abbb0
--- /dev/null
+++ b/src/radiochemistry/synthesis.ts
@@ -0,0 +1,14 @@
+/** radiochemistry synthesis module — tsb analytics library. */
+export interface RadiochemistrySynthesisOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistrySynthesisResult { values: number[]; converged: boolean; }
+export function computeRadiochemistrySynthesis(data: number[], opts: RadiochemistrySynthesisOptions = {}): RadiochemistrySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistrySynthesis };
diff --git a/src/radiochemistry/topology.ts b/src/radiochemistry/topology.ts
new file mode 100644
index 000000000..af11516a1
--- /dev/null
+++ b/src/radiochemistry/topology.ts
@@ -0,0 +1,14 @@
+/** radiochemistry topology module — tsb analytics library. */
+export interface RadiochemistryTopologyOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryTopologyResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryTopology(data: number[], opts: RadiochemistryTopologyOptions = {}): RadiochemistryTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryTopology };
diff --git a/src/radiochemistry/tracking.ts b/src/radiochemistry/tracking.ts
new file mode 100644
index 000000000..68eff85ea
--- /dev/null
+++ b/src/radiochemistry/tracking.ts
@@ -0,0 +1,14 @@
+/** radiochemistry tracking module — tsb analytics library. */
+export interface RadiochemistryTrackingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryTrackingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryTracking(data: number[], opts: RadiochemistryTrackingOptions = {}): RadiochemistryTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryTracking };
diff --git a/src/radiochemistry/transform.ts b/src/radiochemistry/transform.ts
new file mode 100644
index 000000000..9538fca15
--- /dev/null
+++ b/src/radiochemistry/transform.ts
@@ -0,0 +1,14 @@
+/** radiochemistry transform module — tsb analytics library. */
+export interface RadiochemistryTransformOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryTransformResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryTransform(data: number[], opts: RadiochemistryTransformOptions = {}): RadiochemistryTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryTransform };
diff --git a/src/radiochemistry/uncertainty.ts b/src/radiochemistry/uncertainty.ts
new file mode 100644
index 000000000..5ec75a53e
--- /dev/null
+++ b/src/radiochemistry/uncertainty.ts
@@ -0,0 +1,14 @@
+/** radiochemistry uncertainty module — tsb analytics library. */
+export interface RadiochemistryUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryUncertaintyResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryUncertainty(data: number[], opts: RadiochemistryUncertaintyOptions = {}): RadiochemistryUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryUncertainty };
diff --git a/src/radiochemistry/validation.ts b/src/radiochemistry/validation.ts
new file mode 100644
index 000000000..e5c1f2e23
--- /dev/null
+++ b/src/radiochemistry/validation.ts
@@ -0,0 +1,14 @@
+/** radiochemistry validation module — tsb analytics library. */
+export interface RadiochemistryValidationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryValidationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryValidation(data: number[], opts: RadiochemistryValidationOptions = {}): RadiochemistryValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryValidation };
diff --git a/src/radiochemistry/verification.ts b/src/radiochemistry/verification.ts
new file mode 100644
index 000000000..8ba14af3c
--- /dev/null
+++ b/src/radiochemistry/verification.ts
@@ -0,0 +1,14 @@
+/** radiochemistry verification module — tsb analytics library. */
+export interface RadiochemistryVerificationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryVerificationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryVerification(data: number[], opts: RadiochemistryVerificationOptions = {}): RadiochemistryVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryVerification };
diff --git a/src/radiochemistry/visualization.ts b/src/radiochemistry/visualization.ts
new file mode 100644
index 000000000..64cbf9527
--- /dev/null
+++ b/src/radiochemistry/visualization.ts
@@ -0,0 +1,14 @@
+/** radiochemistry visualization module — tsb analytics library. */
+export interface RadiochemistryVisualizationOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryVisualizationResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryVisualization(data: number[], opts: RadiochemistryVisualizationOptions = {}): RadiochemistryVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryVisualization };
diff --git a/src/radiochemistry/voting.ts b/src/radiochemistry/voting.ts
new file mode 100644
index 000000000..8f1c7c8e9
--- /dev/null
+++ b/src/radiochemistry/voting.ts
@@ -0,0 +1,14 @@
+/** radiochemistry voting module — tsb analytics library. */
+export interface RadiochemistryVotingOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryVotingResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryVoting(data: number[], opts: RadiochemistryVotingOptions = {}): RadiochemistryVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryVoting };
diff --git a/src/radiochemistry/wavelet.ts b/src/radiochemistry/wavelet.ts
new file mode 100644
index 000000000..cb561e946
--- /dev/null
+++ b/src/radiochemistry/wavelet.ts
@@ -0,0 +1,14 @@
+/** radiochemistry wavelet module — tsb analytics library. */
+export interface RadiochemistryWaveletOptions { tol?: number; maxIter?: number; }
+export interface RadiochemistryWaveletResult { values: number[]; converged: boolean; }
+export function computeRadiochemistryWavelet(data: number[], opts: RadiochemistryWaveletOptions = {}): RadiochemistryWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRadiochemistryWavelet };
diff --git a/src/remote_sensing/adaptation.ts b/src/remote_sensing/adaptation.ts
new file mode 100644
index 000000000..bd364a8bd
--- /dev/null
+++ b/src/remote_sensing/adaptation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing adaptation module — tsb analytics library. */
+export interface RemoteSensingAdaptationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingAdaptationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingAdaptation(data: number[], opts: RemoteSensingAdaptationOptions = {}): RemoteSensingAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingAdaptation };
diff --git a/src/remote_sensing/aggregation.ts b/src/remote_sensing/aggregation.ts
new file mode 100644
index 000000000..ca090cd5e
--- /dev/null
+++ b/src/remote_sensing/aggregation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing aggregation module — tsb analytics library. */
+export interface RemoteSensingAggregationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingAggregationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingAggregation(data: number[], opts: RemoteSensingAggregationOptions = {}): RemoteSensingAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingAggregation };
diff --git a/src/remote_sensing/algebra.ts b/src/remote_sensing/algebra.ts
new file mode 100644
index 000000000..4ce93ef64
--- /dev/null
+++ b/src/remote_sensing/algebra.ts
@@ -0,0 +1,14 @@
+/** remote_sensing algebra module — tsb analytics library. */
+export interface RemoteSensingAlgebraOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingAlgebraResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingAlgebra(data: number[], opts: RemoteSensingAlgebraOptions = {}): RemoteSensingAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingAlgebra };
diff --git a/src/remote_sensing/alignment.ts b/src/remote_sensing/alignment.ts
new file mode 100644
index 000000000..077749f71
--- /dev/null
+++ b/src/remote_sensing/alignment.ts
@@ -0,0 +1,14 @@
+/** remote_sensing alignment module — tsb analytics library. */
+export interface RemoteSensingAlignmentOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingAlignmentResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingAlignment(data: number[], opts: RemoteSensingAlignmentOptions = {}): RemoteSensingAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingAlignment };
diff --git a/src/remote_sensing/analysis.ts b/src/remote_sensing/analysis.ts
new file mode 100644
index 000000000..1ed3c5bd3
--- /dev/null
+++ b/src/remote_sensing/analysis.ts
@@ -0,0 +1,14 @@
+/** remote_sensing analysis module — tsb analytics library. */
+export interface RemoteSensingAnalysisOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingAnalysisResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingAnalysis(data: number[], opts: RemoteSensingAnalysisOptions = {}): RemoteSensingAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingAnalysis };
diff --git a/src/remote_sensing/augmentation.ts b/src/remote_sensing/augmentation.ts
new file mode 100644
index 000000000..36aa854b4
--- /dev/null
+++ b/src/remote_sensing/augmentation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing augmentation module — tsb analytics library. */
+export interface RemoteSensingAugmentationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingAugmentationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingAugmentation(data: number[], opts: RemoteSensingAugmentationOptions = {}): RemoteSensingAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingAugmentation };
diff --git a/src/remote_sensing/bagging.ts b/src/remote_sensing/bagging.ts
new file mode 100644
index 000000000..754292758
--- /dev/null
+++ b/src/remote_sensing/bagging.ts
@@ -0,0 +1,14 @@
+/** remote_sensing bagging module — tsb analytics library. */
+export interface RemoteSensingBaggingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingBaggingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingBagging(data: number[], opts: RemoteSensingBaggingOptions = {}): RemoteSensingBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingBagging };
diff --git a/src/remote_sensing/basis.ts b/src/remote_sensing/basis.ts
new file mode 100644
index 000000000..39849080c
--- /dev/null
+++ b/src/remote_sensing/basis.ts
@@ -0,0 +1,14 @@
+/** remote_sensing basis module — tsb analytics library. */
+export interface RemoteSensingBasisOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingBasisResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingBasis(data: number[], opts: RemoteSensingBasisOptions = {}): RemoteSensingBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingBasis };
diff --git a/src/remote_sensing/benchmarking.ts b/src/remote_sensing/benchmarking.ts
new file mode 100644
index 000000000..a2885d9fc
--- /dev/null
+++ b/src/remote_sensing/benchmarking.ts
@@ -0,0 +1,14 @@
+/** remote_sensing benchmarking module — tsb analytics library. */
+export interface RemoteSensingBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingBenchmarking(data: number[], opts: RemoteSensingBenchmarkingOptions = {}): RemoteSensingBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingBenchmarking };
diff --git a/src/remote_sensing/blending.ts b/src/remote_sensing/blending.ts
new file mode 100644
index 000000000..c43d5e30e
--- /dev/null
+++ b/src/remote_sensing/blending.ts
@@ -0,0 +1,14 @@
+/** remote_sensing blending module — tsb analytics library. */
+export interface RemoteSensingBlendingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingBlendingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingBlending(data: number[], opts: RemoteSensingBlendingOptions = {}): RemoteSensingBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingBlending };
diff --git a/src/remote_sensing/boosting.ts b/src/remote_sensing/boosting.ts
new file mode 100644
index 000000000..587c34105
--- /dev/null
+++ b/src/remote_sensing/boosting.ts
@@ -0,0 +1,14 @@
+/** remote_sensing boosting module — tsb analytics library. */
+export interface RemoteSensingBoostingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingBoostingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingBoosting(data: number[], opts: RemoteSensingBoostingOptions = {}): RemoteSensingBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingBoosting };
diff --git a/src/remote_sensing/bootstrap.ts b/src/remote_sensing/bootstrap.ts
new file mode 100644
index 000000000..e438ca8b6
--- /dev/null
+++ b/src/remote_sensing/bootstrap.ts
@@ -0,0 +1,14 @@
+/** remote_sensing bootstrap module — tsb analytics library. */
+export interface RemoteSensingBootstrapOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingBootstrapResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingBootstrap(data: number[], opts: RemoteSensingBootstrapOptions = {}): RemoteSensingBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingBootstrap };
diff --git a/src/remote_sensing/calculus.ts b/src/remote_sensing/calculus.ts
new file mode 100644
index 000000000..4e8a017b7
--- /dev/null
+++ b/src/remote_sensing/calculus.ts
@@ -0,0 +1,14 @@
+/** remote_sensing calculus module — tsb analytics library. */
+export interface RemoteSensingCalculusOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingCalculusResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingCalculus(data: number[], opts: RemoteSensingCalculusOptions = {}): RemoteSensingCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingCalculus };
diff --git a/src/remote_sensing/calibration.ts b/src/remote_sensing/calibration.ts
new file mode 100644
index 000000000..98c5a007a
--- /dev/null
+++ b/src/remote_sensing/calibration.ts
@@ -0,0 +1,14 @@
+/** remote_sensing calibration module — tsb analytics library. */
+export interface RemoteSensingCalibrationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingCalibrationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingCalibration(data: number[], opts: RemoteSensingCalibrationOptions = {}): RemoteSensingCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingCalibration };
diff --git a/src/remote_sensing/characterization.ts b/src/remote_sensing/characterization.ts
new file mode 100644
index 000000000..ae396efe0
--- /dev/null
+++ b/src/remote_sensing/characterization.ts
@@ -0,0 +1,14 @@
+/** remote_sensing characterization module — tsb analytics library. */
+export interface RemoteSensingCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingCharacterizationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingCharacterization(data: number[], opts: RemoteSensingCharacterizationOptions = {}): RemoteSensingCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingCharacterization };
diff --git a/src/remote_sensing/classification.ts b/src/remote_sensing/classification.ts
new file mode 100644
index 000000000..e86a5367c
--- /dev/null
+++ b/src/remote_sensing/classification.ts
@@ -0,0 +1,14 @@
+/** remote_sensing classification module — tsb analytics library. */
+export interface RemoteSensingClassificationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingClassificationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingClassification(data: number[], opts: RemoteSensingClassificationOptions = {}): RemoteSensingClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingClassification };
diff --git a/src/remote_sensing/clustering.ts b/src/remote_sensing/clustering.ts
new file mode 100644
index 000000000..d824ae44d
--- /dev/null
+++ b/src/remote_sensing/clustering.ts
@@ -0,0 +1,14 @@
+/** remote_sensing clustering module — tsb analytics library. */
+export interface RemoteSensingClusteringOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingClusteringResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingClustering(data: number[], opts: RemoteSensingClusteringOptions = {}): RemoteSensingClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingClustering };
diff --git a/src/remote_sensing/compression.ts b/src/remote_sensing/compression.ts
new file mode 100644
index 000000000..980ccb69e
--- /dev/null
+++ b/src/remote_sensing/compression.ts
@@ -0,0 +1,14 @@
+/** remote_sensing compression module — tsb analytics library. */
+export interface RemoteSensingCompressionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingCompressionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingCompression(data: number[], opts: RemoteSensingCompressionOptions = {}): RemoteSensingCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingCompression };
diff --git a/src/remote_sensing/continuous.ts b/src/remote_sensing/continuous.ts
new file mode 100644
index 000000000..ef94ac41d
--- /dev/null
+++ b/src/remote_sensing/continuous.ts
@@ -0,0 +1,14 @@
+/** remote_sensing continuous module — tsb analytics library. */
+export interface RemoteSensingContinuousOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingContinuousResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingContinuous(data: number[], opts: RemoteSensingContinuousOptions = {}): RemoteSensingContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingContinuous };
diff --git a/src/remote_sensing/control.ts b/src/remote_sensing/control.ts
new file mode 100644
index 000000000..596a4fe2f
--- /dev/null
+++ b/src/remote_sensing/control.ts
@@ -0,0 +1,14 @@
+/** remote_sensing control module — tsb analytics library. */
+export interface RemoteSensingControlOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingControlResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingControl(data: number[], opts: RemoteSensingControlOptions = {}): RemoteSensingControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingControl };
diff --git a/src/remote_sensing/convergence.ts b/src/remote_sensing/convergence.ts
new file mode 100644
index 000000000..dc8eb239d
--- /dev/null
+++ b/src/remote_sensing/convergence.ts
@@ -0,0 +1,14 @@
+/** remote_sensing convergence module — tsb analytics library. */
+export interface RemoteSensingConvergenceOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingConvergenceResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingConvergence(data: number[], opts: RemoteSensingConvergenceOptions = {}): RemoteSensingConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingConvergence };
diff --git a/src/remote_sensing/convex.ts b/src/remote_sensing/convex.ts
new file mode 100644
index 000000000..3d81006ae
--- /dev/null
+++ b/src/remote_sensing/convex.ts
@@ -0,0 +1,14 @@
+/** remote_sensing convex module — tsb analytics library. */
+export interface RemoteSensingConvexOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingConvexResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingConvex(data: number[], opts: RemoteSensingConvexOptions = {}): RemoteSensingConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingConvex };
diff --git a/src/remote_sensing/correlation.ts b/src/remote_sensing/correlation.ts
new file mode 100644
index 000000000..dd7fd642d
--- /dev/null
+++ b/src/remote_sensing/correlation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing correlation module — tsb analytics library. */
+export interface RemoteSensingCorrelationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingCorrelationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingCorrelation(data: number[], opts: RemoteSensingCorrelationOptions = {}): RemoteSensingCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingCorrelation };
diff --git a/src/remote_sensing/covariance.ts b/src/remote_sensing/covariance.ts
new file mode 100644
index 000000000..6e2c01fa1
--- /dev/null
+++ b/src/remote_sensing/covariance.ts
@@ -0,0 +1,14 @@
+/** remote_sensing covariance module — tsb analytics library. */
+export interface RemoteSensingCovarianceOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingCovarianceResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingCovariance(data: number[], opts: RemoteSensingCovarianceOptions = {}): RemoteSensingCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingCovariance };
diff --git a/src/remote_sensing/cross_validation.ts b/src/remote_sensing/cross_validation.ts
new file mode 100644
index 000000000..a2f3dbc88
--- /dev/null
+++ b/src/remote_sensing/cross_validation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing cross_validation module — tsb analytics library. */
+export interface RemoteSensingCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingCrossValidationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingCrossValidation(data: number[], opts: RemoteSensingCrossValidationOptions = {}): RemoteSensingCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingCrossValidation };
diff --git a/src/remote_sensing/decoding.ts b/src/remote_sensing/decoding.ts
new file mode 100644
index 000000000..61882af18
--- /dev/null
+++ b/src/remote_sensing/decoding.ts
@@ -0,0 +1,14 @@
+/** remote_sensing decoding module — tsb analytics library. */
+export interface RemoteSensingDecodingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDecodingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDecoding(data: number[], opts: RemoteSensingDecodingOptions = {}): RemoteSensingDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDecoding };
diff --git a/src/remote_sensing/decomposition.ts b/src/remote_sensing/decomposition.ts
new file mode 100644
index 000000000..3d198f262
--- /dev/null
+++ b/src/remote_sensing/decomposition.ts
@@ -0,0 +1,14 @@
+/** remote_sensing decomposition module — tsb analytics library. */
+export interface RemoteSensingDecompositionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDecompositionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDecomposition(data: number[], opts: RemoteSensingDecompositionOptions = {}): RemoteSensingDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDecomposition };
diff --git a/src/remote_sensing/detection.ts b/src/remote_sensing/detection.ts
new file mode 100644
index 000000000..6ba04309c
--- /dev/null
+++ b/src/remote_sensing/detection.ts
@@ -0,0 +1,14 @@
+/** remote_sensing detection module — tsb analytics library. */
+export interface RemoteSensingDetectionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDetectionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDetection(data: number[], opts: RemoteSensingDetectionOptions = {}): RemoteSensingDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDetection };
diff --git a/src/remote_sensing/deterministic.ts b/src/remote_sensing/deterministic.ts
new file mode 100644
index 000000000..6f7d9a7c3
--- /dev/null
+++ b/src/remote_sensing/deterministic.ts
@@ -0,0 +1,14 @@
+/** remote_sensing deterministic module — tsb analytics library. */
+export interface RemoteSensingDeterministicOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDeterministicResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDeterministic(data: number[], opts: RemoteSensingDeterministicOptions = {}): RemoteSensingDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDeterministic };
diff --git a/src/remote_sensing/diagnostics.ts b/src/remote_sensing/diagnostics.ts
new file mode 100644
index 000000000..33aa0d662
--- /dev/null
+++ b/src/remote_sensing/diagnostics.ts
@@ -0,0 +1,14 @@
+/** remote_sensing diagnostics module — tsb analytics library. */
+export interface RemoteSensingDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDiagnostics(data: number[], opts: RemoteSensingDiagnosticsOptions = {}): RemoteSensingDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDiagnostics };
diff --git a/src/remote_sensing/differential.ts b/src/remote_sensing/differential.ts
new file mode 100644
index 000000000..ff5837dfe
--- /dev/null
+++ b/src/remote_sensing/differential.ts
@@ -0,0 +1,14 @@
+/** remote_sensing differential module — tsb analytics library. */
+export interface RemoteSensingDifferentialOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDifferentialResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDifferential(data: number[], opts: RemoteSensingDifferentialOptions = {}): RemoteSensingDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDifferential };
diff --git a/src/remote_sensing/discrete.ts b/src/remote_sensing/discrete.ts
new file mode 100644
index 000000000..efbafd6b1
--- /dev/null
+++ b/src/remote_sensing/discrete.ts
@@ -0,0 +1,14 @@
+/** remote_sensing discrete module — tsb analytics library. */
+export interface RemoteSensingDiscreteOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDiscreteResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDiscrete(data: number[], opts: RemoteSensingDiscreteOptions = {}): RemoteSensingDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDiscrete };
diff --git a/src/remote_sensing/distribution.ts b/src/remote_sensing/distribution.ts
new file mode 100644
index 000000000..8f3ba676c
--- /dev/null
+++ b/src/remote_sensing/distribution.ts
@@ -0,0 +1,14 @@
+/** remote_sensing distribution module — tsb analytics library. */
+export interface RemoteSensingDistributionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDistributionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDistribution(data: number[], opts: RemoteSensingDistributionOptions = {}): RemoteSensingDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDistribution };
diff --git a/src/remote_sensing/dynamic.ts b/src/remote_sensing/dynamic.ts
new file mode 100644
index 000000000..d2d8a3e76
--- /dev/null
+++ b/src/remote_sensing/dynamic.ts
@@ -0,0 +1,14 @@
+/** remote_sensing dynamic module — tsb analytics library. */
+export interface RemoteSensingDynamicOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingDynamicResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingDynamic(data: number[], opts: RemoteSensingDynamicOptions = {}): RemoteSensingDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingDynamic };
diff --git a/src/remote_sensing/embedding.ts b/src/remote_sensing/embedding.ts
new file mode 100644
index 000000000..727ac3120
--- /dev/null
+++ b/src/remote_sensing/embedding.ts
@@ -0,0 +1,14 @@
+/** remote_sensing embedding module — tsb analytics library. */
+export interface RemoteSensingEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingEmbeddingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingEmbedding(data: number[], opts: RemoteSensingEmbeddingOptions = {}): RemoteSensingEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingEmbedding };
diff --git a/src/remote_sensing/encoding.ts b/src/remote_sensing/encoding.ts
new file mode 100644
index 000000000..e8f314420
--- /dev/null
+++ b/src/remote_sensing/encoding.ts
@@ -0,0 +1,14 @@
+/** remote_sensing encoding module — tsb analytics library. */
+export interface RemoteSensingEncodingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingEncodingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingEncoding(data: number[], opts: RemoteSensingEncodingOptions = {}): RemoteSensingEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingEncoding };
diff --git a/src/remote_sensing/ensemble.ts b/src/remote_sensing/ensemble.ts
new file mode 100644
index 000000000..31d9b80af
--- /dev/null
+++ b/src/remote_sensing/ensemble.ts
@@ -0,0 +1,14 @@
+/** remote_sensing ensemble module — tsb analytics library. */
+export interface RemoteSensingEnsembleOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingEnsembleResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingEnsemble(data: number[], opts: RemoteSensingEnsembleOptions = {}): RemoteSensingEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingEnsemble };
diff --git a/src/remote_sensing/estimation.ts b/src/remote_sensing/estimation.ts
new file mode 100644
index 000000000..cf3e33192
--- /dev/null
+++ b/src/remote_sensing/estimation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing estimation module — tsb analytics library. */
+export interface RemoteSensingEstimationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingEstimationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingEstimation(data: number[], opts: RemoteSensingEstimationOptions = {}): RemoteSensingEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingEstimation };
diff --git a/src/remote_sensing/evaluation.ts b/src/remote_sensing/evaluation.ts
new file mode 100644
index 000000000..2af63e95a
--- /dev/null
+++ b/src/remote_sensing/evaluation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing evaluation module — tsb analytics library. */
+export interface RemoteSensingEvaluationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingEvaluationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingEvaluation(data: number[], opts: RemoteSensingEvaluationOptions = {}): RemoteSensingEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingEvaluation };
diff --git a/src/remote_sensing/extrapolation.ts b/src/remote_sensing/extrapolation.ts
new file mode 100644
index 000000000..86a57c29f
--- /dev/null
+++ b/src/remote_sensing/extrapolation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing extrapolation module — tsb analytics library. */
+export interface RemoteSensingExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingExtrapolationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingExtrapolation(data: number[], opts: RemoteSensingExtrapolationOptions = {}): RemoteSensingExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingExtrapolation };
diff --git a/src/remote_sensing/features.ts b/src/remote_sensing/features.ts
new file mode 100644
index 000000000..c9400fbed
--- /dev/null
+++ b/src/remote_sensing/features.ts
@@ -0,0 +1,14 @@
+/** remote_sensing features module — tsb analytics library. */
+export interface RemoteSensingFeaturesOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingFeaturesResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingFeatures(data: number[], opts: RemoteSensingFeaturesOptions = {}): RemoteSensingFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingFeatures };
diff --git a/src/remote_sensing/feedback.ts b/src/remote_sensing/feedback.ts
new file mode 100644
index 000000000..f81bacbd5
--- /dev/null
+++ b/src/remote_sensing/feedback.ts
@@ -0,0 +1,14 @@
+/** remote_sensing feedback module — tsb analytics library. */
+export interface RemoteSensingFeedbackOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingFeedbackResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingFeedback(data: number[], opts: RemoteSensingFeedbackOptions = {}): RemoteSensingFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingFeedback };
diff --git a/src/remote_sensing/filtering.ts b/src/remote_sensing/filtering.ts
new file mode 100644
index 000000000..d77b19552
--- /dev/null
+++ b/src/remote_sensing/filtering.ts
@@ -0,0 +1,14 @@
+/** remote_sensing filtering module — tsb analytics library. */
+export interface RemoteSensingFilteringOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingFilteringResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingFiltering(data: number[], opts: RemoteSensingFilteringOptions = {}): RemoteSensingFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingFiltering };
diff --git a/src/remote_sensing/fourier.ts b/src/remote_sensing/fourier.ts
new file mode 100644
index 000000000..d130da9ce
--- /dev/null
+++ b/src/remote_sensing/fourier.ts
@@ -0,0 +1,14 @@
+/** remote_sensing fourier module — tsb analytics library. */
+export interface RemoteSensingFourierOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingFourierResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingFourier(data: number[], opts: RemoteSensingFourierOptions = {}): RemoteSensingFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingFourier };
diff --git a/src/remote_sensing/fusion.ts b/src/remote_sensing/fusion.ts
new file mode 100644
index 000000000..221daa365
--- /dev/null
+++ b/src/remote_sensing/fusion.ts
@@ -0,0 +1,14 @@
+/** remote_sensing fusion module — tsb analytics library. */
+export interface RemoteSensingFusionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingFusionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingFusion(data: number[], opts: RemoteSensingFusionOptions = {}): RemoteSensingFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingFusion };
diff --git a/src/remote_sensing/generation.ts b/src/remote_sensing/generation.ts
new file mode 100644
index 000000000..758738fca
--- /dev/null
+++ b/src/remote_sensing/generation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing generation module — tsb analytics library. */
+export interface RemoteSensingGenerationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingGenerationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingGeneration(data: number[], opts: RemoteSensingGenerationOptions = {}): RemoteSensingGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingGeneration };
diff --git a/src/remote_sensing/geometry.ts b/src/remote_sensing/geometry.ts
new file mode 100644
index 000000000..264af89b8
--- /dev/null
+++ b/src/remote_sensing/geometry.ts
@@ -0,0 +1,14 @@
+/** remote_sensing geometry module — tsb analytics library. */
+export interface RemoteSensingGeometryOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingGeometryResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingGeometry(data: number[], opts: RemoteSensingGeometryOptions = {}): RemoteSensingGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingGeometry };
diff --git a/src/remote_sensing/gradient.ts b/src/remote_sensing/gradient.ts
new file mode 100644
index 000000000..5b136215a
--- /dev/null
+++ b/src/remote_sensing/gradient.ts
@@ -0,0 +1,14 @@
+/** remote_sensing gradient module — tsb analytics library. */
+export interface RemoteSensingGradientOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingGradientResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingGradient(data: number[], opts: RemoteSensingGradientOptions = {}): RemoteSensingGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingGradient };
diff --git a/src/remote_sensing/hessian.ts b/src/remote_sensing/hessian.ts
new file mode 100644
index 000000000..7a2e41f1a
--- /dev/null
+++ b/src/remote_sensing/hessian.ts
@@ -0,0 +1,14 @@
+/** remote_sensing hessian module — tsb analytics library. */
+export interface RemoteSensingHessianOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingHessianResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingHessian(data: number[], opts: RemoteSensingHessianOptions = {}): RemoteSensingHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingHessian };
diff --git a/src/remote_sensing/hypothesis.ts b/src/remote_sensing/hypothesis.ts
new file mode 100644
index 000000000..4c166f120
--- /dev/null
+++ b/src/remote_sensing/hypothesis.ts
@@ -0,0 +1,14 @@
+/** remote_sensing hypothesis module — tsb analytics library. */
+export interface RemoteSensingHypothesisOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingHypothesisResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingHypothesis(data: number[], opts: RemoteSensingHypothesisOptions = {}): RemoteSensingHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingHypothesis };
diff --git a/src/remote_sensing/inference.ts b/src/remote_sensing/inference.ts
new file mode 100644
index 000000000..d2d46130b
--- /dev/null
+++ b/src/remote_sensing/inference.ts
@@ -0,0 +1,14 @@
+/** remote_sensing inference module — tsb analytics library. */
+export interface RemoteSensingInferenceOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingInferenceResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingInference(data: number[], opts: RemoteSensingInferenceOptions = {}): RemoteSensingInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingInference };
diff --git a/src/remote_sensing/inference2.ts b/src/remote_sensing/inference2.ts
new file mode 100644
index 000000000..6e29fda88
--- /dev/null
+++ b/src/remote_sensing/inference2.ts
@@ -0,0 +1,14 @@
+/** remote_sensing inference2 module — tsb analytics library. */
+export interface RemoteSensingInferenceOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingInferenceResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingInference(data: number[], opts: RemoteSensingInferenceOptions = {}): RemoteSensingInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingInference };
diff --git a/src/remote_sensing/integral.ts b/src/remote_sensing/integral.ts
new file mode 100644
index 000000000..a6a048e86
--- /dev/null
+++ b/src/remote_sensing/integral.ts
@@ -0,0 +1,14 @@
+/** remote_sensing integral module — tsb analytics library. */
+export interface RemoteSensingIntegralOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingIntegralResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingIntegral(data: number[], opts: RemoteSensingIntegralOptions = {}): RemoteSensingIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingIntegral };
diff --git a/src/remote_sensing/integration.ts b/src/remote_sensing/integration.ts
new file mode 100644
index 000000000..66703b2ca
--- /dev/null
+++ b/src/remote_sensing/integration.ts
@@ -0,0 +1,14 @@
+/** remote_sensing integration module — tsb analytics library. */
+export interface RemoteSensingIntegrationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingIntegrationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingIntegration(data: number[], opts: RemoteSensingIntegrationOptions = {}): RemoteSensingIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingIntegration };
diff --git a/src/remote_sensing/interpolation.ts b/src/remote_sensing/interpolation.ts
new file mode 100644
index 000000000..873136f03
--- /dev/null
+++ b/src/remote_sensing/interpolation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing interpolation module — tsb analytics library. */
+export interface RemoteSensingInterpolationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingInterpolationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingInterpolation(data: number[], opts: RemoteSensingInterpolationOptions = {}): RemoteSensingInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingInterpolation };
diff --git a/src/remote_sensing/jacobian.ts b/src/remote_sensing/jacobian.ts
new file mode 100644
index 000000000..706c91d97
--- /dev/null
+++ b/src/remote_sensing/jacobian.ts
@@ -0,0 +1,14 @@
+/** remote_sensing jacobian module — tsb analytics library. */
+export interface RemoteSensingJacobianOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingJacobianResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingJacobian(data: number[], opts: RemoteSensingJacobianOptions = {}): RemoteSensingJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingJacobian };
diff --git a/src/remote_sensing/kernel.ts b/src/remote_sensing/kernel.ts
new file mode 100644
index 000000000..34766b546
--- /dev/null
+++ b/src/remote_sensing/kernel.ts
@@ -0,0 +1,14 @@
+/** remote_sensing kernel module — tsb analytics library. */
+export interface RemoteSensingKernelOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingKernelResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingKernel(data: number[], opts: RemoteSensingKernelOptions = {}): RemoteSensingKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingKernel };
diff --git a/src/remote_sensing/laplacian.ts b/src/remote_sensing/laplacian.ts
new file mode 100644
index 000000000..f12d0c8e7
--- /dev/null
+++ b/src/remote_sensing/laplacian.ts
@@ -0,0 +1,14 @@
+/** remote_sensing laplacian module — tsb analytics library. */
+export interface RemoteSensingLaplacianOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingLaplacianResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingLaplacian(data: number[], opts: RemoteSensingLaplacianOptions = {}): RemoteSensingLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingLaplacian };
diff --git a/src/remote_sensing/learning.ts b/src/remote_sensing/learning.ts
new file mode 100644
index 000000000..09cc1315d
--- /dev/null
+++ b/src/remote_sensing/learning.ts
@@ -0,0 +1,14 @@
+/** remote_sensing learning module — tsb analytics library. */
+export interface RemoteSensingLearningOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingLearningResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingLearning(data: number[], opts: RemoteSensingLearningOptions = {}): RemoteSensingLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingLearning };
diff --git a/src/remote_sensing/linear.ts b/src/remote_sensing/linear.ts
new file mode 100644
index 000000000..46de7a556
--- /dev/null
+++ b/src/remote_sensing/linear.ts
@@ -0,0 +1,14 @@
+/** remote_sensing linear module — tsb analytics library. */
+export interface RemoteSensingLinearOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingLinearResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingLinear(data: number[], opts: RemoteSensingLinearOptions = {}): RemoteSensingLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingLinear };
diff --git a/src/remote_sensing/manifold.ts b/src/remote_sensing/manifold.ts
new file mode 100644
index 000000000..70e7d951c
--- /dev/null
+++ b/src/remote_sensing/manifold.ts
@@ -0,0 +1,14 @@
+/** remote_sensing manifold module — tsb analytics library. */
+export interface RemoteSensingManifoldOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingManifoldResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingManifold(data: number[], opts: RemoteSensingManifoldOptions = {}): RemoteSensingManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingManifold };
diff --git a/src/remote_sensing/matching.ts b/src/remote_sensing/matching.ts
new file mode 100644
index 000000000..31606a281
--- /dev/null
+++ b/src/remote_sensing/matching.ts
@@ -0,0 +1,14 @@
+/** remote_sensing matching module — tsb analytics library. */
+export interface RemoteSensingMatchingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingMatchingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingMatching(data: number[], opts: RemoteSensingMatchingOptions = {}): RemoteSensingMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingMatching };
diff --git a/src/remote_sensing/measurement.ts b/src/remote_sensing/measurement.ts
new file mode 100644
index 000000000..c852a4c0f
--- /dev/null
+++ b/src/remote_sensing/measurement.ts
@@ -0,0 +1,14 @@
+/** remote_sensing measurement module — tsb analytics library. */
+export interface RemoteSensingMeasurementOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingMeasurementResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingMeasurement(data: number[], opts: RemoteSensingMeasurementOptions = {}): RemoteSensingMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingMeasurement };
diff --git a/src/remote_sensing/metrics.ts b/src/remote_sensing/metrics.ts
new file mode 100644
index 000000000..0ac8c7b75
--- /dev/null
+++ b/src/remote_sensing/metrics.ts
@@ -0,0 +1,14 @@
+/** remote_sensing metrics module — tsb analytics library. */
+export interface RemoteSensingMetricsOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingMetricsResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingMetrics(data: number[], opts: RemoteSensingMetricsOptions = {}): RemoteSensingMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingMetrics };
diff --git a/src/remote_sensing/modeling.ts b/src/remote_sensing/modeling.ts
new file mode 100644
index 000000000..62c499c79
--- /dev/null
+++ b/src/remote_sensing/modeling.ts
@@ -0,0 +1,14 @@
+/** remote_sensing modeling module — tsb analytics library. */
+export interface RemoteSensingModelingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingModelingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingModeling(data: number[], opts: RemoteSensingModelingOptions = {}): RemoteSensingModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingModeling };
diff --git a/src/remote_sensing/monitoring.ts b/src/remote_sensing/monitoring.ts
new file mode 100644
index 000000000..117bf48a4
--- /dev/null
+++ b/src/remote_sensing/monitoring.ts
@@ -0,0 +1,14 @@
+/** remote_sensing monitoring module — tsb analytics library. */
+export interface RemoteSensingMonitoringOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingMonitoringResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingMonitoring(data: number[], opts: RemoteSensingMonitoringOptions = {}): RemoteSensingMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingMonitoring };
diff --git a/src/remote_sensing/nonlinear.ts b/src/remote_sensing/nonlinear.ts
new file mode 100644
index 000000000..6cee7ddbf
--- /dev/null
+++ b/src/remote_sensing/nonlinear.ts
@@ -0,0 +1,14 @@
+/** remote_sensing nonlinear module — tsb analytics library. */
+export interface RemoteSensingNonlinearOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingNonlinearResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingNonlinear(data: number[], opts: RemoteSensingNonlinearOptions = {}): RemoteSensingNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingNonlinear };
diff --git a/src/remote_sensing/normalization.ts b/src/remote_sensing/normalization.ts
new file mode 100644
index 000000000..e72fc4ab2
--- /dev/null
+++ b/src/remote_sensing/normalization.ts
@@ -0,0 +1,14 @@
+/** remote_sensing normalization module — tsb analytics library. */
+export interface RemoteSensingNormalizationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingNormalizationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingNormalization(data: number[], opts: RemoteSensingNormalizationOptions = {}): RemoteSensingNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingNormalization };
diff --git a/src/remote_sensing/optimization.ts b/src/remote_sensing/optimization.ts
new file mode 100644
index 000000000..534ae8853
--- /dev/null
+++ b/src/remote_sensing/optimization.ts
@@ -0,0 +1,14 @@
+/** remote_sensing optimization module — tsb analytics library. */
+export interface RemoteSensingOptimizationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingOptimizationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingOptimization(data: number[], opts: RemoteSensingOptimizationOptions = {}): RemoteSensingOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingOptimization };
diff --git a/src/remote_sensing/patterns.ts b/src/remote_sensing/patterns.ts
new file mode 100644
index 000000000..76d75ba8d
--- /dev/null
+++ b/src/remote_sensing/patterns.ts
@@ -0,0 +1,14 @@
+/** remote_sensing patterns module — tsb analytics library. */
+export interface RemoteSensingPatternsOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingPatternsResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingPatterns(data: number[], opts: RemoteSensingPatternsOptions = {}): RemoteSensingPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingPatterns };
diff --git a/src/remote_sensing/permutation.ts b/src/remote_sensing/permutation.ts
new file mode 100644
index 000000000..90a966f79
--- /dev/null
+++ b/src/remote_sensing/permutation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing permutation module — tsb analytics library. */
+export interface RemoteSensingPermutationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingPermutationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingPermutation(data: number[], opts: RemoteSensingPermutationOptions = {}): RemoteSensingPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingPermutation };
diff --git a/src/remote_sensing/prediction.ts b/src/remote_sensing/prediction.ts
new file mode 100644
index 000000000..d23d0799a
--- /dev/null
+++ b/src/remote_sensing/prediction.ts
@@ -0,0 +1,14 @@
+/** remote_sensing prediction module — tsb analytics library. */
+export interface RemoteSensingPredictionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingPredictionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingPrediction(data: number[], opts: RemoteSensingPredictionOptions = {}): RemoteSensingPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingPrediction };
diff --git a/src/remote_sensing/processing.ts b/src/remote_sensing/processing.ts
new file mode 100644
index 000000000..51e219e87
--- /dev/null
+++ b/src/remote_sensing/processing.ts
@@ -0,0 +1,14 @@
+/** remote_sensing processing module — tsb analytics library. */
+export interface RemoteSensingProcessingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingProcessingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingProcessing(data: number[], opts: RemoteSensingProcessingOptions = {}): RemoteSensingProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingProcessing };
diff --git a/src/remote_sensing/profiling.ts b/src/remote_sensing/profiling.ts
new file mode 100644
index 000000000..e43f1f9d0
--- /dev/null
+++ b/src/remote_sensing/profiling.ts
@@ -0,0 +1,14 @@
+/** remote_sensing profiling module — tsb analytics library. */
+export interface RemoteSensingProfilingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingProfilingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingProfiling(data: number[], opts: RemoteSensingProfilingOptions = {}): RemoteSensingProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingProfiling };
diff --git a/src/remote_sensing/projection.ts b/src/remote_sensing/projection.ts
new file mode 100644
index 000000000..7f309fa07
--- /dev/null
+++ b/src/remote_sensing/projection.ts
@@ -0,0 +1,14 @@
+/** remote_sensing projection module — tsb analytics library. */
+export interface RemoteSensingProjectionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingProjectionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingProjection(data: number[], opts: RemoteSensingProjectionOptions = {}): RemoteSensingProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingProjection };
diff --git a/src/remote_sensing/ranking.ts b/src/remote_sensing/ranking.ts
new file mode 100644
index 000000000..a6f02963c
--- /dev/null
+++ b/src/remote_sensing/ranking.ts
@@ -0,0 +1,14 @@
+/** remote_sensing ranking module — tsb analytics library. */
+export interface RemoteSensingRankingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingRankingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingRanking(data: number[], opts: RemoteSensingRankingOptions = {}): RemoteSensingRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingRanking };
diff --git a/src/remote_sensing/reconstruction.ts b/src/remote_sensing/reconstruction.ts
new file mode 100644
index 000000000..49cc131c9
--- /dev/null
+++ b/src/remote_sensing/reconstruction.ts
@@ -0,0 +1,14 @@
+/** remote_sensing reconstruction module — tsb analytics library. */
+export interface RemoteSensingReconstructionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingReconstructionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingReconstruction(data: number[], opts: RemoteSensingReconstructionOptions = {}): RemoteSensingReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingReconstruction };
diff --git a/src/remote_sensing/registration.ts b/src/remote_sensing/registration.ts
new file mode 100644
index 000000000..03e27326f
--- /dev/null
+++ b/src/remote_sensing/registration.ts
@@ -0,0 +1,14 @@
+/** remote_sensing registration module — tsb analytics library. */
+export interface RemoteSensingRegistrationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingRegistrationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingRegistration(data: number[], opts: RemoteSensingRegistrationOptions = {}): RemoteSensingRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingRegistration };
diff --git a/src/remote_sensing/regression.ts b/src/remote_sensing/regression.ts
new file mode 100644
index 000000000..461eeab2a
--- /dev/null
+++ b/src/remote_sensing/regression.ts
@@ -0,0 +1,14 @@
+/** remote_sensing regression module — tsb analytics library. */
+export interface RemoteSensingRegressionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingRegressionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingRegression(data: number[], opts: RemoteSensingRegressionOptions = {}): RemoteSensingRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingRegression };
diff --git a/src/remote_sensing/regularization.ts b/src/remote_sensing/regularization.ts
new file mode 100644
index 000000000..8b8eb167b
--- /dev/null
+++ b/src/remote_sensing/regularization.ts
@@ -0,0 +1,14 @@
+/** remote_sensing regularization module — tsb analytics library. */
+export interface RemoteSensingRegularizationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingRegularizationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingRegularization(data: number[], opts: RemoteSensingRegularizationOptions = {}): RemoteSensingRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingRegularization };
diff --git a/src/remote_sensing/robustness.ts b/src/remote_sensing/robustness.ts
new file mode 100644
index 000000000..96a085485
--- /dev/null
+++ b/src/remote_sensing/robustness.ts
@@ -0,0 +1,14 @@
+/** remote_sensing robustness module — tsb analytics library. */
+export interface RemoteSensingRobustnessOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingRobustnessResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingRobustness(data: number[], opts: RemoteSensingRobustnessOptions = {}): RemoteSensingRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingRobustness };
diff --git a/src/remote_sensing/sampling.ts b/src/remote_sensing/sampling.ts
new file mode 100644
index 000000000..029c11224
--- /dev/null
+++ b/src/remote_sensing/sampling.ts
@@ -0,0 +1,14 @@
+/** remote_sensing sampling module — tsb analytics library. */
+export interface RemoteSensingSamplingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingSamplingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingSampling(data: number[], opts: RemoteSensingSamplingOptions = {}): RemoteSensingSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingSampling };
diff --git a/src/remote_sensing/sampling2.ts b/src/remote_sensing/sampling2.ts
new file mode 100644
index 000000000..9758348ca
--- /dev/null
+++ b/src/remote_sensing/sampling2.ts
@@ -0,0 +1,14 @@
+/** remote_sensing sampling2 module — tsb analytics library. */
+export interface RemoteSensingSamplingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingSamplingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingSampling(data: number[], opts: RemoteSensingSamplingOptions = {}): RemoteSensingSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingSampling };
diff --git a/src/remote_sensing/scaling.ts b/src/remote_sensing/scaling.ts
new file mode 100644
index 000000000..d770f85ea
--- /dev/null
+++ b/src/remote_sensing/scaling.ts
@@ -0,0 +1,14 @@
+/** remote_sensing scaling module — tsb analytics library. */
+export interface RemoteSensingScalingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingScalingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingScaling(data: number[], opts: RemoteSensingScalingOptions = {}): RemoteSensingScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingScaling };
diff --git a/src/remote_sensing/scoring.ts b/src/remote_sensing/scoring.ts
new file mode 100644
index 000000000..924c4df5b
--- /dev/null
+++ b/src/remote_sensing/scoring.ts
@@ -0,0 +1,14 @@
+/** remote_sensing scoring module — tsb analytics library. */
+export interface RemoteSensingScoringOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingScoringResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingScoring(data: number[], opts: RemoteSensingScoringOptions = {}): RemoteSensingScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingScoring };
diff --git a/src/remote_sensing/segmentation.ts b/src/remote_sensing/segmentation.ts
new file mode 100644
index 000000000..695b6d129
--- /dev/null
+++ b/src/remote_sensing/segmentation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing segmentation module — tsb analytics library. */
+export interface RemoteSensingSegmentationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingSegmentationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingSegmentation(data: number[], opts: RemoteSensingSegmentationOptions = {}): RemoteSensingSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingSegmentation };
diff --git a/src/remote_sensing/selection.ts b/src/remote_sensing/selection.ts
new file mode 100644
index 000000000..d0c7aabcd
--- /dev/null
+++ b/src/remote_sensing/selection.ts
@@ -0,0 +1,14 @@
+/** remote_sensing selection module — tsb analytics library. */
+export interface RemoteSensingSelectionOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingSelectionResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingSelection(data: number[], opts: RemoteSensingSelectionOptions = {}): RemoteSensingSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingSelection };
diff --git a/src/remote_sensing/sensitivity.ts b/src/remote_sensing/sensitivity.ts
new file mode 100644
index 000000000..6c9c99eff
--- /dev/null
+++ b/src/remote_sensing/sensitivity.ts
@@ -0,0 +1,14 @@
+/** remote_sensing sensitivity module — tsb analytics library. */
+export interface RemoteSensingSensitivityOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingSensitivityResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingSensitivity(data: number[], opts: RemoteSensingSensitivityOptions = {}): RemoteSensingSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingSensitivity };
diff --git a/src/remote_sensing/simulation.ts b/src/remote_sensing/simulation.ts
new file mode 100644
index 000000000..36b065c82
--- /dev/null
+++ b/src/remote_sensing/simulation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing simulation module — tsb analytics library. */
+export interface RemoteSensingSimulationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingSimulationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingSimulation(data: number[], opts: RemoteSensingSimulationOptions = {}): RemoteSensingSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingSimulation };
diff --git a/src/remote_sensing/smoothing.ts b/src/remote_sensing/smoothing.ts
new file mode 100644
index 000000000..439ad7918
--- /dev/null
+++ b/src/remote_sensing/smoothing.ts
@@ -0,0 +1,14 @@
+/** remote_sensing smoothing module — tsb analytics library. */
+export interface RemoteSensingSmoothingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingSmoothingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingSmoothing(data: number[], opts: RemoteSensingSmoothingOptions = {}): RemoteSensingSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingSmoothing };
diff --git a/src/remote_sensing/stability.ts b/src/remote_sensing/stability.ts
new file mode 100644
index 000000000..313c33002
--- /dev/null
+++ b/src/remote_sensing/stability.ts
@@ -0,0 +1,14 @@
+/** remote_sensing stability module — tsb analytics library. */
+export interface RemoteSensingStabilityOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingStabilityResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingStability(data: number[], opts: RemoteSensingStabilityOptions = {}): RemoteSensingStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingStability };
diff --git a/src/remote_sensing/stacking.ts b/src/remote_sensing/stacking.ts
new file mode 100644
index 000000000..c6d5475b4
--- /dev/null
+++ b/src/remote_sensing/stacking.ts
@@ -0,0 +1,14 @@
+/** remote_sensing stacking module — tsb analytics library. */
+export interface RemoteSensingStackingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingStackingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingStacking(data: number[], opts: RemoteSensingStackingOptions = {}): RemoteSensingStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingStacking };
diff --git a/src/remote_sensing/standardization.ts b/src/remote_sensing/standardization.ts
new file mode 100644
index 000000000..d1de1351f
--- /dev/null
+++ b/src/remote_sensing/standardization.ts
@@ -0,0 +1,14 @@
+/** remote_sensing standardization module — tsb analytics library. */
+export interface RemoteSensingStandardizationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingStandardizationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingStandardization(data: number[], opts: RemoteSensingStandardizationOptions = {}): RemoteSensingStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingStandardization };
diff --git a/src/remote_sensing/static.ts b/src/remote_sensing/static.ts
new file mode 100644
index 000000000..9b0e811e7
--- /dev/null
+++ b/src/remote_sensing/static.ts
@@ -0,0 +1,14 @@
+/** remote_sensing static module — tsb analytics library. */
+export interface RemoteSensingStaticOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingStaticResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingStatic(data: number[], opts: RemoteSensingStaticOptions = {}): RemoteSensingStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingStatic };
diff --git a/src/remote_sensing/stochastic.ts b/src/remote_sensing/stochastic.ts
new file mode 100644
index 000000000..3893e1e3b
--- /dev/null
+++ b/src/remote_sensing/stochastic.ts
@@ -0,0 +1,14 @@
+/** remote_sensing stochastic module — tsb analytics library. */
+export interface RemoteSensingStochasticOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingStochasticResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingStochastic(data: number[], opts: RemoteSensingStochasticOptions = {}): RemoteSensingStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingStochastic };
diff --git a/src/remote_sensing/synthesis.ts b/src/remote_sensing/synthesis.ts
new file mode 100644
index 000000000..36b1ce46e
--- /dev/null
+++ b/src/remote_sensing/synthesis.ts
@@ -0,0 +1,14 @@
+/** remote_sensing synthesis module — tsb analytics library. */
+export interface RemoteSensingSynthesisOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingSynthesisResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingSynthesis(data: number[], opts: RemoteSensingSynthesisOptions = {}): RemoteSensingSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingSynthesis };
diff --git a/src/remote_sensing/topology.ts b/src/remote_sensing/topology.ts
new file mode 100644
index 000000000..42a8b6cb7
--- /dev/null
+++ b/src/remote_sensing/topology.ts
@@ -0,0 +1,14 @@
+/** remote_sensing topology module — tsb analytics library. */
+export interface RemoteSensingTopologyOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingTopologyResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingTopology(data: number[], opts: RemoteSensingTopologyOptions = {}): RemoteSensingTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingTopology };
diff --git a/src/remote_sensing/tracking.ts b/src/remote_sensing/tracking.ts
new file mode 100644
index 000000000..58c31f878
--- /dev/null
+++ b/src/remote_sensing/tracking.ts
@@ -0,0 +1,14 @@
+/** remote_sensing tracking module — tsb analytics library. */
+export interface RemoteSensingTrackingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingTrackingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingTracking(data: number[], opts: RemoteSensingTrackingOptions = {}): RemoteSensingTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingTracking };
diff --git a/src/remote_sensing/transform.ts b/src/remote_sensing/transform.ts
new file mode 100644
index 000000000..d8e18a1a4
--- /dev/null
+++ b/src/remote_sensing/transform.ts
@@ -0,0 +1,14 @@
+/** remote_sensing transform module — tsb analytics library. */
+export interface RemoteSensingTransformOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingTransformResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingTransform(data: number[], opts: RemoteSensingTransformOptions = {}): RemoteSensingTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingTransform };
diff --git a/src/remote_sensing/uncertainty.ts b/src/remote_sensing/uncertainty.ts
new file mode 100644
index 000000000..1e3fdf478
--- /dev/null
+++ b/src/remote_sensing/uncertainty.ts
@@ -0,0 +1,14 @@
+/** remote_sensing uncertainty module — tsb analytics library. */
+export interface RemoteSensingUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingUncertaintyResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingUncertainty(data: number[], opts: RemoteSensingUncertaintyOptions = {}): RemoteSensingUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingUncertainty };
diff --git a/src/remote_sensing/validation.ts b/src/remote_sensing/validation.ts
new file mode 100644
index 000000000..a6276f744
--- /dev/null
+++ b/src/remote_sensing/validation.ts
@@ -0,0 +1,14 @@
+/** remote_sensing validation module — tsb analytics library. */
+export interface RemoteSensingValidationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingValidationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingValidation(data: number[], opts: RemoteSensingValidationOptions = {}): RemoteSensingValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingValidation };
diff --git a/src/remote_sensing/verification.ts b/src/remote_sensing/verification.ts
new file mode 100644
index 000000000..aeba82e1c
--- /dev/null
+++ b/src/remote_sensing/verification.ts
@@ -0,0 +1,14 @@
+/** remote_sensing verification module — tsb analytics library. */
+export interface RemoteSensingVerificationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingVerificationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingVerification(data: number[], opts: RemoteSensingVerificationOptions = {}): RemoteSensingVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingVerification };
diff --git a/src/remote_sensing/visualization.ts b/src/remote_sensing/visualization.ts
new file mode 100644
index 000000000..2839b5aff
--- /dev/null
+++ b/src/remote_sensing/visualization.ts
@@ -0,0 +1,14 @@
+/** remote_sensing visualization module — tsb analytics library. */
+export interface RemoteSensingVisualizationOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingVisualizationResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingVisualization(data: number[], opts: RemoteSensingVisualizationOptions = {}): RemoteSensingVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingVisualization };
diff --git a/src/remote_sensing/voting.ts b/src/remote_sensing/voting.ts
new file mode 100644
index 000000000..d7232617b
--- /dev/null
+++ b/src/remote_sensing/voting.ts
@@ -0,0 +1,14 @@
+/** remote_sensing voting module — tsb analytics library. */
+export interface RemoteSensingVotingOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingVotingResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingVoting(data: number[], opts: RemoteSensingVotingOptions = {}): RemoteSensingVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingVoting };
diff --git a/src/remote_sensing/wavelet.ts b/src/remote_sensing/wavelet.ts
new file mode 100644
index 000000000..afc923b77
--- /dev/null
+++ b/src/remote_sensing/wavelet.ts
@@ -0,0 +1,14 @@
+/** remote_sensing wavelet module — tsb analytics library. */
+export interface RemoteSensingWaveletOptions { tol?: number; maxIter?: number; }
+export interface RemoteSensingWaveletResult { values: number[]; converged: boolean; }
+export function computeRemoteSensingWavelet(data: number[], opts: RemoteSensingWaveletOptions = {}): RemoteSensingWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRemoteSensingWavelet };
diff --git a/src/rheology/adaptation.ts b/src/rheology/adaptation.ts
new file mode 100644
index 000000000..611e2a864
--- /dev/null
+++ b/src/rheology/adaptation.ts
@@ -0,0 +1,14 @@
+/** rheology adaptation module — tsb analytics library. */
+export interface RheologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface RheologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeRheologyAdaptation(data: number[], opts: RheologyAdaptationOptions = {}): RheologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyAdaptation };
diff --git a/src/rheology/aggregation.ts b/src/rheology/aggregation.ts
new file mode 100644
index 000000000..2db353581
--- /dev/null
+++ b/src/rheology/aggregation.ts
@@ -0,0 +1,14 @@
+/** rheology aggregation module — tsb analytics library. */
+export interface RheologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface RheologyAggregationResult { values: number[]; converged: boolean; }
+export function computeRheologyAggregation(data: number[], opts: RheologyAggregationOptions = {}): RheologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyAggregation };
diff --git a/src/rheology/algebra.ts b/src/rheology/algebra.ts
new file mode 100644
index 000000000..eaca9cb92
--- /dev/null
+++ b/src/rheology/algebra.ts
@@ -0,0 +1,14 @@
+/** rheology algebra module — tsb analytics library. */
+export interface RheologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface RheologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeRheologyAlgebra(data: number[], opts: RheologyAlgebraOptions = {}): RheologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyAlgebra };
diff --git a/src/rheology/alignment.ts b/src/rheology/alignment.ts
new file mode 100644
index 000000000..c25ebc5cd
--- /dev/null
+++ b/src/rheology/alignment.ts
@@ -0,0 +1,14 @@
+/** rheology alignment module — tsb analytics library. */
+export interface RheologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface RheologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeRheologyAlignment(data: number[], opts: RheologyAlignmentOptions = {}): RheologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyAlignment };
diff --git a/src/rheology/analysis.ts b/src/rheology/analysis.ts
new file mode 100644
index 000000000..a9af8ae37
--- /dev/null
+++ b/src/rheology/analysis.ts
@@ -0,0 +1,14 @@
+/** rheology analysis module — tsb analytics library. */
+export interface RheologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface RheologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeRheologyAnalysis(data: number[], opts: RheologyAnalysisOptions = {}): RheologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyAnalysis };
diff --git a/src/rheology/augmentation.ts b/src/rheology/augmentation.ts
new file mode 100644
index 000000000..e0369af81
--- /dev/null
+++ b/src/rheology/augmentation.ts
@@ -0,0 +1,14 @@
+/** rheology augmentation module — tsb analytics library. */
+export interface RheologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface RheologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeRheologyAugmentation(data: number[], opts: RheologyAugmentationOptions = {}): RheologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyAugmentation };
diff --git a/src/rheology/bagging.ts b/src/rheology/bagging.ts
new file mode 100644
index 000000000..37b1bcff9
--- /dev/null
+++ b/src/rheology/bagging.ts
@@ -0,0 +1,14 @@
+/** rheology bagging module — tsb analytics library. */
+export interface RheologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface RheologyBaggingResult { values: number[]; converged: boolean; }
+export function computeRheologyBagging(data: number[], opts: RheologyBaggingOptions = {}): RheologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyBagging };
diff --git a/src/rheology/basis.ts b/src/rheology/basis.ts
new file mode 100644
index 000000000..064dd7614
--- /dev/null
+++ b/src/rheology/basis.ts
@@ -0,0 +1,14 @@
+/** rheology basis module — tsb analytics library. */
+export interface RheologyBasisOptions { tol?: number; maxIter?: number; }
+export interface RheologyBasisResult { values: number[]; converged: boolean; }
+export function computeRheologyBasis(data: number[], opts: RheologyBasisOptions = {}): RheologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyBasis };
diff --git a/src/rheology/benchmarking.ts b/src/rheology/benchmarking.ts
new file mode 100644
index 000000000..7c2e76237
--- /dev/null
+++ b/src/rheology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** rheology benchmarking module — tsb analytics library. */
+export interface RheologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface RheologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeRheologyBenchmarking(data: number[], opts: RheologyBenchmarkingOptions = {}): RheologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyBenchmarking };
diff --git a/src/rheology/blending.ts b/src/rheology/blending.ts
new file mode 100644
index 000000000..1dcde2332
--- /dev/null
+++ b/src/rheology/blending.ts
@@ -0,0 +1,14 @@
+/** rheology blending module — tsb analytics library. */
+export interface RheologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface RheologyBlendingResult { values: number[]; converged: boolean; }
+export function computeRheologyBlending(data: number[], opts: RheologyBlendingOptions = {}): RheologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyBlending };
diff --git a/src/rheology/boosting.ts b/src/rheology/boosting.ts
new file mode 100644
index 000000000..428bae48a
--- /dev/null
+++ b/src/rheology/boosting.ts
@@ -0,0 +1,14 @@
+/** rheology boosting module — tsb analytics library. */
+export interface RheologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface RheologyBoostingResult { values: number[]; converged: boolean; }
+export function computeRheologyBoosting(data: number[], opts: RheologyBoostingOptions = {}): RheologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyBoosting };
diff --git a/src/rheology/bootstrap.ts b/src/rheology/bootstrap.ts
new file mode 100644
index 000000000..6036c2c6c
--- /dev/null
+++ b/src/rheology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** rheology bootstrap module — tsb analytics library. */
+export interface RheologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface RheologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeRheologyBootstrap(data: number[], opts: RheologyBootstrapOptions = {}): RheologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyBootstrap };
diff --git a/src/rheology/calculus.ts b/src/rheology/calculus.ts
new file mode 100644
index 000000000..a4442a20e
--- /dev/null
+++ b/src/rheology/calculus.ts
@@ -0,0 +1,14 @@
+/** rheology calculus module — tsb analytics library. */
+export interface RheologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface RheologyCalculusResult { values: number[]; converged: boolean; }
+export function computeRheologyCalculus(data: number[], opts: RheologyCalculusOptions = {}): RheologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyCalculus };
diff --git a/src/rheology/calibration.ts b/src/rheology/calibration.ts
new file mode 100644
index 000000000..53af6b72c
--- /dev/null
+++ b/src/rheology/calibration.ts
@@ -0,0 +1,14 @@
+/** rheology calibration module — tsb analytics library. */
+export interface RheologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface RheologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeRheologyCalibration(data: number[], opts: RheologyCalibrationOptions = {}): RheologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyCalibration };
diff --git a/src/rheology/characterization.ts b/src/rheology/characterization.ts
new file mode 100644
index 000000000..8dc665225
--- /dev/null
+++ b/src/rheology/characterization.ts
@@ -0,0 +1,14 @@
+/** rheology characterization module — tsb analytics library. */
+export interface RheologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface RheologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeRheologyCharacterization(data: number[], opts: RheologyCharacterizationOptions = {}): RheologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyCharacterization };
diff --git a/src/rheology/classification.ts b/src/rheology/classification.ts
new file mode 100644
index 000000000..616c7c71c
--- /dev/null
+++ b/src/rheology/classification.ts
@@ -0,0 +1,14 @@
+/** rheology classification module — tsb analytics library. */
+export interface RheologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface RheologyClassificationResult { values: number[]; converged: boolean; }
+export function computeRheologyClassification(data: number[], opts: RheologyClassificationOptions = {}): RheologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyClassification };
diff --git a/src/rheology/clustering.ts b/src/rheology/clustering.ts
new file mode 100644
index 000000000..e8006d591
--- /dev/null
+++ b/src/rheology/clustering.ts
@@ -0,0 +1,14 @@
+/** rheology clustering module — tsb analytics library. */
+export interface RheologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface RheologyClusteringResult { values: number[]; converged: boolean; }
+export function computeRheologyClustering(data: number[], opts: RheologyClusteringOptions = {}): RheologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyClustering };
diff --git a/src/rheology/compression.ts b/src/rheology/compression.ts
new file mode 100644
index 000000000..964a2e714
--- /dev/null
+++ b/src/rheology/compression.ts
@@ -0,0 +1,14 @@
+/** rheology compression module — tsb analytics library. */
+export interface RheologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface RheologyCompressionResult { values: number[]; converged: boolean; }
+export function computeRheologyCompression(data: number[], opts: RheologyCompressionOptions = {}): RheologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyCompression };
diff --git a/src/rheology/continuous.ts b/src/rheology/continuous.ts
new file mode 100644
index 000000000..c7969346b
--- /dev/null
+++ b/src/rheology/continuous.ts
@@ -0,0 +1,14 @@
+/** rheology continuous module — tsb analytics library. */
+export interface RheologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface RheologyContinuousResult { values: number[]; converged: boolean; }
+export function computeRheologyContinuous(data: number[], opts: RheologyContinuousOptions = {}): RheologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyContinuous };
diff --git a/src/rheology/control.ts b/src/rheology/control.ts
new file mode 100644
index 000000000..39860fc18
--- /dev/null
+++ b/src/rheology/control.ts
@@ -0,0 +1,14 @@
+/** rheology control module — tsb analytics library. */
+export interface RheologyControlOptions { tol?: number; maxIter?: number; }
+export interface RheologyControlResult { values: number[]; converged: boolean; }
+export function computeRheologyControl(data: number[], opts: RheologyControlOptions = {}): RheologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyControl };
diff --git a/src/rheology/convergence.ts b/src/rheology/convergence.ts
new file mode 100644
index 000000000..6c795edcc
--- /dev/null
+++ b/src/rheology/convergence.ts
@@ -0,0 +1,14 @@
+/** rheology convergence module — tsb analytics library. */
+export interface RheologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface RheologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeRheologyConvergence(data: number[], opts: RheologyConvergenceOptions = {}): RheologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyConvergence };
diff --git a/src/rheology/convex.ts b/src/rheology/convex.ts
new file mode 100644
index 000000000..0c3f6657f
--- /dev/null
+++ b/src/rheology/convex.ts
@@ -0,0 +1,14 @@
+/** rheology convex module — tsb analytics library. */
+export interface RheologyConvexOptions { tol?: number; maxIter?: number; }
+export interface RheologyConvexResult { values: number[]; converged: boolean; }
+export function computeRheologyConvex(data: number[], opts: RheologyConvexOptions = {}): RheologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyConvex };
diff --git a/src/rheology/correlation.ts b/src/rheology/correlation.ts
new file mode 100644
index 000000000..a31a175d1
--- /dev/null
+++ b/src/rheology/correlation.ts
@@ -0,0 +1,14 @@
+/** rheology correlation module — tsb analytics library. */
+export interface RheologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface RheologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeRheologyCorrelation(data: number[], opts: RheologyCorrelationOptions = {}): RheologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyCorrelation };
diff --git a/src/rheology/covariance.ts b/src/rheology/covariance.ts
new file mode 100644
index 000000000..200ba9888
--- /dev/null
+++ b/src/rheology/covariance.ts
@@ -0,0 +1,14 @@
+/** rheology covariance module — tsb analytics library. */
+export interface RheologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface RheologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeRheologyCovariance(data: number[], opts: RheologyCovarianceOptions = {}): RheologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyCovariance };
diff --git a/src/rheology/cross_validation.ts b/src/rheology/cross_validation.ts
new file mode 100644
index 000000000..328d8653d
--- /dev/null
+++ b/src/rheology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** rheology cross_validation module — tsb analytics library. */
+export interface RheologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface RheologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeRheologyCrossValidation(data: number[], opts: RheologyCrossValidationOptions = {}): RheologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyCrossValidation };
diff --git a/src/rheology/decoding.ts b/src/rheology/decoding.ts
new file mode 100644
index 000000000..73384d199
--- /dev/null
+++ b/src/rheology/decoding.ts
@@ -0,0 +1,14 @@
+/** rheology decoding module — tsb analytics library. */
+export interface RheologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface RheologyDecodingResult { values: number[]; converged: boolean; }
+export function computeRheologyDecoding(data: number[], opts: RheologyDecodingOptions = {}): RheologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDecoding };
diff --git a/src/rheology/decomposition.ts b/src/rheology/decomposition.ts
new file mode 100644
index 000000000..839e5c521
--- /dev/null
+++ b/src/rheology/decomposition.ts
@@ -0,0 +1,14 @@
+/** rheology decomposition module — tsb analytics library. */
+export interface RheologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface RheologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeRheologyDecomposition(data: number[], opts: RheologyDecompositionOptions = {}): RheologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDecomposition };
diff --git a/src/rheology/detection.ts b/src/rheology/detection.ts
new file mode 100644
index 000000000..ab3c6e5f8
--- /dev/null
+++ b/src/rheology/detection.ts
@@ -0,0 +1,14 @@
+/** rheology detection module — tsb analytics library. */
+export interface RheologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface RheologyDetectionResult { values: number[]; converged: boolean; }
+export function computeRheologyDetection(data: number[], opts: RheologyDetectionOptions = {}): RheologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDetection };
diff --git a/src/rheology/deterministic.ts b/src/rheology/deterministic.ts
new file mode 100644
index 000000000..91cdbd912
--- /dev/null
+++ b/src/rheology/deterministic.ts
@@ -0,0 +1,14 @@
+/** rheology deterministic module — tsb analytics library. */
+export interface RheologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface RheologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeRheologyDeterministic(data: number[], opts: RheologyDeterministicOptions = {}): RheologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDeterministic };
diff --git a/src/rheology/diagnostics.ts b/src/rheology/diagnostics.ts
new file mode 100644
index 000000000..127687762
--- /dev/null
+++ b/src/rheology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** rheology diagnostics module — tsb analytics library. */
+export interface RheologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface RheologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeRheologyDiagnostics(data: number[], opts: RheologyDiagnosticsOptions = {}): RheologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDiagnostics };
diff --git a/src/rheology/differential.ts b/src/rheology/differential.ts
new file mode 100644
index 000000000..3b4187aed
--- /dev/null
+++ b/src/rheology/differential.ts
@@ -0,0 +1,14 @@
+/** rheology differential module — tsb analytics library. */
+export interface RheologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface RheologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeRheologyDifferential(data: number[], opts: RheologyDifferentialOptions = {}): RheologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDifferential };
diff --git a/src/rheology/discrete.ts b/src/rheology/discrete.ts
new file mode 100644
index 000000000..ee682b202
--- /dev/null
+++ b/src/rheology/discrete.ts
@@ -0,0 +1,14 @@
+/** rheology discrete module — tsb analytics library. */
+export interface RheologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface RheologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeRheologyDiscrete(data: number[], opts: RheologyDiscreteOptions = {}): RheologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDiscrete };
diff --git a/src/rheology/distribution.ts b/src/rheology/distribution.ts
new file mode 100644
index 000000000..d68dcdf57
--- /dev/null
+++ b/src/rheology/distribution.ts
@@ -0,0 +1,14 @@
+/** rheology distribution module — tsb analytics library. */
+export interface RheologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface RheologyDistributionResult { values: number[]; converged: boolean; }
+export function computeRheologyDistribution(data: number[], opts: RheologyDistributionOptions = {}): RheologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDistribution };
diff --git a/src/rheology/dynamic.ts b/src/rheology/dynamic.ts
new file mode 100644
index 000000000..5adfbab38
--- /dev/null
+++ b/src/rheology/dynamic.ts
@@ -0,0 +1,14 @@
+/** rheology dynamic module — tsb analytics library. */
+export interface RheologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface RheologyDynamicResult { values: number[]; converged: boolean; }
+export function computeRheologyDynamic(data: number[], opts: RheologyDynamicOptions = {}): RheologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyDynamic };
diff --git a/src/rheology/embedding.ts b/src/rheology/embedding.ts
new file mode 100644
index 000000000..e071af80e
--- /dev/null
+++ b/src/rheology/embedding.ts
@@ -0,0 +1,14 @@
+/** rheology embedding module — tsb analytics library. */
+export interface RheologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface RheologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeRheologyEmbedding(data: number[], opts: RheologyEmbeddingOptions = {}): RheologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyEmbedding };
diff --git a/src/rheology/encoding.ts b/src/rheology/encoding.ts
new file mode 100644
index 000000000..f49851ee7
--- /dev/null
+++ b/src/rheology/encoding.ts
@@ -0,0 +1,14 @@
+/** rheology encoding module — tsb analytics library. */
+export interface RheologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface RheologyEncodingResult { values: number[]; converged: boolean; }
+export function computeRheologyEncoding(data: number[], opts: RheologyEncodingOptions = {}): RheologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyEncoding };
diff --git a/src/rheology/ensemble.ts b/src/rheology/ensemble.ts
new file mode 100644
index 000000000..bdd2d0dbf
--- /dev/null
+++ b/src/rheology/ensemble.ts
@@ -0,0 +1,14 @@
+/** rheology ensemble module — tsb analytics library. */
+export interface RheologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface RheologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeRheologyEnsemble(data: number[], opts: RheologyEnsembleOptions = {}): RheologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyEnsemble };
diff --git a/src/rheology/estimation.ts b/src/rheology/estimation.ts
new file mode 100644
index 000000000..e3b2554a4
--- /dev/null
+++ b/src/rheology/estimation.ts
@@ -0,0 +1,14 @@
+/** rheology estimation module — tsb analytics library. */
+export interface RheologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface RheologyEstimationResult { values: number[]; converged: boolean; }
+export function computeRheologyEstimation(data: number[], opts: RheologyEstimationOptions = {}): RheologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyEstimation };
diff --git a/src/rheology/evaluation.ts b/src/rheology/evaluation.ts
new file mode 100644
index 000000000..fa573e765
--- /dev/null
+++ b/src/rheology/evaluation.ts
@@ -0,0 +1,14 @@
+/** rheology evaluation module — tsb analytics library. */
+export interface RheologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface RheologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeRheologyEvaluation(data: number[], opts: RheologyEvaluationOptions = {}): RheologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyEvaluation };
diff --git a/src/rheology/extrapolation.ts b/src/rheology/extrapolation.ts
new file mode 100644
index 000000000..4a82b2b77
--- /dev/null
+++ b/src/rheology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** rheology extrapolation module — tsb analytics library. */
+export interface RheologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface RheologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeRheologyExtrapolation(data: number[], opts: RheologyExtrapolationOptions = {}): RheologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyExtrapolation };
diff --git a/src/rheology/features.ts b/src/rheology/features.ts
new file mode 100644
index 000000000..a55f46652
--- /dev/null
+++ b/src/rheology/features.ts
@@ -0,0 +1,14 @@
+/** rheology features module — tsb analytics library. */
+export interface RheologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface RheologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeRheologyFeatures(data: number[], opts: RheologyFeaturesOptions = {}): RheologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyFeatures };
diff --git a/src/rheology/feedback.ts b/src/rheology/feedback.ts
new file mode 100644
index 000000000..69f1e1f9d
--- /dev/null
+++ b/src/rheology/feedback.ts
@@ -0,0 +1,14 @@
+/** rheology feedback module — tsb analytics library. */
+export interface RheologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface RheologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeRheologyFeedback(data: number[], opts: RheologyFeedbackOptions = {}): RheologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyFeedback };
diff --git a/src/rheology/filtering.ts b/src/rheology/filtering.ts
new file mode 100644
index 000000000..cccb5269e
--- /dev/null
+++ b/src/rheology/filtering.ts
@@ -0,0 +1,14 @@
+/** rheology filtering module — tsb analytics library. */
+export interface RheologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface RheologyFilteringResult { values: number[]; converged: boolean; }
+export function computeRheologyFiltering(data: number[], opts: RheologyFilteringOptions = {}): RheologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyFiltering };
diff --git a/src/rheology/fourier.ts b/src/rheology/fourier.ts
new file mode 100644
index 000000000..53ea9f47f
--- /dev/null
+++ b/src/rheology/fourier.ts
@@ -0,0 +1,14 @@
+/** rheology fourier module — tsb analytics library. */
+export interface RheologyFourierOptions { tol?: number; maxIter?: number; }
+export interface RheologyFourierResult { values: number[]; converged: boolean; }
+export function computeRheologyFourier(data: number[], opts: RheologyFourierOptions = {}): RheologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyFourier };
diff --git a/src/rheology/fusion.ts b/src/rheology/fusion.ts
new file mode 100644
index 000000000..213cb250e
--- /dev/null
+++ b/src/rheology/fusion.ts
@@ -0,0 +1,14 @@
+/** rheology fusion module — tsb analytics library. */
+export interface RheologyFusionOptions { tol?: number; maxIter?: number; }
+export interface RheologyFusionResult { values: number[]; converged: boolean; }
+export function computeRheologyFusion(data: number[], opts: RheologyFusionOptions = {}): RheologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyFusion };
diff --git a/src/rheology/generation.ts b/src/rheology/generation.ts
new file mode 100644
index 000000000..c3383dc96
--- /dev/null
+++ b/src/rheology/generation.ts
@@ -0,0 +1,14 @@
+/** rheology generation module — tsb analytics library. */
+export interface RheologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface RheologyGenerationResult { values: number[]; converged: boolean; }
+export function computeRheologyGeneration(data: number[], opts: RheologyGenerationOptions = {}): RheologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyGeneration };
diff --git a/src/rheology/geometry.ts b/src/rheology/geometry.ts
new file mode 100644
index 000000000..1d8d04e51
--- /dev/null
+++ b/src/rheology/geometry.ts
@@ -0,0 +1,14 @@
+/** rheology geometry module — tsb analytics library. */
+export interface RheologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface RheologyGeometryResult { values: number[]; converged: boolean; }
+export function computeRheologyGeometry(data: number[], opts: RheologyGeometryOptions = {}): RheologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyGeometry };
diff --git a/src/rheology/gradient.ts b/src/rheology/gradient.ts
new file mode 100644
index 000000000..8184e0e5b
--- /dev/null
+++ b/src/rheology/gradient.ts
@@ -0,0 +1,14 @@
+/** rheology gradient module — tsb analytics library. */
+export interface RheologyGradientOptions { tol?: number; maxIter?: number; }
+export interface RheologyGradientResult { values: number[]; converged: boolean; }
+export function computeRheologyGradient(data: number[], opts: RheologyGradientOptions = {}): RheologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyGradient };
diff --git a/src/rheology/hessian.ts b/src/rheology/hessian.ts
new file mode 100644
index 000000000..07664b64e
--- /dev/null
+++ b/src/rheology/hessian.ts
@@ -0,0 +1,14 @@
+/** rheology hessian module — tsb analytics library. */
+export interface RheologyHessianOptions { tol?: number; maxIter?: number; }
+export interface RheologyHessianResult { values: number[]; converged: boolean; }
+export function computeRheologyHessian(data: number[], opts: RheologyHessianOptions = {}): RheologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyHessian };
diff --git a/src/rheology/hypothesis.ts b/src/rheology/hypothesis.ts
new file mode 100644
index 000000000..190591cb9
--- /dev/null
+++ b/src/rheology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** rheology hypothesis module — tsb analytics library. */
+export interface RheologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface RheologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeRheologyHypothesis(data: number[], opts: RheologyHypothesisOptions = {}): RheologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyHypothesis };
diff --git a/src/rheology/inference.ts b/src/rheology/inference.ts
new file mode 100644
index 000000000..ac63fb6cc
--- /dev/null
+++ b/src/rheology/inference.ts
@@ -0,0 +1,14 @@
+/** rheology inference module — tsb analytics library. */
+export interface RheologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface RheologyInferenceResult { values: number[]; converged: boolean; }
+export function computeRheologyInference(data: number[], opts: RheologyInferenceOptions = {}): RheologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyInference };
diff --git a/src/rheology/inference2.ts b/src/rheology/inference2.ts
new file mode 100644
index 000000000..da2318a7c
--- /dev/null
+++ b/src/rheology/inference2.ts
@@ -0,0 +1,14 @@
+/** rheology inference2 module — tsb analytics library. */
+export interface RheologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface RheologyInferenceResult { values: number[]; converged: boolean; }
+export function computeRheologyInference(data: number[], opts: RheologyInferenceOptions = {}): RheologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyInference };
diff --git a/src/rheology/integral.ts b/src/rheology/integral.ts
new file mode 100644
index 000000000..e93f1e658
--- /dev/null
+++ b/src/rheology/integral.ts
@@ -0,0 +1,14 @@
+/** rheology integral module — tsb analytics library. */
+export interface RheologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface RheologyIntegralResult { values: number[]; converged: boolean; }
+export function computeRheologyIntegral(data: number[], opts: RheologyIntegralOptions = {}): RheologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyIntegral };
diff --git a/src/rheology/integration.ts b/src/rheology/integration.ts
new file mode 100644
index 000000000..6a1480e0c
--- /dev/null
+++ b/src/rheology/integration.ts
@@ -0,0 +1,14 @@
+/** rheology integration module — tsb analytics library. */
+export interface RheologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface RheologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeRheologyIntegration(data: number[], opts: RheologyIntegrationOptions = {}): RheologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyIntegration };
diff --git a/src/rheology/interpolation.ts b/src/rheology/interpolation.ts
new file mode 100644
index 000000000..ff599f29d
--- /dev/null
+++ b/src/rheology/interpolation.ts
@@ -0,0 +1,14 @@
+/** rheology interpolation module — tsb analytics library. */
+export interface RheologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface RheologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeRheologyInterpolation(data: number[], opts: RheologyInterpolationOptions = {}): RheologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyInterpolation };
diff --git a/src/rheology/jacobian.ts b/src/rheology/jacobian.ts
new file mode 100644
index 000000000..d39c629b7
--- /dev/null
+++ b/src/rheology/jacobian.ts
@@ -0,0 +1,14 @@
+/** rheology jacobian module — tsb analytics library. */
+export interface RheologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface RheologyJacobianResult { values: number[]; converged: boolean; }
+export function computeRheologyJacobian(data: number[], opts: RheologyJacobianOptions = {}): RheologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyJacobian };
diff --git a/src/rheology/kernel.ts b/src/rheology/kernel.ts
new file mode 100644
index 000000000..81094c577
--- /dev/null
+++ b/src/rheology/kernel.ts
@@ -0,0 +1,14 @@
+/** rheology kernel module — tsb analytics library. */
+export interface RheologyKernelOptions { tol?: number; maxIter?: number; }
+export interface RheologyKernelResult { values: number[]; converged: boolean; }
+export function computeRheologyKernel(data: number[], opts: RheologyKernelOptions = {}): RheologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyKernel };
diff --git a/src/rheology/laplacian.ts b/src/rheology/laplacian.ts
new file mode 100644
index 000000000..3634d6fa5
--- /dev/null
+++ b/src/rheology/laplacian.ts
@@ -0,0 +1,14 @@
+/** rheology laplacian module — tsb analytics library. */
+export interface RheologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface RheologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeRheologyLaplacian(data: number[], opts: RheologyLaplacianOptions = {}): RheologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyLaplacian };
diff --git a/src/rheology/learning.ts b/src/rheology/learning.ts
new file mode 100644
index 000000000..7e1b3c0c6
--- /dev/null
+++ b/src/rheology/learning.ts
@@ -0,0 +1,14 @@
+/** rheology learning module — tsb analytics library. */
+export interface RheologyLearningOptions { tol?: number; maxIter?: number; }
+export interface RheologyLearningResult { values: number[]; converged: boolean; }
+export function computeRheologyLearning(data: number[], opts: RheologyLearningOptions = {}): RheologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyLearning };
diff --git a/src/rheology/linear.ts b/src/rheology/linear.ts
new file mode 100644
index 000000000..5af94cec8
--- /dev/null
+++ b/src/rheology/linear.ts
@@ -0,0 +1,14 @@
+/** rheology linear module — tsb analytics library. */
+export interface RheologyLinearOptions { tol?: number; maxIter?: number; }
+export interface RheologyLinearResult { values: number[]; converged: boolean; }
+export function computeRheologyLinear(data: number[], opts: RheologyLinearOptions = {}): RheologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyLinear };
diff --git a/src/rheology/manifold.ts b/src/rheology/manifold.ts
new file mode 100644
index 000000000..0e2f8a853
--- /dev/null
+++ b/src/rheology/manifold.ts
@@ -0,0 +1,14 @@
+/** rheology manifold module — tsb analytics library. */
+export interface RheologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface RheologyManifoldResult { values: number[]; converged: boolean; }
+export function computeRheologyManifold(data: number[], opts: RheologyManifoldOptions = {}): RheologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyManifold };
diff --git a/src/rheology/matching.ts b/src/rheology/matching.ts
new file mode 100644
index 000000000..cbf3d9be6
--- /dev/null
+++ b/src/rheology/matching.ts
@@ -0,0 +1,14 @@
+/** rheology matching module — tsb analytics library. */
+export interface RheologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface RheologyMatchingResult { values: number[]; converged: boolean; }
+export function computeRheologyMatching(data: number[], opts: RheologyMatchingOptions = {}): RheologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyMatching };
diff --git a/src/rheology/measurement.ts b/src/rheology/measurement.ts
new file mode 100644
index 000000000..dc6f9af9c
--- /dev/null
+++ b/src/rheology/measurement.ts
@@ -0,0 +1,14 @@
+/** rheology measurement module — tsb analytics library. */
+export interface RheologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface RheologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeRheologyMeasurement(data: number[], opts: RheologyMeasurementOptions = {}): RheologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyMeasurement };
diff --git a/src/rheology/metrics.ts b/src/rheology/metrics.ts
new file mode 100644
index 000000000..90a47694f
--- /dev/null
+++ b/src/rheology/metrics.ts
@@ -0,0 +1,14 @@
+/** rheology metrics module — tsb analytics library. */
+export interface RheologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface RheologyMetricsResult { values: number[]; converged: boolean; }
+export function computeRheologyMetrics(data: number[], opts: RheologyMetricsOptions = {}): RheologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyMetrics };
diff --git a/src/rheology/modeling.ts b/src/rheology/modeling.ts
new file mode 100644
index 000000000..631bf531a
--- /dev/null
+++ b/src/rheology/modeling.ts
@@ -0,0 +1,14 @@
+/** rheology modeling module — tsb analytics library. */
+export interface RheologyModelingOptions { tol?: number; maxIter?: number; }
+export interface RheologyModelingResult { values: number[]; converged: boolean; }
+export function computeRheologyModeling(data: number[], opts: RheologyModelingOptions = {}): RheologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyModeling };
diff --git a/src/rheology/monitoring.ts b/src/rheology/monitoring.ts
new file mode 100644
index 000000000..4b0149610
--- /dev/null
+++ b/src/rheology/monitoring.ts
@@ -0,0 +1,14 @@
+/** rheology monitoring module — tsb analytics library. */
+export interface RheologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface RheologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeRheologyMonitoring(data: number[], opts: RheologyMonitoringOptions = {}): RheologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyMonitoring };
diff --git a/src/rheology/nonlinear.ts b/src/rheology/nonlinear.ts
new file mode 100644
index 000000000..04680272f
--- /dev/null
+++ b/src/rheology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** rheology nonlinear module — tsb analytics library. */
+export interface RheologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface RheologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeRheologyNonlinear(data: number[], opts: RheologyNonlinearOptions = {}): RheologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyNonlinear };
diff --git a/src/rheology/normalization.ts b/src/rheology/normalization.ts
new file mode 100644
index 000000000..9b5ba8747
--- /dev/null
+++ b/src/rheology/normalization.ts
@@ -0,0 +1,14 @@
+/** rheology normalization module — tsb analytics library. */
+export interface RheologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface RheologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeRheologyNormalization(data: number[], opts: RheologyNormalizationOptions = {}): RheologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyNormalization };
diff --git a/src/rheology/optimization.ts b/src/rheology/optimization.ts
new file mode 100644
index 000000000..0b81de380
--- /dev/null
+++ b/src/rheology/optimization.ts
@@ -0,0 +1,14 @@
+/** rheology optimization module — tsb analytics library. */
+export interface RheologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface RheologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeRheologyOptimization(data: number[], opts: RheologyOptimizationOptions = {}): RheologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyOptimization };
diff --git a/src/rheology/patterns.ts b/src/rheology/patterns.ts
new file mode 100644
index 000000000..1d456ec0f
--- /dev/null
+++ b/src/rheology/patterns.ts
@@ -0,0 +1,14 @@
+/** rheology patterns module — tsb analytics library. */
+export interface RheologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface RheologyPatternsResult { values: number[]; converged: boolean; }
+export function computeRheologyPatterns(data: number[], opts: RheologyPatternsOptions = {}): RheologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyPatterns };
diff --git a/src/rheology/permutation.ts b/src/rheology/permutation.ts
new file mode 100644
index 000000000..3bc1dfe59
--- /dev/null
+++ b/src/rheology/permutation.ts
@@ -0,0 +1,14 @@
+/** rheology permutation module — tsb analytics library. */
+export interface RheologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface RheologyPermutationResult { values: number[]; converged: boolean; }
+export function computeRheologyPermutation(data: number[], opts: RheologyPermutationOptions = {}): RheologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyPermutation };
diff --git a/src/rheology/prediction.ts b/src/rheology/prediction.ts
new file mode 100644
index 000000000..07b40a124
--- /dev/null
+++ b/src/rheology/prediction.ts
@@ -0,0 +1,14 @@
+/** rheology prediction module — tsb analytics library. */
+export interface RheologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface RheologyPredictionResult { values: number[]; converged: boolean; }
+export function computeRheologyPrediction(data: number[], opts: RheologyPredictionOptions = {}): RheologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyPrediction };
diff --git a/src/rheology/processing.ts b/src/rheology/processing.ts
new file mode 100644
index 000000000..828535512
--- /dev/null
+++ b/src/rheology/processing.ts
@@ -0,0 +1,14 @@
+/** rheology processing module — tsb analytics library. */
+export interface RheologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface RheologyProcessingResult { values: number[]; converged: boolean; }
+export function computeRheologyProcessing(data: number[], opts: RheologyProcessingOptions = {}): RheologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyProcessing };
diff --git a/src/rheology/profiling.ts b/src/rheology/profiling.ts
new file mode 100644
index 000000000..c7b0b1e70
--- /dev/null
+++ b/src/rheology/profiling.ts
@@ -0,0 +1,14 @@
+/** rheology profiling module — tsb analytics library. */
+export interface RheologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface RheologyProfilingResult { values: number[]; converged: boolean; }
+export function computeRheologyProfiling(data: number[], opts: RheologyProfilingOptions = {}): RheologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyProfiling };
diff --git a/src/rheology/projection.ts b/src/rheology/projection.ts
new file mode 100644
index 000000000..25721fbec
--- /dev/null
+++ b/src/rheology/projection.ts
@@ -0,0 +1,14 @@
+/** rheology projection module — tsb analytics library. */
+export interface RheologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface RheologyProjectionResult { values: number[]; converged: boolean; }
+export function computeRheologyProjection(data: number[], opts: RheologyProjectionOptions = {}): RheologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyProjection };
diff --git a/src/rheology/ranking.ts b/src/rheology/ranking.ts
new file mode 100644
index 000000000..50b1f28dc
--- /dev/null
+++ b/src/rheology/ranking.ts
@@ -0,0 +1,14 @@
+/** rheology ranking module — tsb analytics library. */
+export interface RheologyRankingOptions { tol?: number; maxIter?: number; }
+export interface RheologyRankingResult { values: number[]; converged: boolean; }
+export function computeRheologyRanking(data: number[], opts: RheologyRankingOptions = {}): RheologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyRanking };
diff --git a/src/rheology/reconstruction.ts b/src/rheology/reconstruction.ts
new file mode 100644
index 000000000..6bc984ded
--- /dev/null
+++ b/src/rheology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** rheology reconstruction module — tsb analytics library. */
+export interface RheologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface RheologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeRheologyReconstruction(data: number[], opts: RheologyReconstructionOptions = {}): RheologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyReconstruction };
diff --git a/src/rheology/registration.ts b/src/rheology/registration.ts
new file mode 100644
index 000000000..77af3230a
--- /dev/null
+++ b/src/rheology/registration.ts
@@ -0,0 +1,14 @@
+/** rheology registration module — tsb analytics library. */
+export interface RheologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface RheologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeRheologyRegistration(data: number[], opts: RheologyRegistrationOptions = {}): RheologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyRegistration };
diff --git a/src/rheology/regression.ts b/src/rheology/regression.ts
new file mode 100644
index 000000000..d08dc3ea2
--- /dev/null
+++ b/src/rheology/regression.ts
@@ -0,0 +1,14 @@
+/** rheology regression module — tsb analytics library. */
+export interface RheologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface RheologyRegressionResult { values: number[]; converged: boolean; }
+export function computeRheologyRegression(data: number[], opts: RheologyRegressionOptions = {}): RheologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyRegression };
diff --git a/src/rheology/regularization.ts b/src/rheology/regularization.ts
new file mode 100644
index 000000000..0d0f9219c
--- /dev/null
+++ b/src/rheology/regularization.ts
@@ -0,0 +1,14 @@
+/** rheology regularization module — tsb analytics library. */
+export interface RheologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface RheologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeRheologyRegularization(data: number[], opts: RheologyRegularizationOptions = {}): RheologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyRegularization };
diff --git a/src/rheology/robustness.ts b/src/rheology/robustness.ts
new file mode 100644
index 000000000..d109e3179
--- /dev/null
+++ b/src/rheology/robustness.ts
@@ -0,0 +1,14 @@
+/** rheology robustness module — tsb analytics library. */
+export interface RheologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface RheologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeRheologyRobustness(data: number[], opts: RheologyRobustnessOptions = {}): RheologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyRobustness };
diff --git a/src/rheology/sampling.ts b/src/rheology/sampling.ts
new file mode 100644
index 000000000..b32e300fc
--- /dev/null
+++ b/src/rheology/sampling.ts
@@ -0,0 +1,14 @@
+/** rheology sampling module — tsb analytics library. */
+export interface RheologySamplingOptions { tol?: number; maxIter?: number; }
+export interface RheologySamplingResult { values: number[]; converged: boolean; }
+export function computeRheologySampling(data: number[], opts: RheologySamplingOptions = {}): RheologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologySampling };
diff --git a/src/rheology/sampling2.ts b/src/rheology/sampling2.ts
new file mode 100644
index 000000000..f38a4a0a5
--- /dev/null
+++ b/src/rheology/sampling2.ts
@@ -0,0 +1,14 @@
+/** rheology sampling2 module — tsb analytics library. */
+export interface RheologySamplingOptions { tol?: number; maxIter?: number; }
+export interface RheologySamplingResult { values: number[]; converged: boolean; }
+export function computeRheologySampling(data: number[], opts: RheologySamplingOptions = {}): RheologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologySampling };
diff --git a/src/rheology/scaling.ts b/src/rheology/scaling.ts
new file mode 100644
index 000000000..42983b6c4
--- /dev/null
+++ b/src/rheology/scaling.ts
@@ -0,0 +1,14 @@
+/** rheology scaling module — tsb analytics library. */
+export interface RheologyScalingOptions { tol?: number; maxIter?: number; }
+export interface RheologyScalingResult { values: number[]; converged: boolean; }
+export function computeRheologyScaling(data: number[], opts: RheologyScalingOptions = {}): RheologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyScaling };
diff --git a/src/rheology/scoring.ts b/src/rheology/scoring.ts
new file mode 100644
index 000000000..7ba1661d2
--- /dev/null
+++ b/src/rheology/scoring.ts
@@ -0,0 +1,14 @@
+/** rheology scoring module — tsb analytics library. */
+export interface RheologyScoringOptions { tol?: number; maxIter?: number; }
+export interface RheologyScoringResult { values: number[]; converged: boolean; }
+export function computeRheologyScoring(data: number[], opts: RheologyScoringOptions = {}): RheologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyScoring };
diff --git a/src/rheology/segmentation.ts b/src/rheology/segmentation.ts
new file mode 100644
index 000000000..26c8384a7
--- /dev/null
+++ b/src/rheology/segmentation.ts
@@ -0,0 +1,14 @@
+/** rheology segmentation module — tsb analytics library. */
+export interface RheologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface RheologySegmentationResult { values: number[]; converged: boolean; }
+export function computeRheologySegmentation(data: number[], opts: RheologySegmentationOptions = {}): RheologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologySegmentation };
diff --git a/src/rheology/selection.ts b/src/rheology/selection.ts
new file mode 100644
index 000000000..7ce2b65d7
--- /dev/null
+++ b/src/rheology/selection.ts
@@ -0,0 +1,14 @@
+/** rheology selection module — tsb analytics library. */
+export interface RheologySelectionOptions { tol?: number; maxIter?: number; }
+export interface RheologySelectionResult { values: number[]; converged: boolean; }
+export function computeRheologySelection(data: number[], opts: RheologySelectionOptions = {}): RheologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologySelection };
diff --git a/src/rheology/sensitivity.ts b/src/rheology/sensitivity.ts
new file mode 100644
index 000000000..de65f5b23
--- /dev/null
+++ b/src/rheology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** rheology sensitivity module — tsb analytics library. */
+export interface RheologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface RheologySensitivityResult { values: number[]; converged: boolean; }
+export function computeRheologySensitivity(data: number[], opts: RheologySensitivityOptions = {}): RheologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologySensitivity };
diff --git a/src/rheology/simulation.ts b/src/rheology/simulation.ts
new file mode 100644
index 000000000..44ceef8f1
--- /dev/null
+++ b/src/rheology/simulation.ts
@@ -0,0 +1,14 @@
+/** rheology simulation module — tsb analytics library. */
+export interface RheologySimulationOptions { tol?: number; maxIter?: number; }
+export interface RheologySimulationResult { values: number[]; converged: boolean; }
+export function computeRheologySimulation(data: number[], opts: RheologySimulationOptions = {}): RheologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologySimulation };
diff --git a/src/rheology/smoothing.ts b/src/rheology/smoothing.ts
new file mode 100644
index 000000000..ba0c2e8be
--- /dev/null
+++ b/src/rheology/smoothing.ts
@@ -0,0 +1,14 @@
+/** rheology smoothing module — tsb analytics library. */
+export interface RheologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface RheologySmoothingResult { values: number[]; converged: boolean; }
+export function computeRheologySmoothing(data: number[], opts: RheologySmoothingOptions = {}): RheologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologySmoothing };
diff --git a/src/rheology/stability.ts b/src/rheology/stability.ts
new file mode 100644
index 000000000..cd6152f85
--- /dev/null
+++ b/src/rheology/stability.ts
@@ -0,0 +1,14 @@
+/** rheology stability module — tsb analytics library. */
+export interface RheologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface RheologyStabilityResult { values: number[]; converged: boolean; }
+export function computeRheologyStability(data: number[], opts: RheologyStabilityOptions = {}): RheologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyStability };
diff --git a/src/rheology/stacking.ts b/src/rheology/stacking.ts
new file mode 100644
index 000000000..f75e0296c
--- /dev/null
+++ b/src/rheology/stacking.ts
@@ -0,0 +1,14 @@
+/** rheology stacking module — tsb analytics library. */
+export interface RheologyStackingOptions { tol?: number; maxIter?: number; }
+export interface RheologyStackingResult { values: number[]; converged: boolean; }
+export function computeRheologyStacking(data: number[], opts: RheologyStackingOptions = {}): RheologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyStacking };
diff --git a/src/rheology/standardization.ts b/src/rheology/standardization.ts
new file mode 100644
index 000000000..68f5e715b
--- /dev/null
+++ b/src/rheology/standardization.ts
@@ -0,0 +1,14 @@
+/** rheology standardization module — tsb analytics library. */
+export interface RheologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface RheologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeRheologyStandardization(data: number[], opts: RheologyStandardizationOptions = {}): RheologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyStandardization };
diff --git a/src/rheology/static.ts b/src/rheology/static.ts
new file mode 100644
index 000000000..a4003255b
--- /dev/null
+++ b/src/rheology/static.ts
@@ -0,0 +1,14 @@
+/** rheology static module — tsb analytics library. */
+export interface RheologyStaticOptions { tol?: number; maxIter?: number; }
+export interface RheologyStaticResult { values: number[]; converged: boolean; }
+export function computeRheologyStatic(data: number[], opts: RheologyStaticOptions = {}): RheologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyStatic };
diff --git a/src/rheology/stochastic.ts b/src/rheology/stochastic.ts
new file mode 100644
index 000000000..b3c7ac349
--- /dev/null
+++ b/src/rheology/stochastic.ts
@@ -0,0 +1,14 @@
+/** rheology stochastic module — tsb analytics library. */
+export interface RheologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface RheologyStochasticResult { values: number[]; converged: boolean; }
+export function computeRheologyStochastic(data: number[], opts: RheologyStochasticOptions = {}): RheologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyStochastic };
diff --git a/src/rheology/synthesis.ts b/src/rheology/synthesis.ts
new file mode 100644
index 000000000..51aac18cd
--- /dev/null
+++ b/src/rheology/synthesis.ts
@@ -0,0 +1,14 @@
+/** rheology synthesis module — tsb analytics library. */
+export interface RheologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface RheologySynthesisResult { values: number[]; converged: boolean; }
+export function computeRheologySynthesis(data: number[], opts: RheologySynthesisOptions = {}): RheologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologySynthesis };
diff --git a/src/rheology/topology.ts b/src/rheology/topology.ts
new file mode 100644
index 000000000..aa09538a2
--- /dev/null
+++ b/src/rheology/topology.ts
@@ -0,0 +1,14 @@
+/** rheology topology module — tsb analytics library. */
+export interface RheologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface RheologyTopologyResult { values: number[]; converged: boolean; }
+export function computeRheologyTopology(data: number[], opts: RheologyTopologyOptions = {}): RheologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyTopology };
diff --git a/src/rheology/tracking.ts b/src/rheology/tracking.ts
new file mode 100644
index 000000000..dc734b5aa
--- /dev/null
+++ b/src/rheology/tracking.ts
@@ -0,0 +1,14 @@
+/** rheology tracking module — tsb analytics library. */
+export interface RheologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface RheologyTrackingResult { values: number[]; converged: boolean; }
+export function computeRheologyTracking(data: number[], opts: RheologyTrackingOptions = {}): RheologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyTracking };
diff --git a/src/rheology/transform.ts b/src/rheology/transform.ts
new file mode 100644
index 000000000..88918523a
--- /dev/null
+++ b/src/rheology/transform.ts
@@ -0,0 +1,14 @@
+/** rheology transform module — tsb analytics library. */
+export interface RheologyTransformOptions { tol?: number; maxIter?: number; }
+export interface RheologyTransformResult { values: number[]; converged: boolean; }
+export function computeRheologyTransform(data: number[], opts: RheologyTransformOptions = {}): RheologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyTransform };
diff --git a/src/rheology/uncertainty.ts b/src/rheology/uncertainty.ts
new file mode 100644
index 000000000..e53913d7e
--- /dev/null
+++ b/src/rheology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** rheology uncertainty module — tsb analytics library. */
+export interface RheologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface RheologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeRheologyUncertainty(data: number[], opts: RheologyUncertaintyOptions = {}): RheologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyUncertainty };
diff --git a/src/rheology/validation.ts b/src/rheology/validation.ts
new file mode 100644
index 000000000..a984cc19b
--- /dev/null
+++ b/src/rheology/validation.ts
@@ -0,0 +1,14 @@
+/** rheology validation module — tsb analytics library. */
+export interface RheologyValidationOptions { tol?: number; maxIter?: number; }
+export interface RheologyValidationResult { values: number[]; converged: boolean; }
+export function computeRheologyValidation(data: number[], opts: RheologyValidationOptions = {}): RheologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyValidation };
diff --git a/src/rheology/verification.ts b/src/rheology/verification.ts
new file mode 100644
index 000000000..93240b071
--- /dev/null
+++ b/src/rheology/verification.ts
@@ -0,0 +1,14 @@
+/** rheology verification module — tsb analytics library. */
+export interface RheologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface RheologyVerificationResult { values: number[]; converged: boolean; }
+export function computeRheologyVerification(data: number[], opts: RheologyVerificationOptions = {}): RheologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyVerification };
diff --git a/src/rheology/visualization.ts b/src/rheology/visualization.ts
new file mode 100644
index 000000000..7a37d7fdd
--- /dev/null
+++ b/src/rheology/visualization.ts
@@ -0,0 +1,14 @@
+/** rheology visualization module — tsb analytics library. */
+export interface RheologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface RheologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeRheologyVisualization(data: number[], opts: RheologyVisualizationOptions = {}): RheologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyVisualization };
diff --git a/src/rheology/voting.ts b/src/rheology/voting.ts
new file mode 100644
index 000000000..328ecb124
--- /dev/null
+++ b/src/rheology/voting.ts
@@ -0,0 +1,14 @@
+/** rheology voting module — tsb analytics library. */
+export interface RheologyVotingOptions { tol?: number; maxIter?: number; }
+export interface RheologyVotingResult { values: number[]; converged: boolean; }
+export function computeRheologyVoting(data: number[], opts: RheologyVotingOptions = {}): RheologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyVoting };
diff --git a/src/rheology/wavelet.ts b/src/rheology/wavelet.ts
new file mode 100644
index 000000000..ae6453d46
--- /dev/null
+++ b/src/rheology/wavelet.ts
@@ -0,0 +1,14 @@
+/** rheology wavelet module — tsb analytics library. */
+export interface RheologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface RheologyWaveletResult { values: number[]; converged: boolean; }
+export function computeRheologyWavelet(data: number[], opts: RheologyWaveletOptions = {}): RheologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRheologyWavelet };
diff --git a/src/risk2/advanced.ts b/src/risk2/advanced.ts
new file mode 100644
index 000000000..b103b155c
--- /dev/null
+++ b/src/risk2/advanced.ts
@@ -0,0 +1,15 @@
+/** Risk2 Advanced module — tsb analytics library. */
+export interface Risk2 advancedOptions { tol?: number; maxIter?: number; }
+export interface Risk2 advancedResult { values: number[]; converged: boolean; }
+export function computeRisk2 advanced(data: number[], opts: Risk2 advancedOptions = {}): Risk2 advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 advanced };
diff --git a/src/risk2/base2.ts b/src/risk2/base2.ts
new file mode 100644
index 000000000..7113631d1
--- /dev/null
+++ b/src/risk2/base2.ts
@@ -0,0 +1,15 @@
+/** Risk2 Base2 module — tsb analytics library. */
+export interface Risk2 base2Options { tol?: number; maxIter?: number; }
+export interface Risk2 base2Result { values: number[]; converged: boolean; }
+export function computeRisk2 base2(data: number[], opts: Risk2 base2Options = {}): Risk2 base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 base2 };
diff --git a/src/risk2/batch.ts b/src/risk2/batch.ts
new file mode 100644
index 000000000..935ef07a6
--- /dev/null
+++ b/src/risk2/batch.ts
@@ -0,0 +1,15 @@
+/** Risk2 Batch module — tsb analytics library. */
+export interface Risk2 batchOptions { tol?: number; maxIter?: number; }
+export interface Risk2 batchResult { values: number[]; converged: boolean; }
+export function computeRisk2 batch(data: number[], opts: Risk2 batchOptions = {}): Risk2 batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 batch };
diff --git a/src/risk2/beta.ts b/src/risk2/beta.ts
new file mode 100644
index 000000000..18e58fabc
--- /dev/null
+++ b/src/risk2/beta.ts
@@ -0,0 +1,15 @@
+/** Risk2 Beta module — tsb analytics library. */
+export interface Risk2 betaOptions { tol?: number; maxIter?: number; }
+export interface Risk2 betaResult { values: number[]; converged: boolean; }
+export function computeRisk2 beta(data: number[], opts: Risk2 betaOptions = {}): Risk2 betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 beta };
diff --git a/src/risk2/component.ts b/src/risk2/component.ts
new file mode 100644
index 000000000..228b339bf
--- /dev/null
+++ b/src/risk2/component.ts
@@ -0,0 +1,22 @@
+/** Component module — tsb analytics library. */
+
+/** Options for Component. */
+export interface ComponentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Component. */
+export interface ComponentResult { values: number[]; converged: boolean; }
+
+/** Compute Component. */
+export function computeComponent(data: number[], opts: ComponentOptions = {}): ComponentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeComponent };
diff --git a/src/risk2/concentration.ts b/src/risk2/concentration.ts
new file mode 100644
index 000000000..08a00549c
--- /dev/null
+++ b/src/risk2/concentration.ts
@@ -0,0 +1,22 @@
+/** Concentration module — tsb analytics library. */
+
+/** Options for Concentration. */
+export interface ConcentrationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Concentration. */
+export interface ConcentrationResult { values: number[]; converged: boolean; }
+
+/** Compute Concentration. */
+export function computeConcentration(data: number[], opts: ConcentrationOptions = {}): ConcentrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConcentration };
diff --git a/src/risk2/convexity.ts b/src/risk2/convexity.ts
new file mode 100644
index 000000000..ff7c0b042
--- /dev/null
+++ b/src/risk2/convexity.ts
@@ -0,0 +1,22 @@
+/** Convexity module — tsb analytics library. */
+
+/** Options for Convexity. */
+export interface ConvexityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Convexity. */
+export interface ConvexityResult { values: number[]; converged: boolean; }
+
+/** Compute Convexity. */
+export function computeConvexity(data: number[], opts: ConvexityOptions = {}): ConvexityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConvexity };
diff --git a/src/risk2/copula_risk.ts b/src/risk2/copula_risk.ts
new file mode 100644
index 000000000..80f35625a
--- /dev/null
+++ b/src/risk2/copula_risk.ts
@@ -0,0 +1,22 @@
+/** Copula Risk module — tsb analytics library. */
+
+/** Options for Copula Risk. */
+export interface CopulaRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Copula Risk. */
+export interface CopulaRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Copula Risk. */
+export function computeCopulaRisk(data: number[], opts: CopulaRiskOptions = {}): CopulaRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCopulaRisk };
diff --git a/src/risk2/correlation.ts b/src/risk2/correlation.ts
new file mode 100644
index 000000000..2d82cc65d
--- /dev/null
+++ b/src/risk2/correlation.ts
@@ -0,0 +1,22 @@
+/** Correlation module — tsb analytics library. */
+
+/** Options for Correlation. */
+export interface CorrelationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Correlation. */
+export interface CorrelationResult { values: number[]; converged: boolean; }
+
+/** Compute Correlation. */
+export function computeCorrelation(data: number[], opts: CorrelationOptions = {}): CorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCorrelation };
diff --git a/src/risk2/cpu.ts b/src/risk2/cpu.ts
new file mode 100644
index 000000000..a74d8dd13
--- /dev/null
+++ b/src/risk2/cpu.ts
@@ -0,0 +1,15 @@
+/** Risk2 Cpu module — tsb analytics library. */
+export interface Risk2 cpuOptions { tol?: number; maxIter?: number; }
+export interface Risk2 cpuResult { values: number[]; converged: boolean; }
+export function computeRisk2 cpu(data: number[], opts: Risk2 cpuOptions = {}): Risk2 cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 cpu };
diff --git a/src/risk2/credit_risk.ts b/src/risk2/credit_risk.ts
new file mode 100644
index 000000000..f2211fd57
--- /dev/null
+++ b/src/risk2/credit_risk.ts
@@ -0,0 +1,22 @@
+/** Credit Risk module — tsb analytics library. */
+
+/** Options for Credit Risk. */
+export interface CreditRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Credit Risk. */
+export interface CreditRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Credit Risk. */
+export function computeCreditRisk(data: number[], opts: CreditRiskOptions = {}): CreditRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCreditRisk };
diff --git a/src/risk2/delta.ts b/src/risk2/delta.ts
new file mode 100644
index 000000000..8d39fa203
--- /dev/null
+++ b/src/risk2/delta.ts
@@ -0,0 +1,22 @@
+/** Delta module — tsb analytics library. */
+
+/** Options for Delta. */
+export interface DeltaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Delta. */
+export interface DeltaResult { values: number[]; converged: boolean; }
+
+/** Compute Delta. */
+export function computeDelta(data: number[], opts: DeltaOptions = {}): DeltaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDelta };
diff --git a/src/risk2/dense.ts b/src/risk2/dense.ts
new file mode 100644
index 000000000..0978fab8d
--- /dev/null
+++ b/src/risk2/dense.ts
@@ -0,0 +1,15 @@
+/** Risk2 Dense module — tsb analytics library. */
+export interface Risk2 denseOptions { tol?: number; maxIter?: number; }
+export interface Risk2 denseResult { values: number[]; converged: boolean; }
+export function computeRisk2 dense(data: number[], opts: Risk2 denseOptions = {}): Risk2 denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 dense };
diff --git a/src/risk2/distributed.ts b/src/risk2/distributed.ts
new file mode 100644
index 000000000..389dc278d
--- /dev/null
+++ b/src/risk2/distributed.ts
@@ -0,0 +1,15 @@
+/** Risk2 Distributed module — tsb analytics library. */
+export interface Risk2 distributedOptions { tol?: number; maxIter?: number; }
+export interface Risk2 distributedResult { values: number[]; converged: boolean; }
+export function computeRisk2 distributed(data: number[], opts: Risk2 distributedOptions = {}): Risk2 distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 distributed };
diff --git a/src/risk2/diversification.ts b/src/risk2/diversification.ts
new file mode 100644
index 000000000..1806c7b01
--- /dev/null
+++ b/src/risk2/diversification.ts
@@ -0,0 +1,22 @@
+/** Diversification module — tsb analytics library. */
+
+/** Options for Diversification. */
+export interface DiversificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Diversification. */
+export interface DiversificationResult { values: number[]; converged: boolean; }
+
+/** Compute Diversification. */
+export function computeDiversification(data: number[], opts: DiversificationOptions = {}): DiversificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDiversification };
diff --git a/src/risk2/duration.ts b/src/risk2/duration.ts
new file mode 100644
index 000000000..e3e382954
--- /dev/null
+++ b/src/risk2/duration.ts
@@ -0,0 +1,22 @@
+/** Duration module — tsb analytics library. */
+
+/** Options for Duration. */
+export interface DurationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Duration. */
+export interface DurationResult { values: number[]; converged: boolean; }
+
+/** Compute Duration. */
+export function computeDuration(data: number[], opts: DurationOptions = {}): DurationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDuration };
diff --git a/src/risk2/experimental.ts b/src/risk2/experimental.ts
new file mode 100644
index 000000000..bf8ee5f12
--- /dev/null
+++ b/src/risk2/experimental.ts
@@ -0,0 +1,15 @@
+/** Risk2 Experimental module — tsb analytics library. */
+export interface Risk2 experimentalOptions { tol?: number; maxIter?: number; }
+export interface Risk2 experimentalResult { values: number[]; converged: boolean; }
+export function computeRisk2 experimental(data: number[], opts: Risk2 experimentalOptions = {}): Risk2 experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 experimental };
diff --git a/src/risk2/extreme_value.ts b/src/risk2/extreme_value.ts
new file mode 100644
index 000000000..1548f4e93
--- /dev/null
+++ b/src/risk2/extreme_value.ts
@@ -0,0 +1,22 @@
+/** Extreme Value module — tsb analytics library. */
+
+/** Options for Extreme Value. */
+export interface ExtremeValueOptions { tol?: number; maxIter?: number; }
+
+/** Result from Extreme Value. */
+export interface ExtremeValueResult { values: number[]; converged: boolean; }
+
+/** Compute Extreme Value. */
+export function computeExtremeValue(data: number[], opts: ExtremeValueOptions = {}): ExtremeValueResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExtremeValue };
diff --git a/src/risk2/factor_risk.ts b/src/risk2/factor_risk.ts
new file mode 100644
index 000000000..8dcbde1d5
--- /dev/null
+++ b/src/risk2/factor_risk.ts
@@ -0,0 +1,22 @@
+/** Factor Risk module — tsb analytics library. */
+
+/** Options for Factor Risk. */
+export interface FactorRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Factor Risk. */
+export interface FactorRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Factor Risk. */
+export function computeFactorRisk(data: number[], opts: FactorRiskOptions = {}): FactorRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFactorRisk };
diff --git a/src/risk2/fast.ts b/src/risk2/fast.ts
new file mode 100644
index 000000000..64e557770
--- /dev/null
+++ b/src/risk2/fast.ts
@@ -0,0 +1,15 @@
+/** Risk2 Fast module — tsb analytics library. */
+export interface Risk2 fastOptions { tol?: number; maxIter?: number; }
+export interface Risk2 fastResult { values: number[]; converged: boolean; }
+export function computeRisk2 fast(data: number[], opts: Risk2 fastOptions = {}): Risk2 fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 fast };
diff --git a/src/risk2/future.ts b/src/risk2/future.ts
new file mode 100644
index 000000000..6f48be974
--- /dev/null
+++ b/src/risk2/future.ts
@@ -0,0 +1,15 @@
+/** Risk2 Future module — tsb analytics library. */
+export interface Risk2 futureOptions { tol?: number; maxIter?: number; }
+export interface Risk2 futureResult { values: number[]; converged: boolean; }
+export function computeRisk2 future(data: number[], opts: Risk2 futureOptions = {}): Risk2 futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 future };
diff --git a/src/risk2/gamma.ts b/src/risk2/gamma.ts
new file mode 100644
index 000000000..cfbcb3067
--- /dev/null
+++ b/src/risk2/gamma.ts
@@ -0,0 +1,22 @@
+/** Gamma module — tsb analytics library. */
+
+/** Options for Gamma. */
+export interface GammaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gamma. */
+export interface GammaResult { values: number[]; converged: boolean; }
+
+/** Compute Gamma. */
+export function computeGamma(data: number[], opts: GammaOptions = {}): GammaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGamma };
diff --git a/src/risk2/gpu.ts b/src/risk2/gpu.ts
new file mode 100644
index 000000000..17000906b
--- /dev/null
+++ b/src/risk2/gpu.ts
@@ -0,0 +1,15 @@
+/** Risk2 Gpu module — tsb analytics library. */
+export interface Risk2 gpuOptions { tol?: number; maxIter?: number; }
+export interface Risk2 gpuResult { values: number[]; converged: boolean; }
+export function computeRisk2 gpu(data: number[], opts: Risk2 gpuOptions = {}): Risk2 gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 gpu };
diff --git a/src/risk2/greeks.ts b/src/risk2/greeks.ts
new file mode 100644
index 000000000..a02d08cd5
--- /dev/null
+++ b/src/risk2/greeks.ts
@@ -0,0 +1,22 @@
+/** Greeks module — tsb analytics library. */
+
+/** Options for Greeks. */
+export interface GreeksOptions { tol?: number; maxIter?: number; }
+
+/** Result from Greeks. */
+export interface GreeksResult { values: number[]; converged: boolean; }
+
+/** Compute Greeks. */
+export function computeGreeks(data: number[], opts: GreeksOptions = {}): GreeksResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGreeks };
diff --git a/src/risk2/hedging_risk.ts b/src/risk2/hedging_risk.ts
new file mode 100644
index 000000000..d1ffd995c
--- /dev/null
+++ b/src/risk2/hedging_risk.ts
@@ -0,0 +1,22 @@
+/** Hedging Risk module — tsb analytics library. */
+
+/** Options for Hedging Risk. */
+export interface HedgingRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Hedging Risk. */
+export interface HedgingRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Hedging Risk. */
+export function computeHedgingRisk(data: number[], opts: HedgingRiskOptions = {}): HedgingRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHedgingRisk };
diff --git a/src/risk2/incremental.ts b/src/risk2/incremental.ts
new file mode 100644
index 000000000..3967fcc18
--- /dev/null
+++ b/src/risk2/incremental.ts
@@ -0,0 +1,22 @@
+/** Incremental module — tsb analytics library. */
+
+/** Options for Incremental. */
+export interface IncrementalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Incremental. */
+export interface IncrementalResult { values: number[]; converged: boolean; }
+
+/** Compute Incremental. */
+export function computeIncremental(data: number[], opts: IncrementalOptions = {}): IncrementalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIncremental };
diff --git a/src/risk2/key_rate.ts b/src/risk2/key_rate.ts
new file mode 100644
index 000000000..264f2b3a4
--- /dev/null
+++ b/src/risk2/key_rate.ts
@@ -0,0 +1,22 @@
+/** Key Rate module — tsb analytics library. */
+
+/** Options for Key Rate. */
+export interface KeyRateOptions { tol?: number; maxIter?: number; }
+
+/** Result from Key Rate. */
+export interface KeyRateResult { values: number[]; converged: boolean; }
+
+/** Compute Key Rate. */
+export function computeKeyRate(data: number[], opts: KeyRateOptions = {}): KeyRateResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKeyRate };
diff --git a/src/risk2/large.ts b/src/risk2/large.ts
new file mode 100644
index 000000000..1845be50b
--- /dev/null
+++ b/src/risk2/large.ts
@@ -0,0 +1,15 @@
+/** Risk2 Large module — tsb analytics library. */
+export interface Risk2 largeOptions { tol?: number; maxIter?: number; }
+export interface Risk2 largeResult { values: number[]; converged: boolean; }
+export function computeRisk2 large(data: number[], opts: Risk2 largeOptions = {}): Risk2 largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 large };
diff --git a/src/risk2/legacy.ts b/src/risk2/legacy.ts
new file mode 100644
index 000000000..5bdebb6fa
--- /dev/null
+++ b/src/risk2/legacy.ts
@@ -0,0 +1,15 @@
+/** Risk2 Legacy module — tsb analytics library. */
+export interface Risk2 legacyOptions { tol?: number; maxIter?: number; }
+export interface Risk2 legacyResult { values: number[]; converged: boolean; }
+export function computeRisk2 legacy(data: number[], opts: Risk2 legacyOptions = {}): Risk2 legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 legacy };
diff --git a/src/risk2/liquidity_risk.ts b/src/risk2/liquidity_risk.ts
new file mode 100644
index 000000000..5ae3904c9
--- /dev/null
+++ b/src/risk2/liquidity_risk.ts
@@ -0,0 +1,22 @@
+/** Liquidity Risk module — tsb analytics library. */
+
+/** Options for Liquidity Risk. */
+export interface LiquidityRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Liquidity Risk. */
+export interface LiquidityRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Liquidity Risk. */
+export function computeLiquidityRisk(data: number[], opts: LiquidityRiskOptions = {}): LiquidityRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLiquidityRisk };
diff --git a/src/risk2/lite.ts b/src/risk2/lite.ts
new file mode 100644
index 000000000..41bd89595
--- /dev/null
+++ b/src/risk2/lite.ts
@@ -0,0 +1,15 @@
+/** Risk2 Lite module — tsb analytics library. */
+export interface Risk2 liteOptions { tol?: number; maxIter?: number; }
+export interface Risk2 liteResult { values: number[]; converged: boolean; }
+export function computeRisk2 lite(data: number[], opts: Risk2 liteOptions = {}): Risk2 liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 lite };
diff --git a/src/risk2/marginal.ts b/src/risk2/marginal.ts
new file mode 100644
index 000000000..60dee8920
--- /dev/null
+++ b/src/risk2/marginal.ts
@@ -0,0 +1,22 @@
+/** Marginal module — tsb analytics library. */
+
+/** Options for Marginal. */
+export interface MarginalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Marginal. */
+export interface MarginalResult { values: number[]; converged: boolean; }
+
+/** Compute Marginal. */
+export function computeMarginal(data: number[], opts: MarginalOptions = {}): MarginalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMarginal };
diff --git a/src/risk2/market_risk.ts b/src/risk2/market_risk.ts
new file mode 100644
index 000000000..5666c1154
--- /dev/null
+++ b/src/risk2/market_risk.ts
@@ -0,0 +1,22 @@
+/** Market Risk module — tsb analytics library. */
+
+/** Options for Market Risk. */
+export interface MarketRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Market Risk. */
+export interface MarketRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Market Risk. */
+export function computeMarketRisk(data: number[], opts: MarketRiskOptions = {}): MarketRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMarketRisk };
diff --git a/src/risk2/mini.ts b/src/risk2/mini.ts
new file mode 100644
index 000000000..b0913a5d8
--- /dev/null
+++ b/src/risk2/mini.ts
@@ -0,0 +1,15 @@
+/** Risk2 Mini module — tsb analytics library. */
+export interface Risk2 miniOptions { tol?: number; maxIter?: number; }
+export interface Risk2 miniResult { values: number[]; converged: boolean; }
+export function computeRisk2 mini(data: number[], opts: Risk2 miniOptions = {}): Risk2 miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 mini };
diff --git a/src/risk2/next.ts b/src/risk2/next.ts
new file mode 100644
index 000000000..a403609c2
--- /dev/null
+++ b/src/risk2/next.ts
@@ -0,0 +1,15 @@
+/** Risk2 Next module — tsb analytics library. */
+export interface Risk2 nextOptions { tol?: number; maxIter?: number; }
+export interface Risk2 nextResult { values: number[]; converged: boolean; }
+export function computeRisk2 next(data: number[], opts: Risk2 nextOptions = {}): Risk2 nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 next };
diff --git a/src/risk2/online.ts b/src/risk2/online.ts
new file mode 100644
index 000000000..42d991ecd
--- /dev/null
+++ b/src/risk2/online.ts
@@ -0,0 +1,15 @@
+/** Risk2 Online module — tsb analytics library. */
+export interface Risk2 onlineOptions { tol?: number; maxIter?: number; }
+export interface Risk2 onlineResult { values: number[]; converged: boolean; }
+export function computeRisk2 online(data: number[], opts: Risk2 onlineOptions = {}): Risk2 onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 online };
diff --git a/src/risk2/operational_risk.ts b/src/risk2/operational_risk.ts
new file mode 100644
index 000000000..1c19e7536
--- /dev/null
+++ b/src/risk2/operational_risk.ts
@@ -0,0 +1,22 @@
+/** Operational Risk module — tsb analytics library. */
+
+/** Options for Operational Risk. */
+export interface OperationalRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Operational Risk. */
+export interface OperationalRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Operational Risk. */
+export function computeOperationalRisk(data: number[], opts: OperationalRiskOptions = {}): OperationalRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOperationalRisk };
diff --git a/src/risk2/parallel.ts b/src/risk2/parallel.ts
new file mode 100644
index 000000000..2dded6bef
--- /dev/null
+++ b/src/risk2/parallel.ts
@@ -0,0 +1,15 @@
+/** Risk2 Parallel module — tsb analytics library. */
+export interface Risk2 parallelOptions { tol?: number; maxIter?: number; }
+export interface Risk2 parallelResult { values: number[]; converged: boolean; }
+export function computeRisk2 parallel(data: number[], opts: Risk2 parallelOptions = {}): Risk2 parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 parallel };
diff --git a/src/risk2/plus.ts b/src/risk2/plus.ts
new file mode 100644
index 000000000..cd90e1087
--- /dev/null
+++ b/src/risk2/plus.ts
@@ -0,0 +1,15 @@
+/** Risk2 Plus module — tsb analytics library. */
+export interface Risk2 plusOptions { tol?: number; maxIter?: number; }
+export interface Risk2 plusResult { values: number[]; converged: boolean; }
+export function computeRisk2 plus(data: number[], opts: Risk2 plusOptions = {}): Risk2 plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 plus };
diff --git a/src/risk2/principal_component.ts b/src/risk2/principal_component.ts
new file mode 100644
index 000000000..45fec1a2c
--- /dev/null
+++ b/src/risk2/principal_component.ts
@@ -0,0 +1,22 @@
+/** Principal Component module — tsb analytics library. */
+
+/** Options for Principal Component. */
+export interface PrincipalComponentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Principal Component. */
+export interface PrincipalComponentResult { values: number[]; converged: boolean; }
+
+/** Compute Principal Component. */
+export function computePrincipalComponent(data: number[], opts: PrincipalComponentOptions = {}): PrincipalComponentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePrincipalComponent };
diff --git a/src/risk2/pro.ts b/src/risk2/pro.ts
new file mode 100644
index 000000000..8e0441898
--- /dev/null
+++ b/src/risk2/pro.ts
@@ -0,0 +1,15 @@
+/** Risk2 Pro module — tsb analytics library. */
+export interface Risk2 proOptions { tol?: number; maxIter?: number; }
+export interface Risk2 proResult { values: number[]; converged: boolean; }
+export function computeRisk2 pro(data: number[], opts: Risk2 proOptions = {}): Risk2 proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 pro };
diff --git a/src/risk2/rho.ts b/src/risk2/rho.ts
new file mode 100644
index 000000000..50fdc4529
--- /dev/null
+++ b/src/risk2/rho.ts
@@ -0,0 +1,22 @@
+/** Rho module — tsb analytics library. */
+
+/** Options for Rho. */
+export interface RhoOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rho. */
+export interface RhoResult { values: number[]; converged: boolean; }
+
+/** Compute Rho. */
+export function computeRho(data: number[], opts: RhoOptions = {}): RhoResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRho };
diff --git a/src/risk2/robust.ts b/src/risk2/robust.ts
new file mode 100644
index 000000000..bf6a235a3
--- /dev/null
+++ b/src/risk2/robust.ts
@@ -0,0 +1,15 @@
+/** Risk2 Robust module — tsb analytics library. */
+export interface Risk2 robustOptions { tol?: number; maxIter?: number; }
+export interface Risk2 robustResult { values: number[]; converged: boolean; }
+export function computeRisk2 robust(data: number[], opts: Risk2 robustOptions = {}): Risk2 robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 robust };
diff --git a/src/risk2/scenario_analysis.ts b/src/risk2/scenario_analysis.ts
new file mode 100644
index 000000000..5070b21e0
--- /dev/null
+++ b/src/risk2/scenario_analysis.ts
@@ -0,0 +1,22 @@
+/** Scenario Analysis module — tsb analytics library. */
+
+/** Options for Scenario Analysis. */
+export interface ScenarioAnalysisOptions { tol?: number; maxIter?: number; }
+
+/** Result from Scenario Analysis. */
+export interface ScenarioAnalysisResult { values: number[]; converged: boolean; }
+
+/** Compute Scenario Analysis. */
+export function computeScenarioAnalysis(data: number[], opts: ScenarioAnalysisOptions = {}): ScenarioAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeScenarioAnalysis };
diff --git a/src/risk2/sensitivity.ts b/src/risk2/sensitivity.ts
new file mode 100644
index 000000000..2c021c567
--- /dev/null
+++ b/src/risk2/sensitivity.ts
@@ -0,0 +1,22 @@
+/** Sensitivity module — tsb analytics library. */
+
+/** Options for Sensitivity. */
+export interface SensitivityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sensitivity. */
+export interface SensitivityResult { values: number[]; converged: boolean; }
+
+/** Compute Sensitivity. */
+export function computeSensitivity(data: number[], opts: SensitivityOptions = {}): SensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSensitivity };
diff --git a/src/risk2/small.ts b/src/risk2/small.ts
new file mode 100644
index 000000000..e342c40e3
--- /dev/null
+++ b/src/risk2/small.ts
@@ -0,0 +1,15 @@
+/** Risk2 Small module — tsb analytics library. */
+export interface Risk2 smallOptions { tol?: number; maxIter?: number; }
+export interface Risk2 smallResult { values: number[]; converged: boolean; }
+export function computeRisk2 small(data: number[], opts: Risk2 smallOptions = {}): Risk2 smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 small };
diff --git a/src/risk2/sparse.ts b/src/risk2/sparse.ts
new file mode 100644
index 000000000..c9a696c5a
--- /dev/null
+++ b/src/risk2/sparse.ts
@@ -0,0 +1,15 @@
+/** Risk2 Sparse module — tsb analytics library. */
+export interface Risk2 sparseOptions { tol?: number; maxIter?: number; }
+export interface Risk2 sparseResult { values: number[]; converged: boolean; }
+export function computeRisk2 sparse(data: number[], opts: Risk2 sparseOptions = {}): Risk2 sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 sparse };
diff --git a/src/risk2/stable.ts b/src/risk2/stable.ts
new file mode 100644
index 000000000..6a7e0ebc2
--- /dev/null
+++ b/src/risk2/stable.ts
@@ -0,0 +1,15 @@
+/** Risk2 Stable module — tsb analytics library. */
+export interface Risk2 stableOptions { tol?: number; maxIter?: number; }
+export interface Risk2 stableResult { values: number[]; converged: boolean; }
+export function computeRisk2 stable(data: number[], opts: Risk2 stableOptions = {}): Risk2 stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 stable };
diff --git a/src/risk2/streaming.ts b/src/risk2/streaming.ts
new file mode 100644
index 000000000..0e43e9a67
--- /dev/null
+++ b/src/risk2/streaming.ts
@@ -0,0 +1,15 @@
+/** Risk2 Streaming module — tsb analytics library. */
+export interface Risk2 streamingOptions { tol?: number; maxIter?: number; }
+export interface Risk2 streamingResult { values: number[]; converged: boolean; }
+export function computeRisk2 streaming(data: number[], opts: Risk2 streamingOptions = {}): Risk2 streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 streaming };
diff --git a/src/risk2/stress_testing.ts b/src/risk2/stress_testing.ts
new file mode 100644
index 000000000..a38490772
--- /dev/null
+++ b/src/risk2/stress_testing.ts
@@ -0,0 +1,22 @@
+/** Stress Testing module — tsb analytics library. */
+
+/** Options for Stress Testing. */
+export interface StressTestingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stress Testing. */
+export interface StressTestingResult { values: number[]; converged: boolean; }
+
+/** Compute Stress Testing. */
+export function computeStressTesting(data: number[], opts: StressTestingOptions = {}): StressTestingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStressTesting };
diff --git a/src/risk2/systemic_risk.ts b/src/risk2/systemic_risk.ts
new file mode 100644
index 000000000..6191ffb84
--- /dev/null
+++ b/src/risk2/systemic_risk.ts
@@ -0,0 +1,22 @@
+/** Systemic Risk module — tsb analytics library. */
+
+/** Options for Systemic Risk. */
+export interface SystemicRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Systemic Risk. */
+export interface SystemicRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Systemic Risk. */
+export function computeSystemicRisk(data: number[], opts: SystemicRiskOptions = {}): SystemicRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSystemicRisk };
diff --git a/src/risk2/tail_risk.ts b/src/risk2/tail_risk.ts
new file mode 100644
index 000000000..aaf6dd0a5
--- /dev/null
+++ b/src/risk2/tail_risk.ts
@@ -0,0 +1,22 @@
+/** Tail Risk module — tsb analytics library. */
+
+/** Options for Tail Risk. */
+export interface TailRiskOptions { tol?: number; maxIter?: number; }
+
+/** Result from Tail Risk. */
+export interface TailRiskResult { values: number[]; converged: boolean; }
+
+/** Compute Tail Risk. */
+export function computeTailRisk(data: number[], opts: TailRiskOptions = {}): TailRiskResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTailRisk };
diff --git a/src/risk2/theta.ts b/src/risk2/theta.ts
new file mode 100644
index 000000000..6c2db67ff
--- /dev/null
+++ b/src/risk2/theta.ts
@@ -0,0 +1,22 @@
+/** Theta module — tsb analytics library. */
+
+/** Options for Theta. */
+export interface ThetaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Theta. */
+export interface ThetaResult { values: number[]; converged: boolean; }
+
+/** Compute Theta. */
+export function computeTheta(data: number[], opts: ThetaOptions = {}): ThetaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTheta };
diff --git a/src/risk2/v2.ts b/src/risk2/v2.ts
new file mode 100644
index 000000000..74a7d95de
--- /dev/null
+++ b/src/risk2/v2.ts
@@ -0,0 +1,15 @@
+/** Risk2 V2 module — tsb analytics library. */
+export interface Risk2 v2Options { tol?: number; maxIter?: number; }
+export interface Risk2 v2Result { values: number[]; converged: boolean; }
+export function computeRisk2 v2(data: number[], opts: Risk2 v2Options = {}): Risk2 v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 v2 };
diff --git a/src/risk2/v3.ts b/src/risk2/v3.ts
new file mode 100644
index 000000000..a576a5993
--- /dev/null
+++ b/src/risk2/v3.ts
@@ -0,0 +1,15 @@
+/** Risk2 V3 module — tsb analytics library. */
+export interface Risk2 v3Options { tol?: number; maxIter?: number; }
+export interface Risk2 v3Result { values: number[]; converged: boolean; }
+export function computeRisk2 v3(data: number[], opts: Risk2 v3Options = {}): Risk2 v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 v3 };
diff --git a/src/risk2/vega.ts b/src/risk2/vega.ts
new file mode 100644
index 000000000..281a14559
--- /dev/null
+++ b/src/risk2/vega.ts
@@ -0,0 +1,22 @@
+/** Vega module — tsb analytics library. */
+
+/** Options for Vega. */
+export interface VegaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vega. */
+export interface VegaResult { values: number[]; converged: boolean; }
+
+/** Compute Vega. */
+export function computeVega(data: number[], opts: VegaOptions = {}): VegaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVega };
diff --git a/src/risk2/wasm.ts b/src/risk2/wasm.ts
new file mode 100644
index 000000000..c0fb6fabe
--- /dev/null
+++ b/src/risk2/wasm.ts
@@ -0,0 +1,15 @@
+/** Risk2 Wasm module — tsb analytics library. */
+export interface Risk2 wasmOptions { tol?: number; maxIter?: number; }
+export interface Risk2 wasmResult { values: number[]; converged: boolean; }
+export function computeRisk2 wasm(data: number[], opts: Risk2 wasmOptions = {}): Risk2 wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 wasm };
diff --git a/src/risk2/xlarge.ts b/src/risk2/xlarge.ts
new file mode 100644
index 000000000..261e75d23
--- /dev/null
+++ b/src/risk2/xlarge.ts
@@ -0,0 +1,15 @@
+/** Risk2 Xlarge module — tsb analytics library. */
+export interface Risk2 xlargeOptions { tol?: number; maxIter?: number; }
+export interface Risk2 xlargeResult { values: number[]; converged: boolean; }
+export function computeRisk2 xlarge(data: number[], opts: Risk2 xlargeOptions = {}): Risk2 xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRisk2 xlarge };
diff --git a/src/rock_mech/adaptation.ts b/src/rock_mech/adaptation.ts
new file mode 100644
index 000000000..b5b7c105a
--- /dev/null
+++ b/src/rock_mech/adaptation.ts
@@ -0,0 +1,14 @@
+/** rock_mech adaptation module — tsb analytics library. */
+export interface RockMechAdaptationOptions { tol?: number; maxIter?: number; }
+export interface RockMechAdaptationResult { values: number[]; converged: boolean; }
+export function computeRockMechAdaptation(data: number[], opts: RockMechAdaptationOptions = {}): RockMechAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechAdaptation };
diff --git a/src/rock_mech/aggregation.ts b/src/rock_mech/aggregation.ts
new file mode 100644
index 000000000..d7f32b3d4
--- /dev/null
+++ b/src/rock_mech/aggregation.ts
@@ -0,0 +1,14 @@
+/** rock_mech aggregation module — tsb analytics library. */
+export interface RockMechAggregationOptions { tol?: number; maxIter?: number; }
+export interface RockMechAggregationResult { values: number[]; converged: boolean; }
+export function computeRockMechAggregation(data: number[], opts: RockMechAggregationOptions = {}): RockMechAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechAggregation };
diff --git a/src/rock_mech/algebra.ts b/src/rock_mech/algebra.ts
new file mode 100644
index 000000000..493f89977
--- /dev/null
+++ b/src/rock_mech/algebra.ts
@@ -0,0 +1,14 @@
+/** rock_mech algebra module — tsb analytics library. */
+export interface RockMechAlgebraOptions { tol?: number; maxIter?: number; }
+export interface RockMechAlgebraResult { values: number[]; converged: boolean; }
+export function computeRockMechAlgebra(data: number[], opts: RockMechAlgebraOptions = {}): RockMechAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechAlgebra };
diff --git a/src/rock_mech/alignment.ts b/src/rock_mech/alignment.ts
new file mode 100644
index 000000000..ae142bb54
--- /dev/null
+++ b/src/rock_mech/alignment.ts
@@ -0,0 +1,14 @@
+/** rock_mech alignment module — tsb analytics library. */
+export interface RockMechAlignmentOptions { tol?: number; maxIter?: number; }
+export interface RockMechAlignmentResult { values: number[]; converged: boolean; }
+export function computeRockMechAlignment(data: number[], opts: RockMechAlignmentOptions = {}): RockMechAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechAlignment };
diff --git a/src/rock_mech/analysis.ts b/src/rock_mech/analysis.ts
new file mode 100644
index 000000000..d3abec89b
--- /dev/null
+++ b/src/rock_mech/analysis.ts
@@ -0,0 +1,14 @@
+/** rock_mech analysis module — tsb analytics library. */
+export interface RockMechAnalysisOptions { tol?: number; maxIter?: number; }
+export interface RockMechAnalysisResult { values: number[]; converged: boolean; }
+export function computeRockMechAnalysis(data: number[], opts: RockMechAnalysisOptions = {}): RockMechAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechAnalysis };
diff --git a/src/rock_mech/augmentation.ts b/src/rock_mech/augmentation.ts
new file mode 100644
index 000000000..2ab3ce91d
--- /dev/null
+++ b/src/rock_mech/augmentation.ts
@@ -0,0 +1,14 @@
+/** rock_mech augmentation module — tsb analytics library. */
+export interface RockMechAugmentationOptions { tol?: number; maxIter?: number; }
+export interface RockMechAugmentationResult { values: number[]; converged: boolean; }
+export function computeRockMechAugmentation(data: number[], opts: RockMechAugmentationOptions = {}): RockMechAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechAugmentation };
diff --git a/src/rock_mech/bagging.ts b/src/rock_mech/bagging.ts
new file mode 100644
index 000000000..7afac835f
--- /dev/null
+++ b/src/rock_mech/bagging.ts
@@ -0,0 +1,14 @@
+/** rock_mech bagging module — tsb analytics library. */
+export interface RockMechBaggingOptions { tol?: number; maxIter?: number; }
+export interface RockMechBaggingResult { values: number[]; converged: boolean; }
+export function computeRockMechBagging(data: number[], opts: RockMechBaggingOptions = {}): RockMechBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechBagging };
diff --git a/src/rock_mech/basis.ts b/src/rock_mech/basis.ts
new file mode 100644
index 000000000..c2aeccf49
--- /dev/null
+++ b/src/rock_mech/basis.ts
@@ -0,0 +1,14 @@
+/** rock_mech basis module — tsb analytics library. */
+export interface RockMechBasisOptions { tol?: number; maxIter?: number; }
+export interface RockMechBasisResult { values: number[]; converged: boolean; }
+export function computeRockMechBasis(data: number[], opts: RockMechBasisOptions = {}): RockMechBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechBasis };
diff --git a/src/rock_mech/benchmarking.ts b/src/rock_mech/benchmarking.ts
new file mode 100644
index 000000000..bf812994f
--- /dev/null
+++ b/src/rock_mech/benchmarking.ts
@@ -0,0 +1,14 @@
+/** rock_mech benchmarking module — tsb analytics library. */
+export interface RockMechBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface RockMechBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeRockMechBenchmarking(data: number[], opts: RockMechBenchmarkingOptions = {}): RockMechBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechBenchmarking };
diff --git a/src/rock_mech/blending.ts b/src/rock_mech/blending.ts
new file mode 100644
index 000000000..63adb3042
--- /dev/null
+++ b/src/rock_mech/blending.ts
@@ -0,0 +1,14 @@
+/** rock_mech blending module — tsb analytics library. */
+export interface RockMechBlendingOptions { tol?: number; maxIter?: number; }
+export interface RockMechBlendingResult { values: number[]; converged: boolean; }
+export function computeRockMechBlending(data: number[], opts: RockMechBlendingOptions = {}): RockMechBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechBlending };
diff --git a/src/rock_mech/boosting.ts b/src/rock_mech/boosting.ts
new file mode 100644
index 000000000..6ee62005c
--- /dev/null
+++ b/src/rock_mech/boosting.ts
@@ -0,0 +1,14 @@
+/** rock_mech boosting module — tsb analytics library. */
+export interface RockMechBoostingOptions { tol?: number; maxIter?: number; }
+export interface RockMechBoostingResult { values: number[]; converged: boolean; }
+export function computeRockMechBoosting(data: number[], opts: RockMechBoostingOptions = {}): RockMechBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechBoosting };
diff --git a/src/rock_mech/bootstrap.ts b/src/rock_mech/bootstrap.ts
new file mode 100644
index 000000000..60b7cbb1b
--- /dev/null
+++ b/src/rock_mech/bootstrap.ts
@@ -0,0 +1,14 @@
+/** rock_mech bootstrap module — tsb analytics library. */
+export interface RockMechBootstrapOptions { tol?: number; maxIter?: number; }
+export interface RockMechBootstrapResult { values: number[]; converged: boolean; }
+export function computeRockMechBootstrap(data: number[], opts: RockMechBootstrapOptions = {}): RockMechBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechBootstrap };
diff --git a/src/rock_mech/calculus.ts b/src/rock_mech/calculus.ts
new file mode 100644
index 000000000..981b8dde4
--- /dev/null
+++ b/src/rock_mech/calculus.ts
@@ -0,0 +1,14 @@
+/** rock_mech calculus module — tsb analytics library. */
+export interface RockMechCalculusOptions { tol?: number; maxIter?: number; }
+export interface RockMechCalculusResult { values: number[]; converged: boolean; }
+export function computeRockMechCalculus(data: number[], opts: RockMechCalculusOptions = {}): RockMechCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechCalculus };
diff --git a/src/rock_mech/calibration.ts b/src/rock_mech/calibration.ts
new file mode 100644
index 000000000..f0a7348d5
--- /dev/null
+++ b/src/rock_mech/calibration.ts
@@ -0,0 +1,14 @@
+/** rock_mech calibration module — tsb analytics library. */
+export interface RockMechCalibrationOptions { tol?: number; maxIter?: number; }
+export interface RockMechCalibrationResult { values: number[]; converged: boolean; }
+export function computeRockMechCalibration(data: number[], opts: RockMechCalibrationOptions = {}): RockMechCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechCalibration };
diff --git a/src/rock_mech/characterization.ts b/src/rock_mech/characterization.ts
new file mode 100644
index 000000000..e18ca9691
--- /dev/null
+++ b/src/rock_mech/characterization.ts
@@ -0,0 +1,14 @@
+/** rock_mech characterization module — tsb analytics library. */
+export interface RockMechCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface RockMechCharacterizationResult { values: number[]; converged: boolean; }
+export function computeRockMechCharacterization(data: number[], opts: RockMechCharacterizationOptions = {}): RockMechCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechCharacterization };
diff --git a/src/rock_mech/classification.ts b/src/rock_mech/classification.ts
new file mode 100644
index 000000000..7a478d3e5
--- /dev/null
+++ b/src/rock_mech/classification.ts
@@ -0,0 +1,14 @@
+/** rock_mech classification module — tsb analytics library. */
+export interface RockMechClassificationOptions { tol?: number; maxIter?: number; }
+export interface RockMechClassificationResult { values: number[]; converged: boolean; }
+export function computeRockMechClassification(data: number[], opts: RockMechClassificationOptions = {}): RockMechClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechClassification };
diff --git a/src/rock_mech/clustering.ts b/src/rock_mech/clustering.ts
new file mode 100644
index 000000000..a80b6e662
--- /dev/null
+++ b/src/rock_mech/clustering.ts
@@ -0,0 +1,14 @@
+/** rock_mech clustering module — tsb analytics library. */
+export interface RockMechClusteringOptions { tol?: number; maxIter?: number; }
+export interface RockMechClusteringResult { values: number[]; converged: boolean; }
+export function computeRockMechClustering(data: number[], opts: RockMechClusteringOptions = {}): RockMechClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechClustering };
diff --git a/src/rock_mech/compression.ts b/src/rock_mech/compression.ts
new file mode 100644
index 000000000..1a7376a7a
--- /dev/null
+++ b/src/rock_mech/compression.ts
@@ -0,0 +1,14 @@
+/** rock_mech compression module — tsb analytics library. */
+export interface RockMechCompressionOptions { tol?: number; maxIter?: number; }
+export interface RockMechCompressionResult { values: number[]; converged: boolean; }
+export function computeRockMechCompression(data: number[], opts: RockMechCompressionOptions = {}): RockMechCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechCompression };
diff --git a/src/rock_mech/continuous.ts b/src/rock_mech/continuous.ts
new file mode 100644
index 000000000..6a629238e
--- /dev/null
+++ b/src/rock_mech/continuous.ts
@@ -0,0 +1,14 @@
+/** rock_mech continuous module — tsb analytics library. */
+export interface RockMechContinuousOptions { tol?: number; maxIter?: number; }
+export interface RockMechContinuousResult { values: number[]; converged: boolean; }
+export function computeRockMechContinuous(data: number[], opts: RockMechContinuousOptions = {}): RockMechContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechContinuous };
diff --git a/src/rock_mech/control.ts b/src/rock_mech/control.ts
new file mode 100644
index 000000000..9fc2bc1a6
--- /dev/null
+++ b/src/rock_mech/control.ts
@@ -0,0 +1,14 @@
+/** rock_mech control module — tsb analytics library. */
+export interface RockMechControlOptions { tol?: number; maxIter?: number; }
+export interface RockMechControlResult { values: number[]; converged: boolean; }
+export function computeRockMechControl(data: number[], opts: RockMechControlOptions = {}): RockMechControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechControl };
diff --git a/src/rock_mech/convergence.ts b/src/rock_mech/convergence.ts
new file mode 100644
index 000000000..474c6ec22
--- /dev/null
+++ b/src/rock_mech/convergence.ts
@@ -0,0 +1,14 @@
+/** rock_mech convergence module — tsb analytics library. */
+export interface RockMechConvergenceOptions { tol?: number; maxIter?: number; }
+export interface RockMechConvergenceResult { values: number[]; converged: boolean; }
+export function computeRockMechConvergence(data: number[], opts: RockMechConvergenceOptions = {}): RockMechConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechConvergence };
diff --git a/src/rock_mech/convex.ts b/src/rock_mech/convex.ts
new file mode 100644
index 000000000..dc997877a
--- /dev/null
+++ b/src/rock_mech/convex.ts
@@ -0,0 +1,14 @@
+/** rock_mech convex module — tsb analytics library. */
+export interface RockMechConvexOptions { tol?: number; maxIter?: number; }
+export interface RockMechConvexResult { values: number[]; converged: boolean; }
+export function computeRockMechConvex(data: number[], opts: RockMechConvexOptions = {}): RockMechConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechConvex };
diff --git a/src/rock_mech/correlation.ts b/src/rock_mech/correlation.ts
new file mode 100644
index 000000000..8e583fe01
--- /dev/null
+++ b/src/rock_mech/correlation.ts
@@ -0,0 +1,14 @@
+/** rock_mech correlation module — tsb analytics library. */
+export interface RockMechCorrelationOptions { tol?: number; maxIter?: number; }
+export interface RockMechCorrelationResult { values: number[]; converged: boolean; }
+export function computeRockMechCorrelation(data: number[], opts: RockMechCorrelationOptions = {}): RockMechCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechCorrelation };
diff --git a/src/rock_mech/covariance.ts b/src/rock_mech/covariance.ts
new file mode 100644
index 000000000..ca8f3fc94
--- /dev/null
+++ b/src/rock_mech/covariance.ts
@@ -0,0 +1,14 @@
+/** rock_mech covariance module — tsb analytics library. */
+export interface RockMechCovarianceOptions { tol?: number; maxIter?: number; }
+export interface RockMechCovarianceResult { values: number[]; converged: boolean; }
+export function computeRockMechCovariance(data: number[], opts: RockMechCovarianceOptions = {}): RockMechCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechCovariance };
diff --git a/src/rock_mech/cross_validation.ts b/src/rock_mech/cross_validation.ts
new file mode 100644
index 000000000..50bfc37ce
--- /dev/null
+++ b/src/rock_mech/cross_validation.ts
@@ -0,0 +1,14 @@
+/** rock_mech cross_validation module — tsb analytics library. */
+export interface RockMechCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface RockMechCrossValidationResult { values: number[]; converged: boolean; }
+export function computeRockMechCrossValidation(data: number[], opts: RockMechCrossValidationOptions = {}): RockMechCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechCrossValidation };
diff --git a/src/rock_mech/decoding.ts b/src/rock_mech/decoding.ts
new file mode 100644
index 000000000..f74a7c1ad
--- /dev/null
+++ b/src/rock_mech/decoding.ts
@@ -0,0 +1,14 @@
+/** rock_mech decoding module — tsb analytics library. */
+export interface RockMechDecodingOptions { tol?: number; maxIter?: number; }
+export interface RockMechDecodingResult { values: number[]; converged: boolean; }
+export function computeRockMechDecoding(data: number[], opts: RockMechDecodingOptions = {}): RockMechDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDecoding };
diff --git a/src/rock_mech/decomposition.ts b/src/rock_mech/decomposition.ts
new file mode 100644
index 000000000..97253a188
--- /dev/null
+++ b/src/rock_mech/decomposition.ts
@@ -0,0 +1,14 @@
+/** rock_mech decomposition module — tsb analytics library. */
+export interface RockMechDecompositionOptions { tol?: number; maxIter?: number; }
+export interface RockMechDecompositionResult { values: number[]; converged: boolean; }
+export function computeRockMechDecomposition(data: number[], opts: RockMechDecompositionOptions = {}): RockMechDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDecomposition };
diff --git a/src/rock_mech/detection.ts b/src/rock_mech/detection.ts
new file mode 100644
index 000000000..468825a48
--- /dev/null
+++ b/src/rock_mech/detection.ts
@@ -0,0 +1,14 @@
+/** rock_mech detection module — tsb analytics library. */
+export interface RockMechDetectionOptions { tol?: number; maxIter?: number; }
+export interface RockMechDetectionResult { values: number[]; converged: boolean; }
+export function computeRockMechDetection(data: number[], opts: RockMechDetectionOptions = {}): RockMechDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDetection };
diff --git a/src/rock_mech/deterministic.ts b/src/rock_mech/deterministic.ts
new file mode 100644
index 000000000..39041b42e
--- /dev/null
+++ b/src/rock_mech/deterministic.ts
@@ -0,0 +1,14 @@
+/** rock_mech deterministic module — tsb analytics library. */
+export interface RockMechDeterministicOptions { tol?: number; maxIter?: number; }
+export interface RockMechDeterministicResult { values: number[]; converged: boolean; }
+export function computeRockMechDeterministic(data: number[], opts: RockMechDeterministicOptions = {}): RockMechDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDeterministic };
diff --git a/src/rock_mech/diagnostics.ts b/src/rock_mech/diagnostics.ts
new file mode 100644
index 000000000..1bc506566
--- /dev/null
+++ b/src/rock_mech/diagnostics.ts
@@ -0,0 +1,14 @@
+/** rock_mech diagnostics module — tsb analytics library. */
+export interface RockMechDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface RockMechDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeRockMechDiagnostics(data: number[], opts: RockMechDiagnosticsOptions = {}): RockMechDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDiagnostics };
diff --git a/src/rock_mech/differential.ts b/src/rock_mech/differential.ts
new file mode 100644
index 000000000..0e78a6171
--- /dev/null
+++ b/src/rock_mech/differential.ts
@@ -0,0 +1,14 @@
+/** rock_mech differential module — tsb analytics library. */
+export interface RockMechDifferentialOptions { tol?: number; maxIter?: number; }
+export interface RockMechDifferentialResult { values: number[]; converged: boolean; }
+export function computeRockMechDifferential(data: number[], opts: RockMechDifferentialOptions = {}): RockMechDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDifferential };
diff --git a/src/rock_mech/discrete.ts b/src/rock_mech/discrete.ts
new file mode 100644
index 000000000..6f35dfc4f
--- /dev/null
+++ b/src/rock_mech/discrete.ts
@@ -0,0 +1,14 @@
+/** rock_mech discrete module — tsb analytics library. */
+export interface RockMechDiscreteOptions { tol?: number; maxIter?: number; }
+export interface RockMechDiscreteResult { values: number[]; converged: boolean; }
+export function computeRockMechDiscrete(data: number[], opts: RockMechDiscreteOptions = {}): RockMechDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDiscrete };
diff --git a/src/rock_mech/distribution.ts b/src/rock_mech/distribution.ts
new file mode 100644
index 000000000..a89adeaef
--- /dev/null
+++ b/src/rock_mech/distribution.ts
@@ -0,0 +1,14 @@
+/** rock_mech distribution module — tsb analytics library. */
+export interface RockMechDistributionOptions { tol?: number; maxIter?: number; }
+export interface RockMechDistributionResult { values: number[]; converged: boolean; }
+export function computeRockMechDistribution(data: number[], opts: RockMechDistributionOptions = {}): RockMechDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDistribution };
diff --git a/src/rock_mech/dynamic.ts b/src/rock_mech/dynamic.ts
new file mode 100644
index 000000000..1f62b0451
--- /dev/null
+++ b/src/rock_mech/dynamic.ts
@@ -0,0 +1,14 @@
+/** rock_mech dynamic module — tsb analytics library. */
+export interface RockMechDynamicOptions { tol?: number; maxIter?: number; }
+export interface RockMechDynamicResult { values: number[]; converged: boolean; }
+export function computeRockMechDynamic(data: number[], opts: RockMechDynamicOptions = {}): RockMechDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechDynamic };
diff --git a/src/rock_mech/embedding.ts b/src/rock_mech/embedding.ts
new file mode 100644
index 000000000..12c2e81c6
--- /dev/null
+++ b/src/rock_mech/embedding.ts
@@ -0,0 +1,14 @@
+/** rock_mech embedding module — tsb analytics library. */
+export interface RockMechEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface RockMechEmbeddingResult { values: number[]; converged: boolean; }
+export function computeRockMechEmbedding(data: number[], opts: RockMechEmbeddingOptions = {}): RockMechEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechEmbedding };
diff --git a/src/rock_mech/encoding.ts b/src/rock_mech/encoding.ts
new file mode 100644
index 000000000..ae2e14f9f
--- /dev/null
+++ b/src/rock_mech/encoding.ts
@@ -0,0 +1,14 @@
+/** rock_mech encoding module — tsb analytics library. */
+export interface RockMechEncodingOptions { tol?: number; maxIter?: number; }
+export interface RockMechEncodingResult { values: number[]; converged: boolean; }
+export function computeRockMechEncoding(data: number[], opts: RockMechEncodingOptions = {}): RockMechEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechEncoding };
diff --git a/src/rock_mech/ensemble.ts b/src/rock_mech/ensemble.ts
new file mode 100644
index 000000000..84fad430e
--- /dev/null
+++ b/src/rock_mech/ensemble.ts
@@ -0,0 +1,14 @@
+/** rock_mech ensemble module — tsb analytics library. */
+export interface RockMechEnsembleOptions { tol?: number; maxIter?: number; }
+export interface RockMechEnsembleResult { values: number[]; converged: boolean; }
+export function computeRockMechEnsemble(data: number[], opts: RockMechEnsembleOptions = {}): RockMechEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechEnsemble };
diff --git a/src/rock_mech/estimation.ts b/src/rock_mech/estimation.ts
new file mode 100644
index 000000000..6afd4700d
--- /dev/null
+++ b/src/rock_mech/estimation.ts
@@ -0,0 +1,14 @@
+/** rock_mech estimation module — tsb analytics library. */
+export interface RockMechEstimationOptions { tol?: number; maxIter?: number; }
+export interface RockMechEstimationResult { values: number[]; converged: boolean; }
+export function computeRockMechEstimation(data: number[], opts: RockMechEstimationOptions = {}): RockMechEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechEstimation };
diff --git a/src/rock_mech/evaluation.ts b/src/rock_mech/evaluation.ts
new file mode 100644
index 000000000..1676d4eb6
--- /dev/null
+++ b/src/rock_mech/evaluation.ts
@@ -0,0 +1,14 @@
+/** rock_mech evaluation module — tsb analytics library. */
+export interface RockMechEvaluationOptions { tol?: number; maxIter?: number; }
+export interface RockMechEvaluationResult { values: number[]; converged: boolean; }
+export function computeRockMechEvaluation(data: number[], opts: RockMechEvaluationOptions = {}): RockMechEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechEvaluation };
diff --git a/src/rock_mech/extrapolation.ts b/src/rock_mech/extrapolation.ts
new file mode 100644
index 000000000..15c4e1583
--- /dev/null
+++ b/src/rock_mech/extrapolation.ts
@@ -0,0 +1,14 @@
+/** rock_mech extrapolation module — tsb analytics library. */
+export interface RockMechExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface RockMechExtrapolationResult { values: number[]; converged: boolean; }
+export function computeRockMechExtrapolation(data: number[], opts: RockMechExtrapolationOptions = {}): RockMechExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechExtrapolation };
diff --git a/src/rock_mech/features.ts b/src/rock_mech/features.ts
new file mode 100644
index 000000000..ee3b91251
--- /dev/null
+++ b/src/rock_mech/features.ts
@@ -0,0 +1,14 @@
+/** rock_mech features module — tsb analytics library. */
+export interface RockMechFeaturesOptions { tol?: number; maxIter?: number; }
+export interface RockMechFeaturesResult { values: number[]; converged: boolean; }
+export function computeRockMechFeatures(data: number[], opts: RockMechFeaturesOptions = {}): RockMechFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechFeatures };
diff --git a/src/rock_mech/feedback.ts b/src/rock_mech/feedback.ts
new file mode 100644
index 000000000..64a11609d
--- /dev/null
+++ b/src/rock_mech/feedback.ts
@@ -0,0 +1,14 @@
+/** rock_mech feedback module — tsb analytics library. */
+export interface RockMechFeedbackOptions { tol?: number; maxIter?: number; }
+export interface RockMechFeedbackResult { values: number[]; converged: boolean; }
+export function computeRockMechFeedback(data: number[], opts: RockMechFeedbackOptions = {}): RockMechFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechFeedback };
diff --git a/src/rock_mech/filtering.ts b/src/rock_mech/filtering.ts
new file mode 100644
index 000000000..53d033dba
--- /dev/null
+++ b/src/rock_mech/filtering.ts
@@ -0,0 +1,14 @@
+/** rock_mech filtering module — tsb analytics library. */
+export interface RockMechFilteringOptions { tol?: number; maxIter?: number; }
+export interface RockMechFilteringResult { values: number[]; converged: boolean; }
+export function computeRockMechFiltering(data: number[], opts: RockMechFilteringOptions = {}): RockMechFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechFiltering };
diff --git a/src/rock_mech/fourier.ts b/src/rock_mech/fourier.ts
new file mode 100644
index 000000000..3a15ff63f
--- /dev/null
+++ b/src/rock_mech/fourier.ts
@@ -0,0 +1,14 @@
+/** rock_mech fourier module — tsb analytics library. */
+export interface RockMechFourierOptions { tol?: number; maxIter?: number; }
+export interface RockMechFourierResult { values: number[]; converged: boolean; }
+export function computeRockMechFourier(data: number[], opts: RockMechFourierOptions = {}): RockMechFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechFourier };
diff --git a/src/rock_mech/fusion.ts b/src/rock_mech/fusion.ts
new file mode 100644
index 000000000..02fae37cd
--- /dev/null
+++ b/src/rock_mech/fusion.ts
@@ -0,0 +1,14 @@
+/** rock_mech fusion module — tsb analytics library. */
+export interface RockMechFusionOptions { tol?: number; maxIter?: number; }
+export interface RockMechFusionResult { values: number[]; converged: boolean; }
+export function computeRockMechFusion(data: number[], opts: RockMechFusionOptions = {}): RockMechFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechFusion };
diff --git a/src/rock_mech/generation.ts b/src/rock_mech/generation.ts
new file mode 100644
index 000000000..6b47b5ae2
--- /dev/null
+++ b/src/rock_mech/generation.ts
@@ -0,0 +1,14 @@
+/** rock_mech generation module — tsb analytics library. */
+export interface RockMechGenerationOptions { tol?: number; maxIter?: number; }
+export interface RockMechGenerationResult { values: number[]; converged: boolean; }
+export function computeRockMechGeneration(data: number[], opts: RockMechGenerationOptions = {}): RockMechGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechGeneration };
diff --git a/src/rock_mech/geometry.ts b/src/rock_mech/geometry.ts
new file mode 100644
index 000000000..23b955223
--- /dev/null
+++ b/src/rock_mech/geometry.ts
@@ -0,0 +1,14 @@
+/** rock_mech geometry module — tsb analytics library. */
+export interface RockMechGeometryOptions { tol?: number; maxIter?: number; }
+export interface RockMechGeometryResult { values: number[]; converged: boolean; }
+export function computeRockMechGeometry(data: number[], opts: RockMechGeometryOptions = {}): RockMechGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechGeometry };
diff --git a/src/rock_mech/gradient.ts b/src/rock_mech/gradient.ts
new file mode 100644
index 000000000..66831f60a
--- /dev/null
+++ b/src/rock_mech/gradient.ts
@@ -0,0 +1,14 @@
+/** rock_mech gradient module — tsb analytics library. */
+export interface RockMechGradientOptions { tol?: number; maxIter?: number; }
+export interface RockMechGradientResult { values: number[]; converged: boolean; }
+export function computeRockMechGradient(data: number[], opts: RockMechGradientOptions = {}): RockMechGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechGradient };
diff --git a/src/rock_mech/hessian.ts b/src/rock_mech/hessian.ts
new file mode 100644
index 000000000..5cfb6ce1e
--- /dev/null
+++ b/src/rock_mech/hessian.ts
@@ -0,0 +1,14 @@
+/** rock_mech hessian module — tsb analytics library. */
+export interface RockMechHessianOptions { tol?: number; maxIter?: number; }
+export interface RockMechHessianResult { values: number[]; converged: boolean; }
+export function computeRockMechHessian(data: number[], opts: RockMechHessianOptions = {}): RockMechHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechHessian };
diff --git a/src/rock_mech/hypothesis.ts b/src/rock_mech/hypothesis.ts
new file mode 100644
index 000000000..f8b57ca86
--- /dev/null
+++ b/src/rock_mech/hypothesis.ts
@@ -0,0 +1,14 @@
+/** rock_mech hypothesis module — tsb analytics library. */
+export interface RockMechHypothesisOptions { tol?: number; maxIter?: number; }
+export interface RockMechHypothesisResult { values: number[]; converged: boolean; }
+export function computeRockMechHypothesis(data: number[], opts: RockMechHypothesisOptions = {}): RockMechHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechHypothesis };
diff --git a/src/rock_mech/inference.ts b/src/rock_mech/inference.ts
new file mode 100644
index 000000000..9d865e87c
--- /dev/null
+++ b/src/rock_mech/inference.ts
@@ -0,0 +1,14 @@
+/** rock_mech inference module — tsb analytics library. */
+export interface RockMechInferenceOptions { tol?: number; maxIter?: number; }
+export interface RockMechInferenceResult { values: number[]; converged: boolean; }
+export function computeRockMechInference(data: number[], opts: RockMechInferenceOptions = {}): RockMechInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechInference };
diff --git a/src/rock_mech/inference2.ts b/src/rock_mech/inference2.ts
new file mode 100644
index 000000000..dcd69ce79
--- /dev/null
+++ b/src/rock_mech/inference2.ts
@@ -0,0 +1,14 @@
+/** rock_mech inference2 module — tsb analytics library. */
+export interface RockMechInferenceOptions { tol?: number; maxIter?: number; }
+export interface RockMechInferenceResult { values: number[]; converged: boolean; }
+export function computeRockMechInference(data: number[], opts: RockMechInferenceOptions = {}): RockMechInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechInference };
diff --git a/src/rock_mech/integral.ts b/src/rock_mech/integral.ts
new file mode 100644
index 000000000..57ab9b443
--- /dev/null
+++ b/src/rock_mech/integral.ts
@@ -0,0 +1,14 @@
+/** rock_mech integral module — tsb analytics library. */
+export interface RockMechIntegralOptions { tol?: number; maxIter?: number; }
+export interface RockMechIntegralResult { values: number[]; converged: boolean; }
+export function computeRockMechIntegral(data: number[], opts: RockMechIntegralOptions = {}): RockMechIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechIntegral };
diff --git a/src/rock_mech/integration.ts b/src/rock_mech/integration.ts
new file mode 100644
index 000000000..ff4986714
--- /dev/null
+++ b/src/rock_mech/integration.ts
@@ -0,0 +1,14 @@
+/** rock_mech integration module — tsb analytics library. */
+export interface RockMechIntegrationOptions { tol?: number; maxIter?: number; }
+export interface RockMechIntegrationResult { values: number[]; converged: boolean; }
+export function computeRockMechIntegration(data: number[], opts: RockMechIntegrationOptions = {}): RockMechIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechIntegration };
diff --git a/src/rock_mech/interpolation.ts b/src/rock_mech/interpolation.ts
new file mode 100644
index 000000000..d527abe3b
--- /dev/null
+++ b/src/rock_mech/interpolation.ts
@@ -0,0 +1,14 @@
+/** rock_mech interpolation module — tsb analytics library. */
+export interface RockMechInterpolationOptions { tol?: number; maxIter?: number; }
+export interface RockMechInterpolationResult { values: number[]; converged: boolean; }
+export function computeRockMechInterpolation(data: number[], opts: RockMechInterpolationOptions = {}): RockMechInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechInterpolation };
diff --git a/src/rock_mech/jacobian.ts b/src/rock_mech/jacobian.ts
new file mode 100644
index 000000000..557670942
--- /dev/null
+++ b/src/rock_mech/jacobian.ts
@@ -0,0 +1,14 @@
+/** rock_mech jacobian module — tsb analytics library. */
+export interface RockMechJacobianOptions { tol?: number; maxIter?: number; }
+export interface RockMechJacobianResult { values: number[]; converged: boolean; }
+export function computeRockMechJacobian(data: number[], opts: RockMechJacobianOptions = {}): RockMechJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechJacobian };
diff --git a/src/rock_mech/kernel.ts b/src/rock_mech/kernel.ts
new file mode 100644
index 000000000..ee8f1054f
--- /dev/null
+++ b/src/rock_mech/kernel.ts
@@ -0,0 +1,14 @@
+/** rock_mech kernel module — tsb analytics library. */
+export interface RockMechKernelOptions { tol?: number; maxIter?: number; }
+export interface RockMechKernelResult { values: number[]; converged: boolean; }
+export function computeRockMechKernel(data: number[], opts: RockMechKernelOptions = {}): RockMechKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechKernel };
diff --git a/src/rock_mech/laplacian.ts b/src/rock_mech/laplacian.ts
new file mode 100644
index 000000000..df2051688
--- /dev/null
+++ b/src/rock_mech/laplacian.ts
@@ -0,0 +1,14 @@
+/** rock_mech laplacian module — tsb analytics library. */
+export interface RockMechLaplacianOptions { tol?: number; maxIter?: number; }
+export interface RockMechLaplacianResult { values: number[]; converged: boolean; }
+export function computeRockMechLaplacian(data: number[], opts: RockMechLaplacianOptions = {}): RockMechLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechLaplacian };
diff --git a/src/rock_mech/learning.ts b/src/rock_mech/learning.ts
new file mode 100644
index 000000000..5eb6a9703
--- /dev/null
+++ b/src/rock_mech/learning.ts
@@ -0,0 +1,14 @@
+/** rock_mech learning module — tsb analytics library. */
+export interface RockMechLearningOptions { tol?: number; maxIter?: number; }
+export interface RockMechLearningResult { values: number[]; converged: boolean; }
+export function computeRockMechLearning(data: number[], opts: RockMechLearningOptions = {}): RockMechLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechLearning };
diff --git a/src/rock_mech/linear.ts b/src/rock_mech/linear.ts
new file mode 100644
index 000000000..799cf5752
--- /dev/null
+++ b/src/rock_mech/linear.ts
@@ -0,0 +1,14 @@
+/** rock_mech linear module — tsb analytics library. */
+export interface RockMechLinearOptions { tol?: number; maxIter?: number; }
+export interface RockMechLinearResult { values: number[]; converged: boolean; }
+export function computeRockMechLinear(data: number[], opts: RockMechLinearOptions = {}): RockMechLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechLinear };
diff --git a/src/rock_mech/manifold.ts b/src/rock_mech/manifold.ts
new file mode 100644
index 000000000..8b7981e3b
--- /dev/null
+++ b/src/rock_mech/manifold.ts
@@ -0,0 +1,14 @@
+/** rock_mech manifold module — tsb analytics library. */
+export interface RockMechManifoldOptions { tol?: number; maxIter?: number; }
+export interface RockMechManifoldResult { values: number[]; converged: boolean; }
+export function computeRockMechManifold(data: number[], opts: RockMechManifoldOptions = {}): RockMechManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechManifold };
diff --git a/src/rock_mech/matching.ts b/src/rock_mech/matching.ts
new file mode 100644
index 000000000..0aae19133
--- /dev/null
+++ b/src/rock_mech/matching.ts
@@ -0,0 +1,14 @@
+/** rock_mech matching module — tsb analytics library. */
+export interface RockMechMatchingOptions { tol?: number; maxIter?: number; }
+export interface RockMechMatchingResult { values: number[]; converged: boolean; }
+export function computeRockMechMatching(data: number[], opts: RockMechMatchingOptions = {}): RockMechMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechMatching };
diff --git a/src/rock_mech/measurement.ts b/src/rock_mech/measurement.ts
new file mode 100644
index 000000000..eb340be13
--- /dev/null
+++ b/src/rock_mech/measurement.ts
@@ -0,0 +1,14 @@
+/** rock_mech measurement module — tsb analytics library. */
+export interface RockMechMeasurementOptions { tol?: number; maxIter?: number; }
+export interface RockMechMeasurementResult { values: number[]; converged: boolean; }
+export function computeRockMechMeasurement(data: number[], opts: RockMechMeasurementOptions = {}): RockMechMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechMeasurement };
diff --git a/src/rock_mech/metrics.ts b/src/rock_mech/metrics.ts
new file mode 100644
index 000000000..b2832a69f
--- /dev/null
+++ b/src/rock_mech/metrics.ts
@@ -0,0 +1,14 @@
+/** rock_mech metrics module — tsb analytics library. */
+export interface RockMechMetricsOptions { tol?: number; maxIter?: number; }
+export interface RockMechMetricsResult { values: number[]; converged: boolean; }
+export function computeRockMechMetrics(data: number[], opts: RockMechMetricsOptions = {}): RockMechMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechMetrics };
diff --git a/src/rock_mech/modeling.ts b/src/rock_mech/modeling.ts
new file mode 100644
index 000000000..6eddff5e5
--- /dev/null
+++ b/src/rock_mech/modeling.ts
@@ -0,0 +1,14 @@
+/** rock_mech modeling module — tsb analytics library. */
+export interface RockMechModelingOptions { tol?: number; maxIter?: number; }
+export interface RockMechModelingResult { values: number[]; converged: boolean; }
+export function computeRockMechModeling(data: number[], opts: RockMechModelingOptions = {}): RockMechModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechModeling };
diff --git a/src/rock_mech/monitoring.ts b/src/rock_mech/monitoring.ts
new file mode 100644
index 000000000..461e6ba61
--- /dev/null
+++ b/src/rock_mech/monitoring.ts
@@ -0,0 +1,14 @@
+/** rock_mech monitoring module — tsb analytics library. */
+export interface RockMechMonitoringOptions { tol?: number; maxIter?: number; }
+export interface RockMechMonitoringResult { values: number[]; converged: boolean; }
+export function computeRockMechMonitoring(data: number[], opts: RockMechMonitoringOptions = {}): RockMechMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechMonitoring };
diff --git a/src/rock_mech/nonlinear.ts b/src/rock_mech/nonlinear.ts
new file mode 100644
index 000000000..fb11755b6
--- /dev/null
+++ b/src/rock_mech/nonlinear.ts
@@ -0,0 +1,14 @@
+/** rock_mech nonlinear module — tsb analytics library. */
+export interface RockMechNonlinearOptions { tol?: number; maxIter?: number; }
+export interface RockMechNonlinearResult { values: number[]; converged: boolean; }
+export function computeRockMechNonlinear(data: number[], opts: RockMechNonlinearOptions = {}): RockMechNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechNonlinear };
diff --git a/src/rock_mech/normalization.ts b/src/rock_mech/normalization.ts
new file mode 100644
index 000000000..6a3af0098
--- /dev/null
+++ b/src/rock_mech/normalization.ts
@@ -0,0 +1,14 @@
+/** rock_mech normalization module — tsb analytics library. */
+export interface RockMechNormalizationOptions { tol?: number; maxIter?: number; }
+export interface RockMechNormalizationResult { values: number[]; converged: boolean; }
+export function computeRockMechNormalization(data: number[], opts: RockMechNormalizationOptions = {}): RockMechNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechNormalization };
diff --git a/src/rock_mech/optimization.ts b/src/rock_mech/optimization.ts
new file mode 100644
index 000000000..ac053e52b
--- /dev/null
+++ b/src/rock_mech/optimization.ts
@@ -0,0 +1,14 @@
+/** rock_mech optimization module — tsb analytics library. */
+export interface RockMechOptimizationOptions { tol?: number; maxIter?: number; }
+export interface RockMechOptimizationResult { values: number[]; converged: boolean; }
+export function computeRockMechOptimization(data: number[], opts: RockMechOptimizationOptions = {}): RockMechOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechOptimization };
diff --git a/src/rock_mech/patterns.ts b/src/rock_mech/patterns.ts
new file mode 100644
index 000000000..f4e3f10a4
--- /dev/null
+++ b/src/rock_mech/patterns.ts
@@ -0,0 +1,14 @@
+/** rock_mech patterns module — tsb analytics library. */
+export interface RockMechPatternsOptions { tol?: number; maxIter?: number; }
+export interface RockMechPatternsResult { values: number[]; converged: boolean; }
+export function computeRockMechPatterns(data: number[], opts: RockMechPatternsOptions = {}): RockMechPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechPatterns };
diff --git a/src/rock_mech/permutation.ts b/src/rock_mech/permutation.ts
new file mode 100644
index 000000000..0784a14b7
--- /dev/null
+++ b/src/rock_mech/permutation.ts
@@ -0,0 +1,14 @@
+/** rock_mech permutation module — tsb analytics library. */
+export interface RockMechPermutationOptions { tol?: number; maxIter?: number; }
+export interface RockMechPermutationResult { values: number[]; converged: boolean; }
+export function computeRockMechPermutation(data: number[], opts: RockMechPermutationOptions = {}): RockMechPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechPermutation };
diff --git a/src/rock_mech/prediction.ts b/src/rock_mech/prediction.ts
new file mode 100644
index 000000000..8b27bcb94
--- /dev/null
+++ b/src/rock_mech/prediction.ts
@@ -0,0 +1,14 @@
+/** rock_mech prediction module — tsb analytics library. */
+export interface RockMechPredictionOptions { tol?: number; maxIter?: number; }
+export interface RockMechPredictionResult { values: number[]; converged: boolean; }
+export function computeRockMechPrediction(data: number[], opts: RockMechPredictionOptions = {}): RockMechPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechPrediction };
diff --git a/src/rock_mech/processing.ts b/src/rock_mech/processing.ts
new file mode 100644
index 000000000..9eec4c78c
--- /dev/null
+++ b/src/rock_mech/processing.ts
@@ -0,0 +1,14 @@
+/** rock_mech processing module — tsb analytics library. */
+export interface RockMechProcessingOptions { tol?: number; maxIter?: number; }
+export interface RockMechProcessingResult { values: number[]; converged: boolean; }
+export function computeRockMechProcessing(data: number[], opts: RockMechProcessingOptions = {}): RockMechProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechProcessing };
diff --git a/src/rock_mech/profiling.ts b/src/rock_mech/profiling.ts
new file mode 100644
index 000000000..fcb9b3dba
--- /dev/null
+++ b/src/rock_mech/profiling.ts
@@ -0,0 +1,14 @@
+/** rock_mech profiling module — tsb analytics library. */
+export interface RockMechProfilingOptions { tol?: number; maxIter?: number; }
+export interface RockMechProfilingResult { values: number[]; converged: boolean; }
+export function computeRockMechProfiling(data: number[], opts: RockMechProfilingOptions = {}): RockMechProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechProfiling };
diff --git a/src/rock_mech/projection.ts b/src/rock_mech/projection.ts
new file mode 100644
index 000000000..a7df6108e
--- /dev/null
+++ b/src/rock_mech/projection.ts
@@ -0,0 +1,14 @@
+/** rock_mech projection module — tsb analytics library. */
+export interface RockMechProjectionOptions { tol?: number; maxIter?: number; }
+export interface RockMechProjectionResult { values: number[]; converged: boolean; }
+export function computeRockMechProjection(data: number[], opts: RockMechProjectionOptions = {}): RockMechProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechProjection };
diff --git a/src/rock_mech/ranking.ts b/src/rock_mech/ranking.ts
new file mode 100644
index 000000000..bea336df1
--- /dev/null
+++ b/src/rock_mech/ranking.ts
@@ -0,0 +1,14 @@
+/** rock_mech ranking module — tsb analytics library. */
+export interface RockMechRankingOptions { tol?: number; maxIter?: number; }
+export interface RockMechRankingResult { values: number[]; converged: boolean; }
+export function computeRockMechRanking(data: number[], opts: RockMechRankingOptions = {}): RockMechRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechRanking };
diff --git a/src/rock_mech/reconstruction.ts b/src/rock_mech/reconstruction.ts
new file mode 100644
index 000000000..3a4f6bd1e
--- /dev/null
+++ b/src/rock_mech/reconstruction.ts
@@ -0,0 +1,14 @@
+/** rock_mech reconstruction module — tsb analytics library. */
+export interface RockMechReconstructionOptions { tol?: number; maxIter?: number; }
+export interface RockMechReconstructionResult { values: number[]; converged: boolean; }
+export function computeRockMechReconstruction(data: number[], opts: RockMechReconstructionOptions = {}): RockMechReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechReconstruction };
diff --git a/src/rock_mech/registration.ts b/src/rock_mech/registration.ts
new file mode 100644
index 000000000..6292189bc
--- /dev/null
+++ b/src/rock_mech/registration.ts
@@ -0,0 +1,14 @@
+/** rock_mech registration module — tsb analytics library. */
+export interface RockMechRegistrationOptions { tol?: number; maxIter?: number; }
+export interface RockMechRegistrationResult { values: number[]; converged: boolean; }
+export function computeRockMechRegistration(data: number[], opts: RockMechRegistrationOptions = {}): RockMechRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechRegistration };
diff --git a/src/rock_mech/regression.ts b/src/rock_mech/regression.ts
new file mode 100644
index 000000000..37c3e3318
--- /dev/null
+++ b/src/rock_mech/regression.ts
@@ -0,0 +1,14 @@
+/** rock_mech regression module — tsb analytics library. */
+export interface RockMechRegressionOptions { tol?: number; maxIter?: number; }
+export interface RockMechRegressionResult { values: number[]; converged: boolean; }
+export function computeRockMechRegression(data: number[], opts: RockMechRegressionOptions = {}): RockMechRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechRegression };
diff --git a/src/rock_mech/regularization.ts b/src/rock_mech/regularization.ts
new file mode 100644
index 000000000..20d67bc59
--- /dev/null
+++ b/src/rock_mech/regularization.ts
@@ -0,0 +1,14 @@
+/** rock_mech regularization module — tsb analytics library. */
+export interface RockMechRegularizationOptions { tol?: number; maxIter?: number; }
+export interface RockMechRegularizationResult { values: number[]; converged: boolean; }
+export function computeRockMechRegularization(data: number[], opts: RockMechRegularizationOptions = {}): RockMechRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechRegularization };
diff --git a/src/rock_mech/robustness.ts b/src/rock_mech/robustness.ts
new file mode 100644
index 000000000..b73360a4d
--- /dev/null
+++ b/src/rock_mech/robustness.ts
@@ -0,0 +1,14 @@
+/** rock_mech robustness module — tsb analytics library. */
+export interface RockMechRobustnessOptions { tol?: number; maxIter?: number; }
+export interface RockMechRobustnessResult { values: number[]; converged: boolean; }
+export function computeRockMechRobustness(data: number[], opts: RockMechRobustnessOptions = {}): RockMechRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechRobustness };
diff --git a/src/rock_mech/sampling.ts b/src/rock_mech/sampling.ts
new file mode 100644
index 000000000..bf7d92d6c
--- /dev/null
+++ b/src/rock_mech/sampling.ts
@@ -0,0 +1,14 @@
+/** rock_mech sampling module — tsb analytics library. */
+export interface RockMechSamplingOptions { tol?: number; maxIter?: number; }
+export interface RockMechSamplingResult { values: number[]; converged: boolean; }
+export function computeRockMechSampling(data: number[], opts: RockMechSamplingOptions = {}): RockMechSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechSampling };
diff --git a/src/rock_mech/sampling2.ts b/src/rock_mech/sampling2.ts
new file mode 100644
index 000000000..6de3ef8bf
--- /dev/null
+++ b/src/rock_mech/sampling2.ts
@@ -0,0 +1,14 @@
+/** rock_mech sampling2 module — tsb analytics library. */
+export interface RockMechSamplingOptions { tol?: number; maxIter?: number; }
+export interface RockMechSamplingResult { values: number[]; converged: boolean; }
+export function computeRockMechSampling(data: number[], opts: RockMechSamplingOptions = {}): RockMechSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechSampling };
diff --git a/src/rock_mech/scaling.ts b/src/rock_mech/scaling.ts
new file mode 100644
index 000000000..e2f6943ca
--- /dev/null
+++ b/src/rock_mech/scaling.ts
@@ -0,0 +1,14 @@
+/** rock_mech scaling module — tsb analytics library. */
+export interface RockMechScalingOptions { tol?: number; maxIter?: number; }
+export interface RockMechScalingResult { values: number[]; converged: boolean; }
+export function computeRockMechScaling(data: number[], opts: RockMechScalingOptions = {}): RockMechScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechScaling };
diff --git a/src/rock_mech/scoring.ts b/src/rock_mech/scoring.ts
new file mode 100644
index 000000000..cc2e5515d
--- /dev/null
+++ b/src/rock_mech/scoring.ts
@@ -0,0 +1,14 @@
+/** rock_mech scoring module — tsb analytics library. */
+export interface RockMechScoringOptions { tol?: number; maxIter?: number; }
+export interface RockMechScoringResult { values: number[]; converged: boolean; }
+export function computeRockMechScoring(data: number[], opts: RockMechScoringOptions = {}): RockMechScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechScoring };
diff --git a/src/rock_mech/segmentation.ts b/src/rock_mech/segmentation.ts
new file mode 100644
index 000000000..00fbe7da2
--- /dev/null
+++ b/src/rock_mech/segmentation.ts
@@ -0,0 +1,14 @@
+/** rock_mech segmentation module — tsb analytics library. */
+export interface RockMechSegmentationOptions { tol?: number; maxIter?: number; }
+export interface RockMechSegmentationResult { values: number[]; converged: boolean; }
+export function computeRockMechSegmentation(data: number[], opts: RockMechSegmentationOptions = {}): RockMechSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechSegmentation };
diff --git a/src/rock_mech/selection.ts b/src/rock_mech/selection.ts
new file mode 100644
index 000000000..d07762cb6
--- /dev/null
+++ b/src/rock_mech/selection.ts
@@ -0,0 +1,14 @@
+/** rock_mech selection module — tsb analytics library. */
+export interface RockMechSelectionOptions { tol?: number; maxIter?: number; }
+export interface RockMechSelectionResult { values: number[]; converged: boolean; }
+export function computeRockMechSelection(data: number[], opts: RockMechSelectionOptions = {}): RockMechSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechSelection };
diff --git a/src/rock_mech/sensitivity.ts b/src/rock_mech/sensitivity.ts
new file mode 100644
index 000000000..1ca7b4495
--- /dev/null
+++ b/src/rock_mech/sensitivity.ts
@@ -0,0 +1,14 @@
+/** rock_mech sensitivity module — tsb analytics library. */
+export interface RockMechSensitivityOptions { tol?: number; maxIter?: number; }
+export interface RockMechSensitivityResult { values: number[]; converged: boolean; }
+export function computeRockMechSensitivity(data: number[], opts: RockMechSensitivityOptions = {}): RockMechSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechSensitivity };
diff --git a/src/rock_mech/simulation.ts b/src/rock_mech/simulation.ts
new file mode 100644
index 000000000..9b187a336
--- /dev/null
+++ b/src/rock_mech/simulation.ts
@@ -0,0 +1,14 @@
+/** rock_mech simulation module — tsb analytics library. */
+export interface RockMechSimulationOptions { tol?: number; maxIter?: number; }
+export interface RockMechSimulationResult { values: number[]; converged: boolean; }
+export function computeRockMechSimulation(data: number[], opts: RockMechSimulationOptions = {}): RockMechSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechSimulation };
diff --git a/src/rock_mech/smoothing.ts b/src/rock_mech/smoothing.ts
new file mode 100644
index 000000000..718250eea
--- /dev/null
+++ b/src/rock_mech/smoothing.ts
@@ -0,0 +1,14 @@
+/** rock_mech smoothing module — tsb analytics library. */
+export interface RockMechSmoothingOptions { tol?: number; maxIter?: number; }
+export interface RockMechSmoothingResult { values: number[]; converged: boolean; }
+export function computeRockMechSmoothing(data: number[], opts: RockMechSmoothingOptions = {}): RockMechSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechSmoothing };
diff --git a/src/rock_mech/stability.ts b/src/rock_mech/stability.ts
new file mode 100644
index 000000000..70c6faa00
--- /dev/null
+++ b/src/rock_mech/stability.ts
@@ -0,0 +1,14 @@
+/** rock_mech stability module — tsb analytics library. */
+export interface RockMechStabilityOptions { tol?: number; maxIter?: number; }
+export interface RockMechStabilityResult { values: number[]; converged: boolean; }
+export function computeRockMechStability(data: number[], opts: RockMechStabilityOptions = {}): RockMechStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechStability };
diff --git a/src/rock_mech/stacking.ts b/src/rock_mech/stacking.ts
new file mode 100644
index 000000000..236dbd6d0
--- /dev/null
+++ b/src/rock_mech/stacking.ts
@@ -0,0 +1,14 @@
+/** rock_mech stacking module — tsb analytics library. */
+export interface RockMechStackingOptions { tol?: number; maxIter?: number; }
+export interface RockMechStackingResult { values: number[]; converged: boolean; }
+export function computeRockMechStacking(data: number[], opts: RockMechStackingOptions = {}): RockMechStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechStacking };
diff --git a/src/rock_mech/standardization.ts b/src/rock_mech/standardization.ts
new file mode 100644
index 000000000..eb9d2d555
--- /dev/null
+++ b/src/rock_mech/standardization.ts
@@ -0,0 +1,14 @@
+/** rock_mech standardization module — tsb analytics library. */
+export interface RockMechStandardizationOptions { tol?: number; maxIter?: number; }
+export interface RockMechStandardizationResult { values: number[]; converged: boolean; }
+export function computeRockMechStandardization(data: number[], opts: RockMechStandardizationOptions = {}): RockMechStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechStandardization };
diff --git a/src/rock_mech/static.ts b/src/rock_mech/static.ts
new file mode 100644
index 000000000..37baff65d
--- /dev/null
+++ b/src/rock_mech/static.ts
@@ -0,0 +1,14 @@
+/** rock_mech static module — tsb analytics library. */
+export interface RockMechStaticOptions { tol?: number; maxIter?: number; }
+export interface RockMechStaticResult { values: number[]; converged: boolean; }
+export function computeRockMechStatic(data: number[], opts: RockMechStaticOptions = {}): RockMechStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechStatic };
diff --git a/src/rock_mech/stochastic.ts b/src/rock_mech/stochastic.ts
new file mode 100644
index 000000000..65d386901
--- /dev/null
+++ b/src/rock_mech/stochastic.ts
@@ -0,0 +1,14 @@
+/** rock_mech stochastic module — tsb analytics library. */
+export interface RockMechStochasticOptions { tol?: number; maxIter?: number; }
+export interface RockMechStochasticResult { values: number[]; converged: boolean; }
+export function computeRockMechStochastic(data: number[], opts: RockMechStochasticOptions = {}): RockMechStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechStochastic };
diff --git a/src/rock_mech/synthesis.ts b/src/rock_mech/synthesis.ts
new file mode 100644
index 000000000..0fdaa5fa0
--- /dev/null
+++ b/src/rock_mech/synthesis.ts
@@ -0,0 +1,14 @@
+/** rock_mech synthesis module — tsb analytics library. */
+export interface RockMechSynthesisOptions { tol?: number; maxIter?: number; }
+export interface RockMechSynthesisResult { values: number[]; converged: boolean; }
+export function computeRockMechSynthesis(data: number[], opts: RockMechSynthesisOptions = {}): RockMechSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechSynthesis };
diff --git a/src/rock_mech/topology.ts b/src/rock_mech/topology.ts
new file mode 100644
index 000000000..d49ce05b9
--- /dev/null
+++ b/src/rock_mech/topology.ts
@@ -0,0 +1,14 @@
+/** rock_mech topology module — tsb analytics library. */
+export interface RockMechTopologyOptions { tol?: number; maxIter?: number; }
+export interface RockMechTopologyResult { values: number[]; converged: boolean; }
+export function computeRockMechTopology(data: number[], opts: RockMechTopologyOptions = {}): RockMechTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechTopology };
diff --git a/src/rock_mech/tracking.ts b/src/rock_mech/tracking.ts
new file mode 100644
index 000000000..9b7db87da
--- /dev/null
+++ b/src/rock_mech/tracking.ts
@@ -0,0 +1,14 @@
+/** rock_mech tracking module — tsb analytics library. */
+export interface RockMechTrackingOptions { tol?: number; maxIter?: number; }
+export interface RockMechTrackingResult { values: number[]; converged: boolean; }
+export function computeRockMechTracking(data: number[], opts: RockMechTrackingOptions = {}): RockMechTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechTracking };
diff --git a/src/rock_mech/transform.ts b/src/rock_mech/transform.ts
new file mode 100644
index 000000000..26f466b56
--- /dev/null
+++ b/src/rock_mech/transform.ts
@@ -0,0 +1,14 @@
+/** rock_mech transform module — tsb analytics library. */
+export interface RockMechTransformOptions { tol?: number; maxIter?: number; }
+export interface RockMechTransformResult { values: number[]; converged: boolean; }
+export function computeRockMechTransform(data: number[], opts: RockMechTransformOptions = {}): RockMechTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechTransform };
diff --git a/src/rock_mech/uncertainty.ts b/src/rock_mech/uncertainty.ts
new file mode 100644
index 000000000..503950bbd
--- /dev/null
+++ b/src/rock_mech/uncertainty.ts
@@ -0,0 +1,14 @@
+/** rock_mech uncertainty module — tsb analytics library. */
+export interface RockMechUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface RockMechUncertaintyResult { values: number[]; converged: boolean; }
+export function computeRockMechUncertainty(data: number[], opts: RockMechUncertaintyOptions = {}): RockMechUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechUncertainty };
diff --git a/src/rock_mech/validation.ts b/src/rock_mech/validation.ts
new file mode 100644
index 000000000..eaecf26c9
--- /dev/null
+++ b/src/rock_mech/validation.ts
@@ -0,0 +1,14 @@
+/** rock_mech validation module — tsb analytics library. */
+export interface RockMechValidationOptions { tol?: number; maxIter?: number; }
+export interface RockMechValidationResult { values: number[]; converged: boolean; }
+export function computeRockMechValidation(data: number[], opts: RockMechValidationOptions = {}): RockMechValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechValidation };
diff --git a/src/rock_mech/verification.ts b/src/rock_mech/verification.ts
new file mode 100644
index 000000000..f65ec6073
--- /dev/null
+++ b/src/rock_mech/verification.ts
@@ -0,0 +1,14 @@
+/** rock_mech verification module — tsb analytics library. */
+export interface RockMechVerificationOptions { tol?: number; maxIter?: number; }
+export interface RockMechVerificationResult { values: number[]; converged: boolean; }
+export function computeRockMechVerification(data: number[], opts: RockMechVerificationOptions = {}): RockMechVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechVerification };
diff --git a/src/rock_mech/visualization.ts b/src/rock_mech/visualization.ts
new file mode 100644
index 000000000..89531ea35
--- /dev/null
+++ b/src/rock_mech/visualization.ts
@@ -0,0 +1,14 @@
+/** rock_mech visualization module — tsb analytics library. */
+export interface RockMechVisualizationOptions { tol?: number; maxIter?: number; }
+export interface RockMechVisualizationResult { values: number[]; converged: boolean; }
+export function computeRockMechVisualization(data: number[], opts: RockMechVisualizationOptions = {}): RockMechVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechVisualization };
diff --git a/src/rock_mech/voting.ts b/src/rock_mech/voting.ts
new file mode 100644
index 000000000..46a477420
--- /dev/null
+++ b/src/rock_mech/voting.ts
@@ -0,0 +1,14 @@
+/** rock_mech voting module — tsb analytics library. */
+export interface RockMechVotingOptions { tol?: number; maxIter?: number; }
+export interface RockMechVotingResult { values: number[]; converged: boolean; }
+export function computeRockMechVoting(data: number[], opts: RockMechVotingOptions = {}): RockMechVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechVoting };
diff --git a/src/rock_mech/wavelet.ts b/src/rock_mech/wavelet.ts
new file mode 100644
index 000000000..dd80367bc
--- /dev/null
+++ b/src/rock_mech/wavelet.ts
@@ -0,0 +1,14 @@
+/** rock_mech wavelet module — tsb analytics library. */
+export interface RockMechWaveletOptions { tol?: number; maxIter?: number; }
+export interface RockMechWaveletResult { values: number[]; converged: boolean; }
+export function computeRockMechWavelet(data: number[], opts: RockMechWaveletOptions = {}): RockMechWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRockMechWavelet };
diff --git a/src/rubber_sci/adaptation.ts b/src/rubber_sci/adaptation.ts
new file mode 100644
index 000000000..451fee720
--- /dev/null
+++ b/src/rubber_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci adaptation module — tsb analytics library. */
+export interface RubberSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeRubberSciAdaptation(data: number[], opts: RubberSciAdaptationOptions = {}): RubberSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciAdaptation };
diff --git a/src/rubber_sci/aggregation.ts b/src/rubber_sci/aggregation.ts
new file mode 100644
index 000000000..0d52c72cf
--- /dev/null
+++ b/src/rubber_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci aggregation module — tsb analytics library. */
+export interface RubberSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciAggregationResult { values: number[]; converged: boolean; }
+export function computeRubberSciAggregation(data: number[], opts: RubberSciAggregationOptions = {}): RubberSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciAggregation };
diff --git a/src/rubber_sci/algebra.ts b/src/rubber_sci/algebra.ts
new file mode 100644
index 000000000..4432d46d9
--- /dev/null
+++ b/src/rubber_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** rubber_sci algebra module — tsb analytics library. */
+export interface RubberSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface RubberSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeRubberSciAlgebra(data: number[], opts: RubberSciAlgebraOptions = {}): RubberSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciAlgebra };
diff --git a/src/rubber_sci/alignment.ts b/src/rubber_sci/alignment.ts
new file mode 100644
index 000000000..6878a82ef
--- /dev/null
+++ b/src/rubber_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** rubber_sci alignment module — tsb analytics library. */
+export interface RubberSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface RubberSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeRubberSciAlignment(data: number[], opts: RubberSciAlignmentOptions = {}): RubberSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciAlignment };
diff --git a/src/rubber_sci/analysis.ts b/src/rubber_sci/analysis.ts
new file mode 100644
index 000000000..437763a3d
--- /dev/null
+++ b/src/rubber_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** rubber_sci analysis module — tsb analytics library. */
+export interface RubberSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface RubberSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeRubberSciAnalysis(data: number[], opts: RubberSciAnalysisOptions = {}): RubberSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciAnalysis };
diff --git a/src/rubber_sci/augmentation.ts b/src/rubber_sci/augmentation.ts
new file mode 100644
index 000000000..f92619c07
--- /dev/null
+++ b/src/rubber_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci augmentation module — tsb analytics library. */
+export interface RubberSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeRubberSciAugmentation(data: number[], opts: RubberSciAugmentationOptions = {}): RubberSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciAugmentation };
diff --git a/src/rubber_sci/bagging.ts b/src/rubber_sci/bagging.ts
new file mode 100644
index 000000000..5b92227c4
--- /dev/null
+++ b/src/rubber_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** rubber_sci bagging module — tsb analytics library. */
+export interface RubberSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciBaggingResult { values: number[]; converged: boolean; }
+export function computeRubberSciBagging(data: number[], opts: RubberSciBaggingOptions = {}): RubberSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciBagging };
diff --git a/src/rubber_sci/basis.ts b/src/rubber_sci/basis.ts
new file mode 100644
index 000000000..4e4f3e7b1
--- /dev/null
+++ b/src/rubber_sci/basis.ts
@@ -0,0 +1,14 @@
+/** rubber_sci basis module — tsb analytics library. */
+export interface RubberSciBasisOptions { tol?: number; maxIter?: number; }
+export interface RubberSciBasisResult { values: number[]; converged: boolean; }
+export function computeRubberSciBasis(data: number[], opts: RubberSciBasisOptions = {}): RubberSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciBasis };
diff --git a/src/rubber_sci/benchmarking.ts b/src/rubber_sci/benchmarking.ts
new file mode 100644
index 000000000..707574359
--- /dev/null
+++ b/src/rubber_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** rubber_sci benchmarking module — tsb analytics library. */
+export interface RubberSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeRubberSciBenchmarking(data: number[], opts: RubberSciBenchmarkingOptions = {}): RubberSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciBenchmarking };
diff --git a/src/rubber_sci/blending.ts b/src/rubber_sci/blending.ts
new file mode 100644
index 000000000..4d06edf0d
--- /dev/null
+++ b/src/rubber_sci/blending.ts
@@ -0,0 +1,14 @@
+/** rubber_sci blending module — tsb analytics library. */
+export interface RubberSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciBlendingResult { values: number[]; converged: boolean; }
+export function computeRubberSciBlending(data: number[], opts: RubberSciBlendingOptions = {}): RubberSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciBlending };
diff --git a/src/rubber_sci/boosting.ts b/src/rubber_sci/boosting.ts
new file mode 100644
index 000000000..fc551c7c2
--- /dev/null
+++ b/src/rubber_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** rubber_sci boosting module — tsb analytics library. */
+export interface RubberSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciBoostingResult { values: number[]; converged: boolean; }
+export function computeRubberSciBoosting(data: number[], opts: RubberSciBoostingOptions = {}): RubberSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciBoosting };
diff --git a/src/rubber_sci/bootstrap.ts b/src/rubber_sci/bootstrap.ts
new file mode 100644
index 000000000..4cfc84c1c
--- /dev/null
+++ b/src/rubber_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** rubber_sci bootstrap module — tsb analytics library. */
+export interface RubberSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface RubberSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeRubberSciBootstrap(data: number[], opts: RubberSciBootstrapOptions = {}): RubberSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciBootstrap };
diff --git a/src/rubber_sci/calculus.ts b/src/rubber_sci/calculus.ts
new file mode 100644
index 000000000..5d5022e32
--- /dev/null
+++ b/src/rubber_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** rubber_sci calculus module — tsb analytics library. */
+export interface RubberSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface RubberSciCalculusResult { values: number[]; converged: boolean; }
+export function computeRubberSciCalculus(data: number[], opts: RubberSciCalculusOptions = {}): RubberSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciCalculus };
diff --git a/src/rubber_sci/calibration.ts b/src/rubber_sci/calibration.ts
new file mode 100644
index 000000000..69ce7219a
--- /dev/null
+++ b/src/rubber_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** rubber_sci calibration module — tsb analytics library. */
+export interface RubberSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeRubberSciCalibration(data: number[], opts: RubberSciCalibrationOptions = {}): RubberSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciCalibration };
diff --git a/src/rubber_sci/characterization.ts b/src/rubber_sci/characterization.ts
new file mode 100644
index 000000000..44ef4f9f5
--- /dev/null
+++ b/src/rubber_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** rubber_sci characterization module — tsb analytics library. */
+export interface RubberSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeRubberSciCharacterization(data: number[], opts: RubberSciCharacterizationOptions = {}): RubberSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciCharacterization };
diff --git a/src/rubber_sci/classification.ts b/src/rubber_sci/classification.ts
new file mode 100644
index 000000000..894375d6f
--- /dev/null
+++ b/src/rubber_sci/classification.ts
@@ -0,0 +1,14 @@
+/** rubber_sci classification module — tsb analytics library. */
+export interface RubberSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciClassificationResult { values: number[]; converged: boolean; }
+export function computeRubberSciClassification(data: number[], opts: RubberSciClassificationOptions = {}): RubberSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciClassification };
diff --git a/src/rubber_sci/clustering.ts b/src/rubber_sci/clustering.ts
new file mode 100644
index 000000000..d128e9158
--- /dev/null
+++ b/src/rubber_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** rubber_sci clustering module — tsb analytics library. */
+export interface RubberSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface RubberSciClusteringResult { values: number[]; converged: boolean; }
+export function computeRubberSciClustering(data: number[], opts: RubberSciClusteringOptions = {}): RubberSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciClustering };
diff --git a/src/rubber_sci/compression.ts b/src/rubber_sci/compression.ts
new file mode 100644
index 000000000..f68e8d42e
--- /dev/null
+++ b/src/rubber_sci/compression.ts
@@ -0,0 +1,14 @@
+/** rubber_sci compression module — tsb analytics library. */
+export interface RubberSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciCompressionResult { values: number[]; converged: boolean; }
+export function computeRubberSciCompression(data: number[], opts: RubberSciCompressionOptions = {}): RubberSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciCompression };
diff --git a/src/rubber_sci/continuous.ts b/src/rubber_sci/continuous.ts
new file mode 100644
index 000000000..2804f384a
--- /dev/null
+++ b/src/rubber_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** rubber_sci continuous module — tsb analytics library. */
+export interface RubberSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface RubberSciContinuousResult { values: number[]; converged: boolean; }
+export function computeRubberSciContinuous(data: number[], opts: RubberSciContinuousOptions = {}): RubberSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciContinuous };
diff --git a/src/rubber_sci/control.ts b/src/rubber_sci/control.ts
new file mode 100644
index 000000000..464b3e1d3
--- /dev/null
+++ b/src/rubber_sci/control.ts
@@ -0,0 +1,14 @@
+/** rubber_sci control module — tsb analytics library. */
+export interface RubberSciControlOptions { tol?: number; maxIter?: number; }
+export interface RubberSciControlResult { values: number[]; converged: boolean; }
+export function computeRubberSciControl(data: number[], opts: RubberSciControlOptions = {}): RubberSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciControl };
diff --git a/src/rubber_sci/convergence.ts b/src/rubber_sci/convergence.ts
new file mode 100644
index 000000000..7cd1c4e72
--- /dev/null
+++ b/src/rubber_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** rubber_sci convergence module — tsb analytics library. */
+export interface RubberSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface RubberSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeRubberSciConvergence(data: number[], opts: RubberSciConvergenceOptions = {}): RubberSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciConvergence };
diff --git a/src/rubber_sci/convex.ts b/src/rubber_sci/convex.ts
new file mode 100644
index 000000000..1ac33d480
--- /dev/null
+++ b/src/rubber_sci/convex.ts
@@ -0,0 +1,14 @@
+/** rubber_sci convex module — tsb analytics library. */
+export interface RubberSciConvexOptions { tol?: number; maxIter?: number; }
+export interface RubberSciConvexResult { values: number[]; converged: boolean; }
+export function computeRubberSciConvex(data: number[], opts: RubberSciConvexOptions = {}): RubberSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciConvex };
diff --git a/src/rubber_sci/correlation.ts b/src/rubber_sci/correlation.ts
new file mode 100644
index 000000000..1bceb442d
--- /dev/null
+++ b/src/rubber_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci correlation module — tsb analytics library. */
+export interface RubberSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeRubberSciCorrelation(data: number[], opts: RubberSciCorrelationOptions = {}): RubberSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciCorrelation };
diff --git a/src/rubber_sci/covariance.ts b/src/rubber_sci/covariance.ts
new file mode 100644
index 000000000..5a8f35432
--- /dev/null
+++ b/src/rubber_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** rubber_sci covariance module — tsb analytics library. */
+export interface RubberSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface RubberSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeRubberSciCovariance(data: number[], opts: RubberSciCovarianceOptions = {}): RubberSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciCovariance };
diff --git a/src/rubber_sci/cross_validation.ts b/src/rubber_sci/cross_validation.ts
new file mode 100644
index 000000000..4aaaf3a31
--- /dev/null
+++ b/src/rubber_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci cross_validation module — tsb analytics library. */
+export interface RubberSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeRubberSciCrossValidation(data: number[], opts: RubberSciCrossValidationOptions = {}): RubberSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciCrossValidation };
diff --git a/src/rubber_sci/decoding.ts b/src/rubber_sci/decoding.ts
new file mode 100644
index 000000000..9312f845a
--- /dev/null
+++ b/src/rubber_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** rubber_sci decoding module — tsb analytics library. */
+export interface RubberSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDecodingResult { values: number[]; converged: boolean; }
+export function computeRubberSciDecoding(data: number[], opts: RubberSciDecodingOptions = {}): RubberSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDecoding };
diff --git a/src/rubber_sci/decomposition.ts b/src/rubber_sci/decomposition.ts
new file mode 100644
index 000000000..97ec64686
--- /dev/null
+++ b/src/rubber_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** rubber_sci decomposition module — tsb analytics library. */
+export interface RubberSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeRubberSciDecomposition(data: number[], opts: RubberSciDecompositionOptions = {}): RubberSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDecomposition };
diff --git a/src/rubber_sci/detection.ts b/src/rubber_sci/detection.ts
new file mode 100644
index 000000000..51fd60335
--- /dev/null
+++ b/src/rubber_sci/detection.ts
@@ -0,0 +1,14 @@
+/** rubber_sci detection module — tsb analytics library. */
+export interface RubberSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDetectionResult { values: number[]; converged: boolean; }
+export function computeRubberSciDetection(data: number[], opts: RubberSciDetectionOptions = {}): RubberSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDetection };
diff --git a/src/rubber_sci/deterministic.ts b/src/rubber_sci/deterministic.ts
new file mode 100644
index 000000000..3e57c34a2
--- /dev/null
+++ b/src/rubber_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** rubber_sci deterministic module — tsb analytics library. */
+export interface RubberSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeRubberSciDeterministic(data: number[], opts: RubberSciDeterministicOptions = {}): RubberSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDeterministic };
diff --git a/src/rubber_sci/diagnostics.ts b/src/rubber_sci/diagnostics.ts
new file mode 100644
index 000000000..52fe2fc2c
--- /dev/null
+++ b/src/rubber_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** rubber_sci diagnostics module — tsb analytics library. */
+export interface RubberSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeRubberSciDiagnostics(data: number[], opts: RubberSciDiagnosticsOptions = {}): RubberSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDiagnostics };
diff --git a/src/rubber_sci/differential.ts b/src/rubber_sci/differential.ts
new file mode 100644
index 000000000..a6071b80a
--- /dev/null
+++ b/src/rubber_sci/differential.ts
@@ -0,0 +1,14 @@
+/** rubber_sci differential module — tsb analytics library. */
+export interface RubberSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeRubberSciDifferential(data: number[], opts: RubberSciDifferentialOptions = {}): RubberSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDifferential };
diff --git a/src/rubber_sci/discrete.ts b/src/rubber_sci/discrete.ts
new file mode 100644
index 000000000..7d60c9e99
--- /dev/null
+++ b/src/rubber_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** rubber_sci discrete module — tsb analytics library. */
+export interface RubberSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeRubberSciDiscrete(data: number[], opts: RubberSciDiscreteOptions = {}): RubberSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDiscrete };
diff --git a/src/rubber_sci/distribution.ts b/src/rubber_sci/distribution.ts
new file mode 100644
index 000000000..47eab01b2
--- /dev/null
+++ b/src/rubber_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** rubber_sci distribution module — tsb analytics library. */
+export interface RubberSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDistributionResult { values: number[]; converged: boolean; }
+export function computeRubberSciDistribution(data: number[], opts: RubberSciDistributionOptions = {}): RubberSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDistribution };
diff --git a/src/rubber_sci/dynamic.ts b/src/rubber_sci/dynamic.ts
new file mode 100644
index 000000000..9f04a9e4c
--- /dev/null
+++ b/src/rubber_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** rubber_sci dynamic module — tsb analytics library. */
+export interface RubberSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface RubberSciDynamicResult { values: number[]; converged: boolean; }
+export function computeRubberSciDynamic(data: number[], opts: RubberSciDynamicOptions = {}): RubberSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciDynamic };
diff --git a/src/rubber_sci/embedding.ts b/src/rubber_sci/embedding.ts
new file mode 100644
index 000000000..84d75fc10
--- /dev/null
+++ b/src/rubber_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** rubber_sci embedding module — tsb analytics library. */
+export interface RubberSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeRubberSciEmbedding(data: number[], opts: RubberSciEmbeddingOptions = {}): RubberSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciEmbedding };
diff --git a/src/rubber_sci/encoding.ts b/src/rubber_sci/encoding.ts
new file mode 100644
index 000000000..f4252252b
--- /dev/null
+++ b/src/rubber_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** rubber_sci encoding module — tsb analytics library. */
+export interface RubberSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciEncodingResult { values: number[]; converged: boolean; }
+export function computeRubberSciEncoding(data: number[], opts: RubberSciEncodingOptions = {}): RubberSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciEncoding };
diff --git a/src/rubber_sci/ensemble.ts b/src/rubber_sci/ensemble.ts
new file mode 100644
index 000000000..cd5b577cd
--- /dev/null
+++ b/src/rubber_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** rubber_sci ensemble module — tsb analytics library. */
+export interface RubberSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface RubberSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeRubberSciEnsemble(data: number[], opts: RubberSciEnsembleOptions = {}): RubberSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciEnsemble };
diff --git a/src/rubber_sci/estimation.ts b/src/rubber_sci/estimation.ts
new file mode 100644
index 000000000..0222ea9e4
--- /dev/null
+++ b/src/rubber_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci estimation module — tsb analytics library. */
+export interface RubberSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciEstimationResult { values: number[]; converged: boolean; }
+export function computeRubberSciEstimation(data: number[], opts: RubberSciEstimationOptions = {}): RubberSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciEstimation };
diff --git a/src/rubber_sci/evaluation.ts b/src/rubber_sci/evaluation.ts
new file mode 100644
index 000000000..7ef558cbc
--- /dev/null
+++ b/src/rubber_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci evaluation module — tsb analytics library. */
+export interface RubberSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeRubberSciEvaluation(data: number[], opts: RubberSciEvaluationOptions = {}): RubberSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciEvaluation };
diff --git a/src/rubber_sci/extrapolation.ts b/src/rubber_sci/extrapolation.ts
new file mode 100644
index 000000000..1b72997e9
--- /dev/null
+++ b/src/rubber_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci extrapolation module — tsb analytics library. */
+export interface RubberSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeRubberSciExtrapolation(data: number[], opts: RubberSciExtrapolationOptions = {}): RubberSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciExtrapolation };
diff --git a/src/rubber_sci/features.ts b/src/rubber_sci/features.ts
new file mode 100644
index 000000000..bd5fe5d00
--- /dev/null
+++ b/src/rubber_sci/features.ts
@@ -0,0 +1,14 @@
+/** rubber_sci features module — tsb analytics library. */
+export interface RubberSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface RubberSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeRubberSciFeatures(data: number[], opts: RubberSciFeaturesOptions = {}): RubberSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciFeatures };
diff --git a/src/rubber_sci/feedback.ts b/src/rubber_sci/feedback.ts
new file mode 100644
index 000000000..0fbe6c528
--- /dev/null
+++ b/src/rubber_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** rubber_sci feedback module — tsb analytics library. */
+export interface RubberSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface RubberSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeRubberSciFeedback(data: number[], opts: RubberSciFeedbackOptions = {}): RubberSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciFeedback };
diff --git a/src/rubber_sci/filtering.ts b/src/rubber_sci/filtering.ts
new file mode 100644
index 000000000..817cb2178
--- /dev/null
+++ b/src/rubber_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** rubber_sci filtering module — tsb analytics library. */
+export interface RubberSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface RubberSciFilteringResult { values: number[]; converged: boolean; }
+export function computeRubberSciFiltering(data: number[], opts: RubberSciFilteringOptions = {}): RubberSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciFiltering };
diff --git a/src/rubber_sci/fourier.ts b/src/rubber_sci/fourier.ts
new file mode 100644
index 000000000..8dc143583
--- /dev/null
+++ b/src/rubber_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** rubber_sci fourier module — tsb analytics library. */
+export interface RubberSciFourierOptions { tol?: number; maxIter?: number; }
+export interface RubberSciFourierResult { values: number[]; converged: boolean; }
+export function computeRubberSciFourier(data: number[], opts: RubberSciFourierOptions = {}): RubberSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciFourier };
diff --git a/src/rubber_sci/fusion.ts b/src/rubber_sci/fusion.ts
new file mode 100644
index 000000000..4323869cb
--- /dev/null
+++ b/src/rubber_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** rubber_sci fusion module — tsb analytics library. */
+export interface RubberSciFusionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciFusionResult { values: number[]; converged: boolean; }
+export function computeRubberSciFusion(data: number[], opts: RubberSciFusionOptions = {}): RubberSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciFusion };
diff --git a/src/rubber_sci/generation.ts b/src/rubber_sci/generation.ts
new file mode 100644
index 000000000..9aa0e1dc3
--- /dev/null
+++ b/src/rubber_sci/generation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci generation module — tsb analytics library. */
+export interface RubberSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciGenerationResult { values: number[]; converged: boolean; }
+export function computeRubberSciGeneration(data: number[], opts: RubberSciGenerationOptions = {}): RubberSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciGeneration };
diff --git a/src/rubber_sci/geometry.ts b/src/rubber_sci/geometry.ts
new file mode 100644
index 000000000..836bb1da7
--- /dev/null
+++ b/src/rubber_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** rubber_sci geometry module — tsb analytics library. */
+export interface RubberSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface RubberSciGeometryResult { values: number[]; converged: boolean; }
+export function computeRubberSciGeometry(data: number[], opts: RubberSciGeometryOptions = {}): RubberSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciGeometry };
diff --git a/src/rubber_sci/gradient.ts b/src/rubber_sci/gradient.ts
new file mode 100644
index 000000000..62e4ec139
--- /dev/null
+++ b/src/rubber_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** rubber_sci gradient module — tsb analytics library. */
+export interface RubberSciGradientOptions { tol?: number; maxIter?: number; }
+export interface RubberSciGradientResult { values: number[]; converged: boolean; }
+export function computeRubberSciGradient(data: number[], opts: RubberSciGradientOptions = {}): RubberSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciGradient };
diff --git a/src/rubber_sci/hessian.ts b/src/rubber_sci/hessian.ts
new file mode 100644
index 000000000..6491dbbde
--- /dev/null
+++ b/src/rubber_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** rubber_sci hessian module — tsb analytics library. */
+export interface RubberSciHessianOptions { tol?: number; maxIter?: number; }
+export interface RubberSciHessianResult { values: number[]; converged: boolean; }
+export function computeRubberSciHessian(data: number[], opts: RubberSciHessianOptions = {}): RubberSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciHessian };
diff --git a/src/rubber_sci/hypothesis.ts b/src/rubber_sci/hypothesis.ts
new file mode 100644
index 000000000..2a7e1b8a0
--- /dev/null
+++ b/src/rubber_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** rubber_sci hypothesis module — tsb analytics library. */
+export interface RubberSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface RubberSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeRubberSciHypothesis(data: number[], opts: RubberSciHypothesisOptions = {}): RubberSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciHypothesis };
diff --git a/src/rubber_sci/inference.ts b/src/rubber_sci/inference.ts
new file mode 100644
index 000000000..547d83bb4
--- /dev/null
+++ b/src/rubber_sci/inference.ts
@@ -0,0 +1,14 @@
+/** rubber_sci inference module — tsb analytics library. */
+export interface RubberSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface RubberSciInferenceResult { values: number[]; converged: boolean; }
+export function computeRubberSciInference(data: number[], opts: RubberSciInferenceOptions = {}): RubberSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciInference };
diff --git a/src/rubber_sci/inference2.ts b/src/rubber_sci/inference2.ts
new file mode 100644
index 000000000..061bb0c27
--- /dev/null
+++ b/src/rubber_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** rubber_sci inference2 module — tsb analytics library. */
+export interface RubberSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface RubberSciInferenceResult { values: number[]; converged: boolean; }
+export function computeRubberSciInference(data: number[], opts: RubberSciInferenceOptions = {}): RubberSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciInference };
diff --git a/src/rubber_sci/integral.ts b/src/rubber_sci/integral.ts
new file mode 100644
index 000000000..c9af2e055
--- /dev/null
+++ b/src/rubber_sci/integral.ts
@@ -0,0 +1,14 @@
+/** rubber_sci integral module — tsb analytics library. */
+export interface RubberSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface RubberSciIntegralResult { values: number[]; converged: boolean; }
+export function computeRubberSciIntegral(data: number[], opts: RubberSciIntegralOptions = {}): RubberSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciIntegral };
diff --git a/src/rubber_sci/integration.ts b/src/rubber_sci/integration.ts
new file mode 100644
index 000000000..f7f2576b0
--- /dev/null
+++ b/src/rubber_sci/integration.ts
@@ -0,0 +1,14 @@
+/** rubber_sci integration module — tsb analytics library. */
+export interface RubberSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeRubberSciIntegration(data: number[], opts: RubberSciIntegrationOptions = {}): RubberSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciIntegration };
diff --git a/src/rubber_sci/interpolation.ts b/src/rubber_sci/interpolation.ts
new file mode 100644
index 000000000..808170ebc
--- /dev/null
+++ b/src/rubber_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci interpolation module — tsb analytics library. */
+export interface RubberSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeRubberSciInterpolation(data: number[], opts: RubberSciInterpolationOptions = {}): RubberSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciInterpolation };
diff --git a/src/rubber_sci/jacobian.ts b/src/rubber_sci/jacobian.ts
new file mode 100644
index 000000000..43fbd724f
--- /dev/null
+++ b/src/rubber_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** rubber_sci jacobian module — tsb analytics library. */
+export interface RubberSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface RubberSciJacobianResult { values: number[]; converged: boolean; }
+export function computeRubberSciJacobian(data: number[], opts: RubberSciJacobianOptions = {}): RubberSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciJacobian };
diff --git a/src/rubber_sci/kernel.ts b/src/rubber_sci/kernel.ts
new file mode 100644
index 000000000..21c8abcfd
--- /dev/null
+++ b/src/rubber_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** rubber_sci kernel module — tsb analytics library. */
+export interface RubberSciKernelOptions { tol?: number; maxIter?: number; }
+export interface RubberSciKernelResult { values: number[]; converged: boolean; }
+export function computeRubberSciKernel(data: number[], opts: RubberSciKernelOptions = {}): RubberSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciKernel };
diff --git a/src/rubber_sci/laplacian.ts b/src/rubber_sci/laplacian.ts
new file mode 100644
index 000000000..62ddb8945
--- /dev/null
+++ b/src/rubber_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** rubber_sci laplacian module — tsb analytics library. */
+export interface RubberSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface RubberSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeRubberSciLaplacian(data: number[], opts: RubberSciLaplacianOptions = {}): RubberSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciLaplacian };
diff --git a/src/rubber_sci/learning.ts b/src/rubber_sci/learning.ts
new file mode 100644
index 000000000..68f94b108
--- /dev/null
+++ b/src/rubber_sci/learning.ts
@@ -0,0 +1,14 @@
+/** rubber_sci learning module — tsb analytics library. */
+export interface RubberSciLearningOptions { tol?: number; maxIter?: number; }
+export interface RubberSciLearningResult { values: number[]; converged: boolean; }
+export function computeRubberSciLearning(data: number[], opts: RubberSciLearningOptions = {}): RubberSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciLearning };
diff --git a/src/rubber_sci/linear.ts b/src/rubber_sci/linear.ts
new file mode 100644
index 000000000..96fe38fe0
--- /dev/null
+++ b/src/rubber_sci/linear.ts
@@ -0,0 +1,14 @@
+/** rubber_sci linear module — tsb analytics library. */
+export interface RubberSciLinearOptions { tol?: number; maxIter?: number; }
+export interface RubberSciLinearResult { values: number[]; converged: boolean; }
+export function computeRubberSciLinear(data: number[], opts: RubberSciLinearOptions = {}): RubberSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciLinear };
diff --git a/src/rubber_sci/manifold.ts b/src/rubber_sci/manifold.ts
new file mode 100644
index 000000000..7a1fdca81
--- /dev/null
+++ b/src/rubber_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** rubber_sci manifold module — tsb analytics library. */
+export interface RubberSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface RubberSciManifoldResult { values: number[]; converged: boolean; }
+export function computeRubberSciManifold(data: number[], opts: RubberSciManifoldOptions = {}): RubberSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciManifold };
diff --git a/src/rubber_sci/matching.ts b/src/rubber_sci/matching.ts
new file mode 100644
index 000000000..8e2423a0b
--- /dev/null
+++ b/src/rubber_sci/matching.ts
@@ -0,0 +1,14 @@
+/** rubber_sci matching module — tsb analytics library. */
+export interface RubberSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciMatchingResult { values: number[]; converged: boolean; }
+export function computeRubberSciMatching(data: number[], opts: RubberSciMatchingOptions = {}): RubberSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciMatching };
diff --git a/src/rubber_sci/measurement.ts b/src/rubber_sci/measurement.ts
new file mode 100644
index 000000000..b7e18ae9f
--- /dev/null
+++ b/src/rubber_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** rubber_sci measurement module — tsb analytics library. */
+export interface RubberSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface RubberSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeRubberSciMeasurement(data: number[], opts: RubberSciMeasurementOptions = {}): RubberSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciMeasurement };
diff --git a/src/rubber_sci/metrics.ts b/src/rubber_sci/metrics.ts
new file mode 100644
index 000000000..a7dd01be9
--- /dev/null
+++ b/src/rubber_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** rubber_sci metrics module — tsb analytics library. */
+export interface RubberSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface RubberSciMetricsResult { values: number[]; converged: boolean; }
+export function computeRubberSciMetrics(data: number[], opts: RubberSciMetricsOptions = {}): RubberSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciMetrics };
diff --git a/src/rubber_sci/modeling.ts b/src/rubber_sci/modeling.ts
new file mode 100644
index 000000000..0c61325e9
--- /dev/null
+++ b/src/rubber_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** rubber_sci modeling module — tsb analytics library. */
+export interface RubberSciModelingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciModelingResult { values: number[]; converged: boolean; }
+export function computeRubberSciModeling(data: number[], opts: RubberSciModelingOptions = {}): RubberSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciModeling };
diff --git a/src/rubber_sci/monitoring.ts b/src/rubber_sci/monitoring.ts
new file mode 100644
index 000000000..aa1a31dd4
--- /dev/null
+++ b/src/rubber_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** rubber_sci monitoring module — tsb analytics library. */
+export interface RubberSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface RubberSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeRubberSciMonitoring(data: number[], opts: RubberSciMonitoringOptions = {}): RubberSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciMonitoring };
diff --git a/src/rubber_sci/nonlinear.ts b/src/rubber_sci/nonlinear.ts
new file mode 100644
index 000000000..891d05633
--- /dev/null
+++ b/src/rubber_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** rubber_sci nonlinear module — tsb analytics library. */
+export interface RubberSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface RubberSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeRubberSciNonlinear(data: number[], opts: RubberSciNonlinearOptions = {}): RubberSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciNonlinear };
diff --git a/src/rubber_sci/normalization.ts b/src/rubber_sci/normalization.ts
new file mode 100644
index 000000000..d52bb0353
--- /dev/null
+++ b/src/rubber_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** rubber_sci normalization module — tsb analytics library. */
+export interface RubberSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeRubberSciNormalization(data: number[], opts: RubberSciNormalizationOptions = {}): RubberSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciNormalization };
diff --git a/src/rubber_sci/optimization.ts b/src/rubber_sci/optimization.ts
new file mode 100644
index 000000000..c5672f702
--- /dev/null
+++ b/src/rubber_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** rubber_sci optimization module — tsb analytics library. */
+export interface RubberSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeRubberSciOptimization(data: number[], opts: RubberSciOptimizationOptions = {}): RubberSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciOptimization };
diff --git a/src/rubber_sci/patterns.ts b/src/rubber_sci/patterns.ts
new file mode 100644
index 000000000..7739211d0
--- /dev/null
+++ b/src/rubber_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** rubber_sci patterns module — tsb analytics library. */
+export interface RubberSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface RubberSciPatternsResult { values: number[]; converged: boolean; }
+export function computeRubberSciPatterns(data: number[], opts: RubberSciPatternsOptions = {}): RubberSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciPatterns };
diff --git a/src/rubber_sci/permutation.ts b/src/rubber_sci/permutation.ts
new file mode 100644
index 000000000..5c0bb4c53
--- /dev/null
+++ b/src/rubber_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci permutation module — tsb analytics library. */
+export interface RubberSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciPermutationResult { values: number[]; converged: boolean; }
+export function computeRubberSciPermutation(data: number[], opts: RubberSciPermutationOptions = {}): RubberSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciPermutation };
diff --git a/src/rubber_sci/prediction.ts b/src/rubber_sci/prediction.ts
new file mode 100644
index 000000000..8fe37cdad
--- /dev/null
+++ b/src/rubber_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** rubber_sci prediction module — tsb analytics library. */
+export interface RubberSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciPredictionResult { values: number[]; converged: boolean; }
+export function computeRubberSciPrediction(data: number[], opts: RubberSciPredictionOptions = {}): RubberSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciPrediction };
diff --git a/src/rubber_sci/processing.ts b/src/rubber_sci/processing.ts
new file mode 100644
index 000000000..f5bfb9775
--- /dev/null
+++ b/src/rubber_sci/processing.ts
@@ -0,0 +1,14 @@
+/** rubber_sci processing module — tsb analytics library. */
+export interface RubberSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciProcessingResult { values: number[]; converged: boolean; }
+export function computeRubberSciProcessing(data: number[], opts: RubberSciProcessingOptions = {}): RubberSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciProcessing };
diff --git a/src/rubber_sci/profiling.ts b/src/rubber_sci/profiling.ts
new file mode 100644
index 000000000..3d0336190
--- /dev/null
+++ b/src/rubber_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** rubber_sci profiling module — tsb analytics library. */
+export interface RubberSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciProfilingResult { values: number[]; converged: boolean; }
+export function computeRubberSciProfiling(data: number[], opts: RubberSciProfilingOptions = {}): RubberSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciProfiling };
diff --git a/src/rubber_sci/projection.ts b/src/rubber_sci/projection.ts
new file mode 100644
index 000000000..7f78650b4
--- /dev/null
+++ b/src/rubber_sci/projection.ts
@@ -0,0 +1,14 @@
+/** rubber_sci projection module — tsb analytics library. */
+export interface RubberSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciProjectionResult { values: number[]; converged: boolean; }
+export function computeRubberSciProjection(data: number[], opts: RubberSciProjectionOptions = {}): RubberSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciProjection };
diff --git a/src/rubber_sci/ranking.ts b/src/rubber_sci/ranking.ts
new file mode 100644
index 000000000..5a06ec025
--- /dev/null
+++ b/src/rubber_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** rubber_sci ranking module — tsb analytics library. */
+export interface RubberSciRankingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciRankingResult { values: number[]; converged: boolean; }
+export function computeRubberSciRanking(data: number[], opts: RubberSciRankingOptions = {}): RubberSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciRanking };
diff --git a/src/rubber_sci/reconstruction.ts b/src/rubber_sci/reconstruction.ts
new file mode 100644
index 000000000..fa88f9995
--- /dev/null
+++ b/src/rubber_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** rubber_sci reconstruction module — tsb analytics library. */
+export interface RubberSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeRubberSciReconstruction(data: number[], opts: RubberSciReconstructionOptions = {}): RubberSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciReconstruction };
diff --git a/src/rubber_sci/registration.ts b/src/rubber_sci/registration.ts
new file mode 100644
index 000000000..2a034da13
--- /dev/null
+++ b/src/rubber_sci/registration.ts
@@ -0,0 +1,14 @@
+/** rubber_sci registration module — tsb analytics library. */
+export interface RubberSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeRubberSciRegistration(data: number[], opts: RubberSciRegistrationOptions = {}): RubberSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciRegistration };
diff --git a/src/rubber_sci/regression.ts b/src/rubber_sci/regression.ts
new file mode 100644
index 000000000..e42f5c0f9
--- /dev/null
+++ b/src/rubber_sci/regression.ts
@@ -0,0 +1,14 @@
+/** rubber_sci regression module — tsb analytics library. */
+export interface RubberSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciRegressionResult { values: number[]; converged: boolean; }
+export function computeRubberSciRegression(data: number[], opts: RubberSciRegressionOptions = {}): RubberSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciRegression };
diff --git a/src/rubber_sci/regularization.ts b/src/rubber_sci/regularization.ts
new file mode 100644
index 000000000..df7eae6c1
--- /dev/null
+++ b/src/rubber_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** rubber_sci regularization module — tsb analytics library. */
+export interface RubberSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeRubberSciRegularization(data: number[], opts: RubberSciRegularizationOptions = {}): RubberSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciRegularization };
diff --git a/src/rubber_sci/robustness.ts b/src/rubber_sci/robustness.ts
new file mode 100644
index 000000000..74fcea397
--- /dev/null
+++ b/src/rubber_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** rubber_sci robustness module — tsb analytics library. */
+export interface RubberSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface RubberSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeRubberSciRobustness(data: number[], opts: RubberSciRobustnessOptions = {}): RubberSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciRobustness };
diff --git a/src/rubber_sci/sampling.ts b/src/rubber_sci/sampling.ts
new file mode 100644
index 000000000..d0f24794e
--- /dev/null
+++ b/src/rubber_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** rubber_sci sampling module — tsb analytics library. */
+export interface RubberSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciSamplingResult { values: number[]; converged: boolean; }
+export function computeRubberSciSampling(data: number[], opts: RubberSciSamplingOptions = {}): RubberSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciSampling };
diff --git a/src/rubber_sci/sampling2.ts b/src/rubber_sci/sampling2.ts
new file mode 100644
index 000000000..e4a607484
--- /dev/null
+++ b/src/rubber_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** rubber_sci sampling2 module — tsb analytics library. */
+export interface RubberSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciSamplingResult { values: number[]; converged: boolean; }
+export function computeRubberSciSampling(data: number[], opts: RubberSciSamplingOptions = {}): RubberSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciSampling };
diff --git a/src/rubber_sci/scaling.ts b/src/rubber_sci/scaling.ts
new file mode 100644
index 000000000..c6e71fd23
--- /dev/null
+++ b/src/rubber_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** rubber_sci scaling module — tsb analytics library. */
+export interface RubberSciScalingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciScalingResult { values: number[]; converged: boolean; }
+export function computeRubberSciScaling(data: number[], opts: RubberSciScalingOptions = {}): RubberSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciScaling };
diff --git a/src/rubber_sci/scoring.ts b/src/rubber_sci/scoring.ts
new file mode 100644
index 000000000..5ab844f8c
--- /dev/null
+++ b/src/rubber_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** rubber_sci scoring module — tsb analytics library. */
+export interface RubberSciScoringOptions { tol?: number; maxIter?: number; }
+export interface RubberSciScoringResult { values: number[]; converged: boolean; }
+export function computeRubberSciScoring(data: number[], opts: RubberSciScoringOptions = {}): RubberSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciScoring };
diff --git a/src/rubber_sci/segmentation.ts b/src/rubber_sci/segmentation.ts
new file mode 100644
index 000000000..fd0041bbc
--- /dev/null
+++ b/src/rubber_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci segmentation module — tsb analytics library. */
+export interface RubberSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeRubberSciSegmentation(data: number[], opts: RubberSciSegmentationOptions = {}): RubberSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciSegmentation };
diff --git a/src/rubber_sci/selection.ts b/src/rubber_sci/selection.ts
new file mode 100644
index 000000000..f4ede431a
--- /dev/null
+++ b/src/rubber_sci/selection.ts
@@ -0,0 +1,14 @@
+/** rubber_sci selection module — tsb analytics library. */
+export interface RubberSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface RubberSciSelectionResult { values: number[]; converged: boolean; }
+export function computeRubberSciSelection(data: number[], opts: RubberSciSelectionOptions = {}): RubberSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciSelection };
diff --git a/src/rubber_sci/sensitivity.ts b/src/rubber_sci/sensitivity.ts
new file mode 100644
index 000000000..0ff570b98
--- /dev/null
+++ b/src/rubber_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** rubber_sci sensitivity module — tsb analytics library. */
+export interface RubberSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface RubberSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeRubberSciSensitivity(data: number[], opts: RubberSciSensitivityOptions = {}): RubberSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciSensitivity };
diff --git a/src/rubber_sci/simulation.ts b/src/rubber_sci/simulation.ts
new file mode 100644
index 000000000..2c3ef1f63
--- /dev/null
+++ b/src/rubber_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci simulation module — tsb analytics library. */
+export interface RubberSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciSimulationResult { values: number[]; converged: boolean; }
+export function computeRubberSciSimulation(data: number[], opts: RubberSciSimulationOptions = {}): RubberSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciSimulation };
diff --git a/src/rubber_sci/smoothing.ts b/src/rubber_sci/smoothing.ts
new file mode 100644
index 000000000..eef55d7e6
--- /dev/null
+++ b/src/rubber_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** rubber_sci smoothing module — tsb analytics library. */
+export interface RubberSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeRubberSciSmoothing(data: number[], opts: RubberSciSmoothingOptions = {}): RubberSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciSmoothing };
diff --git a/src/rubber_sci/stability.ts b/src/rubber_sci/stability.ts
new file mode 100644
index 000000000..d13990ca1
--- /dev/null
+++ b/src/rubber_sci/stability.ts
@@ -0,0 +1,14 @@
+/** rubber_sci stability module — tsb analytics library. */
+export interface RubberSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface RubberSciStabilityResult { values: number[]; converged: boolean; }
+export function computeRubberSciStability(data: number[], opts: RubberSciStabilityOptions = {}): RubberSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciStability };
diff --git a/src/rubber_sci/stacking.ts b/src/rubber_sci/stacking.ts
new file mode 100644
index 000000000..c9cbcd752
--- /dev/null
+++ b/src/rubber_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** rubber_sci stacking module — tsb analytics library. */
+export interface RubberSciStackingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciStackingResult { values: number[]; converged: boolean; }
+export function computeRubberSciStacking(data: number[], opts: RubberSciStackingOptions = {}): RubberSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciStacking };
diff --git a/src/rubber_sci/standardization.ts b/src/rubber_sci/standardization.ts
new file mode 100644
index 000000000..28403f643
--- /dev/null
+++ b/src/rubber_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** rubber_sci standardization module — tsb analytics library. */
+export interface RubberSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeRubberSciStandardization(data: number[], opts: RubberSciStandardizationOptions = {}): RubberSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciStandardization };
diff --git a/src/rubber_sci/static.ts b/src/rubber_sci/static.ts
new file mode 100644
index 000000000..1e4325bde
--- /dev/null
+++ b/src/rubber_sci/static.ts
@@ -0,0 +1,14 @@
+/** rubber_sci static module — tsb analytics library. */
+export interface RubberSciStaticOptions { tol?: number; maxIter?: number; }
+export interface RubberSciStaticResult { values: number[]; converged: boolean; }
+export function computeRubberSciStatic(data: number[], opts: RubberSciStaticOptions = {}): RubberSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciStatic };
diff --git a/src/rubber_sci/stochastic.ts b/src/rubber_sci/stochastic.ts
new file mode 100644
index 000000000..cf7b9b61e
--- /dev/null
+++ b/src/rubber_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** rubber_sci stochastic module — tsb analytics library. */
+export interface RubberSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface RubberSciStochasticResult { values: number[]; converged: boolean; }
+export function computeRubberSciStochastic(data: number[], opts: RubberSciStochasticOptions = {}): RubberSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciStochastic };
diff --git a/src/rubber_sci/synthesis.ts b/src/rubber_sci/synthesis.ts
new file mode 100644
index 000000000..01fec569f
--- /dev/null
+++ b/src/rubber_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** rubber_sci synthesis module — tsb analytics library. */
+export interface RubberSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface RubberSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeRubberSciSynthesis(data: number[], opts: RubberSciSynthesisOptions = {}): RubberSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciSynthesis };
diff --git a/src/rubber_sci/topology.ts b/src/rubber_sci/topology.ts
new file mode 100644
index 000000000..aae4f0674
--- /dev/null
+++ b/src/rubber_sci/topology.ts
@@ -0,0 +1,14 @@
+/** rubber_sci topology module — tsb analytics library. */
+export interface RubberSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface RubberSciTopologyResult { values: number[]; converged: boolean; }
+export function computeRubberSciTopology(data: number[], opts: RubberSciTopologyOptions = {}): RubberSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciTopology };
diff --git a/src/rubber_sci/tracking.ts b/src/rubber_sci/tracking.ts
new file mode 100644
index 000000000..243a065e8
--- /dev/null
+++ b/src/rubber_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** rubber_sci tracking module — tsb analytics library. */
+export interface RubberSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciTrackingResult { values: number[]; converged: boolean; }
+export function computeRubberSciTracking(data: number[], opts: RubberSciTrackingOptions = {}): RubberSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciTracking };
diff --git a/src/rubber_sci/transform.ts b/src/rubber_sci/transform.ts
new file mode 100644
index 000000000..f22e84204
--- /dev/null
+++ b/src/rubber_sci/transform.ts
@@ -0,0 +1,14 @@
+/** rubber_sci transform module — tsb analytics library. */
+export interface RubberSciTransformOptions { tol?: number; maxIter?: number; }
+export interface RubberSciTransformResult { values: number[]; converged: boolean; }
+export function computeRubberSciTransform(data: number[], opts: RubberSciTransformOptions = {}): RubberSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciTransform };
diff --git a/src/rubber_sci/uncertainty.ts b/src/rubber_sci/uncertainty.ts
new file mode 100644
index 000000000..142dbacb1
--- /dev/null
+++ b/src/rubber_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** rubber_sci uncertainty module — tsb analytics library. */
+export interface RubberSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface RubberSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeRubberSciUncertainty(data: number[], opts: RubberSciUncertaintyOptions = {}): RubberSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciUncertainty };
diff --git a/src/rubber_sci/validation.ts b/src/rubber_sci/validation.ts
new file mode 100644
index 000000000..a92fd02e3
--- /dev/null
+++ b/src/rubber_sci/validation.ts
@@ -0,0 +1,14 @@
+/** rubber_sci validation module — tsb analytics library. */
+export interface RubberSciValidationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciValidationResult { values: number[]; converged: boolean; }
+export function computeRubberSciValidation(data: number[], opts: RubberSciValidationOptions = {}): RubberSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciValidation };
diff --git a/src/rubber_sci/verification.ts b/src/rubber_sci/verification.ts
new file mode 100644
index 000000000..b8f11bf12
--- /dev/null
+++ b/src/rubber_sci/verification.ts
@@ -0,0 +1,14 @@
+/** rubber_sci verification module — tsb analytics library. */
+export interface RubberSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciVerificationResult { values: number[]; converged: boolean; }
+export function computeRubberSciVerification(data: number[], opts: RubberSciVerificationOptions = {}): RubberSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciVerification };
diff --git a/src/rubber_sci/visualization.ts b/src/rubber_sci/visualization.ts
new file mode 100644
index 000000000..0a4529b0f
--- /dev/null
+++ b/src/rubber_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** rubber_sci visualization module — tsb analytics library. */
+export interface RubberSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface RubberSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeRubberSciVisualization(data: number[], opts: RubberSciVisualizationOptions = {}): RubberSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciVisualization };
diff --git a/src/rubber_sci/voting.ts b/src/rubber_sci/voting.ts
new file mode 100644
index 000000000..0544c0c72
--- /dev/null
+++ b/src/rubber_sci/voting.ts
@@ -0,0 +1,14 @@
+/** rubber_sci voting module — tsb analytics library. */
+export interface RubberSciVotingOptions { tol?: number; maxIter?: number; }
+export interface RubberSciVotingResult { values: number[]; converged: boolean; }
+export function computeRubberSciVoting(data: number[], opts: RubberSciVotingOptions = {}): RubberSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciVoting };
diff --git a/src/rubber_sci/wavelet.ts b/src/rubber_sci/wavelet.ts
new file mode 100644
index 000000000..b3767d1ec
--- /dev/null
+++ b/src/rubber_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** rubber_sci wavelet module — tsb analytics library. */
+export interface RubberSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface RubberSciWaveletResult { values: number[]; converged: boolean; }
+export function computeRubberSciWavelet(data: number[], opts: RubberSciWaveletOptions = {}): RubberSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeRubberSciWavelet };
diff --git a/src/sedimentology/adaptation.ts b/src/sedimentology/adaptation.ts
new file mode 100644
index 000000000..db8469be3
--- /dev/null
+++ b/src/sedimentology/adaptation.ts
@@ -0,0 +1,14 @@
+/** sedimentology adaptation module — tsb analytics library. */
+export interface SedimentologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyAdaptation(data: number[], opts: SedimentologyAdaptationOptions = {}): SedimentologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyAdaptation };
diff --git a/src/sedimentology/aggregation.ts b/src/sedimentology/aggregation.ts
new file mode 100644
index 000000000..a14552481
--- /dev/null
+++ b/src/sedimentology/aggregation.ts
@@ -0,0 +1,14 @@
+/** sedimentology aggregation module — tsb analytics library. */
+export interface SedimentologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyAggregationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyAggregation(data: number[], opts: SedimentologyAggregationOptions = {}): SedimentologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyAggregation };
diff --git a/src/sedimentology/algebra.ts b/src/sedimentology/algebra.ts
new file mode 100644
index 000000000..cee473cc5
--- /dev/null
+++ b/src/sedimentology/algebra.ts
@@ -0,0 +1,14 @@
+/** sedimentology algebra module — tsb analytics library. */
+export interface SedimentologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeSedimentologyAlgebra(data: number[], opts: SedimentologyAlgebraOptions = {}): SedimentologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyAlgebra };
diff --git a/src/sedimentology/alignment.ts b/src/sedimentology/alignment.ts
new file mode 100644
index 000000000..7ac36d820
--- /dev/null
+++ b/src/sedimentology/alignment.ts
@@ -0,0 +1,14 @@
+/** sedimentology alignment module — tsb analytics library. */
+export interface SedimentologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeSedimentologyAlignment(data: number[], opts: SedimentologyAlignmentOptions = {}): SedimentologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyAlignment };
diff --git a/src/sedimentology/analysis.ts b/src/sedimentology/analysis.ts
new file mode 100644
index 000000000..88eaa0dcd
--- /dev/null
+++ b/src/sedimentology/analysis.ts
@@ -0,0 +1,14 @@
+/** sedimentology analysis module — tsb analytics library. */
+export interface SedimentologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeSedimentologyAnalysis(data: number[], opts: SedimentologyAnalysisOptions = {}): SedimentologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyAnalysis };
diff --git a/src/sedimentology/augmentation.ts b/src/sedimentology/augmentation.ts
new file mode 100644
index 000000000..e98f688b2
--- /dev/null
+++ b/src/sedimentology/augmentation.ts
@@ -0,0 +1,14 @@
+/** sedimentology augmentation module — tsb analytics library. */
+export interface SedimentologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyAugmentation(data: number[], opts: SedimentologyAugmentationOptions = {}): SedimentologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyAugmentation };
diff --git a/src/sedimentology/bagging.ts b/src/sedimentology/bagging.ts
new file mode 100644
index 000000000..49f9efd9c
--- /dev/null
+++ b/src/sedimentology/bagging.ts
@@ -0,0 +1,14 @@
+/** sedimentology bagging module — tsb analytics library. */
+export interface SedimentologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyBaggingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyBagging(data: number[], opts: SedimentologyBaggingOptions = {}): SedimentologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyBagging };
diff --git a/src/sedimentology/basis.ts b/src/sedimentology/basis.ts
new file mode 100644
index 000000000..1b0208145
--- /dev/null
+++ b/src/sedimentology/basis.ts
@@ -0,0 +1,14 @@
+/** sedimentology basis module — tsb analytics library. */
+export interface SedimentologyBasisOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyBasisResult { values: number[]; converged: boolean; }
+export function computeSedimentologyBasis(data: number[], opts: SedimentologyBasisOptions = {}): SedimentologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyBasis };
diff --git a/src/sedimentology/benchmarking.ts b/src/sedimentology/benchmarking.ts
new file mode 100644
index 000000000..37d9b0f99
--- /dev/null
+++ b/src/sedimentology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** sedimentology benchmarking module — tsb analytics library. */
+export interface SedimentologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyBenchmarking(data: number[], opts: SedimentologyBenchmarkingOptions = {}): SedimentologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyBenchmarking };
diff --git a/src/sedimentology/blending.ts b/src/sedimentology/blending.ts
new file mode 100644
index 000000000..4bac0e1c6
--- /dev/null
+++ b/src/sedimentology/blending.ts
@@ -0,0 +1,14 @@
+/** sedimentology blending module — tsb analytics library. */
+export interface SedimentologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyBlendingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyBlending(data: number[], opts: SedimentologyBlendingOptions = {}): SedimentologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyBlending };
diff --git a/src/sedimentology/boosting.ts b/src/sedimentology/boosting.ts
new file mode 100644
index 000000000..0f441792b
--- /dev/null
+++ b/src/sedimentology/boosting.ts
@@ -0,0 +1,14 @@
+/** sedimentology boosting module — tsb analytics library. */
+export interface SedimentologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyBoostingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyBoosting(data: number[], opts: SedimentologyBoostingOptions = {}): SedimentologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyBoosting };
diff --git a/src/sedimentology/bootstrap.ts b/src/sedimentology/bootstrap.ts
new file mode 100644
index 000000000..b84bdd17a
--- /dev/null
+++ b/src/sedimentology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** sedimentology bootstrap module — tsb analytics library. */
+export interface SedimentologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeSedimentologyBootstrap(data: number[], opts: SedimentologyBootstrapOptions = {}): SedimentologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyBootstrap };
diff --git a/src/sedimentology/calculus.ts b/src/sedimentology/calculus.ts
new file mode 100644
index 000000000..cba793292
--- /dev/null
+++ b/src/sedimentology/calculus.ts
@@ -0,0 +1,14 @@
+/** sedimentology calculus module — tsb analytics library. */
+export interface SedimentologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyCalculusResult { values: number[]; converged: boolean; }
+export function computeSedimentologyCalculus(data: number[], opts: SedimentologyCalculusOptions = {}): SedimentologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyCalculus };
diff --git a/src/sedimentology/calibration.ts b/src/sedimentology/calibration.ts
new file mode 100644
index 000000000..f041ef023
--- /dev/null
+++ b/src/sedimentology/calibration.ts
@@ -0,0 +1,14 @@
+/** sedimentology calibration module — tsb analytics library. */
+export interface SedimentologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyCalibration(data: number[], opts: SedimentologyCalibrationOptions = {}): SedimentologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyCalibration };
diff --git a/src/sedimentology/characterization.ts b/src/sedimentology/characterization.ts
new file mode 100644
index 000000000..2efde0534
--- /dev/null
+++ b/src/sedimentology/characterization.ts
@@ -0,0 +1,14 @@
+/** sedimentology characterization module — tsb analytics library. */
+export interface SedimentologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyCharacterization(data: number[], opts: SedimentologyCharacterizationOptions = {}): SedimentologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyCharacterization };
diff --git a/src/sedimentology/classification.ts b/src/sedimentology/classification.ts
new file mode 100644
index 000000000..0287fdfd9
--- /dev/null
+++ b/src/sedimentology/classification.ts
@@ -0,0 +1,14 @@
+/** sedimentology classification module — tsb analytics library. */
+export interface SedimentologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyClassificationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyClassification(data: number[], opts: SedimentologyClassificationOptions = {}): SedimentologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyClassification };
diff --git a/src/sedimentology/clustering.ts b/src/sedimentology/clustering.ts
new file mode 100644
index 000000000..de3df5878
--- /dev/null
+++ b/src/sedimentology/clustering.ts
@@ -0,0 +1,14 @@
+/** sedimentology clustering module — tsb analytics library. */
+export interface SedimentologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyClusteringResult { values: number[]; converged: boolean; }
+export function computeSedimentologyClustering(data: number[], opts: SedimentologyClusteringOptions = {}): SedimentologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyClustering };
diff --git a/src/sedimentology/compression.ts b/src/sedimentology/compression.ts
new file mode 100644
index 000000000..44ac8ad5c
--- /dev/null
+++ b/src/sedimentology/compression.ts
@@ -0,0 +1,14 @@
+/** sedimentology compression module — tsb analytics library. */
+export interface SedimentologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyCompressionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyCompression(data: number[], opts: SedimentologyCompressionOptions = {}): SedimentologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyCompression };
diff --git a/src/sedimentology/continuous.ts b/src/sedimentology/continuous.ts
new file mode 100644
index 000000000..80b8324ff
--- /dev/null
+++ b/src/sedimentology/continuous.ts
@@ -0,0 +1,14 @@
+/** sedimentology continuous module — tsb analytics library. */
+export interface SedimentologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyContinuousResult { values: number[]; converged: boolean; }
+export function computeSedimentologyContinuous(data: number[], opts: SedimentologyContinuousOptions = {}): SedimentologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyContinuous };
diff --git a/src/sedimentology/control.ts b/src/sedimentology/control.ts
new file mode 100644
index 000000000..25646308c
--- /dev/null
+++ b/src/sedimentology/control.ts
@@ -0,0 +1,14 @@
+/** sedimentology control module — tsb analytics library. */
+export interface SedimentologyControlOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyControlResult { values: number[]; converged: boolean; }
+export function computeSedimentologyControl(data: number[], opts: SedimentologyControlOptions = {}): SedimentologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyControl };
diff --git a/src/sedimentology/convergence.ts b/src/sedimentology/convergence.ts
new file mode 100644
index 000000000..0aae109b8
--- /dev/null
+++ b/src/sedimentology/convergence.ts
@@ -0,0 +1,14 @@
+/** sedimentology convergence module — tsb analytics library. */
+export interface SedimentologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeSedimentologyConvergence(data: number[], opts: SedimentologyConvergenceOptions = {}): SedimentologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyConvergence };
diff --git a/src/sedimentology/convex.ts b/src/sedimentology/convex.ts
new file mode 100644
index 000000000..c7657825e
--- /dev/null
+++ b/src/sedimentology/convex.ts
@@ -0,0 +1,14 @@
+/** sedimentology convex module — tsb analytics library. */
+export interface SedimentologyConvexOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyConvexResult { values: number[]; converged: boolean; }
+export function computeSedimentologyConvex(data: number[], opts: SedimentologyConvexOptions = {}): SedimentologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyConvex };
diff --git a/src/sedimentology/correlation.ts b/src/sedimentology/correlation.ts
new file mode 100644
index 000000000..009f3c3b1
--- /dev/null
+++ b/src/sedimentology/correlation.ts
@@ -0,0 +1,14 @@
+/** sedimentology correlation module — tsb analytics library. */
+export interface SedimentologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyCorrelation(data: number[], opts: SedimentologyCorrelationOptions = {}): SedimentologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyCorrelation };
diff --git a/src/sedimentology/covariance.ts b/src/sedimentology/covariance.ts
new file mode 100644
index 000000000..041627dd8
--- /dev/null
+++ b/src/sedimentology/covariance.ts
@@ -0,0 +1,14 @@
+/** sedimentology covariance module — tsb analytics library. */
+export interface SedimentologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeSedimentologyCovariance(data: number[], opts: SedimentologyCovarianceOptions = {}): SedimentologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyCovariance };
diff --git a/src/sedimentology/cross_validation.ts b/src/sedimentology/cross_validation.ts
new file mode 100644
index 000000000..ce21c36f4
--- /dev/null
+++ b/src/sedimentology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** sedimentology cross_validation module — tsb analytics library. */
+export interface SedimentologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyCrossValidation(data: number[], opts: SedimentologyCrossValidationOptions = {}): SedimentologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyCrossValidation };
diff --git a/src/sedimentology/decoding.ts b/src/sedimentology/decoding.ts
new file mode 100644
index 000000000..58d08bb1d
--- /dev/null
+++ b/src/sedimentology/decoding.ts
@@ -0,0 +1,14 @@
+/** sedimentology decoding module — tsb analytics library. */
+export interface SedimentologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDecodingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDecoding(data: number[], opts: SedimentologyDecodingOptions = {}): SedimentologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDecoding };
diff --git a/src/sedimentology/decomposition.ts b/src/sedimentology/decomposition.ts
new file mode 100644
index 000000000..aed20c188
--- /dev/null
+++ b/src/sedimentology/decomposition.ts
@@ -0,0 +1,14 @@
+/** sedimentology decomposition module — tsb analytics library. */
+export interface SedimentologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDecomposition(data: number[], opts: SedimentologyDecompositionOptions = {}): SedimentologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDecomposition };
diff --git a/src/sedimentology/detection.ts b/src/sedimentology/detection.ts
new file mode 100644
index 000000000..5e4024dff
--- /dev/null
+++ b/src/sedimentology/detection.ts
@@ -0,0 +1,14 @@
+/** sedimentology detection module — tsb analytics library. */
+export interface SedimentologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDetectionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDetection(data: number[], opts: SedimentologyDetectionOptions = {}): SedimentologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDetection };
diff --git a/src/sedimentology/deterministic.ts b/src/sedimentology/deterministic.ts
new file mode 100644
index 000000000..fb16e43a1
--- /dev/null
+++ b/src/sedimentology/deterministic.ts
@@ -0,0 +1,14 @@
+/** sedimentology deterministic module — tsb analytics library. */
+export interface SedimentologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDeterministic(data: number[], opts: SedimentologyDeterministicOptions = {}): SedimentologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDeterministic };
diff --git a/src/sedimentology/diagnostics.ts b/src/sedimentology/diagnostics.ts
new file mode 100644
index 000000000..c56c2f5c4
--- /dev/null
+++ b/src/sedimentology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** sedimentology diagnostics module — tsb analytics library. */
+export interface SedimentologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDiagnostics(data: number[], opts: SedimentologyDiagnosticsOptions = {}): SedimentologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDiagnostics };
diff --git a/src/sedimentology/differential.ts b/src/sedimentology/differential.ts
new file mode 100644
index 000000000..3a2c7a2af
--- /dev/null
+++ b/src/sedimentology/differential.ts
@@ -0,0 +1,14 @@
+/** sedimentology differential module — tsb analytics library. */
+export interface SedimentologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDifferential(data: number[], opts: SedimentologyDifferentialOptions = {}): SedimentologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDifferential };
diff --git a/src/sedimentology/discrete.ts b/src/sedimentology/discrete.ts
new file mode 100644
index 000000000..15f1b0df1
--- /dev/null
+++ b/src/sedimentology/discrete.ts
@@ -0,0 +1,14 @@
+/** sedimentology discrete module — tsb analytics library. */
+export interface SedimentologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDiscrete(data: number[], opts: SedimentologyDiscreteOptions = {}): SedimentologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDiscrete };
diff --git a/src/sedimentology/distribution.ts b/src/sedimentology/distribution.ts
new file mode 100644
index 000000000..0f1504f8e
--- /dev/null
+++ b/src/sedimentology/distribution.ts
@@ -0,0 +1,14 @@
+/** sedimentology distribution module — tsb analytics library. */
+export interface SedimentologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDistributionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDistribution(data: number[], opts: SedimentologyDistributionOptions = {}): SedimentologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDistribution };
diff --git a/src/sedimentology/dynamic.ts b/src/sedimentology/dynamic.ts
new file mode 100644
index 000000000..33f2622ce
--- /dev/null
+++ b/src/sedimentology/dynamic.ts
@@ -0,0 +1,14 @@
+/** sedimentology dynamic module — tsb analytics library. */
+export interface SedimentologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyDynamicResult { values: number[]; converged: boolean; }
+export function computeSedimentologyDynamic(data: number[], opts: SedimentologyDynamicOptions = {}): SedimentologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyDynamic };
diff --git a/src/sedimentology/embedding.ts b/src/sedimentology/embedding.ts
new file mode 100644
index 000000000..9f82aaa81
--- /dev/null
+++ b/src/sedimentology/embedding.ts
@@ -0,0 +1,14 @@
+/** sedimentology embedding module — tsb analytics library. */
+export interface SedimentologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyEmbedding(data: number[], opts: SedimentologyEmbeddingOptions = {}): SedimentologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyEmbedding };
diff --git a/src/sedimentology/encoding.ts b/src/sedimentology/encoding.ts
new file mode 100644
index 000000000..85df6086f
--- /dev/null
+++ b/src/sedimentology/encoding.ts
@@ -0,0 +1,14 @@
+/** sedimentology encoding module — tsb analytics library. */
+export interface SedimentologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyEncodingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyEncoding(data: number[], opts: SedimentologyEncodingOptions = {}): SedimentologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyEncoding };
diff --git a/src/sedimentology/ensemble.ts b/src/sedimentology/ensemble.ts
new file mode 100644
index 000000000..bdc1a3c6c
--- /dev/null
+++ b/src/sedimentology/ensemble.ts
@@ -0,0 +1,14 @@
+/** sedimentology ensemble module — tsb analytics library. */
+export interface SedimentologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeSedimentologyEnsemble(data: number[], opts: SedimentologyEnsembleOptions = {}): SedimentologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyEnsemble };
diff --git a/src/sedimentology/estimation.ts b/src/sedimentology/estimation.ts
new file mode 100644
index 000000000..3db3d96b2
--- /dev/null
+++ b/src/sedimentology/estimation.ts
@@ -0,0 +1,14 @@
+/** sedimentology estimation module — tsb analytics library. */
+export interface SedimentologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyEstimationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyEstimation(data: number[], opts: SedimentologyEstimationOptions = {}): SedimentologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyEstimation };
diff --git a/src/sedimentology/evaluation.ts b/src/sedimentology/evaluation.ts
new file mode 100644
index 000000000..3f43468d8
--- /dev/null
+++ b/src/sedimentology/evaluation.ts
@@ -0,0 +1,14 @@
+/** sedimentology evaluation module — tsb analytics library. */
+export interface SedimentologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyEvaluation(data: number[], opts: SedimentologyEvaluationOptions = {}): SedimentologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyEvaluation };
diff --git a/src/sedimentology/extrapolation.ts b/src/sedimentology/extrapolation.ts
new file mode 100644
index 000000000..2cfca9e8d
--- /dev/null
+++ b/src/sedimentology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** sedimentology extrapolation module — tsb analytics library. */
+export interface SedimentologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyExtrapolation(data: number[], opts: SedimentologyExtrapolationOptions = {}): SedimentologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyExtrapolation };
diff --git a/src/sedimentology/features.ts b/src/sedimentology/features.ts
new file mode 100644
index 000000000..b21990f6e
--- /dev/null
+++ b/src/sedimentology/features.ts
@@ -0,0 +1,14 @@
+/** sedimentology features module — tsb analytics library. */
+export interface SedimentologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeSedimentologyFeatures(data: number[], opts: SedimentologyFeaturesOptions = {}): SedimentologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyFeatures };
diff --git a/src/sedimentology/feedback.ts b/src/sedimentology/feedback.ts
new file mode 100644
index 000000000..2604168d5
--- /dev/null
+++ b/src/sedimentology/feedback.ts
@@ -0,0 +1,14 @@
+/** sedimentology feedback module — tsb analytics library. */
+export interface SedimentologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeSedimentologyFeedback(data: number[], opts: SedimentologyFeedbackOptions = {}): SedimentologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyFeedback };
diff --git a/src/sedimentology/filtering.ts b/src/sedimentology/filtering.ts
new file mode 100644
index 000000000..6d37b36e1
--- /dev/null
+++ b/src/sedimentology/filtering.ts
@@ -0,0 +1,14 @@
+/** sedimentology filtering module — tsb analytics library. */
+export interface SedimentologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyFilteringResult { values: number[]; converged: boolean; }
+export function computeSedimentologyFiltering(data: number[], opts: SedimentologyFilteringOptions = {}): SedimentologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyFiltering };
diff --git a/src/sedimentology/fourier.ts b/src/sedimentology/fourier.ts
new file mode 100644
index 000000000..292f8817f
--- /dev/null
+++ b/src/sedimentology/fourier.ts
@@ -0,0 +1,14 @@
+/** sedimentology fourier module — tsb analytics library. */
+export interface SedimentologyFourierOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyFourierResult { values: number[]; converged: boolean; }
+export function computeSedimentologyFourier(data: number[], opts: SedimentologyFourierOptions = {}): SedimentologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyFourier };
diff --git a/src/sedimentology/fusion.ts b/src/sedimentology/fusion.ts
new file mode 100644
index 000000000..fccfdc2c0
--- /dev/null
+++ b/src/sedimentology/fusion.ts
@@ -0,0 +1,14 @@
+/** sedimentology fusion module — tsb analytics library. */
+export interface SedimentologyFusionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyFusionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyFusion(data: number[], opts: SedimentologyFusionOptions = {}): SedimentologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyFusion };
diff --git a/src/sedimentology/generation.ts b/src/sedimentology/generation.ts
new file mode 100644
index 000000000..8c8875f39
--- /dev/null
+++ b/src/sedimentology/generation.ts
@@ -0,0 +1,14 @@
+/** sedimentology generation module — tsb analytics library. */
+export interface SedimentologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyGenerationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyGeneration(data: number[], opts: SedimentologyGenerationOptions = {}): SedimentologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyGeneration };
diff --git a/src/sedimentology/geometry.ts b/src/sedimentology/geometry.ts
new file mode 100644
index 000000000..606350d5e
--- /dev/null
+++ b/src/sedimentology/geometry.ts
@@ -0,0 +1,14 @@
+/** sedimentology geometry module — tsb analytics library. */
+export interface SedimentologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyGeometryResult { values: number[]; converged: boolean; }
+export function computeSedimentologyGeometry(data: number[], opts: SedimentologyGeometryOptions = {}): SedimentologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyGeometry };
diff --git a/src/sedimentology/gradient.ts b/src/sedimentology/gradient.ts
new file mode 100644
index 000000000..084995b7e
--- /dev/null
+++ b/src/sedimentology/gradient.ts
@@ -0,0 +1,14 @@
+/** sedimentology gradient module — tsb analytics library. */
+export interface SedimentologyGradientOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyGradientResult { values: number[]; converged: boolean; }
+export function computeSedimentologyGradient(data: number[], opts: SedimentologyGradientOptions = {}): SedimentologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyGradient };
diff --git a/src/sedimentology/hessian.ts b/src/sedimentology/hessian.ts
new file mode 100644
index 000000000..0792306bb
--- /dev/null
+++ b/src/sedimentology/hessian.ts
@@ -0,0 +1,14 @@
+/** sedimentology hessian module — tsb analytics library. */
+export interface SedimentologyHessianOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyHessianResult { values: number[]; converged: boolean; }
+export function computeSedimentologyHessian(data: number[], opts: SedimentologyHessianOptions = {}): SedimentologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyHessian };
diff --git a/src/sedimentology/hypothesis.ts b/src/sedimentology/hypothesis.ts
new file mode 100644
index 000000000..6f8af3d1f
--- /dev/null
+++ b/src/sedimentology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** sedimentology hypothesis module — tsb analytics library. */
+export interface SedimentologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeSedimentologyHypothesis(data: number[], opts: SedimentologyHypothesisOptions = {}): SedimentologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyHypothesis };
diff --git a/src/sedimentology/inference.ts b/src/sedimentology/inference.ts
new file mode 100644
index 000000000..a49f20720
--- /dev/null
+++ b/src/sedimentology/inference.ts
@@ -0,0 +1,14 @@
+/** sedimentology inference module — tsb analytics library. */
+export interface SedimentologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyInferenceResult { values: number[]; converged: boolean; }
+export function computeSedimentologyInference(data: number[], opts: SedimentologyInferenceOptions = {}): SedimentologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyInference };
diff --git a/src/sedimentology/inference2.ts b/src/sedimentology/inference2.ts
new file mode 100644
index 000000000..9d0d01c2f
--- /dev/null
+++ b/src/sedimentology/inference2.ts
@@ -0,0 +1,14 @@
+/** sedimentology inference2 module — tsb analytics library. */
+export interface SedimentologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyInferenceResult { values: number[]; converged: boolean; }
+export function computeSedimentologyInference(data: number[], opts: SedimentologyInferenceOptions = {}): SedimentologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyInference };
diff --git a/src/sedimentology/integral.ts b/src/sedimentology/integral.ts
new file mode 100644
index 000000000..93513e774
--- /dev/null
+++ b/src/sedimentology/integral.ts
@@ -0,0 +1,14 @@
+/** sedimentology integral module — tsb analytics library. */
+export interface SedimentologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyIntegralResult { values: number[]; converged: boolean; }
+export function computeSedimentologyIntegral(data: number[], opts: SedimentologyIntegralOptions = {}): SedimentologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyIntegral };
diff --git a/src/sedimentology/integration.ts b/src/sedimentology/integration.ts
new file mode 100644
index 000000000..7d32edcd2
--- /dev/null
+++ b/src/sedimentology/integration.ts
@@ -0,0 +1,14 @@
+/** sedimentology integration module — tsb analytics library. */
+export interface SedimentologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyIntegration(data: number[], opts: SedimentologyIntegrationOptions = {}): SedimentologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyIntegration };
diff --git a/src/sedimentology/interpolation.ts b/src/sedimentology/interpolation.ts
new file mode 100644
index 000000000..1c0cfd971
--- /dev/null
+++ b/src/sedimentology/interpolation.ts
@@ -0,0 +1,14 @@
+/** sedimentology interpolation module — tsb analytics library. */
+export interface SedimentologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyInterpolation(data: number[], opts: SedimentologyInterpolationOptions = {}): SedimentologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyInterpolation };
diff --git a/src/sedimentology/jacobian.ts b/src/sedimentology/jacobian.ts
new file mode 100644
index 000000000..59a49953b
--- /dev/null
+++ b/src/sedimentology/jacobian.ts
@@ -0,0 +1,14 @@
+/** sedimentology jacobian module — tsb analytics library. */
+export interface SedimentologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyJacobianResult { values: number[]; converged: boolean; }
+export function computeSedimentologyJacobian(data: number[], opts: SedimentologyJacobianOptions = {}): SedimentologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyJacobian };
diff --git a/src/sedimentology/kernel.ts b/src/sedimentology/kernel.ts
new file mode 100644
index 000000000..171c8f15b
--- /dev/null
+++ b/src/sedimentology/kernel.ts
@@ -0,0 +1,14 @@
+/** sedimentology kernel module — tsb analytics library. */
+export interface SedimentologyKernelOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyKernelResult { values: number[]; converged: boolean; }
+export function computeSedimentologyKernel(data: number[], opts: SedimentologyKernelOptions = {}): SedimentologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyKernel };
diff --git a/src/sedimentology/laplacian.ts b/src/sedimentology/laplacian.ts
new file mode 100644
index 000000000..29da6d021
--- /dev/null
+++ b/src/sedimentology/laplacian.ts
@@ -0,0 +1,14 @@
+/** sedimentology laplacian module — tsb analytics library. */
+export interface SedimentologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeSedimentologyLaplacian(data: number[], opts: SedimentologyLaplacianOptions = {}): SedimentologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyLaplacian };
diff --git a/src/sedimentology/learning.ts b/src/sedimentology/learning.ts
new file mode 100644
index 000000000..7d420beb4
--- /dev/null
+++ b/src/sedimentology/learning.ts
@@ -0,0 +1,14 @@
+/** sedimentology learning module — tsb analytics library. */
+export interface SedimentologyLearningOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyLearningResult { values: number[]; converged: boolean; }
+export function computeSedimentologyLearning(data: number[], opts: SedimentologyLearningOptions = {}): SedimentologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyLearning };
diff --git a/src/sedimentology/linear.ts b/src/sedimentology/linear.ts
new file mode 100644
index 000000000..bf7811f87
--- /dev/null
+++ b/src/sedimentology/linear.ts
@@ -0,0 +1,14 @@
+/** sedimentology linear module — tsb analytics library. */
+export interface SedimentologyLinearOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyLinearResult { values: number[]; converged: boolean; }
+export function computeSedimentologyLinear(data: number[], opts: SedimentologyLinearOptions = {}): SedimentologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyLinear };
diff --git a/src/sedimentology/manifold.ts b/src/sedimentology/manifold.ts
new file mode 100644
index 000000000..31023104b
--- /dev/null
+++ b/src/sedimentology/manifold.ts
@@ -0,0 +1,14 @@
+/** sedimentology manifold module — tsb analytics library. */
+export interface SedimentologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyManifoldResult { values: number[]; converged: boolean; }
+export function computeSedimentologyManifold(data: number[], opts: SedimentologyManifoldOptions = {}): SedimentologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyManifold };
diff --git a/src/sedimentology/matching.ts b/src/sedimentology/matching.ts
new file mode 100644
index 000000000..ab0fb7379
--- /dev/null
+++ b/src/sedimentology/matching.ts
@@ -0,0 +1,14 @@
+/** sedimentology matching module — tsb analytics library. */
+export interface SedimentologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyMatchingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyMatching(data: number[], opts: SedimentologyMatchingOptions = {}): SedimentologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyMatching };
diff --git a/src/sedimentology/measurement.ts b/src/sedimentology/measurement.ts
new file mode 100644
index 000000000..097ec26e3
--- /dev/null
+++ b/src/sedimentology/measurement.ts
@@ -0,0 +1,14 @@
+/** sedimentology measurement module — tsb analytics library. */
+export interface SedimentologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeSedimentologyMeasurement(data: number[], opts: SedimentologyMeasurementOptions = {}): SedimentologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyMeasurement };
diff --git a/src/sedimentology/metrics.ts b/src/sedimentology/metrics.ts
new file mode 100644
index 000000000..357843fe3
--- /dev/null
+++ b/src/sedimentology/metrics.ts
@@ -0,0 +1,14 @@
+/** sedimentology metrics module — tsb analytics library. */
+export interface SedimentologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyMetricsResult { values: number[]; converged: boolean; }
+export function computeSedimentologyMetrics(data: number[], opts: SedimentologyMetricsOptions = {}): SedimentologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyMetrics };
diff --git a/src/sedimentology/modeling.ts b/src/sedimentology/modeling.ts
new file mode 100644
index 000000000..c450895eb
--- /dev/null
+++ b/src/sedimentology/modeling.ts
@@ -0,0 +1,14 @@
+/** sedimentology modeling module — tsb analytics library. */
+export interface SedimentologyModelingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyModelingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyModeling(data: number[], opts: SedimentologyModelingOptions = {}): SedimentologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyModeling };
diff --git a/src/sedimentology/monitoring.ts b/src/sedimentology/monitoring.ts
new file mode 100644
index 000000000..92d8b0984
--- /dev/null
+++ b/src/sedimentology/monitoring.ts
@@ -0,0 +1,14 @@
+/** sedimentology monitoring module — tsb analytics library. */
+export interface SedimentologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeSedimentologyMonitoring(data: number[], opts: SedimentologyMonitoringOptions = {}): SedimentologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyMonitoring };
diff --git a/src/sedimentology/nonlinear.ts b/src/sedimentology/nonlinear.ts
new file mode 100644
index 000000000..de294c780
--- /dev/null
+++ b/src/sedimentology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** sedimentology nonlinear module — tsb analytics library. */
+export interface SedimentologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeSedimentologyNonlinear(data: number[], opts: SedimentologyNonlinearOptions = {}): SedimentologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyNonlinear };
diff --git a/src/sedimentology/normalization.ts b/src/sedimentology/normalization.ts
new file mode 100644
index 000000000..2ee086d1b
--- /dev/null
+++ b/src/sedimentology/normalization.ts
@@ -0,0 +1,14 @@
+/** sedimentology normalization module — tsb analytics library. */
+export interface SedimentologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyNormalization(data: number[], opts: SedimentologyNormalizationOptions = {}): SedimentologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyNormalization };
diff --git a/src/sedimentology/optimization.ts b/src/sedimentology/optimization.ts
new file mode 100644
index 000000000..8d4e8eac1
--- /dev/null
+++ b/src/sedimentology/optimization.ts
@@ -0,0 +1,14 @@
+/** sedimentology optimization module — tsb analytics library. */
+export interface SedimentologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyOptimization(data: number[], opts: SedimentologyOptimizationOptions = {}): SedimentologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyOptimization };
diff --git a/src/sedimentology/patterns.ts b/src/sedimentology/patterns.ts
new file mode 100644
index 000000000..73785926d
--- /dev/null
+++ b/src/sedimentology/patterns.ts
@@ -0,0 +1,14 @@
+/** sedimentology patterns module — tsb analytics library. */
+export interface SedimentologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyPatternsResult { values: number[]; converged: boolean; }
+export function computeSedimentologyPatterns(data: number[], opts: SedimentologyPatternsOptions = {}): SedimentologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyPatterns };
diff --git a/src/sedimentology/permutation.ts b/src/sedimentology/permutation.ts
new file mode 100644
index 000000000..bbd861a2f
--- /dev/null
+++ b/src/sedimentology/permutation.ts
@@ -0,0 +1,14 @@
+/** sedimentology permutation module — tsb analytics library. */
+export interface SedimentologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyPermutationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyPermutation(data: number[], opts: SedimentologyPermutationOptions = {}): SedimentologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyPermutation };
diff --git a/src/sedimentology/prediction.ts b/src/sedimentology/prediction.ts
new file mode 100644
index 000000000..f3e43b6f0
--- /dev/null
+++ b/src/sedimentology/prediction.ts
@@ -0,0 +1,14 @@
+/** sedimentology prediction module — tsb analytics library. */
+export interface SedimentologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyPredictionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyPrediction(data: number[], opts: SedimentologyPredictionOptions = {}): SedimentologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyPrediction };
diff --git a/src/sedimentology/processing.ts b/src/sedimentology/processing.ts
new file mode 100644
index 000000000..ffeb22a0d
--- /dev/null
+++ b/src/sedimentology/processing.ts
@@ -0,0 +1,14 @@
+/** sedimentology processing module — tsb analytics library. */
+export interface SedimentologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyProcessingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyProcessing(data: number[], opts: SedimentologyProcessingOptions = {}): SedimentologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyProcessing };
diff --git a/src/sedimentology/profiling.ts b/src/sedimentology/profiling.ts
new file mode 100644
index 000000000..e54b1cbce
--- /dev/null
+++ b/src/sedimentology/profiling.ts
@@ -0,0 +1,14 @@
+/** sedimentology profiling module — tsb analytics library. */
+export interface SedimentologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyProfilingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyProfiling(data: number[], opts: SedimentologyProfilingOptions = {}): SedimentologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyProfiling };
diff --git a/src/sedimentology/projection.ts b/src/sedimentology/projection.ts
new file mode 100644
index 000000000..ba1f88d51
--- /dev/null
+++ b/src/sedimentology/projection.ts
@@ -0,0 +1,14 @@
+/** sedimentology projection module — tsb analytics library. */
+export interface SedimentologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyProjectionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyProjection(data: number[], opts: SedimentologyProjectionOptions = {}): SedimentologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyProjection };
diff --git a/src/sedimentology/ranking.ts b/src/sedimentology/ranking.ts
new file mode 100644
index 000000000..ecfc11206
--- /dev/null
+++ b/src/sedimentology/ranking.ts
@@ -0,0 +1,14 @@
+/** sedimentology ranking module — tsb analytics library. */
+export interface SedimentologyRankingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyRankingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyRanking(data: number[], opts: SedimentologyRankingOptions = {}): SedimentologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyRanking };
diff --git a/src/sedimentology/reconstruction.ts b/src/sedimentology/reconstruction.ts
new file mode 100644
index 000000000..096d517e4
--- /dev/null
+++ b/src/sedimentology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** sedimentology reconstruction module — tsb analytics library. */
+export interface SedimentologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyReconstruction(data: number[], opts: SedimentologyReconstructionOptions = {}): SedimentologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyReconstruction };
diff --git a/src/sedimentology/registration.ts b/src/sedimentology/registration.ts
new file mode 100644
index 000000000..5dd15c4fc
--- /dev/null
+++ b/src/sedimentology/registration.ts
@@ -0,0 +1,14 @@
+/** sedimentology registration module — tsb analytics library. */
+export interface SedimentologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyRegistration(data: number[], opts: SedimentologyRegistrationOptions = {}): SedimentologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyRegistration };
diff --git a/src/sedimentology/regression.ts b/src/sedimentology/regression.ts
new file mode 100644
index 000000000..63b436d79
--- /dev/null
+++ b/src/sedimentology/regression.ts
@@ -0,0 +1,14 @@
+/** sedimentology regression module — tsb analytics library. */
+export interface SedimentologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyRegressionResult { values: number[]; converged: boolean; }
+export function computeSedimentologyRegression(data: number[], opts: SedimentologyRegressionOptions = {}): SedimentologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyRegression };
diff --git a/src/sedimentology/regularization.ts b/src/sedimentology/regularization.ts
new file mode 100644
index 000000000..15decad92
--- /dev/null
+++ b/src/sedimentology/regularization.ts
@@ -0,0 +1,14 @@
+/** sedimentology regularization module — tsb analytics library. */
+export interface SedimentologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyRegularization(data: number[], opts: SedimentologyRegularizationOptions = {}): SedimentologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyRegularization };
diff --git a/src/sedimentology/robustness.ts b/src/sedimentology/robustness.ts
new file mode 100644
index 000000000..e8d6f4581
--- /dev/null
+++ b/src/sedimentology/robustness.ts
@@ -0,0 +1,14 @@
+/** sedimentology robustness module — tsb analytics library. */
+export interface SedimentologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeSedimentologyRobustness(data: number[], opts: SedimentologyRobustnessOptions = {}): SedimentologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyRobustness };
diff --git a/src/sedimentology/sampling.ts b/src/sedimentology/sampling.ts
new file mode 100644
index 000000000..53588ce69
--- /dev/null
+++ b/src/sedimentology/sampling.ts
@@ -0,0 +1,14 @@
+/** sedimentology sampling module — tsb analytics library. */
+export interface SedimentologySamplingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologySamplingResult { values: number[]; converged: boolean; }
+export function computeSedimentologySampling(data: number[], opts: SedimentologySamplingOptions = {}): SedimentologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologySampling };
diff --git a/src/sedimentology/sampling2.ts b/src/sedimentology/sampling2.ts
new file mode 100644
index 000000000..ee115b68d
--- /dev/null
+++ b/src/sedimentology/sampling2.ts
@@ -0,0 +1,14 @@
+/** sedimentology sampling2 module — tsb analytics library. */
+export interface SedimentologySamplingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologySamplingResult { values: number[]; converged: boolean; }
+export function computeSedimentologySampling(data: number[], opts: SedimentologySamplingOptions = {}): SedimentologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologySampling };
diff --git a/src/sedimentology/scaling.ts b/src/sedimentology/scaling.ts
new file mode 100644
index 000000000..299ee88b1
--- /dev/null
+++ b/src/sedimentology/scaling.ts
@@ -0,0 +1,14 @@
+/** sedimentology scaling module — tsb analytics library. */
+export interface SedimentologyScalingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyScalingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyScaling(data: number[], opts: SedimentologyScalingOptions = {}): SedimentologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyScaling };
diff --git a/src/sedimentology/scoring.ts b/src/sedimentology/scoring.ts
new file mode 100644
index 000000000..25b18c42b
--- /dev/null
+++ b/src/sedimentology/scoring.ts
@@ -0,0 +1,14 @@
+/** sedimentology scoring module — tsb analytics library. */
+export interface SedimentologyScoringOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyScoringResult { values: number[]; converged: boolean; }
+export function computeSedimentologyScoring(data: number[], opts: SedimentologyScoringOptions = {}): SedimentologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyScoring };
diff --git a/src/sedimentology/segmentation.ts b/src/sedimentology/segmentation.ts
new file mode 100644
index 000000000..b0427f268
--- /dev/null
+++ b/src/sedimentology/segmentation.ts
@@ -0,0 +1,14 @@
+/** sedimentology segmentation module — tsb analytics library. */
+export interface SedimentologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologySegmentationResult { values: number[]; converged: boolean; }
+export function computeSedimentologySegmentation(data: number[], opts: SedimentologySegmentationOptions = {}): SedimentologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologySegmentation };
diff --git a/src/sedimentology/selection.ts b/src/sedimentology/selection.ts
new file mode 100644
index 000000000..374b74af9
--- /dev/null
+++ b/src/sedimentology/selection.ts
@@ -0,0 +1,14 @@
+/** sedimentology selection module — tsb analytics library. */
+export interface SedimentologySelectionOptions { tol?: number; maxIter?: number; }
+export interface SedimentologySelectionResult { values: number[]; converged: boolean; }
+export function computeSedimentologySelection(data: number[], opts: SedimentologySelectionOptions = {}): SedimentologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologySelection };
diff --git a/src/sedimentology/sensitivity.ts b/src/sedimentology/sensitivity.ts
new file mode 100644
index 000000000..b69cb854f
--- /dev/null
+++ b/src/sedimentology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** sedimentology sensitivity module — tsb analytics library. */
+export interface SedimentologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface SedimentologySensitivityResult { values: number[]; converged: boolean; }
+export function computeSedimentologySensitivity(data: number[], opts: SedimentologySensitivityOptions = {}): SedimentologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologySensitivity };
diff --git a/src/sedimentology/simulation.ts b/src/sedimentology/simulation.ts
new file mode 100644
index 000000000..92c8bf510
--- /dev/null
+++ b/src/sedimentology/simulation.ts
@@ -0,0 +1,14 @@
+/** sedimentology simulation module — tsb analytics library. */
+export interface SedimentologySimulationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologySimulationResult { values: number[]; converged: boolean; }
+export function computeSedimentologySimulation(data: number[], opts: SedimentologySimulationOptions = {}): SedimentologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologySimulation };
diff --git a/src/sedimentology/smoothing.ts b/src/sedimentology/smoothing.ts
new file mode 100644
index 000000000..6fc79a462
--- /dev/null
+++ b/src/sedimentology/smoothing.ts
@@ -0,0 +1,14 @@
+/** sedimentology smoothing module — tsb analytics library. */
+export interface SedimentologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologySmoothingResult { values: number[]; converged: boolean; }
+export function computeSedimentologySmoothing(data: number[], opts: SedimentologySmoothingOptions = {}): SedimentologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologySmoothing };
diff --git a/src/sedimentology/stability.ts b/src/sedimentology/stability.ts
new file mode 100644
index 000000000..1bb5d8665
--- /dev/null
+++ b/src/sedimentology/stability.ts
@@ -0,0 +1,14 @@
+/** sedimentology stability module — tsb analytics library. */
+export interface SedimentologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyStabilityResult { values: number[]; converged: boolean; }
+export function computeSedimentologyStability(data: number[], opts: SedimentologyStabilityOptions = {}): SedimentologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyStability };
diff --git a/src/sedimentology/stacking.ts b/src/sedimentology/stacking.ts
new file mode 100644
index 000000000..e2ef9bad1
--- /dev/null
+++ b/src/sedimentology/stacking.ts
@@ -0,0 +1,14 @@
+/** sedimentology stacking module — tsb analytics library. */
+export interface SedimentologyStackingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyStackingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyStacking(data: number[], opts: SedimentologyStackingOptions = {}): SedimentologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyStacking };
diff --git a/src/sedimentology/standardization.ts b/src/sedimentology/standardization.ts
new file mode 100644
index 000000000..85454f419
--- /dev/null
+++ b/src/sedimentology/standardization.ts
@@ -0,0 +1,14 @@
+/** sedimentology standardization module — tsb analytics library. */
+export interface SedimentologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyStandardization(data: number[], opts: SedimentologyStandardizationOptions = {}): SedimentologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyStandardization };
diff --git a/src/sedimentology/static.ts b/src/sedimentology/static.ts
new file mode 100644
index 000000000..7665a9480
--- /dev/null
+++ b/src/sedimentology/static.ts
@@ -0,0 +1,14 @@
+/** sedimentology static module — tsb analytics library. */
+export interface SedimentologyStaticOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyStaticResult { values: number[]; converged: boolean; }
+export function computeSedimentologyStatic(data: number[], opts: SedimentologyStaticOptions = {}): SedimentologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyStatic };
diff --git a/src/sedimentology/stochastic.ts b/src/sedimentology/stochastic.ts
new file mode 100644
index 000000000..66f5a879d
--- /dev/null
+++ b/src/sedimentology/stochastic.ts
@@ -0,0 +1,14 @@
+/** sedimentology stochastic module — tsb analytics library. */
+export interface SedimentologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyStochasticResult { values: number[]; converged: boolean; }
+export function computeSedimentologyStochastic(data: number[], opts: SedimentologyStochasticOptions = {}): SedimentologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyStochastic };
diff --git a/src/sedimentology/synthesis.ts b/src/sedimentology/synthesis.ts
new file mode 100644
index 000000000..218b5ac77
--- /dev/null
+++ b/src/sedimentology/synthesis.ts
@@ -0,0 +1,14 @@
+/** sedimentology synthesis module — tsb analytics library. */
+export interface SedimentologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface SedimentologySynthesisResult { values: number[]; converged: boolean; }
+export function computeSedimentologySynthesis(data: number[], opts: SedimentologySynthesisOptions = {}): SedimentologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologySynthesis };
diff --git a/src/sedimentology/topology.ts b/src/sedimentology/topology.ts
new file mode 100644
index 000000000..bb8e24fa9
--- /dev/null
+++ b/src/sedimentology/topology.ts
@@ -0,0 +1,14 @@
+/** sedimentology topology module — tsb analytics library. */
+export interface SedimentologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyTopologyResult { values: number[]; converged: boolean; }
+export function computeSedimentologyTopology(data: number[], opts: SedimentologyTopologyOptions = {}): SedimentologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyTopology };
diff --git a/src/sedimentology/tracking.ts b/src/sedimentology/tracking.ts
new file mode 100644
index 000000000..b54bcf4d5
--- /dev/null
+++ b/src/sedimentology/tracking.ts
@@ -0,0 +1,14 @@
+/** sedimentology tracking module — tsb analytics library. */
+export interface SedimentologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyTrackingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyTracking(data: number[], opts: SedimentologyTrackingOptions = {}): SedimentologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyTracking };
diff --git a/src/sedimentology/transform.ts b/src/sedimentology/transform.ts
new file mode 100644
index 000000000..2db8e12af
--- /dev/null
+++ b/src/sedimentology/transform.ts
@@ -0,0 +1,14 @@
+/** sedimentology transform module — tsb analytics library. */
+export interface SedimentologyTransformOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyTransformResult { values: number[]; converged: boolean; }
+export function computeSedimentologyTransform(data: number[], opts: SedimentologyTransformOptions = {}): SedimentologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyTransform };
diff --git a/src/sedimentology/uncertainty.ts b/src/sedimentology/uncertainty.ts
new file mode 100644
index 000000000..80d24a910
--- /dev/null
+++ b/src/sedimentology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** sedimentology uncertainty module — tsb analytics library. */
+export interface SedimentologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeSedimentologyUncertainty(data: number[], opts: SedimentologyUncertaintyOptions = {}): SedimentologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyUncertainty };
diff --git a/src/sedimentology/validation.ts b/src/sedimentology/validation.ts
new file mode 100644
index 000000000..bac6a0f40
--- /dev/null
+++ b/src/sedimentology/validation.ts
@@ -0,0 +1,14 @@
+/** sedimentology validation module — tsb analytics library. */
+export interface SedimentologyValidationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyValidationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyValidation(data: number[], opts: SedimentologyValidationOptions = {}): SedimentologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyValidation };
diff --git a/src/sedimentology/verification.ts b/src/sedimentology/verification.ts
new file mode 100644
index 000000000..3e3d13b00
--- /dev/null
+++ b/src/sedimentology/verification.ts
@@ -0,0 +1,14 @@
+/** sedimentology verification module — tsb analytics library. */
+export interface SedimentologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyVerificationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyVerification(data: number[], opts: SedimentologyVerificationOptions = {}): SedimentologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyVerification };
diff --git a/src/sedimentology/visualization.ts b/src/sedimentology/visualization.ts
new file mode 100644
index 000000000..ab0c63fe7
--- /dev/null
+++ b/src/sedimentology/visualization.ts
@@ -0,0 +1,14 @@
+/** sedimentology visualization module — tsb analytics library. */
+export interface SedimentologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeSedimentologyVisualization(data: number[], opts: SedimentologyVisualizationOptions = {}): SedimentologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyVisualization };
diff --git a/src/sedimentology/voting.ts b/src/sedimentology/voting.ts
new file mode 100644
index 000000000..f91f06a6d
--- /dev/null
+++ b/src/sedimentology/voting.ts
@@ -0,0 +1,14 @@
+/** sedimentology voting module — tsb analytics library. */
+export interface SedimentologyVotingOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyVotingResult { values: number[]; converged: boolean; }
+export function computeSedimentologyVoting(data: number[], opts: SedimentologyVotingOptions = {}): SedimentologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyVoting };
diff --git a/src/sedimentology/wavelet.ts b/src/sedimentology/wavelet.ts
new file mode 100644
index 000000000..3d8bba64f
--- /dev/null
+++ b/src/sedimentology/wavelet.ts
@@ -0,0 +1,14 @@
+/** sedimentology wavelet module — tsb analytics library. */
+export interface SedimentologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface SedimentologyWaveletResult { values: number[]; converged: boolean; }
+export function computeSedimentologyWavelet(data: number[], opts: SedimentologyWaveletOptions = {}): SedimentologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSedimentologyWavelet };
diff --git a/src/seismology_sci/adaptation.ts b/src/seismology_sci/adaptation.ts
new file mode 100644
index 000000000..d2ea00178
--- /dev/null
+++ b/src/seismology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci adaptation module — tsb analytics library. */
+export interface SeismologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciAdaptation(data: number[], opts: SeismologySciAdaptationOptions = {}): SeismologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciAdaptation };
diff --git a/src/seismology_sci/aggregation.ts b/src/seismology_sci/aggregation.ts
new file mode 100644
index 000000000..4505c524c
--- /dev/null
+++ b/src/seismology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci aggregation module — tsb analytics library. */
+export interface SeismologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciAggregation(data: number[], opts: SeismologySciAggregationOptions = {}): SeismologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciAggregation };
diff --git a/src/seismology_sci/algebra.ts b/src/seismology_sci/algebra.ts
new file mode 100644
index 000000000..6b6e0813a
--- /dev/null
+++ b/src/seismology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** seismology_sci algebra module — tsb analytics library. */
+export interface SeismologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeSeismologySciAlgebra(data: number[], opts: SeismologySciAlgebraOptions = {}): SeismologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciAlgebra };
diff --git a/src/seismology_sci/alignment.ts b/src/seismology_sci/alignment.ts
new file mode 100644
index 000000000..a9f91b6b6
--- /dev/null
+++ b/src/seismology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** seismology_sci alignment module — tsb analytics library. */
+export interface SeismologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeSeismologySciAlignment(data: number[], opts: SeismologySciAlignmentOptions = {}): SeismologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciAlignment };
diff --git a/src/seismology_sci/analysis.ts b/src/seismology_sci/analysis.ts
new file mode 100644
index 000000000..99546c903
--- /dev/null
+++ b/src/seismology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** seismology_sci analysis module — tsb analytics library. */
+export interface SeismologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeSeismologySciAnalysis(data: number[], opts: SeismologySciAnalysisOptions = {}): SeismologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciAnalysis };
diff --git a/src/seismology_sci/augmentation.ts b/src/seismology_sci/augmentation.ts
new file mode 100644
index 000000000..a342097c3
--- /dev/null
+++ b/src/seismology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci augmentation module — tsb analytics library. */
+export interface SeismologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciAugmentation(data: number[], opts: SeismologySciAugmentationOptions = {}): SeismologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciAugmentation };
diff --git a/src/seismology_sci/bagging.ts b/src/seismology_sci/bagging.ts
new file mode 100644
index 000000000..2f3e1e5be
--- /dev/null
+++ b/src/seismology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** seismology_sci bagging module — tsb analytics library. */
+export interface SeismologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciBagging(data: number[], opts: SeismologySciBaggingOptions = {}): SeismologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciBagging };
diff --git a/src/seismology_sci/basis.ts b/src/seismology_sci/basis.ts
new file mode 100644
index 000000000..86ae315c4
--- /dev/null
+++ b/src/seismology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** seismology_sci basis module — tsb analytics library. */
+export interface SeismologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciBasisResult { values: number[]; converged: boolean; }
+export function computeSeismologySciBasis(data: number[], opts: SeismologySciBasisOptions = {}): SeismologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciBasis };
diff --git a/src/seismology_sci/benchmarking.ts b/src/seismology_sci/benchmarking.ts
new file mode 100644
index 000000000..fbec3ff47
--- /dev/null
+++ b/src/seismology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** seismology_sci benchmarking module — tsb analytics library. */
+export interface SeismologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciBenchmarking(data: number[], opts: SeismologySciBenchmarkingOptions = {}): SeismologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciBenchmarking };
diff --git a/src/seismology_sci/blending.ts b/src/seismology_sci/blending.ts
new file mode 100644
index 000000000..cee14078e
--- /dev/null
+++ b/src/seismology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** seismology_sci blending module — tsb analytics library. */
+export interface SeismologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciBlending(data: number[], opts: SeismologySciBlendingOptions = {}): SeismologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciBlending };
diff --git a/src/seismology_sci/boosting.ts b/src/seismology_sci/boosting.ts
new file mode 100644
index 000000000..7158e0259
--- /dev/null
+++ b/src/seismology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** seismology_sci boosting module — tsb analytics library. */
+export interface SeismologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciBoosting(data: number[], opts: SeismologySciBoostingOptions = {}): SeismologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciBoosting };
diff --git a/src/seismology_sci/bootstrap.ts b/src/seismology_sci/bootstrap.ts
new file mode 100644
index 000000000..243601f33
--- /dev/null
+++ b/src/seismology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** seismology_sci bootstrap module — tsb analytics library. */
+export interface SeismologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeSeismologySciBootstrap(data: number[], opts: SeismologySciBootstrapOptions = {}): SeismologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciBootstrap };
diff --git a/src/seismology_sci/calculus.ts b/src/seismology_sci/calculus.ts
new file mode 100644
index 000000000..67e9560aa
--- /dev/null
+++ b/src/seismology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** seismology_sci calculus module — tsb analytics library. */
+export interface SeismologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeSeismologySciCalculus(data: number[], opts: SeismologySciCalculusOptions = {}): SeismologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciCalculus };
diff --git a/src/seismology_sci/calibration.ts b/src/seismology_sci/calibration.ts
new file mode 100644
index 000000000..ecb1c2b99
--- /dev/null
+++ b/src/seismology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** seismology_sci calibration module — tsb analytics library. */
+export interface SeismologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciCalibration(data: number[], opts: SeismologySciCalibrationOptions = {}): SeismologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciCalibration };
diff --git a/src/seismology_sci/characterization.ts b/src/seismology_sci/characterization.ts
new file mode 100644
index 000000000..9fd386900
--- /dev/null
+++ b/src/seismology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** seismology_sci characterization module — tsb analytics library. */
+export interface SeismologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciCharacterization(data: number[], opts: SeismologySciCharacterizationOptions = {}): SeismologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciCharacterization };
diff --git a/src/seismology_sci/classification.ts b/src/seismology_sci/classification.ts
new file mode 100644
index 000000000..664a81df8
--- /dev/null
+++ b/src/seismology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** seismology_sci classification module — tsb analytics library. */
+export interface SeismologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciClassification(data: number[], opts: SeismologySciClassificationOptions = {}): SeismologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciClassification };
diff --git a/src/seismology_sci/clustering.ts b/src/seismology_sci/clustering.ts
new file mode 100644
index 000000000..4ad84e8aa
--- /dev/null
+++ b/src/seismology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** seismology_sci clustering module — tsb analytics library. */
+export interface SeismologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeSeismologySciClustering(data: number[], opts: SeismologySciClusteringOptions = {}): SeismologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciClustering };
diff --git a/src/seismology_sci/compression.ts b/src/seismology_sci/compression.ts
new file mode 100644
index 000000000..8981d4eb6
--- /dev/null
+++ b/src/seismology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** seismology_sci compression module — tsb analytics library. */
+export interface SeismologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciCompression(data: number[], opts: SeismologySciCompressionOptions = {}): SeismologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciCompression };
diff --git a/src/seismology_sci/continuous.ts b/src/seismology_sci/continuous.ts
new file mode 100644
index 000000000..97f4b615d
--- /dev/null
+++ b/src/seismology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** seismology_sci continuous module — tsb analytics library. */
+export interface SeismologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeSeismologySciContinuous(data: number[], opts: SeismologySciContinuousOptions = {}): SeismologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciContinuous };
diff --git a/src/seismology_sci/control.ts b/src/seismology_sci/control.ts
new file mode 100644
index 000000000..6230ec831
--- /dev/null
+++ b/src/seismology_sci/control.ts
@@ -0,0 +1,14 @@
+/** seismology_sci control module — tsb analytics library. */
+export interface SeismologySciControlOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciControlResult { values: number[]; converged: boolean; }
+export function computeSeismologySciControl(data: number[], opts: SeismologySciControlOptions = {}): SeismologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciControl };
diff --git a/src/seismology_sci/convergence.ts b/src/seismology_sci/convergence.ts
new file mode 100644
index 000000000..ea7d87646
--- /dev/null
+++ b/src/seismology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** seismology_sci convergence module — tsb analytics library. */
+export interface SeismologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeSeismologySciConvergence(data: number[], opts: SeismologySciConvergenceOptions = {}): SeismologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciConvergence };
diff --git a/src/seismology_sci/convex.ts b/src/seismology_sci/convex.ts
new file mode 100644
index 000000000..3c9c23557
--- /dev/null
+++ b/src/seismology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** seismology_sci convex module — tsb analytics library. */
+export interface SeismologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciConvexResult { values: number[]; converged: boolean; }
+export function computeSeismologySciConvex(data: number[], opts: SeismologySciConvexOptions = {}): SeismologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciConvex };
diff --git a/src/seismology_sci/correlation.ts b/src/seismology_sci/correlation.ts
new file mode 100644
index 000000000..764f2eab2
--- /dev/null
+++ b/src/seismology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci correlation module — tsb analytics library. */
+export interface SeismologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciCorrelation(data: number[], opts: SeismologySciCorrelationOptions = {}): SeismologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciCorrelation };
diff --git a/src/seismology_sci/covariance.ts b/src/seismology_sci/covariance.ts
new file mode 100644
index 000000000..853e97493
--- /dev/null
+++ b/src/seismology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** seismology_sci covariance module — tsb analytics library. */
+export interface SeismologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeSeismologySciCovariance(data: number[], opts: SeismologySciCovarianceOptions = {}): SeismologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciCovariance };
diff --git a/src/seismology_sci/cross_validation.ts b/src/seismology_sci/cross_validation.ts
new file mode 100644
index 000000000..ee03aa7da
--- /dev/null
+++ b/src/seismology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci cross_validation module — tsb analytics library. */
+export interface SeismologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciCrossValidation(data: number[], opts: SeismologySciCrossValidationOptions = {}): SeismologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciCrossValidation };
diff --git a/src/seismology_sci/decoding.ts b/src/seismology_sci/decoding.ts
new file mode 100644
index 000000000..b647e1b45
--- /dev/null
+++ b/src/seismology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** seismology_sci decoding module — tsb analytics library. */
+export interface SeismologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDecoding(data: number[], opts: SeismologySciDecodingOptions = {}): SeismologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDecoding };
diff --git a/src/seismology_sci/decomposition.ts b/src/seismology_sci/decomposition.ts
new file mode 100644
index 000000000..f9973ebdd
--- /dev/null
+++ b/src/seismology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** seismology_sci decomposition module — tsb analytics library. */
+export interface SeismologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDecomposition(data: number[], opts: SeismologySciDecompositionOptions = {}): SeismologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDecomposition };
diff --git a/src/seismology_sci/detection.ts b/src/seismology_sci/detection.ts
new file mode 100644
index 000000000..8117f6d29
--- /dev/null
+++ b/src/seismology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** seismology_sci detection module — tsb analytics library. */
+export interface SeismologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDetection(data: number[], opts: SeismologySciDetectionOptions = {}): SeismologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDetection };
diff --git a/src/seismology_sci/deterministic.ts b/src/seismology_sci/deterministic.ts
new file mode 100644
index 000000000..2b0e9e02b
--- /dev/null
+++ b/src/seismology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** seismology_sci deterministic module — tsb analytics library. */
+export interface SeismologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDeterministic(data: number[], opts: SeismologySciDeterministicOptions = {}): SeismologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDeterministic };
diff --git a/src/seismology_sci/diagnostics.ts b/src/seismology_sci/diagnostics.ts
new file mode 100644
index 000000000..912c9f38d
--- /dev/null
+++ b/src/seismology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** seismology_sci diagnostics module — tsb analytics library. */
+export interface SeismologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDiagnostics(data: number[], opts: SeismologySciDiagnosticsOptions = {}): SeismologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDiagnostics };
diff --git a/src/seismology_sci/differential.ts b/src/seismology_sci/differential.ts
new file mode 100644
index 000000000..a7385ff78
--- /dev/null
+++ b/src/seismology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** seismology_sci differential module — tsb analytics library. */
+export interface SeismologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDifferential(data: number[], opts: SeismologySciDifferentialOptions = {}): SeismologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDifferential };
diff --git a/src/seismology_sci/discrete.ts b/src/seismology_sci/discrete.ts
new file mode 100644
index 000000000..64e7478e5
--- /dev/null
+++ b/src/seismology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** seismology_sci discrete module — tsb analytics library. */
+export interface SeismologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDiscrete(data: number[], opts: SeismologySciDiscreteOptions = {}): SeismologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDiscrete };
diff --git a/src/seismology_sci/distribution.ts b/src/seismology_sci/distribution.ts
new file mode 100644
index 000000000..8656e50f0
--- /dev/null
+++ b/src/seismology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** seismology_sci distribution module — tsb analytics library. */
+export interface SeismologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDistribution(data: number[], opts: SeismologySciDistributionOptions = {}): SeismologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDistribution };
diff --git a/src/seismology_sci/dynamic.ts b/src/seismology_sci/dynamic.ts
new file mode 100644
index 000000000..bc1dc6aae
--- /dev/null
+++ b/src/seismology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** seismology_sci dynamic module — tsb analytics library. */
+export interface SeismologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeSeismologySciDynamic(data: number[], opts: SeismologySciDynamicOptions = {}): SeismologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciDynamic };
diff --git a/src/seismology_sci/embedding.ts b/src/seismology_sci/embedding.ts
new file mode 100644
index 000000000..1b9894132
--- /dev/null
+++ b/src/seismology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** seismology_sci embedding module — tsb analytics library. */
+export interface SeismologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciEmbedding(data: number[], opts: SeismologySciEmbeddingOptions = {}): SeismologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciEmbedding };
diff --git a/src/seismology_sci/encoding.ts b/src/seismology_sci/encoding.ts
new file mode 100644
index 000000000..3c59aa2e9
--- /dev/null
+++ b/src/seismology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** seismology_sci encoding module — tsb analytics library. */
+export interface SeismologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciEncoding(data: number[], opts: SeismologySciEncodingOptions = {}): SeismologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciEncoding };
diff --git a/src/seismology_sci/ensemble.ts b/src/seismology_sci/ensemble.ts
new file mode 100644
index 000000000..61a8c2d1b
--- /dev/null
+++ b/src/seismology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** seismology_sci ensemble module — tsb analytics library. */
+export interface SeismologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeSeismologySciEnsemble(data: number[], opts: SeismologySciEnsembleOptions = {}): SeismologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciEnsemble };
diff --git a/src/seismology_sci/estimation.ts b/src/seismology_sci/estimation.ts
new file mode 100644
index 000000000..e1312e89f
--- /dev/null
+++ b/src/seismology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci estimation module — tsb analytics library. */
+export interface SeismologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciEstimation(data: number[], opts: SeismologySciEstimationOptions = {}): SeismologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciEstimation };
diff --git a/src/seismology_sci/evaluation.ts b/src/seismology_sci/evaluation.ts
new file mode 100644
index 000000000..5adcac36e
--- /dev/null
+++ b/src/seismology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci evaluation module — tsb analytics library. */
+export interface SeismologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciEvaluation(data: number[], opts: SeismologySciEvaluationOptions = {}): SeismologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciEvaluation };
diff --git a/src/seismology_sci/extrapolation.ts b/src/seismology_sci/extrapolation.ts
new file mode 100644
index 000000000..56b317fe4
--- /dev/null
+++ b/src/seismology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci extrapolation module — tsb analytics library. */
+export interface SeismologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciExtrapolation(data: number[], opts: SeismologySciExtrapolationOptions = {}): SeismologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciExtrapolation };
diff --git a/src/seismology_sci/features.ts b/src/seismology_sci/features.ts
new file mode 100644
index 000000000..ba13c116d
--- /dev/null
+++ b/src/seismology_sci/features.ts
@@ -0,0 +1,14 @@
+/** seismology_sci features module — tsb analytics library. */
+export interface SeismologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeSeismologySciFeatures(data: number[], opts: SeismologySciFeaturesOptions = {}): SeismologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciFeatures };
diff --git a/src/seismology_sci/feedback.ts b/src/seismology_sci/feedback.ts
new file mode 100644
index 000000000..d50840c74
--- /dev/null
+++ b/src/seismology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** seismology_sci feedback module — tsb analytics library. */
+export interface SeismologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeSeismologySciFeedback(data: number[], opts: SeismologySciFeedbackOptions = {}): SeismologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciFeedback };
diff --git a/src/seismology_sci/filtering.ts b/src/seismology_sci/filtering.ts
new file mode 100644
index 000000000..d58fcad2c
--- /dev/null
+++ b/src/seismology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** seismology_sci filtering module — tsb analytics library. */
+export interface SeismologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeSeismologySciFiltering(data: number[], opts: SeismologySciFilteringOptions = {}): SeismologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciFiltering };
diff --git a/src/seismology_sci/fourier.ts b/src/seismology_sci/fourier.ts
new file mode 100644
index 000000000..1975ca21c
--- /dev/null
+++ b/src/seismology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** seismology_sci fourier module — tsb analytics library. */
+export interface SeismologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciFourierResult { values: number[]; converged: boolean; }
+export function computeSeismologySciFourier(data: number[], opts: SeismologySciFourierOptions = {}): SeismologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciFourier };
diff --git a/src/seismology_sci/fusion.ts b/src/seismology_sci/fusion.ts
new file mode 100644
index 000000000..62a8517d9
--- /dev/null
+++ b/src/seismology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** seismology_sci fusion module — tsb analytics library. */
+export interface SeismologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciFusionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciFusion(data: number[], opts: SeismologySciFusionOptions = {}): SeismologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciFusion };
diff --git a/src/seismology_sci/generation.ts b/src/seismology_sci/generation.ts
new file mode 100644
index 000000000..7e4748fb7
--- /dev/null
+++ b/src/seismology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci generation module — tsb analytics library. */
+export interface SeismologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciGeneration(data: number[], opts: SeismologySciGenerationOptions = {}): SeismologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciGeneration };
diff --git a/src/seismology_sci/geometry.ts b/src/seismology_sci/geometry.ts
new file mode 100644
index 000000000..bad48a759
--- /dev/null
+++ b/src/seismology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** seismology_sci geometry module — tsb analytics library. */
+export interface SeismologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeSeismologySciGeometry(data: number[], opts: SeismologySciGeometryOptions = {}): SeismologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciGeometry };
diff --git a/src/seismology_sci/gradient.ts b/src/seismology_sci/gradient.ts
new file mode 100644
index 000000000..5116c9008
--- /dev/null
+++ b/src/seismology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** seismology_sci gradient module — tsb analytics library. */
+export interface SeismologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciGradientResult { values: number[]; converged: boolean; }
+export function computeSeismologySciGradient(data: number[], opts: SeismologySciGradientOptions = {}): SeismologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciGradient };
diff --git a/src/seismology_sci/hessian.ts b/src/seismology_sci/hessian.ts
new file mode 100644
index 000000000..28a40722b
--- /dev/null
+++ b/src/seismology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** seismology_sci hessian module — tsb analytics library. */
+export interface SeismologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciHessianResult { values: number[]; converged: boolean; }
+export function computeSeismologySciHessian(data: number[], opts: SeismologySciHessianOptions = {}): SeismologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciHessian };
diff --git a/src/seismology_sci/hypothesis.ts b/src/seismology_sci/hypothesis.ts
new file mode 100644
index 000000000..c2d50e1da
--- /dev/null
+++ b/src/seismology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** seismology_sci hypothesis module — tsb analytics library. */
+export interface SeismologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeSeismologySciHypothesis(data: number[], opts: SeismologySciHypothesisOptions = {}): SeismologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciHypothesis };
diff --git a/src/seismology_sci/inference.ts b/src/seismology_sci/inference.ts
new file mode 100644
index 000000000..dbb3508b7
--- /dev/null
+++ b/src/seismology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** seismology_sci inference module — tsb analytics library. */
+export interface SeismologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeSeismologySciInference(data: number[], opts: SeismologySciInferenceOptions = {}): SeismologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciInference };
diff --git a/src/seismology_sci/inference2.ts b/src/seismology_sci/inference2.ts
new file mode 100644
index 000000000..bd0bf5348
--- /dev/null
+++ b/src/seismology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** seismology_sci inference2 module — tsb analytics library. */
+export interface SeismologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeSeismologySciInference(data: number[], opts: SeismologySciInferenceOptions = {}): SeismologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciInference };
diff --git a/src/seismology_sci/integral.ts b/src/seismology_sci/integral.ts
new file mode 100644
index 000000000..38ef9e3c2
--- /dev/null
+++ b/src/seismology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** seismology_sci integral module — tsb analytics library. */
+export interface SeismologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeSeismologySciIntegral(data: number[], opts: SeismologySciIntegralOptions = {}): SeismologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciIntegral };
diff --git a/src/seismology_sci/integration.ts b/src/seismology_sci/integration.ts
new file mode 100644
index 000000000..a29b9431a
--- /dev/null
+++ b/src/seismology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** seismology_sci integration module — tsb analytics library. */
+export interface SeismologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciIntegration(data: number[], opts: SeismologySciIntegrationOptions = {}): SeismologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciIntegration };
diff --git a/src/seismology_sci/interpolation.ts b/src/seismology_sci/interpolation.ts
new file mode 100644
index 000000000..674a0d5ac
--- /dev/null
+++ b/src/seismology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci interpolation module — tsb analytics library. */
+export interface SeismologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciInterpolation(data: number[], opts: SeismologySciInterpolationOptions = {}): SeismologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciInterpolation };
diff --git a/src/seismology_sci/jacobian.ts b/src/seismology_sci/jacobian.ts
new file mode 100644
index 000000000..26e6a6d9b
--- /dev/null
+++ b/src/seismology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** seismology_sci jacobian module — tsb analytics library. */
+export interface SeismologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeSeismologySciJacobian(data: number[], opts: SeismologySciJacobianOptions = {}): SeismologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciJacobian };
diff --git a/src/seismology_sci/kernel.ts b/src/seismology_sci/kernel.ts
new file mode 100644
index 000000000..6241a4e12
--- /dev/null
+++ b/src/seismology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** seismology_sci kernel module — tsb analytics library. */
+export interface SeismologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciKernelResult { values: number[]; converged: boolean; }
+export function computeSeismologySciKernel(data: number[], opts: SeismologySciKernelOptions = {}): SeismologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciKernel };
diff --git a/src/seismology_sci/laplacian.ts b/src/seismology_sci/laplacian.ts
new file mode 100644
index 000000000..5de50f22d
--- /dev/null
+++ b/src/seismology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** seismology_sci laplacian module — tsb analytics library. */
+export interface SeismologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeSeismologySciLaplacian(data: number[], opts: SeismologySciLaplacianOptions = {}): SeismologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciLaplacian };
diff --git a/src/seismology_sci/learning.ts b/src/seismology_sci/learning.ts
new file mode 100644
index 000000000..10309f331
--- /dev/null
+++ b/src/seismology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** seismology_sci learning module — tsb analytics library. */
+export interface SeismologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciLearningResult { values: number[]; converged: boolean; }
+export function computeSeismologySciLearning(data: number[], opts: SeismologySciLearningOptions = {}): SeismologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciLearning };
diff --git a/src/seismology_sci/linear.ts b/src/seismology_sci/linear.ts
new file mode 100644
index 000000000..f1a6edd0f
--- /dev/null
+++ b/src/seismology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** seismology_sci linear module — tsb analytics library. */
+export interface SeismologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciLinearResult { values: number[]; converged: boolean; }
+export function computeSeismologySciLinear(data: number[], opts: SeismologySciLinearOptions = {}): SeismologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciLinear };
diff --git a/src/seismology_sci/manifold.ts b/src/seismology_sci/manifold.ts
new file mode 100644
index 000000000..333d9f457
--- /dev/null
+++ b/src/seismology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** seismology_sci manifold module — tsb analytics library. */
+export interface SeismologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeSeismologySciManifold(data: number[], opts: SeismologySciManifoldOptions = {}): SeismologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciManifold };
diff --git a/src/seismology_sci/matching.ts b/src/seismology_sci/matching.ts
new file mode 100644
index 000000000..0c6758efd
--- /dev/null
+++ b/src/seismology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** seismology_sci matching module — tsb analytics library. */
+export interface SeismologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciMatching(data: number[], opts: SeismologySciMatchingOptions = {}): SeismologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciMatching };
diff --git a/src/seismology_sci/measurement.ts b/src/seismology_sci/measurement.ts
new file mode 100644
index 000000000..ed860845a
--- /dev/null
+++ b/src/seismology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** seismology_sci measurement module — tsb analytics library. */
+export interface SeismologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeSeismologySciMeasurement(data: number[], opts: SeismologySciMeasurementOptions = {}): SeismologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciMeasurement };
diff --git a/src/seismology_sci/metrics.ts b/src/seismology_sci/metrics.ts
new file mode 100644
index 000000000..ffb13e57c
--- /dev/null
+++ b/src/seismology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** seismology_sci metrics module — tsb analytics library. */
+export interface SeismologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeSeismologySciMetrics(data: number[], opts: SeismologySciMetricsOptions = {}): SeismologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciMetrics };
diff --git a/src/seismology_sci/modeling.ts b/src/seismology_sci/modeling.ts
new file mode 100644
index 000000000..c1b528084
--- /dev/null
+++ b/src/seismology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** seismology_sci modeling module — tsb analytics library. */
+export interface SeismologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciModelingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciModeling(data: number[], opts: SeismologySciModelingOptions = {}): SeismologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciModeling };
diff --git a/src/seismology_sci/monitoring.ts b/src/seismology_sci/monitoring.ts
new file mode 100644
index 000000000..2cbd57f42
--- /dev/null
+++ b/src/seismology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** seismology_sci monitoring module — tsb analytics library. */
+export interface SeismologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeSeismologySciMonitoring(data: number[], opts: SeismologySciMonitoringOptions = {}): SeismologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciMonitoring };
diff --git a/src/seismology_sci/nonlinear.ts b/src/seismology_sci/nonlinear.ts
new file mode 100644
index 000000000..c6c03313d
--- /dev/null
+++ b/src/seismology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** seismology_sci nonlinear module — tsb analytics library. */
+export interface SeismologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeSeismologySciNonlinear(data: number[], opts: SeismologySciNonlinearOptions = {}): SeismologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciNonlinear };
diff --git a/src/seismology_sci/normalization.ts b/src/seismology_sci/normalization.ts
new file mode 100644
index 000000000..8d34eecef
--- /dev/null
+++ b/src/seismology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** seismology_sci normalization module — tsb analytics library. */
+export interface SeismologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciNormalization(data: number[], opts: SeismologySciNormalizationOptions = {}): SeismologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciNormalization };
diff --git a/src/seismology_sci/optimization.ts b/src/seismology_sci/optimization.ts
new file mode 100644
index 000000000..8c901ef35
--- /dev/null
+++ b/src/seismology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** seismology_sci optimization module — tsb analytics library. */
+export interface SeismologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciOptimization(data: number[], opts: SeismologySciOptimizationOptions = {}): SeismologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciOptimization };
diff --git a/src/seismology_sci/patterns.ts b/src/seismology_sci/patterns.ts
new file mode 100644
index 000000000..604e3265b
--- /dev/null
+++ b/src/seismology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** seismology_sci patterns module — tsb analytics library. */
+export interface SeismologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeSeismologySciPatterns(data: number[], opts: SeismologySciPatternsOptions = {}): SeismologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciPatterns };
diff --git a/src/seismology_sci/permutation.ts b/src/seismology_sci/permutation.ts
new file mode 100644
index 000000000..b1467a5d2
--- /dev/null
+++ b/src/seismology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci permutation module — tsb analytics library. */
+export interface SeismologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciPermutation(data: number[], opts: SeismologySciPermutationOptions = {}): SeismologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciPermutation };
diff --git a/src/seismology_sci/prediction.ts b/src/seismology_sci/prediction.ts
new file mode 100644
index 000000000..b176e008e
--- /dev/null
+++ b/src/seismology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** seismology_sci prediction module — tsb analytics library. */
+export interface SeismologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciPrediction(data: number[], opts: SeismologySciPredictionOptions = {}): SeismologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciPrediction };
diff --git a/src/seismology_sci/processing.ts b/src/seismology_sci/processing.ts
new file mode 100644
index 000000000..47b8722c8
--- /dev/null
+++ b/src/seismology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** seismology_sci processing module — tsb analytics library. */
+export interface SeismologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciProcessing(data: number[], opts: SeismologySciProcessingOptions = {}): SeismologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciProcessing };
diff --git a/src/seismology_sci/profiling.ts b/src/seismology_sci/profiling.ts
new file mode 100644
index 000000000..6e6168df3
--- /dev/null
+++ b/src/seismology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** seismology_sci profiling module — tsb analytics library. */
+export interface SeismologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciProfiling(data: number[], opts: SeismologySciProfilingOptions = {}): SeismologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciProfiling };
diff --git a/src/seismology_sci/projection.ts b/src/seismology_sci/projection.ts
new file mode 100644
index 000000000..c559663e5
--- /dev/null
+++ b/src/seismology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** seismology_sci projection module — tsb analytics library. */
+export interface SeismologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciProjection(data: number[], opts: SeismologySciProjectionOptions = {}): SeismologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciProjection };
diff --git a/src/seismology_sci/ranking.ts b/src/seismology_sci/ranking.ts
new file mode 100644
index 000000000..0534c953e
--- /dev/null
+++ b/src/seismology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** seismology_sci ranking module — tsb analytics library. */
+export interface SeismologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciRankingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciRanking(data: number[], opts: SeismologySciRankingOptions = {}): SeismologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciRanking };
diff --git a/src/seismology_sci/reconstruction.ts b/src/seismology_sci/reconstruction.ts
new file mode 100644
index 000000000..2446be1f4
--- /dev/null
+++ b/src/seismology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** seismology_sci reconstruction module — tsb analytics library. */
+export interface SeismologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciReconstruction(data: number[], opts: SeismologySciReconstructionOptions = {}): SeismologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciReconstruction };
diff --git a/src/seismology_sci/registration.ts b/src/seismology_sci/registration.ts
new file mode 100644
index 000000000..76f9ece3a
--- /dev/null
+++ b/src/seismology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** seismology_sci registration module — tsb analytics library. */
+export interface SeismologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciRegistration(data: number[], opts: SeismologySciRegistrationOptions = {}): SeismologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciRegistration };
diff --git a/src/seismology_sci/regression.ts b/src/seismology_sci/regression.ts
new file mode 100644
index 000000000..cf8e3f95a
--- /dev/null
+++ b/src/seismology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** seismology_sci regression module — tsb analytics library. */
+export interface SeismologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciRegression(data: number[], opts: SeismologySciRegressionOptions = {}): SeismologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciRegression };
diff --git a/src/seismology_sci/regularization.ts b/src/seismology_sci/regularization.ts
new file mode 100644
index 000000000..2b4b30430
--- /dev/null
+++ b/src/seismology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** seismology_sci regularization module — tsb analytics library. */
+export interface SeismologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciRegularization(data: number[], opts: SeismologySciRegularizationOptions = {}): SeismologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciRegularization };
diff --git a/src/seismology_sci/robustness.ts b/src/seismology_sci/robustness.ts
new file mode 100644
index 000000000..d8fd41bbd
--- /dev/null
+++ b/src/seismology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** seismology_sci robustness module — tsb analytics library. */
+export interface SeismologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeSeismologySciRobustness(data: number[], opts: SeismologySciRobustnessOptions = {}): SeismologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciRobustness };
diff --git a/src/seismology_sci/sampling.ts b/src/seismology_sci/sampling.ts
new file mode 100644
index 000000000..30fd616c6
--- /dev/null
+++ b/src/seismology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** seismology_sci sampling module — tsb analytics library. */
+export interface SeismologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciSampling(data: number[], opts: SeismologySciSamplingOptions = {}): SeismologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciSampling };
diff --git a/src/seismology_sci/sampling2.ts b/src/seismology_sci/sampling2.ts
new file mode 100644
index 000000000..410eeb63e
--- /dev/null
+++ b/src/seismology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** seismology_sci sampling2 module — tsb analytics library. */
+export interface SeismologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciSampling(data: number[], opts: SeismologySciSamplingOptions = {}): SeismologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciSampling };
diff --git a/src/seismology_sci/scaling.ts b/src/seismology_sci/scaling.ts
new file mode 100644
index 000000000..699c4b755
--- /dev/null
+++ b/src/seismology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** seismology_sci scaling module — tsb analytics library. */
+export interface SeismologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciScalingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciScaling(data: number[], opts: SeismologySciScalingOptions = {}): SeismologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciScaling };
diff --git a/src/seismology_sci/scoring.ts b/src/seismology_sci/scoring.ts
new file mode 100644
index 000000000..cdc0ee7ed
--- /dev/null
+++ b/src/seismology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** seismology_sci scoring module — tsb analytics library. */
+export interface SeismologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciScoringResult { values: number[]; converged: boolean; }
+export function computeSeismologySciScoring(data: number[], opts: SeismologySciScoringOptions = {}): SeismologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciScoring };
diff --git a/src/seismology_sci/segmentation.ts b/src/seismology_sci/segmentation.ts
new file mode 100644
index 000000000..4a646ef3a
--- /dev/null
+++ b/src/seismology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci segmentation module — tsb analytics library. */
+export interface SeismologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciSegmentation(data: number[], opts: SeismologySciSegmentationOptions = {}): SeismologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciSegmentation };
diff --git a/src/seismology_sci/selection.ts b/src/seismology_sci/selection.ts
new file mode 100644
index 000000000..85cae3c17
--- /dev/null
+++ b/src/seismology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** seismology_sci selection module — tsb analytics library. */
+export interface SeismologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeSeismologySciSelection(data: number[], opts: SeismologySciSelectionOptions = {}): SeismologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciSelection };
diff --git a/src/seismology_sci/sensitivity.ts b/src/seismology_sci/sensitivity.ts
new file mode 100644
index 000000000..2a6755a99
--- /dev/null
+++ b/src/seismology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** seismology_sci sensitivity module — tsb analytics library. */
+export interface SeismologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeSeismologySciSensitivity(data: number[], opts: SeismologySciSensitivityOptions = {}): SeismologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciSensitivity };
diff --git a/src/seismology_sci/simulation.ts b/src/seismology_sci/simulation.ts
new file mode 100644
index 000000000..a1fa78f8b
--- /dev/null
+++ b/src/seismology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci simulation module — tsb analytics library. */
+export interface SeismologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciSimulation(data: number[], opts: SeismologySciSimulationOptions = {}): SeismologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciSimulation };
diff --git a/src/seismology_sci/smoothing.ts b/src/seismology_sci/smoothing.ts
new file mode 100644
index 000000000..082834400
--- /dev/null
+++ b/src/seismology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** seismology_sci smoothing module — tsb analytics library. */
+export interface SeismologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciSmoothing(data: number[], opts: SeismologySciSmoothingOptions = {}): SeismologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciSmoothing };
diff --git a/src/seismology_sci/stability.ts b/src/seismology_sci/stability.ts
new file mode 100644
index 000000000..542ccc0c0
--- /dev/null
+++ b/src/seismology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** seismology_sci stability module — tsb analytics library. */
+export interface SeismologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeSeismologySciStability(data: number[], opts: SeismologySciStabilityOptions = {}): SeismologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciStability };
diff --git a/src/seismology_sci/stacking.ts b/src/seismology_sci/stacking.ts
new file mode 100644
index 000000000..1f0f5f3b6
--- /dev/null
+++ b/src/seismology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** seismology_sci stacking module — tsb analytics library. */
+export interface SeismologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciStackingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciStacking(data: number[], opts: SeismologySciStackingOptions = {}): SeismologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciStacking };
diff --git a/src/seismology_sci/standardization.ts b/src/seismology_sci/standardization.ts
new file mode 100644
index 000000000..464927973
--- /dev/null
+++ b/src/seismology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** seismology_sci standardization module — tsb analytics library. */
+export interface SeismologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciStandardization(data: number[], opts: SeismologySciStandardizationOptions = {}): SeismologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciStandardization };
diff --git a/src/seismology_sci/static.ts b/src/seismology_sci/static.ts
new file mode 100644
index 000000000..a37b81854
--- /dev/null
+++ b/src/seismology_sci/static.ts
@@ -0,0 +1,14 @@
+/** seismology_sci static module — tsb analytics library. */
+export interface SeismologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciStaticResult { values: number[]; converged: boolean; }
+export function computeSeismologySciStatic(data: number[], opts: SeismologySciStaticOptions = {}): SeismologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciStatic };
diff --git a/src/seismology_sci/stochastic.ts b/src/seismology_sci/stochastic.ts
new file mode 100644
index 000000000..6c96d07b5
--- /dev/null
+++ b/src/seismology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** seismology_sci stochastic module — tsb analytics library. */
+export interface SeismologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeSeismologySciStochastic(data: number[], opts: SeismologySciStochasticOptions = {}): SeismologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciStochastic };
diff --git a/src/seismology_sci/synthesis.ts b/src/seismology_sci/synthesis.ts
new file mode 100644
index 000000000..86fbe1e94
--- /dev/null
+++ b/src/seismology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** seismology_sci synthesis module — tsb analytics library. */
+export interface SeismologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeSeismologySciSynthesis(data: number[], opts: SeismologySciSynthesisOptions = {}): SeismologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciSynthesis };
diff --git a/src/seismology_sci/topology.ts b/src/seismology_sci/topology.ts
new file mode 100644
index 000000000..ad982a237
--- /dev/null
+++ b/src/seismology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** seismology_sci topology module — tsb analytics library. */
+export interface SeismologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeSeismologySciTopology(data: number[], opts: SeismologySciTopologyOptions = {}): SeismologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciTopology };
diff --git a/src/seismology_sci/tracking.ts b/src/seismology_sci/tracking.ts
new file mode 100644
index 000000000..d651beaf2
--- /dev/null
+++ b/src/seismology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** seismology_sci tracking module — tsb analytics library. */
+export interface SeismologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciTracking(data: number[], opts: SeismologySciTrackingOptions = {}): SeismologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciTracking };
diff --git a/src/seismology_sci/transform.ts b/src/seismology_sci/transform.ts
new file mode 100644
index 000000000..dcd933ded
--- /dev/null
+++ b/src/seismology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** seismology_sci transform module — tsb analytics library. */
+export interface SeismologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciTransformResult { values: number[]; converged: boolean; }
+export function computeSeismologySciTransform(data: number[], opts: SeismologySciTransformOptions = {}): SeismologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciTransform };
diff --git a/src/seismology_sci/uncertainty.ts b/src/seismology_sci/uncertainty.ts
new file mode 100644
index 000000000..b7122e3d9
--- /dev/null
+++ b/src/seismology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** seismology_sci uncertainty module — tsb analytics library. */
+export interface SeismologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeSeismologySciUncertainty(data: number[], opts: SeismologySciUncertaintyOptions = {}): SeismologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciUncertainty };
diff --git a/src/seismology_sci/validation.ts b/src/seismology_sci/validation.ts
new file mode 100644
index 000000000..e6f95f69a
--- /dev/null
+++ b/src/seismology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** seismology_sci validation module — tsb analytics library. */
+export interface SeismologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciValidationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciValidation(data: number[], opts: SeismologySciValidationOptions = {}): SeismologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciValidation };
diff --git a/src/seismology_sci/verification.ts b/src/seismology_sci/verification.ts
new file mode 100644
index 000000000..f41ff2c65
--- /dev/null
+++ b/src/seismology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** seismology_sci verification module — tsb analytics library. */
+export interface SeismologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciVerification(data: number[], opts: SeismologySciVerificationOptions = {}): SeismologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciVerification };
diff --git a/src/seismology_sci/visualization.ts b/src/seismology_sci/visualization.ts
new file mode 100644
index 000000000..4b224f3d4
--- /dev/null
+++ b/src/seismology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** seismology_sci visualization module — tsb analytics library. */
+export interface SeismologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeSeismologySciVisualization(data: number[], opts: SeismologySciVisualizationOptions = {}): SeismologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciVisualization };
diff --git a/src/seismology_sci/voting.ts b/src/seismology_sci/voting.ts
new file mode 100644
index 000000000..8fe058215
--- /dev/null
+++ b/src/seismology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** seismology_sci voting module — tsb analytics library. */
+export interface SeismologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciVotingResult { values: number[]; converged: boolean; }
+export function computeSeismologySciVoting(data: number[], opts: SeismologySciVotingOptions = {}): SeismologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciVoting };
diff --git a/src/seismology_sci/wavelet.ts b/src/seismology_sci/wavelet.ts
new file mode 100644
index 000000000..4605d1d79
--- /dev/null
+++ b/src/seismology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** seismology_sci wavelet module — tsb analytics library. */
+export interface SeismologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface SeismologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeSeismologySciWavelet(data: number[], opts: SeismologySciWaveletOptions = {}): SeismologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSeismologySciWavelet };
diff --git a/src/signal/adaptive.ts b/src/signal/adaptive.ts
new file mode 100644
index 000000000..178519f44
--- /dev/null
+++ b/src/signal/adaptive.ts
@@ -0,0 +1,22 @@
+/** Adaptive module — tsb analytics library. */
+
+/** Options for Adaptive. */
+export interface AdaptiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Adaptive. */
+export interface AdaptiveResult { values: number[]; converged: boolean; }
+
+/** Compute Adaptive. */
+export function computeAdaptive(data: number[], opts: AdaptiveOptions = {}): AdaptiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAdaptive };
diff --git a/src/signal/advanced.ts b/src/signal/advanced.ts
new file mode 100644
index 000000000..939a208f3
--- /dev/null
+++ b/src/signal/advanced.ts
@@ -0,0 +1,15 @@
+/** Signal Advanced module — tsb analytics library. */
+export interface Signal advancedOptions { tol?: number; maxIter?: number; }
+export interface Signal advancedResult { values: number[]; converged: boolean; }
+export function computeSignal advanced(data: number[], opts: Signal advancedOptions = {}): Signal advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal advanced };
diff --git a/src/signal/autocorrelation_signal.ts b/src/signal/autocorrelation_signal.ts
new file mode 100644
index 000000000..03ba41523
--- /dev/null
+++ b/src/signal/autocorrelation_signal.ts
@@ -0,0 +1,22 @@
+/** Autocorrelation Signal module — tsb analytics library. */
+
+/** Options for Autocorrelation Signal. */
+export interface AutocorrelationSignalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Autocorrelation Signal. */
+export interface AutocorrelationSignalResult { values: number[]; converged: boolean; }
+
+/** Compute Autocorrelation Signal. */
+export function computeAutocorrelationSignal(data: number[], opts: AutocorrelationSignalOptions = {}): AutocorrelationSignalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAutocorrelationSignal };
diff --git a/src/signal/bandpass.ts b/src/signal/bandpass.ts
new file mode 100644
index 000000000..9c15a34d7
--- /dev/null
+++ b/src/signal/bandpass.ts
@@ -0,0 +1,22 @@
+/** Bandpass module — tsb analytics library. */
+
+/** Options for Bandpass. */
+export interface BandpassOptions { tol?: number; maxIter?: number; }
+
+/** Result from Bandpass. */
+export interface BandpassResult { values: number[]; converged: boolean; }
+
+/** Compute Bandpass. */
+export function computeBandpass(data: number[], opts: BandpassOptions = {}): BandpassResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBandpass };
diff --git a/src/signal/base2.ts b/src/signal/base2.ts
new file mode 100644
index 000000000..3918829e6
--- /dev/null
+++ b/src/signal/base2.ts
@@ -0,0 +1,15 @@
+/** Signal Base2 module — tsb analytics library. */
+export interface Signal base2Options { tol?: number; maxIter?: number; }
+export interface Signal base2Result { values: number[]; converged: boolean; }
+export function computeSignal base2(data: number[], opts: Signal base2Options = {}): Signal base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal base2 };
diff --git a/src/signal/batch.ts b/src/signal/batch.ts
new file mode 100644
index 000000000..acf35b37e
--- /dev/null
+++ b/src/signal/batch.ts
@@ -0,0 +1,15 @@
+/** Signal Batch module — tsb analytics library. */
+export interface Signal batchOptions { tol?: number; maxIter?: number; }
+export interface Signal batchResult { values: number[]; converged: boolean; }
+export function computeSignal batch(data: number[], opts: Signal batchOptions = {}): Signal batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal batch };
diff --git a/src/signal/beamforming.ts b/src/signal/beamforming.ts
new file mode 100644
index 000000000..ffee5e15f
--- /dev/null
+++ b/src/signal/beamforming.ts
@@ -0,0 +1,22 @@
+/** Beamforming module — tsb analytics library. */
+
+/** Options for Beamforming. */
+export interface BeamformingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Beamforming. */
+export interface BeamformingResult { values: number[]; converged: boolean; }
+
+/** Compute Beamforming. */
+export function computeBeamforming(data: number[], opts: BeamformingOptions = {}): BeamformingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBeamforming };
diff --git a/src/signal/beta.ts b/src/signal/beta.ts
new file mode 100644
index 000000000..4a7c111b5
--- /dev/null
+++ b/src/signal/beta.ts
@@ -0,0 +1,15 @@
+/** Signal Beta module — tsb analytics library. */
+export interface Signal betaOptions { tol?: number; maxIter?: number; }
+export interface Signal betaResult { values: number[]; converged: boolean; }
+export function computeSignal beta(data: number[], opts: Signal betaOptions = {}): Signal betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal beta };
diff --git a/src/signal/blind.ts b/src/signal/blind.ts
new file mode 100644
index 000000000..78a7209bf
--- /dev/null
+++ b/src/signal/blind.ts
@@ -0,0 +1,22 @@
+/** Blind module — tsb analytics library. */
+
+/** Options for Blind. */
+export interface BlindOptions { tol?: number; maxIter?: number; }
+
+/** Result from Blind. */
+export interface BlindResult { values: number[]; converged: boolean; }
+
+/** Compute Blind. */
+export function computeBlind(data: number[], opts: BlindOptions = {}): BlindResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBlind };
diff --git a/src/signal/cepstrum.ts b/src/signal/cepstrum.ts
new file mode 100644
index 000000000..97fec7173
--- /dev/null
+++ b/src/signal/cepstrum.ts
@@ -0,0 +1,22 @@
+/** Cepstrum module — tsb analytics library. */
+
+/** Options for Cepstrum. */
+export interface CepstrumOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cepstrum. */
+export interface CepstrumResult { values: number[]; converged: boolean; }
+
+/** Compute Cepstrum. */
+export function computeCepstrum(data: number[], opts: CepstrumOptions = {}): CepstrumResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCepstrum };
diff --git a/src/signal/coherence.ts b/src/signal/coherence.ts
new file mode 100644
index 000000000..893529681
--- /dev/null
+++ b/src/signal/coherence.ts
@@ -0,0 +1,22 @@
+/** Coherence module — tsb analytics library. */
+
+/** Options for Coherence. */
+export interface CoherenceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Coherence. */
+export interface CoherenceResult { values: number[]; converged: boolean; }
+
+/** Compute Coherence. */
+export function computeCoherence(data: number[], opts: CoherenceOptions = {}): CoherenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCoherence };
diff --git a/src/signal/compressed_sensing.ts b/src/signal/compressed_sensing.ts
new file mode 100644
index 000000000..72f93acee
--- /dev/null
+++ b/src/signal/compressed_sensing.ts
@@ -0,0 +1,22 @@
+/** Compressed Sensing module — tsb analytics library. */
+
+/** Options for Compressed Sensing. */
+export interface CompressedSensingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Compressed Sensing. */
+export interface CompressedSensingResult { values: number[]; converged: boolean; }
+
+/** Compute Compressed Sensing. */
+export function computeCompressedSensing(data: number[], opts: CompressedSensingOptions = {}): CompressedSensingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCompressedSensing };
diff --git a/src/signal/convolution_signal.ts b/src/signal/convolution_signal.ts
new file mode 100644
index 000000000..ed56ba3e4
--- /dev/null
+++ b/src/signal/convolution_signal.ts
@@ -0,0 +1,22 @@
+/** Convolution Signal module — tsb analytics library. */
+
+/** Options for Convolution Signal. */
+export interface ConvolutionSignalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Convolution Signal. */
+export interface ConvolutionSignalResult { values: number[]; converged: boolean; }
+
+/** Compute Convolution Signal. */
+export function computeConvolutionSignal(data: number[], opts: ConvolutionSignalOptions = {}): ConvolutionSignalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConvolutionSignal };
diff --git a/src/signal/cpu.ts b/src/signal/cpu.ts
new file mode 100644
index 000000000..52a7c5120
--- /dev/null
+++ b/src/signal/cpu.ts
@@ -0,0 +1,15 @@
+/** Signal Cpu module — tsb analytics library. */
+export interface Signal cpuOptions { tol?: number; maxIter?: number; }
+export interface Signal cpuResult { values: number[]; converged: boolean; }
+export function computeSignal cpu(data: number[], opts: Signal cpuOptions = {}): Signal cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal cpu };
diff --git a/src/signal/cross_correlation.ts b/src/signal/cross_correlation.ts
new file mode 100644
index 000000000..fa34b43e7
--- /dev/null
+++ b/src/signal/cross_correlation.ts
@@ -0,0 +1,22 @@
+/** Cross Correlation module — tsb analytics library. */
+
+/** Options for Cross Correlation. */
+export interface CrossCorrelationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cross Correlation. */
+export interface CrossCorrelationResult { values: number[]; converged: boolean; }
+
+/** Compute Cross Correlation. */
+export function computeCrossCorrelation(data: number[], opts: CrossCorrelationOptions = {}): CrossCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCrossCorrelation };
diff --git a/src/signal/cwt.ts b/src/signal/cwt.ts
new file mode 100644
index 000000000..cad49f91d
--- /dev/null
+++ b/src/signal/cwt.ts
@@ -0,0 +1,22 @@
+/** Cwt module — tsb analytics library. */
+
+/** Options for Cwt. */
+export interface CwtOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cwt. */
+export interface CwtResult { values: number[]; converged: boolean; }
+
+/** Compute Cwt. */
+export function computeCwt(data: number[], opts: CwtOptions = {}): CwtResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCwt };
diff --git a/src/signal/deconvolution.ts b/src/signal/deconvolution.ts
new file mode 100644
index 000000000..be64a3233
--- /dev/null
+++ b/src/signal/deconvolution.ts
@@ -0,0 +1,22 @@
+/** Deconvolution module — tsb analytics library. */
+
+/** Options for Deconvolution. */
+export interface DeconvolutionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Deconvolution. */
+export interface DeconvolutionResult { values: number[]; converged: boolean; }
+
+/** Compute Deconvolution. */
+export function computeDeconvolution(data: number[], opts: DeconvolutionOptions = {}): DeconvolutionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDeconvolution };
diff --git a/src/signal/demodulation.ts b/src/signal/demodulation.ts
new file mode 100644
index 000000000..e2c113a86
--- /dev/null
+++ b/src/signal/demodulation.ts
@@ -0,0 +1,22 @@
+/** Demodulation module — tsb analytics library. */
+
+/** Options for Demodulation. */
+export interface DemodulationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Demodulation. */
+export interface DemodulationResult { values: number[]; converged: boolean; }
+
+/** Compute Demodulation. */
+export function computeDemodulation(data: number[], opts: DemodulationOptions = {}): DemodulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDemodulation };
diff --git a/src/signal/dense.ts b/src/signal/dense.ts
new file mode 100644
index 000000000..aa6164a1d
--- /dev/null
+++ b/src/signal/dense.ts
@@ -0,0 +1,15 @@
+/** Signal Dense module — tsb analytics library. */
+export interface Signal denseOptions { tol?: number; maxIter?: number; }
+export interface Signal denseResult { values: number[]; converged: boolean; }
+export function computeSignal dense(data: number[], opts: Signal denseOptions = {}): Signal denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal dense };
diff --git a/src/signal/distributed.ts b/src/signal/distributed.ts
new file mode 100644
index 000000000..f950201f2
--- /dev/null
+++ b/src/signal/distributed.ts
@@ -0,0 +1,15 @@
+/** Signal Distributed module — tsb analytics library. */
+export interface Signal distributedOptions { tol?: number; maxIter?: number; }
+export interface Signal distributedResult { values: number[]; converged: boolean; }
+export function computeSignal distributed(data: number[], opts: Signal distributedOptions = {}): Signal distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal distributed };
diff --git a/src/signal/dwt.ts b/src/signal/dwt.ts
new file mode 100644
index 000000000..c41576823
--- /dev/null
+++ b/src/signal/dwt.ts
@@ -0,0 +1,22 @@
+/** Dwt module — tsb analytics library. */
+
+/** Options for Dwt. */
+export interface DwtOptions { tol?: number; maxIter?: number; }
+
+/** Result from Dwt. */
+export interface DwtResult { values: number[]; converged: boolean; }
+
+/** Compute Dwt. */
+export function computeDwt(data: number[], opts: DwtOptions = {}): DwtResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDwt };
diff --git a/src/signal/envelope.ts b/src/signal/envelope.ts
new file mode 100644
index 000000000..d6f373f78
--- /dev/null
+++ b/src/signal/envelope.ts
@@ -0,0 +1,22 @@
+/** Envelope module — tsb analytics library. */
+
+/** Options for Envelope. */
+export interface EnvelopeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Envelope. */
+export interface EnvelopeResult { values: number[]; converged: boolean; }
+
+/** Compute Envelope. */
+export function computeEnvelope(data: number[], opts: EnvelopeOptions = {}): EnvelopeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEnvelope };
diff --git a/src/signal/experimental.ts b/src/signal/experimental.ts
new file mode 100644
index 000000000..dcb64188c
--- /dev/null
+++ b/src/signal/experimental.ts
@@ -0,0 +1,15 @@
+/** Signal Experimental module — tsb analytics library. */
+export interface Signal experimentalOptions { tol?: number; maxIter?: number; }
+export interface Signal experimentalResult { values: number[]; converged: boolean; }
+export function computeSignal experimental(data: number[], opts: Signal experimentalOptions = {}): Signal experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal experimental };
diff --git a/src/signal/fast.ts b/src/signal/fast.ts
new file mode 100644
index 000000000..0d50733c7
--- /dev/null
+++ b/src/signal/fast.ts
@@ -0,0 +1,15 @@
+/** Signal Fast module — tsb analytics library. */
+export interface Signal fastOptions { tol?: number; maxIter?: number; }
+export interface Signal fastResult { values: number[]; converged: boolean; }
+export function computeSignal fast(data: number[], opts: Signal fastOptions = {}): Signal fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal fast };
diff --git a/src/signal/fft.ts b/src/signal/fft.ts
new file mode 100644
index 000000000..ef1f48310
--- /dev/null
+++ b/src/signal/fft.ts
@@ -0,0 +1,22 @@
+/** Fft module — tsb analytics library. */
+
+/** Options for Fft. */
+export interface FftOptions { tol?: number; maxIter?: number; }
+
+/** Result from Fft. */
+export interface FftResult { values: number[]; converged: boolean; }
+
+/** Compute Fft. */
+export function computeFft(data: number[], opts: FftOptions = {}): FftResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFft };
diff --git a/src/signal/filter_design.ts b/src/signal/filter_design.ts
new file mode 100644
index 000000000..676ac5360
--- /dev/null
+++ b/src/signal/filter_design.ts
@@ -0,0 +1,22 @@
+/** Filter Design module — tsb analytics library. */
+
+/** Options for Filter Design. */
+export interface FilterDesignOptions { tol?: number; maxIter?: number; }
+
+/** Result from Filter Design. */
+export interface FilterDesignResult { values: number[]; converged: boolean; }
+
+/** Compute Filter Design. */
+export function computeFilterDesign(data: number[], opts: FilterDesignOptions = {}): FilterDesignResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFilterDesign };
diff --git a/src/signal/future.ts b/src/signal/future.ts
new file mode 100644
index 000000000..6de1d8a83
--- /dev/null
+++ b/src/signal/future.ts
@@ -0,0 +1,15 @@
+/** Signal Future module — tsb analytics library. */
+export interface Signal futureOptions { tol?: number; maxIter?: number; }
+export interface Signal futureResult { values: number[]; converged: boolean; }
+export function computeSignal future(data: number[], opts: Signal futureOptions = {}): Signal futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal future };
diff --git a/src/signal/gpu.ts b/src/signal/gpu.ts
new file mode 100644
index 000000000..fe3473fbf
--- /dev/null
+++ b/src/signal/gpu.ts
@@ -0,0 +1,15 @@
+/** Signal Gpu module — tsb analytics library. */
+export interface Signal gpuOptions { tol?: number; maxIter?: number; }
+export interface Signal gpuResult { values: number[]; converged: boolean; }
+export function computeSignal gpu(data: number[], opts: Signal gpuOptions = {}): Signal gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal gpu };
diff --git a/src/signal/highpass.ts b/src/signal/highpass.ts
new file mode 100644
index 000000000..03c30f8e3
--- /dev/null
+++ b/src/signal/highpass.ts
@@ -0,0 +1,22 @@
+/** Highpass module — tsb analytics library. */
+
+/** Options for Highpass. */
+export interface HighpassOptions { tol?: number; maxIter?: number; }
+
+/** Result from Highpass. */
+export interface HighpassResult { values: number[]; converged: boolean; }
+
+/** Compute Highpass. */
+export function computeHighpass(data: number[], opts: HighpassOptions = {}): HighpassResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHighpass };
diff --git a/src/signal/ifft.ts b/src/signal/ifft.ts
new file mode 100644
index 000000000..b44039a1d
--- /dev/null
+++ b/src/signal/ifft.ts
@@ -0,0 +1,22 @@
+/** Ifft module — tsb analytics library. */
+
+/** Options for Ifft. */
+export interface IfftOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ifft. */
+export interface IfftResult { values: number[]; converged: boolean; }
+
+/** Compute Ifft. */
+export function computeIfft(data: number[], opts: IfftOptions = {}): IfftResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIfft };
diff --git a/src/signal/kalman_signal.ts b/src/signal/kalman_signal.ts
new file mode 100644
index 000000000..a4f8c25bb
--- /dev/null
+++ b/src/signal/kalman_signal.ts
@@ -0,0 +1,22 @@
+/** Kalman Signal module — tsb analytics library. */
+
+/** Options for Kalman Signal. */
+export interface KalmanSignalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Kalman Signal. */
+export interface KalmanSignalResult { values: number[]; converged: boolean; }
+
+/** Compute Kalman Signal. */
+export function computeKalmanSignal(data: number[], opts: KalmanSignalOptions = {}): KalmanSignalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKalmanSignal };
diff --git a/src/signal/large.ts b/src/signal/large.ts
new file mode 100644
index 000000000..68bd4f174
--- /dev/null
+++ b/src/signal/large.ts
@@ -0,0 +1,15 @@
+/** Signal Large module — tsb analytics library. */
+export interface Signal largeOptions { tol?: number; maxIter?: number; }
+export interface Signal largeResult { values: number[]; converged: boolean; }
+export function computeSignal large(data: number[], opts: Signal largeOptions = {}): Signal largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal large };
diff --git a/src/signal/legacy.ts b/src/signal/legacy.ts
new file mode 100644
index 000000000..3f0117803
--- /dev/null
+++ b/src/signal/legacy.ts
@@ -0,0 +1,15 @@
+/** Signal Legacy module — tsb analytics library. */
+export interface Signal legacyOptions { tol?: number; maxIter?: number; }
+export interface Signal legacyResult { values: number[]; converged: boolean; }
+export function computeSignal legacy(data: number[], opts: Signal legacyOptions = {}): Signal legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal legacy };
diff --git a/src/signal/lite.ts b/src/signal/lite.ts
new file mode 100644
index 000000000..a66b9697c
--- /dev/null
+++ b/src/signal/lite.ts
@@ -0,0 +1,15 @@
+/** Signal Lite module — tsb analytics library. */
+export interface Signal liteOptions { tol?: number; maxIter?: number; }
+export interface Signal liteResult { values: number[]; converged: boolean; }
+export function computeSignal lite(data: number[], opts: Signal liteOptions = {}): Signal liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal lite };
diff --git a/src/signal/lowpass.ts b/src/signal/lowpass.ts
new file mode 100644
index 000000000..9c6adeee1
--- /dev/null
+++ b/src/signal/lowpass.ts
@@ -0,0 +1,22 @@
+/** Lowpass module — tsb analytics library. */
+
+/** Options for Lowpass. */
+export interface LowpassOptions { tol?: number; maxIter?: number; }
+
+/** Result from Lowpass. */
+export interface LowpassResult { values: number[]; converged: boolean; }
+
+/** Compute Lowpass. */
+export function computeLowpass(data: number[], opts: LowpassOptions = {}): LowpassResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLowpass };
diff --git a/src/signal/mini.ts b/src/signal/mini.ts
new file mode 100644
index 000000000..d2a52670d
--- /dev/null
+++ b/src/signal/mini.ts
@@ -0,0 +1,15 @@
+/** Signal Mini module — tsb analytics library. */
+export interface Signal miniOptions { tol?: number; maxIter?: number; }
+export interface Signal miniResult { values: number[]; converged: boolean; }
+export function computeSignal mini(data: number[], opts: Signal miniOptions = {}): Signal miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal mini };
diff --git a/src/signal/modulation.ts b/src/signal/modulation.ts
new file mode 100644
index 000000000..84565de9c
--- /dev/null
+++ b/src/signal/modulation.ts
@@ -0,0 +1,22 @@
+/** Modulation module — tsb analytics library. */
+
+/** Options for Modulation. */
+export interface ModulationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Modulation. */
+export interface ModulationResult { values: number[]; converged: boolean; }
+
+/** Compute Modulation. */
+export function computeModulation(data: number[], opts: ModulationOptions = {}): ModulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeModulation };
diff --git a/src/signal/next.ts b/src/signal/next.ts
new file mode 100644
index 000000000..bbbb9e354
--- /dev/null
+++ b/src/signal/next.ts
@@ -0,0 +1,15 @@
+/** Signal Next module — tsb analytics library. */
+export interface Signal nextOptions { tol?: number; maxIter?: number; }
+export interface Signal nextResult { values: number[]; converged: boolean; }
+export function computeSignal next(data: number[], opts: Signal nextOptions = {}): Signal nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal next };
diff --git a/src/signal/notch.ts b/src/signal/notch.ts
new file mode 100644
index 000000000..d9fd6d2b0
--- /dev/null
+++ b/src/signal/notch.ts
@@ -0,0 +1,22 @@
+/** Notch module — tsb analytics library. */
+
+/** Options for Notch. */
+export interface NotchOptions { tol?: number; maxIter?: number; }
+
+/** Result from Notch. */
+export interface NotchResult { values: number[]; converged: boolean; }
+
+/** Compute Notch. */
+export function computeNotch(data: number[], opts: NotchOptions = {}): NotchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNotch };
diff --git a/src/signal/online.ts b/src/signal/online.ts
new file mode 100644
index 000000000..2d017a713
--- /dev/null
+++ b/src/signal/online.ts
@@ -0,0 +1,15 @@
+/** Signal Online module — tsb analytics library. */
+export interface Signal onlineOptions { tol?: number; maxIter?: number; }
+export interface Signal onlineResult { values: number[]; converged: boolean; }
+export function computeSignal online(data: number[], opts: Signal onlineOptions = {}): Signal onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal online };
diff --git a/src/signal/parallel.ts b/src/signal/parallel.ts
new file mode 100644
index 000000000..e9e65700e
--- /dev/null
+++ b/src/signal/parallel.ts
@@ -0,0 +1,15 @@
+/** Signal Parallel module — tsb analytics library. */
+export interface Signal parallelOptions { tol?: number; maxIter?: number; }
+export interface Signal parallelResult { values: number[]; converged: boolean; }
+export function computeSignal parallel(data: number[], opts: Signal parallelOptions = {}): Signal parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal parallel };
diff --git a/src/signal/particle.ts b/src/signal/particle.ts
new file mode 100644
index 000000000..96dfa9cd6
--- /dev/null
+++ b/src/signal/particle.ts
@@ -0,0 +1,22 @@
+/** Particle module — tsb analytics library. */
+
+/** Options for Particle. */
+export interface ParticleOptions { tol?: number; maxIter?: number; }
+
+/** Result from Particle. */
+export interface ParticleResult { values: number[]; converged: boolean; }
+
+/** Compute Particle. */
+export function computeParticle(data: number[], opts: ParticleOptions = {}): ParticleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeParticle };
diff --git a/src/signal/phase.ts b/src/signal/phase.ts
new file mode 100644
index 000000000..5145eaba0
--- /dev/null
+++ b/src/signal/phase.ts
@@ -0,0 +1,22 @@
+/** Phase module — tsb analytics library. */
+
+/** Options for Phase. */
+export interface PhaseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Phase. */
+export interface PhaseResult { values: number[]; converged: boolean; }
+
+/** Compute Phase. */
+export function computePhase(data: number[], opts: PhaseOptions = {}): PhaseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePhase };
diff --git a/src/signal/plus.ts b/src/signal/plus.ts
new file mode 100644
index 000000000..a3f76b594
--- /dev/null
+++ b/src/signal/plus.ts
@@ -0,0 +1,15 @@
+/** Signal Plus module — tsb analytics library. */
+export interface Signal plusOptions { tol?: number; maxIter?: number; }
+export interface Signal plusResult { values: number[]; converged: boolean; }
+export function computeSignal plus(data: number[], opts: Signal plusOptions = {}): Signal plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal plus };
diff --git a/src/signal/pro.ts b/src/signal/pro.ts
new file mode 100644
index 000000000..b550dfdac
--- /dev/null
+++ b/src/signal/pro.ts
@@ -0,0 +1,15 @@
+/** Signal Pro module — tsb analytics library. */
+export interface Signal proOptions { tol?: number; maxIter?: number; }
+export interface Signal proResult { values: number[]; converged: boolean; }
+export function computeSignal pro(data: number[], opts: Signal proOptions = {}): Signal proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal pro };
diff --git a/src/signal/psd.ts b/src/signal/psd.ts
new file mode 100644
index 000000000..73fafe01d
--- /dev/null
+++ b/src/signal/psd.ts
@@ -0,0 +1,22 @@
+/** Psd module — tsb analytics library. */
+
+/** Options for Psd. */
+export interface PsdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Psd. */
+export interface PsdResult { values: number[]; converged: boolean; }
+
+/** Compute Psd. */
+export function computePsd(data: number[], opts: PsdOptions = {}): PsdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePsd };
diff --git a/src/signal/robust.ts b/src/signal/robust.ts
new file mode 100644
index 000000000..dead5f316
--- /dev/null
+++ b/src/signal/robust.ts
@@ -0,0 +1,15 @@
+/** Signal Robust module — tsb analytics library. */
+export interface Signal robustOptions { tol?: number; maxIter?: number; }
+export interface Signal robustResult { values: number[]; converged: boolean; }
+export function computeSignal robust(data: number[], opts: Signal robustOptions = {}): Signal robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal robust };
diff --git a/src/signal/small.ts b/src/signal/small.ts
new file mode 100644
index 000000000..0ab2d1664
--- /dev/null
+++ b/src/signal/small.ts
@@ -0,0 +1,15 @@
+/** Signal Small module — tsb analytics library. */
+export interface Signal smallOptions { tol?: number; maxIter?: number; }
+export interface Signal smallResult { values: number[]; converged: boolean; }
+export function computeSignal small(data: number[], opts: Signal smallOptions = {}): Signal smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal small };
diff --git a/src/signal/source_separation.ts b/src/signal/source_separation.ts
new file mode 100644
index 000000000..0e18ae275
--- /dev/null
+++ b/src/signal/source_separation.ts
@@ -0,0 +1,22 @@
+/** Source Separation module — tsb analytics library. */
+
+/** Options for Source Separation. */
+export interface SourceSeparationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Source Separation. */
+export interface SourceSeparationResult { values: number[]; converged: boolean; }
+
+/** Compute Source Separation. */
+export function computeSourceSeparation(data: number[], opts: SourceSeparationOptions = {}): SourceSeparationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSourceSeparation };
diff --git a/src/signal/sparse.ts b/src/signal/sparse.ts
new file mode 100644
index 000000000..d43912f78
--- /dev/null
+++ b/src/signal/sparse.ts
@@ -0,0 +1,22 @@
+/** Sparse module — tsb analytics library. */
+
+/** Options for Sparse. */
+export interface SparseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sparse. */
+export interface SparseResult { values: number[]; converged: boolean; }
+
+/** Compute Sparse. */
+export function computeSparse(data: number[], opts: SparseOptions = {}): SparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSparse };
diff --git a/src/signal/spectrogram.ts b/src/signal/spectrogram.ts
new file mode 100644
index 000000000..4be55f3bb
--- /dev/null
+++ b/src/signal/spectrogram.ts
@@ -0,0 +1,22 @@
+/** Spectrogram module — tsb analytics library. */
+
+/** Options for Spectrogram. */
+export interface SpectrogramOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spectrogram. */
+export interface SpectrogramResult { values: number[]; converged: boolean; }
+
+/** Compute Spectrogram. */
+export function computeSpectrogram(data: number[], opts: SpectrogramOptions = {}): SpectrogramResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpectrogram };
diff --git a/src/signal/stable.ts b/src/signal/stable.ts
new file mode 100644
index 000000000..83583f97e
--- /dev/null
+++ b/src/signal/stable.ts
@@ -0,0 +1,15 @@
+/** Signal Stable module — tsb analytics library. */
+export interface Signal stableOptions { tol?: number; maxIter?: number; }
+export interface Signal stableResult { values: number[]; converged: boolean; }
+export function computeSignal stable(data: number[], opts: Signal stableOptions = {}): Signal stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal stable };
diff --git a/src/signal/stft.ts b/src/signal/stft.ts
new file mode 100644
index 000000000..72303c1ba
--- /dev/null
+++ b/src/signal/stft.ts
@@ -0,0 +1,22 @@
+/** Stft module — tsb analytics library. */
+
+/** Options for Stft. */
+export interface StftOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stft. */
+export interface StftResult { values: number[]; converged: boolean; }
+
+/** Compute Stft. */
+export function computeStft(data: number[], opts: StftOptions = {}): StftResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStft };
diff --git a/src/signal/streaming.ts b/src/signal/streaming.ts
new file mode 100644
index 000000000..baf1bb291
--- /dev/null
+++ b/src/signal/streaming.ts
@@ -0,0 +1,15 @@
+/** Signal Streaming module — tsb analytics library. */
+export interface Signal streamingOptions { tol?: number; maxIter?: number; }
+export interface Signal streamingResult { values: number[]; converged: boolean; }
+export function computeSignal streaming(data: number[], opts: Signal streamingOptions = {}): Signal streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal streaming };
diff --git a/src/signal/v2.ts b/src/signal/v2.ts
new file mode 100644
index 000000000..6f75d838b
--- /dev/null
+++ b/src/signal/v2.ts
@@ -0,0 +1,15 @@
+/** Signal V2 module — tsb analytics library. */
+export interface Signal v2Options { tol?: number; maxIter?: number; }
+export interface Signal v2Result { values: number[]; converged: boolean; }
+export function computeSignal v2(data: number[], opts: Signal v2Options = {}): Signal v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal v2 };
diff --git a/src/signal/v3.ts b/src/signal/v3.ts
new file mode 100644
index 000000000..5cbf9a8ca
--- /dev/null
+++ b/src/signal/v3.ts
@@ -0,0 +1,15 @@
+/** Signal V3 module — tsb analytics library. */
+export interface Signal v3Options { tol?: number; maxIter?: number; }
+export interface Signal v3Result { values: number[]; converged: boolean; }
+export function computeSignal v3(data: number[], opts: Signal v3Options = {}): Signal v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal v3 };
diff --git a/src/signal/wasm.ts b/src/signal/wasm.ts
new file mode 100644
index 000000000..8502b6a3e
--- /dev/null
+++ b/src/signal/wasm.ts
@@ -0,0 +1,15 @@
+/** Signal Wasm module — tsb analytics library. */
+export interface Signal wasmOptions { tol?: number; maxIter?: number; }
+export interface Signal wasmResult { values: number[]; converged: boolean; }
+export function computeSignal wasm(data: number[], opts: Signal wasmOptions = {}): Signal wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal wasm };
diff --git a/src/signal/xlarge.ts b/src/signal/xlarge.ts
new file mode 100644
index 000000000..6d3e3f9fd
--- /dev/null
+++ b/src/signal/xlarge.ts
@@ -0,0 +1,15 @@
+/** Signal Xlarge module — tsb analytics library. */
+export interface Signal xlargeOptions { tol?: number; maxIter?: number; }
+export interface Signal xlargeResult { values: number[]; converged: boolean; }
+export function computeSignal xlarge(data: number[], opts: Signal xlargeOptions = {}): Signal xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSignal xlarge };
diff --git a/src/sociology/advanced.ts b/src/sociology/advanced.ts
new file mode 100644
index 000000000..5070fddbf
--- /dev/null
+++ b/src/sociology/advanced.ts
@@ -0,0 +1,15 @@
+/** Sociology Advanced module — tsb analytics library. */
+export interface Sociology advancedOptions { tol?: number; maxIter?: number; }
+export interface Sociology advancedResult { values: number[]; converged: boolean; }
+export function computeSociology advanced(data: number[], opts: Sociology advancedOptions = {}): Sociology advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology advanced };
diff --git a/src/sociology/base2.ts b/src/sociology/base2.ts
new file mode 100644
index 000000000..da9332356
--- /dev/null
+++ b/src/sociology/base2.ts
@@ -0,0 +1,15 @@
+/** Sociology Base2 module — tsb analytics library. */
+export interface Sociology base2Options { tol?: number; maxIter?: number; }
+export interface Sociology base2Result { values: number[]; converged: boolean; }
+export function computeSociology base2(data: number[], opts: Sociology base2Options = {}): Sociology base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology base2 };
diff --git a/src/sociology/batch.ts b/src/sociology/batch.ts
new file mode 100644
index 000000000..cd2efdf2f
--- /dev/null
+++ b/src/sociology/batch.ts
@@ -0,0 +1,15 @@
+/** Sociology Batch module — tsb analytics library. */
+export interface Sociology batchOptions { tol?: number; maxIter?: number; }
+export interface Sociology batchResult { values: number[]; converged: boolean; }
+export function computeSociology batch(data: number[], opts: Sociology batchOptions = {}): Sociology batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology batch };
diff --git a/src/sociology/beta.ts b/src/sociology/beta.ts
new file mode 100644
index 000000000..b70dc33d3
--- /dev/null
+++ b/src/sociology/beta.ts
@@ -0,0 +1,15 @@
+/** Sociology Beta module — tsb analytics library. */
+export interface Sociology betaOptions { tol?: number; maxIter?: number; }
+export interface Sociology betaResult { values: number[]; converged: boolean; }
+export function computeSociology beta(data: number[], opts: Sociology betaOptions = {}): Sociology betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology beta };
diff --git a/src/sociology/class.ts b/src/sociology/class.ts
new file mode 100644
index 000000000..898318ef4
--- /dev/null
+++ b/src/sociology/class.ts
@@ -0,0 +1,22 @@
+/** Class module — tsb analytics library. */
+
+/** Options for Class. */
+export interface ClassOptions { tol?: number; maxIter?: number; }
+
+/** Result from Class. */
+export interface ClassResult { values: number[]; converged: boolean; }
+
+/** Compute Class. */
+export function computeClass(data: number[], opts: ClassOptions = {}): ClassResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeClass };
diff --git a/src/sociology/collective.ts b/src/sociology/collective.ts
new file mode 100644
index 000000000..95c90c0f8
--- /dev/null
+++ b/src/sociology/collective.ts
@@ -0,0 +1,22 @@
+/** Collective module — tsb analytics library. */
+
+/** Options for Collective. */
+export interface CollectiveOptions { tol?: number; maxIter?: number; }
+
+/** Result from Collective. */
+export interface CollectiveResult { values: number[]; converged: boolean; }
+
+/** Compute Collective. */
+export function computeCollective(data: number[], opts: CollectiveOptions = {}): CollectiveResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCollective };
diff --git a/src/sociology/cpu.ts b/src/sociology/cpu.ts
new file mode 100644
index 000000000..61bf7b372
--- /dev/null
+++ b/src/sociology/cpu.ts
@@ -0,0 +1,15 @@
+/** Sociology Cpu module — tsb analytics library. */
+export interface Sociology cpuOptions { tol?: number; maxIter?: number; }
+export interface Sociology cpuResult { values: number[]; converged: boolean; }
+export function computeSociology cpu(data: number[], opts: Sociology cpuOptions = {}): Sociology cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology cpu };
diff --git a/src/sociology/crime.ts b/src/sociology/crime.ts
new file mode 100644
index 000000000..ac5cae984
--- /dev/null
+++ b/src/sociology/crime.ts
@@ -0,0 +1,22 @@
+/** Crime module — tsb analytics library. */
+
+/** Options for Crime. */
+export interface CrimeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Crime. */
+export interface CrimeResult { values: number[]; converged: boolean; }
+
+/** Compute Crime. */
+export function computeCrime(data: number[], opts: CrimeOptions = {}): CrimeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCrime };
diff --git a/src/sociology/culture.ts b/src/sociology/culture.ts
new file mode 100644
index 000000000..3695869bb
--- /dev/null
+++ b/src/sociology/culture.ts
@@ -0,0 +1,22 @@
+/** Culture module — tsb analytics library. */
+
+/** Options for Culture. */
+export interface CultureOptions { tol?: number; maxIter?: number; }
+
+/** Result from Culture. */
+export interface CultureResult { values: number[]; converged: boolean; }
+
+/** Compute Culture. */
+export function computeCulture(data: number[], opts: CultureOptions = {}): CultureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCulture };
diff --git a/src/sociology/dense.ts b/src/sociology/dense.ts
new file mode 100644
index 000000000..5e7d4c4f1
--- /dev/null
+++ b/src/sociology/dense.ts
@@ -0,0 +1,15 @@
+/** Sociology Dense module — tsb analytics library. */
+export interface Sociology denseOptions { tol?: number; maxIter?: number; }
+export interface Sociology denseResult { values: number[]; converged: boolean; }
+export function computeSociology dense(data: number[], opts: Sociology denseOptions = {}): Sociology denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology dense };
diff --git a/src/sociology/deviance.ts b/src/sociology/deviance.ts
new file mode 100644
index 000000000..be67d5252
--- /dev/null
+++ b/src/sociology/deviance.ts
@@ -0,0 +1,22 @@
+/** Deviance module — tsb analytics library. */
+
+/** Options for Deviance. */
+export interface DevianceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Deviance. */
+export interface DevianceResult { values: number[]; converged: boolean; }
+
+/** Compute Deviance. */
+export function computeDeviance(data: number[], opts: DevianceOptions = {}): DevianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDeviance };
diff --git a/src/sociology/distributed.ts b/src/sociology/distributed.ts
new file mode 100644
index 000000000..123e47c69
--- /dev/null
+++ b/src/sociology/distributed.ts
@@ -0,0 +1,15 @@
+/** Sociology Distributed module — tsb analytics library. */
+export interface Sociology distributedOptions { tol?: number; maxIter?: number; }
+export interface Sociology distributedResult { values: number[]; converged: boolean; }
+export function computeSociology distributed(data: number[], opts: Sociology distributedOptions = {}): Sociology distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology distributed };
diff --git a/src/sociology/economic_soc.ts b/src/sociology/economic_soc.ts
new file mode 100644
index 000000000..116ad3101
--- /dev/null
+++ b/src/sociology/economic_soc.ts
@@ -0,0 +1,22 @@
+/** Economic Soc module — tsb analytics library. */
+
+/** Options for Economic Soc. */
+export interface EconomicSocOptions { tol?: number; maxIter?: number; }
+
+/** Result from Economic Soc. */
+export interface EconomicSocResult { values: number[]; converged: boolean; }
+
+/** Compute Economic Soc. */
+export function computeEconomicSoc(data: number[], opts: EconomicSocOptions = {}): EconomicSocResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEconomicSoc };
diff --git a/src/sociology/education_soc.ts b/src/sociology/education_soc.ts
new file mode 100644
index 000000000..42b45e344
--- /dev/null
+++ b/src/sociology/education_soc.ts
@@ -0,0 +1,22 @@
+/** Education Soc module — tsb analytics library. */
+
+/** Options for Education Soc. */
+export interface EducationSocOptions { tol?: number; maxIter?: number; }
+
+/** Result from Education Soc. */
+export interface EducationSocResult { values: number[]; converged: boolean; }
+
+/** Compute Education Soc. */
+export function computeEducationSoc(data: number[], opts: EducationSocOptions = {}): EducationSocResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEducationSoc };
diff --git a/src/sociology/environment_soc.ts b/src/sociology/environment_soc.ts
new file mode 100644
index 000000000..1eab0bc78
--- /dev/null
+++ b/src/sociology/environment_soc.ts
@@ -0,0 +1,22 @@
+/** Environment Soc module — tsb analytics library. */
+
+/** Options for Environment Soc. */
+export interface EnvironmentSocOptions { tol?: number; maxIter?: number; }
+
+/** Result from Environment Soc. */
+export interface EnvironmentSocResult { values: number[]; converged: boolean; }
+
+/** Compute Environment Soc. */
+export function computeEnvironmentSoc(data: number[], opts: EnvironmentSocOptions = {}): EnvironmentSocResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEnvironmentSoc };
diff --git a/src/sociology/ethnicity.ts b/src/sociology/ethnicity.ts
new file mode 100644
index 000000000..3175df2ea
--- /dev/null
+++ b/src/sociology/ethnicity.ts
@@ -0,0 +1,22 @@
+/** Ethnicity module — tsb analytics library. */
+
+/** Options for Ethnicity. */
+export interface EthnicityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Ethnicity. */
+export interface EthnicityResult { values: number[]; converged: boolean; }
+
+/** Compute Ethnicity. */
+export function computeEthnicity(data: number[], opts: EthnicityOptions = {}): EthnicityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeEthnicity };
diff --git a/src/sociology/experimental.ts b/src/sociology/experimental.ts
new file mode 100644
index 000000000..793ed9426
--- /dev/null
+++ b/src/sociology/experimental.ts
@@ -0,0 +1,15 @@
+/** Sociology Experimental module — tsb analytics library. */
+export interface Sociology experimentalOptions { tol?: number; maxIter?: number; }
+export interface Sociology experimentalResult { values: number[]; converged: boolean; }
+export function computeSociology experimental(data: number[], opts: Sociology experimentalOptions = {}): Sociology experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology experimental };
diff --git a/src/sociology/family.ts b/src/sociology/family.ts
new file mode 100644
index 000000000..a43bf42cd
--- /dev/null
+++ b/src/sociology/family.ts
@@ -0,0 +1,22 @@
+/** Family module — tsb analytics library. */
+
+/** Options for Family. */
+export interface FamilyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Family. */
+export interface FamilyResult { values: number[]; converged: boolean; }
+
+/** Compute Family. */
+export function computeFamily(data: number[], opts: FamilyOptions = {}): FamilyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFamily };
diff --git a/src/sociology/fast.ts b/src/sociology/fast.ts
new file mode 100644
index 000000000..630521cb0
--- /dev/null
+++ b/src/sociology/fast.ts
@@ -0,0 +1,15 @@
+/** Sociology Fast module — tsb analytics library. */
+export interface Sociology fastOptions { tol?: number; maxIter?: number; }
+export interface Sociology fastResult { values: number[]; converged: boolean; }
+export function computeSociology fast(data: number[], opts: Sociology fastOptions = {}): Sociology fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology fast };
diff --git a/src/sociology/future.ts b/src/sociology/future.ts
new file mode 100644
index 000000000..29073a97d
--- /dev/null
+++ b/src/sociology/future.ts
@@ -0,0 +1,15 @@
+/** Sociology Future module — tsb analytics library. */
+export interface Sociology futureOptions { tol?: number; maxIter?: number; }
+export interface Sociology futureResult { values: number[]; converged: boolean; }
+export function computeSociology future(data: number[], opts: Sociology futureOptions = {}): Sociology futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology future };
diff --git a/src/sociology/gender.ts b/src/sociology/gender.ts
new file mode 100644
index 000000000..2c5aff82a
--- /dev/null
+++ b/src/sociology/gender.ts
@@ -0,0 +1,22 @@
+/** Gender module — tsb analytics library. */
+
+/** Options for Gender. */
+export interface GenderOptions { tol?: number; maxIter?: number; }
+
+/** Result from Gender. */
+export interface GenderResult { values: number[]; converged: boolean; }
+
+/** Compute Gender. */
+export function computeGender(data: number[], opts: GenderOptions = {}): GenderResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGender };
diff --git a/src/sociology/globalization.ts b/src/sociology/globalization.ts
new file mode 100644
index 000000000..dfcad792b
--- /dev/null
+++ b/src/sociology/globalization.ts
@@ -0,0 +1,22 @@
+/** Globalization module — tsb analytics library. */
+
+/** Options for Globalization. */
+export interface GlobalizationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Globalization. */
+export interface GlobalizationResult { values: number[]; converged: boolean; }
+
+/** Compute Globalization. */
+export function computeGlobalization(data: number[], opts: GlobalizationOptions = {}): GlobalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGlobalization };
diff --git a/src/sociology/gpu.ts b/src/sociology/gpu.ts
new file mode 100644
index 000000000..48d3ef768
--- /dev/null
+++ b/src/sociology/gpu.ts
@@ -0,0 +1,15 @@
+/** Sociology Gpu module — tsb analytics library. */
+export interface Sociology gpuOptions { tol?: number; maxIter?: number; }
+export interface Sociology gpuResult { values: number[]; converged: boolean; }
+export function computeSociology gpu(data: number[], opts: Sociology gpuOptions = {}): Sociology gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology gpu };
diff --git a/src/sociology/health_soc.ts b/src/sociology/health_soc.ts
new file mode 100644
index 000000000..3be991f08
--- /dev/null
+++ b/src/sociology/health_soc.ts
@@ -0,0 +1,22 @@
+/** Health Soc module — tsb analytics library. */
+
+/** Options for Health Soc. */
+export interface HealthSocOptions { tol?: number; maxIter?: number; }
+
+/** Result from Health Soc. */
+export interface HealthSocResult { values: number[]; converged: boolean; }
+
+/** Compute Health Soc. */
+export function computeHealthSoc(data: number[], opts: HealthSocOptions = {}): HealthSocResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeHealthSoc };
diff --git a/src/sociology/identity.ts b/src/sociology/identity.ts
new file mode 100644
index 000000000..f4b560e2c
--- /dev/null
+++ b/src/sociology/identity.ts
@@ -0,0 +1,22 @@
+/** Identity module — tsb analytics library. */
+
+/** Options for Identity. */
+export interface IdentityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Identity. */
+export interface IdentityResult { values: number[]; converged: boolean; }
+
+/** Compute Identity. */
+export function computeIdentity(data: number[], opts: IdentityOptions = {}): IdentityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIdentity };
diff --git a/src/sociology/inequality.ts b/src/sociology/inequality.ts
new file mode 100644
index 000000000..680d9dcd2
--- /dev/null
+++ b/src/sociology/inequality.ts
@@ -0,0 +1,22 @@
+/** Inequality module — tsb analytics library. */
+
+/** Options for Inequality. */
+export interface InequalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Inequality. */
+export interface InequalityResult { values: number[]; converged: boolean; }
+
+/** Compute Inequality. */
+export function computeInequality(data: number[], opts: InequalityOptions = {}): InequalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInequality };
diff --git a/src/sociology/integration.ts b/src/sociology/integration.ts
new file mode 100644
index 000000000..3b4e45681
--- /dev/null
+++ b/src/sociology/integration.ts
@@ -0,0 +1,22 @@
+/** Integration module — tsb analytics library. */
+
+/** Options for Integration. */
+export interface IntegrationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Integration. */
+export interface IntegrationResult { values: number[]; converged: boolean; }
+
+/** Compute Integration. */
+export function computeIntegration(data: number[], opts: IntegrationOptions = {}): IntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIntegration };
diff --git a/src/sociology/intersectionality.ts b/src/sociology/intersectionality.ts
new file mode 100644
index 000000000..ead4f0f10
--- /dev/null
+++ b/src/sociology/intersectionality.ts
@@ -0,0 +1,22 @@
+/** Intersectionality module — tsb analytics library. */
+
+/** Options for Intersectionality. */
+export interface IntersectionalityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Intersectionality. */
+export interface IntersectionalityResult { values: number[]; converged: boolean; }
+
+/** Compute Intersectionality. */
+export function computeIntersectionality(data: number[], opts: IntersectionalityOptions = {}): IntersectionalityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIntersectionality };
diff --git a/src/sociology/large.ts b/src/sociology/large.ts
new file mode 100644
index 000000000..5f2401d5b
--- /dev/null
+++ b/src/sociology/large.ts
@@ -0,0 +1,15 @@
+/** Sociology Large module — tsb analytics library. */
+export interface Sociology largeOptions { tol?: number; maxIter?: number; }
+export interface Sociology largeResult { values: number[]; converged: boolean; }
+export function computeSociology large(data: number[], opts: Sociology largeOptions = {}): Sociology largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology large };
diff --git a/src/sociology/law.ts b/src/sociology/law.ts
new file mode 100644
index 000000000..1e66d24d5
--- /dev/null
+++ b/src/sociology/law.ts
@@ -0,0 +1,22 @@
+/** Law module — tsb analytics library. */
+
+/** Options for Law. */
+export interface LawOptions { tol?: number; maxIter?: number; }
+
+/** Result from Law. */
+export interface LawResult { values: number[]; converged: boolean; }
+
+/** Compute Law. */
+export function computeLaw(data: number[], opts: LawOptions = {}): LawResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLaw };
diff --git a/src/sociology/legacy.ts b/src/sociology/legacy.ts
new file mode 100644
index 000000000..3935fb400
--- /dev/null
+++ b/src/sociology/legacy.ts
@@ -0,0 +1,15 @@
+/** Sociology Legacy module — tsb analytics library. */
+export interface Sociology legacyOptions { tol?: number; maxIter?: number; }
+export interface Sociology legacyResult { values: number[]; converged: boolean; }
+export function computeSociology legacy(data: number[], opts: Sociology legacyOptions = {}): Sociology legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology legacy };
diff --git a/src/sociology/lite.ts b/src/sociology/lite.ts
new file mode 100644
index 000000000..92148418b
--- /dev/null
+++ b/src/sociology/lite.ts
@@ -0,0 +1,15 @@
+/** Sociology Lite module — tsb analytics library. */
+export interface Sociology liteOptions { tol?: number; maxIter?: number; }
+export interface Sociology liteResult { values: number[]; converged: boolean; }
+export function computeSociology lite(data: number[], opts: Sociology liteOptions = {}): Sociology liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology lite };
diff --git a/src/sociology/media.ts b/src/sociology/media.ts
new file mode 100644
index 000000000..eb16cf794
--- /dev/null
+++ b/src/sociology/media.ts
@@ -0,0 +1,22 @@
+/** Media module — tsb analytics library. */
+
+/** Options for Media. */
+export interface MediaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Media. */
+export interface MediaResult { values: number[]; converged: boolean; }
+
+/** Compute Media. */
+export function computeMedia(data: number[], opts: MediaOptions = {}): MediaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMedia };
diff --git a/src/sociology/migration_soc.ts b/src/sociology/migration_soc.ts
new file mode 100644
index 000000000..ad965eeb0
--- /dev/null
+++ b/src/sociology/migration_soc.ts
@@ -0,0 +1,22 @@
+/** Migration Soc module — tsb analytics library. */
+
+/** Options for Migration Soc. */
+export interface MigrationSocOptions { tol?: number; maxIter?: number; }
+
+/** Result from Migration Soc. */
+export interface MigrationSocResult { values: number[]; converged: boolean; }
+
+/** Compute Migration Soc. */
+export function computeMigrationSoc(data: number[], opts: MigrationSocOptions = {}): MigrationSocResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMigrationSoc };
diff --git a/src/sociology/mini.ts b/src/sociology/mini.ts
new file mode 100644
index 000000000..5c0888055
--- /dev/null
+++ b/src/sociology/mini.ts
@@ -0,0 +1,15 @@
+/** Sociology Mini module — tsb analytics library. */
+export interface Sociology miniOptions { tol?: number; maxIter?: number; }
+export interface Sociology miniResult { values: number[]; converged: boolean; }
+export function computeSociology mini(data: number[], opts: Sociology miniOptions = {}): Sociology miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology mini };
diff --git a/src/sociology/mobility.ts b/src/sociology/mobility.ts
new file mode 100644
index 000000000..e40457674
--- /dev/null
+++ b/src/sociology/mobility.ts
@@ -0,0 +1,22 @@
+/** Mobility module — tsb analytics library. */
+
+/** Options for Mobility. */
+export interface MobilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mobility. */
+export interface MobilityResult { values: number[]; converged: boolean; }
+
+/** Compute Mobility. */
+export function computeMobility(data: number[], opts: MobilityOptions = {}): MobilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMobility };
diff --git a/src/sociology/networks_soc.ts b/src/sociology/networks_soc.ts
new file mode 100644
index 000000000..35decc8e6
--- /dev/null
+++ b/src/sociology/networks_soc.ts
@@ -0,0 +1,22 @@
+/** Networks Soc module — tsb analytics library. */
+
+/** Options for Networks Soc. */
+export interface NetworksSocOptions { tol?: number; maxIter?: number; }
+
+/** Result from Networks Soc. */
+export interface NetworksSocResult { values: number[]; converged: boolean; }
+
+/** Compute Networks Soc. */
+export function computeNetworksSoc(data: number[], opts: NetworksSocOptions = {}): NetworksSocResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNetworksSoc };
diff --git a/src/sociology/next.ts b/src/sociology/next.ts
new file mode 100644
index 000000000..9f2088bf0
--- /dev/null
+++ b/src/sociology/next.ts
@@ -0,0 +1,15 @@
+/** Sociology Next module — tsb analytics library. */
+export interface Sociology nextOptions { tol?: number; maxIter?: number; }
+export interface Sociology nextResult { values: number[]; converged: boolean; }
+export function computeSociology next(data: number[], opts: Sociology nextOptions = {}): Sociology nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology next };
diff --git a/src/sociology/online.ts b/src/sociology/online.ts
new file mode 100644
index 000000000..ae1762fbd
--- /dev/null
+++ b/src/sociology/online.ts
@@ -0,0 +1,15 @@
+/** Sociology Online module — tsb analytics library. */
+export interface Sociology onlineOptions { tol?: number; maxIter?: number; }
+export interface Sociology onlineResult { values: number[]; converged: boolean; }
+export function computeSociology online(data: number[], opts: Sociology onlineOptions = {}): Sociology onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology online };
diff --git a/src/sociology/organizations.ts b/src/sociology/organizations.ts
new file mode 100644
index 000000000..6388cf30b
--- /dev/null
+++ b/src/sociology/organizations.ts
@@ -0,0 +1,22 @@
+/** Organizations module — tsb analytics library. */
+
+/** Options for Organizations. */
+export interface OrganizationsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Organizations. */
+export interface OrganizationsResult { values: number[]; converged: boolean; }
+
+/** Compute Organizations. */
+export function computeOrganizations(data: number[], opts: OrganizationsOptions = {}): OrganizationsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOrganizations };
diff --git a/src/sociology/parallel.ts b/src/sociology/parallel.ts
new file mode 100644
index 000000000..bbd33d85c
--- /dev/null
+++ b/src/sociology/parallel.ts
@@ -0,0 +1,15 @@
+/** Sociology Parallel module — tsb analytics library. */
+export interface Sociology parallelOptions { tol?: number; maxIter?: number; }
+export interface Sociology parallelResult { values: number[]; converged: boolean; }
+export function computeSociology parallel(data: number[], opts: Sociology parallelOptions = {}): Sociology parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology parallel };
diff --git a/src/sociology/plus.ts b/src/sociology/plus.ts
new file mode 100644
index 000000000..dae1c721b
--- /dev/null
+++ b/src/sociology/plus.ts
@@ -0,0 +1,15 @@
+/** Sociology Plus module — tsb analytics library. */
+export interface Sociology plusOptions { tol?: number; maxIter?: number; }
+export interface Sociology plusResult { values: number[]; converged: boolean; }
+export function computeSociology plus(data: number[], opts: Sociology plusOptions = {}): Sociology plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology plus };
diff --git a/src/sociology/political_soc.ts b/src/sociology/political_soc.ts
new file mode 100644
index 000000000..6c93ba829
--- /dev/null
+++ b/src/sociology/political_soc.ts
@@ -0,0 +1,22 @@
+/** Political Soc module — tsb analytics library. */
+
+/** Options for Political Soc. */
+export interface PoliticalSocOptions { tol?: number; maxIter?: number; }
+
+/** Result from Political Soc. */
+export interface PoliticalSocResult { values: number[]; converged: boolean; }
+
+/** Compute Political Soc. */
+export function computePoliticalSoc(data: number[], opts: PoliticalSocOptions = {}): PoliticalSocResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePoliticalSoc };
diff --git a/src/sociology/pro.ts b/src/sociology/pro.ts
new file mode 100644
index 000000000..8532a7320
--- /dev/null
+++ b/src/sociology/pro.ts
@@ -0,0 +1,15 @@
+/** Sociology Pro module — tsb analytics library. */
+export interface Sociology proOptions { tol?: number; maxIter?: number; }
+export interface Sociology proResult { values: number[]; converged: boolean; }
+export function computeSociology pro(data: number[], opts: Sociology proOptions = {}): Sociology proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology pro };
diff --git a/src/sociology/race.ts b/src/sociology/race.ts
new file mode 100644
index 000000000..77d7cc781
--- /dev/null
+++ b/src/sociology/race.ts
@@ -0,0 +1,22 @@
+/** Race module — tsb analytics library. */
+
+/** Options for Race. */
+export interface RaceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Race. */
+export interface RaceResult { values: number[]; converged: boolean; }
+
+/** Compute Race. */
+export function computeRace(data: number[], opts: RaceOptions = {}): RaceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRace };
diff --git a/src/sociology/religion.ts b/src/sociology/religion.ts
new file mode 100644
index 000000000..eddabecd3
--- /dev/null
+++ b/src/sociology/religion.ts
@@ -0,0 +1,22 @@
+/** Religion module — tsb analytics library. */
+
+/** Options for Religion. */
+export interface ReligionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Religion. */
+export interface ReligionResult { values: number[]; converged: boolean; }
+
+/** Compute Religion. */
+export function computeReligion(data: number[], opts: ReligionOptions = {}): ReligionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReligion };
diff --git a/src/sociology/robust.ts b/src/sociology/robust.ts
new file mode 100644
index 000000000..a5ff6336b
--- /dev/null
+++ b/src/sociology/robust.ts
@@ -0,0 +1,15 @@
+/** Sociology Robust module — tsb analytics library. */
+export interface Sociology robustOptions { tol?: number; maxIter?: number; }
+export interface Sociology robustResult { values: number[]; converged: boolean; }
+export function computeSociology robust(data: number[], opts: Sociology robustOptions = {}): Sociology robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology robust };
diff --git a/src/sociology/rural.ts b/src/sociology/rural.ts
new file mode 100644
index 000000000..a07451953
--- /dev/null
+++ b/src/sociology/rural.ts
@@ -0,0 +1,22 @@
+/** Rural module — tsb analytics library. */
+
+/** Options for Rural. */
+export interface RuralOptions { tol?: number; maxIter?: number; }
+
+/** Result from Rural. */
+export interface RuralResult { values: number[]; converged: boolean; }
+
+/** Compute Rural. */
+export function computeRural(data: number[], opts: RuralOptions = {}): RuralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRural };
diff --git a/src/sociology/small.ts b/src/sociology/small.ts
new file mode 100644
index 000000000..df493d0c4
--- /dev/null
+++ b/src/sociology/small.ts
@@ -0,0 +1,15 @@
+/** Sociology Small module — tsb analytics library. */
+export interface Sociology smallOptions { tol?: number; maxIter?: number; }
+export interface Sociology smallResult { values: number[]; converged: boolean; }
+export function computeSociology small(data: number[], opts: Sociology smallOptions = {}): Sociology smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology small };
diff --git a/src/sociology/social_movements.ts b/src/sociology/social_movements.ts
new file mode 100644
index 000000000..34a96a68e
--- /dev/null
+++ b/src/sociology/social_movements.ts
@@ -0,0 +1,22 @@
+/** Social Movements module — tsb analytics library. */
+
+/** Options for Social Movements. */
+export interface SocialMovementsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Social Movements. */
+export interface SocialMovementsResult { values: number[]; converged: boolean; }
+
+/** Compute Social Movements. */
+export function computeSocialMovements(data: number[], opts: SocialMovementsOptions = {}): SocialMovementsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSocialMovements };
diff --git a/src/sociology/social_stratification.ts b/src/sociology/social_stratification.ts
new file mode 100644
index 000000000..d39e877a7
--- /dev/null
+++ b/src/sociology/social_stratification.ts
@@ -0,0 +1,22 @@
+/** Social Stratification module — tsb analytics library. */
+
+/** Options for Social Stratification. */
+export interface SocialStratificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Social Stratification. */
+export interface SocialStratificationResult { values: number[]; converged: boolean; }
+
+/** Compute Social Stratification. */
+export function computeSocialStratification(data: number[], opts: SocialStratificationOptions = {}): SocialStratificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSocialStratification };
diff --git a/src/sociology/sparse.ts b/src/sociology/sparse.ts
new file mode 100644
index 000000000..ac043de65
--- /dev/null
+++ b/src/sociology/sparse.ts
@@ -0,0 +1,15 @@
+/** Sociology Sparse module — tsb analytics library. */
+export interface Sociology sparseOptions { tol?: number; maxIter?: number; }
+export interface Sociology sparseResult { values: number[]; converged: boolean; }
+export function computeSociology sparse(data: number[], opts: Sociology sparseOptions = {}): Sociology sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology sparse };
diff --git a/src/sociology/stable.ts b/src/sociology/stable.ts
new file mode 100644
index 000000000..ef8a1a41b
--- /dev/null
+++ b/src/sociology/stable.ts
@@ -0,0 +1,15 @@
+/** Sociology Stable module — tsb analytics library. */
+export interface Sociology stableOptions { tol?: number; maxIter?: number; }
+export interface Sociology stableResult { values: number[]; converged: boolean; }
+export function computeSociology stable(data: number[], opts: Sociology stableOptions = {}): Sociology stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology stable };
diff --git a/src/sociology/streaming.ts b/src/sociology/streaming.ts
new file mode 100644
index 000000000..311f6e56e
--- /dev/null
+++ b/src/sociology/streaming.ts
@@ -0,0 +1,15 @@
+/** Sociology Streaming module — tsb analytics library. */
+export interface Sociology streamingOptions { tol?: number; maxIter?: number; }
+export interface Sociology streamingResult { values: number[]; converged: boolean; }
+export function computeSociology streaming(data: number[], opts: Sociology streamingOptions = {}): Sociology streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology streaming };
diff --git a/src/sociology/urbanization.ts b/src/sociology/urbanization.ts
new file mode 100644
index 000000000..25bddf6b6
--- /dev/null
+++ b/src/sociology/urbanization.ts
@@ -0,0 +1,22 @@
+/** Urbanization module — tsb analytics library. */
+
+/** Options for Urbanization. */
+export interface UrbanizationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Urbanization. */
+export interface UrbanizationResult { values: number[]; converged: boolean; }
+
+/** Compute Urbanization. */
+export function computeUrbanization(data: number[], opts: UrbanizationOptions = {}): UrbanizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeUrbanization };
diff --git a/src/sociology/v2.ts b/src/sociology/v2.ts
new file mode 100644
index 000000000..5b51c41ea
--- /dev/null
+++ b/src/sociology/v2.ts
@@ -0,0 +1,15 @@
+/** Sociology V2 module — tsb analytics library. */
+export interface Sociology v2Options { tol?: number; maxIter?: number; }
+export interface Sociology v2Result { values: number[]; converged: boolean; }
+export function computeSociology v2(data: number[], opts: Sociology v2Options = {}): Sociology v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology v2 };
diff --git a/src/sociology/v3.ts b/src/sociology/v3.ts
new file mode 100644
index 000000000..bbb6987d0
--- /dev/null
+++ b/src/sociology/v3.ts
@@ -0,0 +1,15 @@
+/** Sociology V3 module — tsb analytics library. */
+export interface Sociology v3Options { tol?: number; maxIter?: number; }
+export interface Sociology v3Result { values: number[]; converged: boolean; }
+export function computeSociology v3(data: number[], opts: Sociology v3Options = {}): Sociology v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology v3 };
diff --git a/src/sociology/wasm.ts b/src/sociology/wasm.ts
new file mode 100644
index 000000000..dba62e813
--- /dev/null
+++ b/src/sociology/wasm.ts
@@ -0,0 +1,15 @@
+/** Sociology Wasm module — tsb analytics library. */
+export interface Sociology wasmOptions { tol?: number; maxIter?: number; }
+export interface Sociology wasmResult { values: number[]; converged: boolean; }
+export function computeSociology wasm(data: number[], opts: Sociology wasmOptions = {}): Sociology wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology wasm };
diff --git a/src/sociology/xlarge.ts b/src/sociology/xlarge.ts
new file mode 100644
index 000000000..7ca2a6101
--- /dev/null
+++ b/src/sociology/xlarge.ts
@@ -0,0 +1,15 @@
+/** Sociology Xlarge module — tsb analytics library. */
+export interface Sociology xlargeOptions { tol?: number; maxIter?: number; }
+export interface Sociology xlargeResult { values: number[]; converged: boolean; }
+export function computeSociology xlarge(data: number[], opts: Sociology xlargeOptions = {}): Sociology xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSociology xlarge };
diff --git a/src/soil_biology/adaptation.ts b/src/soil_biology/adaptation.ts
new file mode 100644
index 000000000..aadc2dcae
--- /dev/null
+++ b/src/soil_biology/adaptation.ts
@@ -0,0 +1,14 @@
+/** soil_biology adaptation module — tsb analytics library. */
+export interface SoilBiologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyAdaptation(data: number[], opts: SoilBiologyAdaptationOptions = {}): SoilBiologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyAdaptation };
diff --git a/src/soil_biology/aggregation.ts b/src/soil_biology/aggregation.ts
new file mode 100644
index 000000000..1e185a05e
--- /dev/null
+++ b/src/soil_biology/aggregation.ts
@@ -0,0 +1,14 @@
+/** soil_biology aggregation module — tsb analytics library. */
+export interface SoilBiologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyAggregationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyAggregation(data: number[], opts: SoilBiologyAggregationOptions = {}): SoilBiologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyAggregation };
diff --git a/src/soil_biology/algebra.ts b/src/soil_biology/algebra.ts
new file mode 100644
index 000000000..a5dff1bfd
--- /dev/null
+++ b/src/soil_biology/algebra.ts
@@ -0,0 +1,14 @@
+/** soil_biology algebra module — tsb analytics library. */
+export interface SoilBiologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyAlgebra(data: number[], opts: SoilBiologyAlgebraOptions = {}): SoilBiologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyAlgebra };
diff --git a/src/soil_biology/alignment.ts b/src/soil_biology/alignment.ts
new file mode 100644
index 000000000..87cbc8128
--- /dev/null
+++ b/src/soil_biology/alignment.ts
@@ -0,0 +1,14 @@
+/** soil_biology alignment module — tsb analytics library. */
+export interface SoilBiologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyAlignment(data: number[], opts: SoilBiologyAlignmentOptions = {}): SoilBiologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyAlignment };
diff --git a/src/soil_biology/analysis.ts b/src/soil_biology/analysis.ts
new file mode 100644
index 000000000..9dd920769
--- /dev/null
+++ b/src/soil_biology/analysis.ts
@@ -0,0 +1,14 @@
+/** soil_biology analysis module — tsb analytics library. */
+export interface SoilBiologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyAnalysis(data: number[], opts: SoilBiologyAnalysisOptions = {}): SoilBiologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyAnalysis };
diff --git a/src/soil_biology/augmentation.ts b/src/soil_biology/augmentation.ts
new file mode 100644
index 000000000..73e8f00b9
--- /dev/null
+++ b/src/soil_biology/augmentation.ts
@@ -0,0 +1,14 @@
+/** soil_biology augmentation module — tsb analytics library. */
+export interface SoilBiologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyAugmentation(data: number[], opts: SoilBiologyAugmentationOptions = {}): SoilBiologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyAugmentation };
diff --git a/src/soil_biology/bagging.ts b/src/soil_biology/bagging.ts
new file mode 100644
index 000000000..4b7044833
--- /dev/null
+++ b/src/soil_biology/bagging.ts
@@ -0,0 +1,14 @@
+/** soil_biology bagging module — tsb analytics library. */
+export interface SoilBiologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyBaggingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyBagging(data: number[], opts: SoilBiologyBaggingOptions = {}): SoilBiologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyBagging };
diff --git a/src/soil_biology/basis.ts b/src/soil_biology/basis.ts
new file mode 100644
index 000000000..1c3ef4e34
--- /dev/null
+++ b/src/soil_biology/basis.ts
@@ -0,0 +1,14 @@
+/** soil_biology basis module — tsb analytics library. */
+export interface SoilBiologyBasisOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyBasisResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyBasis(data: number[], opts: SoilBiologyBasisOptions = {}): SoilBiologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyBasis };
diff --git a/src/soil_biology/benchmarking.ts b/src/soil_biology/benchmarking.ts
new file mode 100644
index 000000000..41fb0e4f8
--- /dev/null
+++ b/src/soil_biology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** soil_biology benchmarking module — tsb analytics library. */
+export interface SoilBiologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyBenchmarking(data: number[], opts: SoilBiologyBenchmarkingOptions = {}): SoilBiologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyBenchmarking };
diff --git a/src/soil_biology/blending.ts b/src/soil_biology/blending.ts
new file mode 100644
index 000000000..7e52ce6ae
--- /dev/null
+++ b/src/soil_biology/blending.ts
@@ -0,0 +1,14 @@
+/** soil_biology blending module — tsb analytics library. */
+export interface SoilBiologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyBlendingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyBlending(data: number[], opts: SoilBiologyBlendingOptions = {}): SoilBiologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyBlending };
diff --git a/src/soil_biology/boosting.ts b/src/soil_biology/boosting.ts
new file mode 100644
index 000000000..8dd5f5778
--- /dev/null
+++ b/src/soil_biology/boosting.ts
@@ -0,0 +1,14 @@
+/** soil_biology boosting module — tsb analytics library. */
+export interface SoilBiologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyBoostingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyBoosting(data: number[], opts: SoilBiologyBoostingOptions = {}): SoilBiologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyBoosting };
diff --git a/src/soil_biology/bootstrap.ts b/src/soil_biology/bootstrap.ts
new file mode 100644
index 000000000..ffbad5086
--- /dev/null
+++ b/src/soil_biology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** soil_biology bootstrap module — tsb analytics library. */
+export interface SoilBiologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyBootstrap(data: number[], opts: SoilBiologyBootstrapOptions = {}): SoilBiologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyBootstrap };
diff --git a/src/soil_biology/calculus.ts b/src/soil_biology/calculus.ts
new file mode 100644
index 000000000..d72c06c4f
--- /dev/null
+++ b/src/soil_biology/calculus.ts
@@ -0,0 +1,14 @@
+/** soil_biology calculus module — tsb analytics library. */
+export interface SoilBiologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyCalculusResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyCalculus(data: number[], opts: SoilBiologyCalculusOptions = {}): SoilBiologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyCalculus };
diff --git a/src/soil_biology/calibration.ts b/src/soil_biology/calibration.ts
new file mode 100644
index 000000000..b26a268c1
--- /dev/null
+++ b/src/soil_biology/calibration.ts
@@ -0,0 +1,14 @@
+/** soil_biology calibration module — tsb analytics library. */
+export interface SoilBiologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyCalibration(data: number[], opts: SoilBiologyCalibrationOptions = {}): SoilBiologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyCalibration };
diff --git a/src/soil_biology/characterization.ts b/src/soil_biology/characterization.ts
new file mode 100644
index 000000000..40262dbe3
--- /dev/null
+++ b/src/soil_biology/characterization.ts
@@ -0,0 +1,14 @@
+/** soil_biology characterization module — tsb analytics library. */
+export interface SoilBiologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyCharacterization(data: number[], opts: SoilBiologyCharacterizationOptions = {}): SoilBiologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyCharacterization };
diff --git a/src/soil_biology/classification.ts b/src/soil_biology/classification.ts
new file mode 100644
index 000000000..7ab615ca7
--- /dev/null
+++ b/src/soil_biology/classification.ts
@@ -0,0 +1,14 @@
+/** soil_biology classification module — tsb analytics library. */
+export interface SoilBiologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyClassificationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyClassification(data: number[], opts: SoilBiologyClassificationOptions = {}): SoilBiologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyClassification };
diff --git a/src/soil_biology/clustering.ts b/src/soil_biology/clustering.ts
new file mode 100644
index 000000000..7b26ec7f1
--- /dev/null
+++ b/src/soil_biology/clustering.ts
@@ -0,0 +1,14 @@
+/** soil_biology clustering module — tsb analytics library. */
+export interface SoilBiologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyClusteringResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyClustering(data: number[], opts: SoilBiologyClusteringOptions = {}): SoilBiologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyClustering };
diff --git a/src/soil_biology/compression.ts b/src/soil_biology/compression.ts
new file mode 100644
index 000000000..dc6a201f8
--- /dev/null
+++ b/src/soil_biology/compression.ts
@@ -0,0 +1,14 @@
+/** soil_biology compression module — tsb analytics library. */
+export interface SoilBiologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyCompressionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyCompression(data: number[], opts: SoilBiologyCompressionOptions = {}): SoilBiologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyCompression };
diff --git a/src/soil_biology/continuous.ts b/src/soil_biology/continuous.ts
new file mode 100644
index 000000000..b080c1790
--- /dev/null
+++ b/src/soil_biology/continuous.ts
@@ -0,0 +1,14 @@
+/** soil_biology continuous module — tsb analytics library. */
+export interface SoilBiologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyContinuousResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyContinuous(data: number[], opts: SoilBiologyContinuousOptions = {}): SoilBiologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyContinuous };
diff --git a/src/soil_biology/control.ts b/src/soil_biology/control.ts
new file mode 100644
index 000000000..ce19649d0
--- /dev/null
+++ b/src/soil_biology/control.ts
@@ -0,0 +1,14 @@
+/** soil_biology control module — tsb analytics library. */
+export interface SoilBiologyControlOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyControlResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyControl(data: number[], opts: SoilBiologyControlOptions = {}): SoilBiologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyControl };
diff --git a/src/soil_biology/convergence.ts b/src/soil_biology/convergence.ts
new file mode 100644
index 000000000..83d23d6e6
--- /dev/null
+++ b/src/soil_biology/convergence.ts
@@ -0,0 +1,14 @@
+/** soil_biology convergence module — tsb analytics library. */
+export interface SoilBiologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyConvergence(data: number[], opts: SoilBiologyConvergenceOptions = {}): SoilBiologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyConvergence };
diff --git a/src/soil_biology/convex.ts b/src/soil_biology/convex.ts
new file mode 100644
index 000000000..13bf22a30
--- /dev/null
+++ b/src/soil_biology/convex.ts
@@ -0,0 +1,14 @@
+/** soil_biology convex module — tsb analytics library. */
+export interface SoilBiologyConvexOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyConvexResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyConvex(data: number[], opts: SoilBiologyConvexOptions = {}): SoilBiologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyConvex };
diff --git a/src/soil_biology/correlation.ts b/src/soil_biology/correlation.ts
new file mode 100644
index 000000000..9a82b2316
--- /dev/null
+++ b/src/soil_biology/correlation.ts
@@ -0,0 +1,14 @@
+/** soil_biology correlation module — tsb analytics library. */
+export interface SoilBiologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyCorrelation(data: number[], opts: SoilBiologyCorrelationOptions = {}): SoilBiologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyCorrelation };
diff --git a/src/soil_biology/covariance.ts b/src/soil_biology/covariance.ts
new file mode 100644
index 000000000..a9190e698
--- /dev/null
+++ b/src/soil_biology/covariance.ts
@@ -0,0 +1,14 @@
+/** soil_biology covariance module — tsb analytics library. */
+export interface SoilBiologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyCovariance(data: number[], opts: SoilBiologyCovarianceOptions = {}): SoilBiologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyCovariance };
diff --git a/src/soil_biology/cross_validation.ts b/src/soil_biology/cross_validation.ts
new file mode 100644
index 000000000..34934ae02
--- /dev/null
+++ b/src/soil_biology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** soil_biology cross_validation module — tsb analytics library. */
+export interface SoilBiologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyCrossValidation(data: number[], opts: SoilBiologyCrossValidationOptions = {}): SoilBiologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyCrossValidation };
diff --git a/src/soil_biology/decoding.ts b/src/soil_biology/decoding.ts
new file mode 100644
index 000000000..310e4f941
--- /dev/null
+++ b/src/soil_biology/decoding.ts
@@ -0,0 +1,14 @@
+/** soil_biology decoding module — tsb analytics library. */
+export interface SoilBiologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDecodingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDecoding(data: number[], opts: SoilBiologyDecodingOptions = {}): SoilBiologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDecoding };
diff --git a/src/soil_biology/decomposition.ts b/src/soil_biology/decomposition.ts
new file mode 100644
index 000000000..4917560da
--- /dev/null
+++ b/src/soil_biology/decomposition.ts
@@ -0,0 +1,14 @@
+/** soil_biology decomposition module — tsb analytics library. */
+export interface SoilBiologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDecomposition(data: number[], opts: SoilBiologyDecompositionOptions = {}): SoilBiologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDecomposition };
diff --git a/src/soil_biology/detection.ts b/src/soil_biology/detection.ts
new file mode 100644
index 000000000..a74689320
--- /dev/null
+++ b/src/soil_biology/detection.ts
@@ -0,0 +1,14 @@
+/** soil_biology detection module — tsb analytics library. */
+export interface SoilBiologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDetectionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDetection(data: number[], opts: SoilBiologyDetectionOptions = {}): SoilBiologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDetection };
diff --git a/src/soil_biology/deterministic.ts b/src/soil_biology/deterministic.ts
new file mode 100644
index 000000000..2d7f97fa4
--- /dev/null
+++ b/src/soil_biology/deterministic.ts
@@ -0,0 +1,14 @@
+/** soil_biology deterministic module — tsb analytics library. */
+export interface SoilBiologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDeterministic(data: number[], opts: SoilBiologyDeterministicOptions = {}): SoilBiologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDeterministic };
diff --git a/src/soil_biology/diagnostics.ts b/src/soil_biology/diagnostics.ts
new file mode 100644
index 000000000..ac1430d89
--- /dev/null
+++ b/src/soil_biology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** soil_biology diagnostics module — tsb analytics library. */
+export interface SoilBiologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDiagnostics(data: number[], opts: SoilBiologyDiagnosticsOptions = {}): SoilBiologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDiagnostics };
diff --git a/src/soil_biology/differential.ts b/src/soil_biology/differential.ts
new file mode 100644
index 000000000..9333dc8c7
--- /dev/null
+++ b/src/soil_biology/differential.ts
@@ -0,0 +1,14 @@
+/** soil_biology differential module — tsb analytics library. */
+export interface SoilBiologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDifferential(data: number[], opts: SoilBiologyDifferentialOptions = {}): SoilBiologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDifferential };
diff --git a/src/soil_biology/discrete.ts b/src/soil_biology/discrete.ts
new file mode 100644
index 000000000..b322df4de
--- /dev/null
+++ b/src/soil_biology/discrete.ts
@@ -0,0 +1,14 @@
+/** soil_biology discrete module — tsb analytics library. */
+export interface SoilBiologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDiscrete(data: number[], opts: SoilBiologyDiscreteOptions = {}): SoilBiologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDiscrete };
diff --git a/src/soil_biology/distribution.ts b/src/soil_biology/distribution.ts
new file mode 100644
index 000000000..1e2043ceb
--- /dev/null
+++ b/src/soil_biology/distribution.ts
@@ -0,0 +1,14 @@
+/** soil_biology distribution module — tsb analytics library. */
+export interface SoilBiologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDistributionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDistribution(data: number[], opts: SoilBiologyDistributionOptions = {}): SoilBiologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDistribution };
diff --git a/src/soil_biology/dynamic.ts b/src/soil_biology/dynamic.ts
new file mode 100644
index 000000000..1be613a61
--- /dev/null
+++ b/src/soil_biology/dynamic.ts
@@ -0,0 +1,14 @@
+/** soil_biology dynamic module — tsb analytics library. */
+export interface SoilBiologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyDynamicResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyDynamic(data: number[], opts: SoilBiologyDynamicOptions = {}): SoilBiologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyDynamic };
diff --git a/src/soil_biology/embedding.ts b/src/soil_biology/embedding.ts
new file mode 100644
index 000000000..112a671ef
--- /dev/null
+++ b/src/soil_biology/embedding.ts
@@ -0,0 +1,14 @@
+/** soil_biology embedding module — tsb analytics library. */
+export interface SoilBiologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyEmbedding(data: number[], opts: SoilBiologyEmbeddingOptions = {}): SoilBiologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyEmbedding };
diff --git a/src/soil_biology/encoding.ts b/src/soil_biology/encoding.ts
new file mode 100644
index 000000000..24613e6bd
--- /dev/null
+++ b/src/soil_biology/encoding.ts
@@ -0,0 +1,14 @@
+/** soil_biology encoding module — tsb analytics library. */
+export interface SoilBiologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyEncodingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyEncoding(data: number[], opts: SoilBiologyEncodingOptions = {}): SoilBiologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyEncoding };
diff --git a/src/soil_biology/ensemble.ts b/src/soil_biology/ensemble.ts
new file mode 100644
index 000000000..e44ca131e
--- /dev/null
+++ b/src/soil_biology/ensemble.ts
@@ -0,0 +1,14 @@
+/** soil_biology ensemble module — tsb analytics library. */
+export interface SoilBiologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyEnsemble(data: number[], opts: SoilBiologyEnsembleOptions = {}): SoilBiologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyEnsemble };
diff --git a/src/soil_biology/estimation.ts b/src/soil_biology/estimation.ts
new file mode 100644
index 000000000..f3df483d0
--- /dev/null
+++ b/src/soil_biology/estimation.ts
@@ -0,0 +1,14 @@
+/** soil_biology estimation module — tsb analytics library. */
+export interface SoilBiologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyEstimationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyEstimation(data: number[], opts: SoilBiologyEstimationOptions = {}): SoilBiologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyEstimation };
diff --git a/src/soil_biology/evaluation.ts b/src/soil_biology/evaluation.ts
new file mode 100644
index 000000000..bc25ddc8c
--- /dev/null
+++ b/src/soil_biology/evaluation.ts
@@ -0,0 +1,14 @@
+/** soil_biology evaluation module — tsb analytics library. */
+export interface SoilBiologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyEvaluation(data: number[], opts: SoilBiologyEvaluationOptions = {}): SoilBiologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyEvaluation };
diff --git a/src/soil_biology/extrapolation.ts b/src/soil_biology/extrapolation.ts
new file mode 100644
index 000000000..c0090ce5c
--- /dev/null
+++ b/src/soil_biology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** soil_biology extrapolation module — tsb analytics library. */
+export interface SoilBiologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyExtrapolation(data: number[], opts: SoilBiologyExtrapolationOptions = {}): SoilBiologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyExtrapolation };
diff --git a/src/soil_biology/features.ts b/src/soil_biology/features.ts
new file mode 100644
index 000000000..e5c300dd8
--- /dev/null
+++ b/src/soil_biology/features.ts
@@ -0,0 +1,14 @@
+/** soil_biology features module — tsb analytics library. */
+export interface SoilBiologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyFeatures(data: number[], opts: SoilBiologyFeaturesOptions = {}): SoilBiologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyFeatures };
diff --git a/src/soil_biology/feedback.ts b/src/soil_biology/feedback.ts
new file mode 100644
index 000000000..94377081e
--- /dev/null
+++ b/src/soil_biology/feedback.ts
@@ -0,0 +1,14 @@
+/** soil_biology feedback module — tsb analytics library. */
+export interface SoilBiologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyFeedback(data: number[], opts: SoilBiologyFeedbackOptions = {}): SoilBiologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyFeedback };
diff --git a/src/soil_biology/filtering.ts b/src/soil_biology/filtering.ts
new file mode 100644
index 000000000..6e315a092
--- /dev/null
+++ b/src/soil_biology/filtering.ts
@@ -0,0 +1,14 @@
+/** soil_biology filtering module — tsb analytics library. */
+export interface SoilBiologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyFilteringResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyFiltering(data: number[], opts: SoilBiologyFilteringOptions = {}): SoilBiologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyFiltering };
diff --git a/src/soil_biology/fourier.ts b/src/soil_biology/fourier.ts
new file mode 100644
index 000000000..b4731dac3
--- /dev/null
+++ b/src/soil_biology/fourier.ts
@@ -0,0 +1,14 @@
+/** soil_biology fourier module — tsb analytics library. */
+export interface SoilBiologyFourierOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyFourierResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyFourier(data: number[], opts: SoilBiologyFourierOptions = {}): SoilBiologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyFourier };
diff --git a/src/soil_biology/fusion.ts b/src/soil_biology/fusion.ts
new file mode 100644
index 000000000..fb88383d7
--- /dev/null
+++ b/src/soil_biology/fusion.ts
@@ -0,0 +1,14 @@
+/** soil_biology fusion module — tsb analytics library. */
+export interface SoilBiologyFusionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyFusionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyFusion(data: number[], opts: SoilBiologyFusionOptions = {}): SoilBiologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyFusion };
diff --git a/src/soil_biology/generation.ts b/src/soil_biology/generation.ts
new file mode 100644
index 000000000..f870aedb9
--- /dev/null
+++ b/src/soil_biology/generation.ts
@@ -0,0 +1,14 @@
+/** soil_biology generation module — tsb analytics library. */
+export interface SoilBiologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyGenerationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyGeneration(data: number[], opts: SoilBiologyGenerationOptions = {}): SoilBiologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyGeneration };
diff --git a/src/soil_biology/geometry.ts b/src/soil_biology/geometry.ts
new file mode 100644
index 000000000..df76fbd6e
--- /dev/null
+++ b/src/soil_biology/geometry.ts
@@ -0,0 +1,14 @@
+/** soil_biology geometry module — tsb analytics library. */
+export interface SoilBiologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyGeometryResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyGeometry(data: number[], opts: SoilBiologyGeometryOptions = {}): SoilBiologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyGeometry };
diff --git a/src/soil_biology/gradient.ts b/src/soil_biology/gradient.ts
new file mode 100644
index 000000000..ea23aa8c2
--- /dev/null
+++ b/src/soil_biology/gradient.ts
@@ -0,0 +1,14 @@
+/** soil_biology gradient module — tsb analytics library. */
+export interface SoilBiologyGradientOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyGradientResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyGradient(data: number[], opts: SoilBiologyGradientOptions = {}): SoilBiologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyGradient };
diff --git a/src/soil_biology/hessian.ts b/src/soil_biology/hessian.ts
new file mode 100644
index 000000000..6e9135565
--- /dev/null
+++ b/src/soil_biology/hessian.ts
@@ -0,0 +1,14 @@
+/** soil_biology hessian module — tsb analytics library. */
+export interface SoilBiologyHessianOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyHessianResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyHessian(data: number[], opts: SoilBiologyHessianOptions = {}): SoilBiologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyHessian };
diff --git a/src/soil_biology/hypothesis.ts b/src/soil_biology/hypothesis.ts
new file mode 100644
index 000000000..b65d707c6
--- /dev/null
+++ b/src/soil_biology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** soil_biology hypothesis module — tsb analytics library. */
+export interface SoilBiologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyHypothesis(data: number[], opts: SoilBiologyHypothesisOptions = {}): SoilBiologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyHypothesis };
diff --git a/src/soil_biology/inference.ts b/src/soil_biology/inference.ts
new file mode 100644
index 000000000..2019f8f68
--- /dev/null
+++ b/src/soil_biology/inference.ts
@@ -0,0 +1,14 @@
+/** soil_biology inference module — tsb analytics library. */
+export interface SoilBiologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyInferenceResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyInference(data: number[], opts: SoilBiologyInferenceOptions = {}): SoilBiologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyInference };
diff --git a/src/soil_biology/inference2.ts b/src/soil_biology/inference2.ts
new file mode 100644
index 000000000..baf22b555
--- /dev/null
+++ b/src/soil_biology/inference2.ts
@@ -0,0 +1,14 @@
+/** soil_biology inference2 module — tsb analytics library. */
+export interface SoilBiologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyInferenceResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyInference(data: number[], opts: SoilBiologyInferenceOptions = {}): SoilBiologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyInference };
diff --git a/src/soil_biology/integral.ts b/src/soil_biology/integral.ts
new file mode 100644
index 000000000..f9fa0b8c7
--- /dev/null
+++ b/src/soil_biology/integral.ts
@@ -0,0 +1,14 @@
+/** soil_biology integral module — tsb analytics library. */
+export interface SoilBiologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyIntegralResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyIntegral(data: number[], opts: SoilBiologyIntegralOptions = {}): SoilBiologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyIntegral };
diff --git a/src/soil_biology/integration.ts b/src/soil_biology/integration.ts
new file mode 100644
index 000000000..5134c0436
--- /dev/null
+++ b/src/soil_biology/integration.ts
@@ -0,0 +1,14 @@
+/** soil_biology integration module — tsb analytics library. */
+export interface SoilBiologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyIntegration(data: number[], opts: SoilBiologyIntegrationOptions = {}): SoilBiologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyIntegration };
diff --git a/src/soil_biology/interpolation.ts b/src/soil_biology/interpolation.ts
new file mode 100644
index 000000000..163ea91a3
--- /dev/null
+++ b/src/soil_biology/interpolation.ts
@@ -0,0 +1,14 @@
+/** soil_biology interpolation module — tsb analytics library. */
+export interface SoilBiologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyInterpolation(data: number[], opts: SoilBiologyInterpolationOptions = {}): SoilBiologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyInterpolation };
diff --git a/src/soil_biology/jacobian.ts b/src/soil_biology/jacobian.ts
new file mode 100644
index 000000000..ab9e89e64
--- /dev/null
+++ b/src/soil_biology/jacobian.ts
@@ -0,0 +1,14 @@
+/** soil_biology jacobian module — tsb analytics library. */
+export interface SoilBiologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyJacobianResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyJacobian(data: number[], opts: SoilBiologyJacobianOptions = {}): SoilBiologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyJacobian };
diff --git a/src/soil_biology/kernel.ts b/src/soil_biology/kernel.ts
new file mode 100644
index 000000000..7ccb01bd1
--- /dev/null
+++ b/src/soil_biology/kernel.ts
@@ -0,0 +1,14 @@
+/** soil_biology kernel module — tsb analytics library. */
+export interface SoilBiologyKernelOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyKernelResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyKernel(data: number[], opts: SoilBiologyKernelOptions = {}): SoilBiologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyKernel };
diff --git a/src/soil_biology/laplacian.ts b/src/soil_biology/laplacian.ts
new file mode 100644
index 000000000..b0ed27b34
--- /dev/null
+++ b/src/soil_biology/laplacian.ts
@@ -0,0 +1,14 @@
+/** soil_biology laplacian module — tsb analytics library. */
+export interface SoilBiologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyLaplacian(data: number[], opts: SoilBiologyLaplacianOptions = {}): SoilBiologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyLaplacian };
diff --git a/src/soil_biology/learning.ts b/src/soil_biology/learning.ts
new file mode 100644
index 000000000..5abdaaa20
--- /dev/null
+++ b/src/soil_biology/learning.ts
@@ -0,0 +1,14 @@
+/** soil_biology learning module — tsb analytics library. */
+export interface SoilBiologyLearningOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyLearningResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyLearning(data: number[], opts: SoilBiologyLearningOptions = {}): SoilBiologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyLearning };
diff --git a/src/soil_biology/linear.ts b/src/soil_biology/linear.ts
new file mode 100644
index 000000000..4391a763e
--- /dev/null
+++ b/src/soil_biology/linear.ts
@@ -0,0 +1,14 @@
+/** soil_biology linear module — tsb analytics library. */
+export interface SoilBiologyLinearOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyLinearResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyLinear(data: number[], opts: SoilBiologyLinearOptions = {}): SoilBiologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyLinear };
diff --git a/src/soil_biology/manifold.ts b/src/soil_biology/manifold.ts
new file mode 100644
index 000000000..d520e116b
--- /dev/null
+++ b/src/soil_biology/manifold.ts
@@ -0,0 +1,14 @@
+/** soil_biology manifold module — tsb analytics library. */
+export interface SoilBiologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyManifoldResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyManifold(data: number[], opts: SoilBiologyManifoldOptions = {}): SoilBiologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyManifold };
diff --git a/src/soil_biology/matching.ts b/src/soil_biology/matching.ts
new file mode 100644
index 000000000..81a2b5b36
--- /dev/null
+++ b/src/soil_biology/matching.ts
@@ -0,0 +1,14 @@
+/** soil_biology matching module — tsb analytics library. */
+export interface SoilBiologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyMatchingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyMatching(data: number[], opts: SoilBiologyMatchingOptions = {}): SoilBiologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyMatching };
diff --git a/src/soil_biology/measurement.ts b/src/soil_biology/measurement.ts
new file mode 100644
index 000000000..3302c6a83
--- /dev/null
+++ b/src/soil_biology/measurement.ts
@@ -0,0 +1,14 @@
+/** soil_biology measurement module — tsb analytics library. */
+export interface SoilBiologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyMeasurement(data: number[], opts: SoilBiologyMeasurementOptions = {}): SoilBiologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyMeasurement };
diff --git a/src/soil_biology/metrics.ts b/src/soil_biology/metrics.ts
new file mode 100644
index 000000000..3796c2b5b
--- /dev/null
+++ b/src/soil_biology/metrics.ts
@@ -0,0 +1,14 @@
+/** soil_biology metrics module — tsb analytics library. */
+export interface SoilBiologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyMetricsResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyMetrics(data: number[], opts: SoilBiologyMetricsOptions = {}): SoilBiologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyMetrics };
diff --git a/src/soil_biology/modeling.ts b/src/soil_biology/modeling.ts
new file mode 100644
index 000000000..6c1751152
--- /dev/null
+++ b/src/soil_biology/modeling.ts
@@ -0,0 +1,14 @@
+/** soil_biology modeling module — tsb analytics library. */
+export interface SoilBiologyModelingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyModelingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyModeling(data: number[], opts: SoilBiologyModelingOptions = {}): SoilBiologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyModeling };
diff --git a/src/soil_biology/monitoring.ts b/src/soil_biology/monitoring.ts
new file mode 100644
index 000000000..3600978f2
--- /dev/null
+++ b/src/soil_biology/monitoring.ts
@@ -0,0 +1,14 @@
+/** soil_biology monitoring module — tsb analytics library. */
+export interface SoilBiologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyMonitoring(data: number[], opts: SoilBiologyMonitoringOptions = {}): SoilBiologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyMonitoring };
diff --git a/src/soil_biology/nonlinear.ts b/src/soil_biology/nonlinear.ts
new file mode 100644
index 000000000..fd6b948f3
--- /dev/null
+++ b/src/soil_biology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** soil_biology nonlinear module — tsb analytics library. */
+export interface SoilBiologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyNonlinear(data: number[], opts: SoilBiologyNonlinearOptions = {}): SoilBiologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyNonlinear };
diff --git a/src/soil_biology/normalization.ts b/src/soil_biology/normalization.ts
new file mode 100644
index 000000000..c8f903b3b
--- /dev/null
+++ b/src/soil_biology/normalization.ts
@@ -0,0 +1,14 @@
+/** soil_biology normalization module — tsb analytics library. */
+export interface SoilBiologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyNormalization(data: number[], opts: SoilBiologyNormalizationOptions = {}): SoilBiologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyNormalization };
diff --git a/src/soil_biology/optimization.ts b/src/soil_biology/optimization.ts
new file mode 100644
index 000000000..9ea35abcf
--- /dev/null
+++ b/src/soil_biology/optimization.ts
@@ -0,0 +1,14 @@
+/** soil_biology optimization module — tsb analytics library. */
+export interface SoilBiologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyOptimization(data: number[], opts: SoilBiologyOptimizationOptions = {}): SoilBiologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyOptimization };
diff --git a/src/soil_biology/patterns.ts b/src/soil_biology/patterns.ts
new file mode 100644
index 000000000..54ef71771
--- /dev/null
+++ b/src/soil_biology/patterns.ts
@@ -0,0 +1,14 @@
+/** soil_biology patterns module — tsb analytics library. */
+export interface SoilBiologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyPatternsResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyPatterns(data: number[], opts: SoilBiologyPatternsOptions = {}): SoilBiologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyPatterns };
diff --git a/src/soil_biology/permutation.ts b/src/soil_biology/permutation.ts
new file mode 100644
index 000000000..5f0c23a30
--- /dev/null
+++ b/src/soil_biology/permutation.ts
@@ -0,0 +1,14 @@
+/** soil_biology permutation module — tsb analytics library. */
+export interface SoilBiologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyPermutationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyPermutation(data: number[], opts: SoilBiologyPermutationOptions = {}): SoilBiologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyPermutation };
diff --git a/src/soil_biology/prediction.ts b/src/soil_biology/prediction.ts
new file mode 100644
index 000000000..b222a5b94
--- /dev/null
+++ b/src/soil_biology/prediction.ts
@@ -0,0 +1,14 @@
+/** soil_biology prediction module — tsb analytics library. */
+export interface SoilBiologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyPredictionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyPrediction(data: number[], opts: SoilBiologyPredictionOptions = {}): SoilBiologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyPrediction };
diff --git a/src/soil_biology/processing.ts b/src/soil_biology/processing.ts
new file mode 100644
index 000000000..6ddbf893c
--- /dev/null
+++ b/src/soil_biology/processing.ts
@@ -0,0 +1,14 @@
+/** soil_biology processing module — tsb analytics library. */
+export interface SoilBiologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyProcessingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyProcessing(data: number[], opts: SoilBiologyProcessingOptions = {}): SoilBiologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyProcessing };
diff --git a/src/soil_biology/profiling.ts b/src/soil_biology/profiling.ts
new file mode 100644
index 000000000..078cf0d2b
--- /dev/null
+++ b/src/soil_biology/profiling.ts
@@ -0,0 +1,14 @@
+/** soil_biology profiling module — tsb analytics library. */
+export interface SoilBiologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyProfilingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyProfiling(data: number[], opts: SoilBiologyProfilingOptions = {}): SoilBiologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyProfiling };
diff --git a/src/soil_biology/projection.ts b/src/soil_biology/projection.ts
new file mode 100644
index 000000000..dcb2cd86c
--- /dev/null
+++ b/src/soil_biology/projection.ts
@@ -0,0 +1,14 @@
+/** soil_biology projection module — tsb analytics library. */
+export interface SoilBiologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyProjectionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyProjection(data: number[], opts: SoilBiologyProjectionOptions = {}): SoilBiologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyProjection };
diff --git a/src/soil_biology/ranking.ts b/src/soil_biology/ranking.ts
new file mode 100644
index 000000000..60425d184
--- /dev/null
+++ b/src/soil_biology/ranking.ts
@@ -0,0 +1,14 @@
+/** soil_biology ranking module — tsb analytics library. */
+export interface SoilBiologyRankingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyRankingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyRanking(data: number[], opts: SoilBiologyRankingOptions = {}): SoilBiologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyRanking };
diff --git a/src/soil_biology/reconstruction.ts b/src/soil_biology/reconstruction.ts
new file mode 100644
index 000000000..4aa95ed89
--- /dev/null
+++ b/src/soil_biology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** soil_biology reconstruction module — tsb analytics library. */
+export interface SoilBiologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyReconstruction(data: number[], opts: SoilBiologyReconstructionOptions = {}): SoilBiologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyReconstruction };
diff --git a/src/soil_biology/registration.ts b/src/soil_biology/registration.ts
new file mode 100644
index 000000000..0064717fa
--- /dev/null
+++ b/src/soil_biology/registration.ts
@@ -0,0 +1,14 @@
+/** soil_biology registration module — tsb analytics library. */
+export interface SoilBiologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyRegistration(data: number[], opts: SoilBiologyRegistrationOptions = {}): SoilBiologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyRegistration };
diff --git a/src/soil_biology/regression.ts b/src/soil_biology/regression.ts
new file mode 100644
index 000000000..0beae3172
--- /dev/null
+++ b/src/soil_biology/regression.ts
@@ -0,0 +1,14 @@
+/** soil_biology regression module — tsb analytics library. */
+export interface SoilBiologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyRegressionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyRegression(data: number[], opts: SoilBiologyRegressionOptions = {}): SoilBiologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyRegression };
diff --git a/src/soil_biology/regularization.ts b/src/soil_biology/regularization.ts
new file mode 100644
index 000000000..43d783d58
--- /dev/null
+++ b/src/soil_biology/regularization.ts
@@ -0,0 +1,14 @@
+/** soil_biology regularization module — tsb analytics library. */
+export interface SoilBiologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyRegularization(data: number[], opts: SoilBiologyRegularizationOptions = {}): SoilBiologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyRegularization };
diff --git a/src/soil_biology/robustness.ts b/src/soil_biology/robustness.ts
new file mode 100644
index 000000000..fae2abce5
--- /dev/null
+++ b/src/soil_biology/robustness.ts
@@ -0,0 +1,14 @@
+/** soil_biology robustness module — tsb analytics library. */
+export interface SoilBiologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyRobustness(data: number[], opts: SoilBiologyRobustnessOptions = {}): SoilBiologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyRobustness };
diff --git a/src/soil_biology/sampling.ts b/src/soil_biology/sampling.ts
new file mode 100644
index 000000000..3cfea778c
--- /dev/null
+++ b/src/soil_biology/sampling.ts
@@ -0,0 +1,14 @@
+/** soil_biology sampling module — tsb analytics library. */
+export interface SoilBiologySamplingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologySamplingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologySampling(data: number[], opts: SoilBiologySamplingOptions = {}): SoilBiologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologySampling };
diff --git a/src/soil_biology/sampling2.ts b/src/soil_biology/sampling2.ts
new file mode 100644
index 000000000..5fe014d1a
--- /dev/null
+++ b/src/soil_biology/sampling2.ts
@@ -0,0 +1,14 @@
+/** soil_biology sampling2 module — tsb analytics library. */
+export interface SoilBiologySamplingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologySamplingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologySampling(data: number[], opts: SoilBiologySamplingOptions = {}): SoilBiologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologySampling };
diff --git a/src/soil_biology/scaling.ts b/src/soil_biology/scaling.ts
new file mode 100644
index 000000000..b44b9e94f
--- /dev/null
+++ b/src/soil_biology/scaling.ts
@@ -0,0 +1,14 @@
+/** soil_biology scaling module — tsb analytics library. */
+export interface SoilBiologyScalingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyScalingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyScaling(data: number[], opts: SoilBiologyScalingOptions = {}): SoilBiologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyScaling };
diff --git a/src/soil_biology/scoring.ts b/src/soil_biology/scoring.ts
new file mode 100644
index 000000000..83d268ce1
--- /dev/null
+++ b/src/soil_biology/scoring.ts
@@ -0,0 +1,14 @@
+/** soil_biology scoring module — tsb analytics library. */
+export interface SoilBiologyScoringOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyScoringResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyScoring(data: number[], opts: SoilBiologyScoringOptions = {}): SoilBiologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyScoring };
diff --git a/src/soil_biology/segmentation.ts b/src/soil_biology/segmentation.ts
new file mode 100644
index 000000000..02f155b5f
--- /dev/null
+++ b/src/soil_biology/segmentation.ts
@@ -0,0 +1,14 @@
+/** soil_biology segmentation module — tsb analytics library. */
+export interface SoilBiologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologySegmentationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologySegmentation(data: number[], opts: SoilBiologySegmentationOptions = {}): SoilBiologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologySegmentation };
diff --git a/src/soil_biology/selection.ts b/src/soil_biology/selection.ts
new file mode 100644
index 000000000..433cd6089
--- /dev/null
+++ b/src/soil_biology/selection.ts
@@ -0,0 +1,14 @@
+/** soil_biology selection module — tsb analytics library. */
+export interface SoilBiologySelectionOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologySelectionResult { values: number[]; converged: boolean; }
+export function computeSoilBiologySelection(data: number[], opts: SoilBiologySelectionOptions = {}): SoilBiologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologySelection };
diff --git a/src/soil_biology/sensitivity.ts b/src/soil_biology/sensitivity.ts
new file mode 100644
index 000000000..b762208ce
--- /dev/null
+++ b/src/soil_biology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** soil_biology sensitivity module — tsb analytics library. */
+export interface SoilBiologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologySensitivityResult { values: number[]; converged: boolean; }
+export function computeSoilBiologySensitivity(data: number[], opts: SoilBiologySensitivityOptions = {}): SoilBiologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologySensitivity };
diff --git a/src/soil_biology/simulation.ts b/src/soil_biology/simulation.ts
new file mode 100644
index 000000000..be26db237
--- /dev/null
+++ b/src/soil_biology/simulation.ts
@@ -0,0 +1,14 @@
+/** soil_biology simulation module — tsb analytics library. */
+export interface SoilBiologySimulationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologySimulationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologySimulation(data: number[], opts: SoilBiologySimulationOptions = {}): SoilBiologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologySimulation };
diff --git a/src/soil_biology/smoothing.ts b/src/soil_biology/smoothing.ts
new file mode 100644
index 000000000..d0e521894
--- /dev/null
+++ b/src/soil_biology/smoothing.ts
@@ -0,0 +1,14 @@
+/** soil_biology smoothing module — tsb analytics library. */
+export interface SoilBiologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologySmoothingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologySmoothing(data: number[], opts: SoilBiologySmoothingOptions = {}): SoilBiologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologySmoothing };
diff --git a/src/soil_biology/stability.ts b/src/soil_biology/stability.ts
new file mode 100644
index 000000000..9c4d069ab
--- /dev/null
+++ b/src/soil_biology/stability.ts
@@ -0,0 +1,14 @@
+/** soil_biology stability module — tsb analytics library. */
+export interface SoilBiologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyStabilityResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyStability(data: number[], opts: SoilBiologyStabilityOptions = {}): SoilBiologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyStability };
diff --git a/src/soil_biology/stacking.ts b/src/soil_biology/stacking.ts
new file mode 100644
index 000000000..127c7adb8
--- /dev/null
+++ b/src/soil_biology/stacking.ts
@@ -0,0 +1,14 @@
+/** soil_biology stacking module — tsb analytics library. */
+export interface SoilBiologyStackingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyStackingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyStacking(data: number[], opts: SoilBiologyStackingOptions = {}): SoilBiologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyStacking };
diff --git a/src/soil_biology/standardization.ts b/src/soil_biology/standardization.ts
new file mode 100644
index 000000000..e5108480c
--- /dev/null
+++ b/src/soil_biology/standardization.ts
@@ -0,0 +1,14 @@
+/** soil_biology standardization module — tsb analytics library. */
+export interface SoilBiologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyStandardization(data: number[], opts: SoilBiologyStandardizationOptions = {}): SoilBiologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyStandardization };
diff --git a/src/soil_biology/static.ts b/src/soil_biology/static.ts
new file mode 100644
index 000000000..6bedc16df
--- /dev/null
+++ b/src/soil_biology/static.ts
@@ -0,0 +1,14 @@
+/** soil_biology static module — tsb analytics library. */
+export interface SoilBiologyStaticOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyStaticResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyStatic(data: number[], opts: SoilBiologyStaticOptions = {}): SoilBiologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyStatic };
diff --git a/src/soil_biology/stochastic.ts b/src/soil_biology/stochastic.ts
new file mode 100644
index 000000000..c24dc264a
--- /dev/null
+++ b/src/soil_biology/stochastic.ts
@@ -0,0 +1,14 @@
+/** soil_biology stochastic module — tsb analytics library. */
+export interface SoilBiologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyStochasticResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyStochastic(data: number[], opts: SoilBiologyStochasticOptions = {}): SoilBiologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyStochastic };
diff --git a/src/soil_biology/synthesis.ts b/src/soil_biology/synthesis.ts
new file mode 100644
index 000000000..36bf79f11
--- /dev/null
+++ b/src/soil_biology/synthesis.ts
@@ -0,0 +1,14 @@
+/** soil_biology synthesis module — tsb analytics library. */
+export interface SoilBiologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologySynthesisResult { values: number[]; converged: boolean; }
+export function computeSoilBiologySynthesis(data: number[], opts: SoilBiologySynthesisOptions = {}): SoilBiologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologySynthesis };
diff --git a/src/soil_biology/topology.ts b/src/soil_biology/topology.ts
new file mode 100644
index 000000000..610289d9e
--- /dev/null
+++ b/src/soil_biology/topology.ts
@@ -0,0 +1,14 @@
+/** soil_biology topology module — tsb analytics library. */
+export interface SoilBiologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyTopologyResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyTopology(data: number[], opts: SoilBiologyTopologyOptions = {}): SoilBiologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyTopology };
diff --git a/src/soil_biology/tracking.ts b/src/soil_biology/tracking.ts
new file mode 100644
index 000000000..7a959c5ee
--- /dev/null
+++ b/src/soil_biology/tracking.ts
@@ -0,0 +1,14 @@
+/** soil_biology tracking module — tsb analytics library. */
+export interface SoilBiologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyTrackingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyTracking(data: number[], opts: SoilBiologyTrackingOptions = {}): SoilBiologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyTracking };
diff --git a/src/soil_biology/transform.ts b/src/soil_biology/transform.ts
new file mode 100644
index 000000000..137d8f57b
--- /dev/null
+++ b/src/soil_biology/transform.ts
@@ -0,0 +1,14 @@
+/** soil_biology transform module — tsb analytics library. */
+export interface SoilBiologyTransformOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyTransformResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyTransform(data: number[], opts: SoilBiologyTransformOptions = {}): SoilBiologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyTransform };
diff --git a/src/soil_biology/uncertainty.ts b/src/soil_biology/uncertainty.ts
new file mode 100644
index 000000000..624a5ad92
--- /dev/null
+++ b/src/soil_biology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** soil_biology uncertainty module — tsb analytics library. */
+export interface SoilBiologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyUncertainty(data: number[], opts: SoilBiologyUncertaintyOptions = {}): SoilBiologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyUncertainty };
diff --git a/src/soil_biology/validation.ts b/src/soil_biology/validation.ts
new file mode 100644
index 000000000..856ff0c27
--- /dev/null
+++ b/src/soil_biology/validation.ts
@@ -0,0 +1,14 @@
+/** soil_biology validation module — tsb analytics library. */
+export interface SoilBiologyValidationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyValidationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyValidation(data: number[], opts: SoilBiologyValidationOptions = {}): SoilBiologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyValidation };
diff --git a/src/soil_biology/verification.ts b/src/soil_biology/verification.ts
new file mode 100644
index 000000000..96e786d10
--- /dev/null
+++ b/src/soil_biology/verification.ts
@@ -0,0 +1,14 @@
+/** soil_biology verification module — tsb analytics library. */
+export interface SoilBiologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyVerificationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyVerification(data: number[], opts: SoilBiologyVerificationOptions = {}): SoilBiologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyVerification };
diff --git a/src/soil_biology/visualization.ts b/src/soil_biology/visualization.ts
new file mode 100644
index 000000000..eeaecdcdf
--- /dev/null
+++ b/src/soil_biology/visualization.ts
@@ -0,0 +1,14 @@
+/** soil_biology visualization module — tsb analytics library. */
+export interface SoilBiologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyVisualization(data: number[], opts: SoilBiologyVisualizationOptions = {}): SoilBiologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyVisualization };
diff --git a/src/soil_biology/voting.ts b/src/soil_biology/voting.ts
new file mode 100644
index 000000000..d672e7172
--- /dev/null
+++ b/src/soil_biology/voting.ts
@@ -0,0 +1,14 @@
+/** soil_biology voting module — tsb analytics library. */
+export interface SoilBiologyVotingOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyVotingResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyVoting(data: number[], opts: SoilBiologyVotingOptions = {}): SoilBiologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyVoting };
diff --git a/src/soil_biology/wavelet.ts b/src/soil_biology/wavelet.ts
new file mode 100644
index 000000000..5ee4165ab
--- /dev/null
+++ b/src/soil_biology/wavelet.ts
@@ -0,0 +1,14 @@
+/** soil_biology wavelet module — tsb analytics library. */
+export interface SoilBiologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface SoilBiologyWaveletResult { values: number[]; converged: boolean; }
+export function computeSoilBiologyWavelet(data: number[], opts: SoilBiologyWaveletOptions = {}): SoilBiologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilBiologyWavelet };
diff --git a/src/soil_mech/adaptation.ts b/src/soil_mech/adaptation.ts
new file mode 100644
index 000000000..500664c0a
--- /dev/null
+++ b/src/soil_mech/adaptation.ts
@@ -0,0 +1,14 @@
+/** soil_mech adaptation module — tsb analytics library. */
+export interface SoilMechAdaptationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechAdaptationResult { values: number[]; converged: boolean; }
+export function computeSoilMechAdaptation(data: number[], opts: SoilMechAdaptationOptions = {}): SoilMechAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechAdaptation };
diff --git a/src/soil_mech/aggregation.ts b/src/soil_mech/aggregation.ts
new file mode 100644
index 000000000..816c9c2cf
--- /dev/null
+++ b/src/soil_mech/aggregation.ts
@@ -0,0 +1,14 @@
+/** soil_mech aggregation module — tsb analytics library. */
+export interface SoilMechAggregationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechAggregationResult { values: number[]; converged: boolean; }
+export function computeSoilMechAggregation(data: number[], opts: SoilMechAggregationOptions = {}): SoilMechAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechAggregation };
diff --git a/src/soil_mech/algebra.ts b/src/soil_mech/algebra.ts
new file mode 100644
index 000000000..38b1ec414
--- /dev/null
+++ b/src/soil_mech/algebra.ts
@@ -0,0 +1,14 @@
+/** soil_mech algebra module — tsb analytics library. */
+export interface SoilMechAlgebraOptions { tol?: number; maxIter?: number; }
+export interface SoilMechAlgebraResult { values: number[]; converged: boolean; }
+export function computeSoilMechAlgebra(data: number[], opts: SoilMechAlgebraOptions = {}): SoilMechAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechAlgebra };
diff --git a/src/soil_mech/alignment.ts b/src/soil_mech/alignment.ts
new file mode 100644
index 000000000..7673d8796
--- /dev/null
+++ b/src/soil_mech/alignment.ts
@@ -0,0 +1,14 @@
+/** soil_mech alignment module — tsb analytics library. */
+export interface SoilMechAlignmentOptions { tol?: number; maxIter?: number; }
+export interface SoilMechAlignmentResult { values: number[]; converged: boolean; }
+export function computeSoilMechAlignment(data: number[], opts: SoilMechAlignmentOptions = {}): SoilMechAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechAlignment };
diff --git a/src/soil_mech/analysis.ts b/src/soil_mech/analysis.ts
new file mode 100644
index 000000000..4eb92e363
--- /dev/null
+++ b/src/soil_mech/analysis.ts
@@ -0,0 +1,14 @@
+/** soil_mech analysis module — tsb analytics library. */
+export interface SoilMechAnalysisOptions { tol?: number; maxIter?: number; }
+export interface SoilMechAnalysisResult { values: number[]; converged: boolean; }
+export function computeSoilMechAnalysis(data: number[], opts: SoilMechAnalysisOptions = {}): SoilMechAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechAnalysis };
diff --git a/src/soil_mech/augmentation.ts b/src/soil_mech/augmentation.ts
new file mode 100644
index 000000000..2ba6bb9f1
--- /dev/null
+++ b/src/soil_mech/augmentation.ts
@@ -0,0 +1,14 @@
+/** soil_mech augmentation module — tsb analytics library. */
+export interface SoilMechAugmentationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechAugmentationResult { values: number[]; converged: boolean; }
+export function computeSoilMechAugmentation(data: number[], opts: SoilMechAugmentationOptions = {}): SoilMechAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechAugmentation };
diff --git a/src/soil_mech/bagging.ts b/src/soil_mech/bagging.ts
new file mode 100644
index 000000000..22c77cf46
--- /dev/null
+++ b/src/soil_mech/bagging.ts
@@ -0,0 +1,14 @@
+/** soil_mech bagging module — tsb analytics library. */
+export interface SoilMechBaggingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechBaggingResult { values: number[]; converged: boolean; }
+export function computeSoilMechBagging(data: number[], opts: SoilMechBaggingOptions = {}): SoilMechBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechBagging };
diff --git a/src/soil_mech/basis.ts b/src/soil_mech/basis.ts
new file mode 100644
index 000000000..39b0f0031
--- /dev/null
+++ b/src/soil_mech/basis.ts
@@ -0,0 +1,14 @@
+/** soil_mech basis module — tsb analytics library. */
+export interface SoilMechBasisOptions { tol?: number; maxIter?: number; }
+export interface SoilMechBasisResult { values: number[]; converged: boolean; }
+export function computeSoilMechBasis(data: number[], opts: SoilMechBasisOptions = {}): SoilMechBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechBasis };
diff --git a/src/soil_mech/benchmarking.ts b/src/soil_mech/benchmarking.ts
new file mode 100644
index 000000000..a1832bd0f
--- /dev/null
+++ b/src/soil_mech/benchmarking.ts
@@ -0,0 +1,14 @@
+/** soil_mech benchmarking module — tsb analytics library. */
+export interface SoilMechBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeSoilMechBenchmarking(data: number[], opts: SoilMechBenchmarkingOptions = {}): SoilMechBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechBenchmarking };
diff --git a/src/soil_mech/blending.ts b/src/soil_mech/blending.ts
new file mode 100644
index 000000000..88d90f1bb
--- /dev/null
+++ b/src/soil_mech/blending.ts
@@ -0,0 +1,14 @@
+/** soil_mech blending module — tsb analytics library. */
+export interface SoilMechBlendingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechBlendingResult { values: number[]; converged: boolean; }
+export function computeSoilMechBlending(data: number[], opts: SoilMechBlendingOptions = {}): SoilMechBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechBlending };
diff --git a/src/soil_mech/boosting.ts b/src/soil_mech/boosting.ts
new file mode 100644
index 000000000..8a56caf6a
--- /dev/null
+++ b/src/soil_mech/boosting.ts
@@ -0,0 +1,14 @@
+/** soil_mech boosting module — tsb analytics library. */
+export interface SoilMechBoostingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechBoostingResult { values: number[]; converged: boolean; }
+export function computeSoilMechBoosting(data: number[], opts: SoilMechBoostingOptions = {}): SoilMechBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechBoosting };
diff --git a/src/soil_mech/bootstrap.ts b/src/soil_mech/bootstrap.ts
new file mode 100644
index 000000000..b9a914872
--- /dev/null
+++ b/src/soil_mech/bootstrap.ts
@@ -0,0 +1,14 @@
+/** soil_mech bootstrap module — tsb analytics library. */
+export interface SoilMechBootstrapOptions { tol?: number; maxIter?: number; }
+export interface SoilMechBootstrapResult { values: number[]; converged: boolean; }
+export function computeSoilMechBootstrap(data: number[], opts: SoilMechBootstrapOptions = {}): SoilMechBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechBootstrap };
diff --git a/src/soil_mech/calculus.ts b/src/soil_mech/calculus.ts
new file mode 100644
index 000000000..22d899f08
--- /dev/null
+++ b/src/soil_mech/calculus.ts
@@ -0,0 +1,14 @@
+/** soil_mech calculus module — tsb analytics library. */
+export interface SoilMechCalculusOptions { tol?: number; maxIter?: number; }
+export interface SoilMechCalculusResult { values: number[]; converged: boolean; }
+export function computeSoilMechCalculus(data: number[], opts: SoilMechCalculusOptions = {}): SoilMechCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechCalculus };
diff --git a/src/soil_mech/calibration.ts b/src/soil_mech/calibration.ts
new file mode 100644
index 000000000..c361fa56b
--- /dev/null
+++ b/src/soil_mech/calibration.ts
@@ -0,0 +1,14 @@
+/** soil_mech calibration module — tsb analytics library. */
+export interface SoilMechCalibrationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechCalibrationResult { values: number[]; converged: boolean; }
+export function computeSoilMechCalibration(data: number[], opts: SoilMechCalibrationOptions = {}): SoilMechCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechCalibration };
diff --git a/src/soil_mech/characterization.ts b/src/soil_mech/characterization.ts
new file mode 100644
index 000000000..c2e8060e6
--- /dev/null
+++ b/src/soil_mech/characterization.ts
@@ -0,0 +1,14 @@
+/** soil_mech characterization module — tsb analytics library. */
+export interface SoilMechCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechCharacterizationResult { values: number[]; converged: boolean; }
+export function computeSoilMechCharacterization(data: number[], opts: SoilMechCharacterizationOptions = {}): SoilMechCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechCharacterization };
diff --git a/src/soil_mech/classification.ts b/src/soil_mech/classification.ts
new file mode 100644
index 000000000..f8c7cb5e9
--- /dev/null
+++ b/src/soil_mech/classification.ts
@@ -0,0 +1,14 @@
+/** soil_mech classification module — tsb analytics library. */
+export interface SoilMechClassificationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechClassificationResult { values: number[]; converged: boolean; }
+export function computeSoilMechClassification(data: number[], opts: SoilMechClassificationOptions = {}): SoilMechClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechClassification };
diff --git a/src/soil_mech/clustering.ts b/src/soil_mech/clustering.ts
new file mode 100644
index 000000000..7536f4048
--- /dev/null
+++ b/src/soil_mech/clustering.ts
@@ -0,0 +1,14 @@
+/** soil_mech clustering module — tsb analytics library. */
+export interface SoilMechClusteringOptions { tol?: number; maxIter?: number; }
+export interface SoilMechClusteringResult { values: number[]; converged: boolean; }
+export function computeSoilMechClustering(data: number[], opts: SoilMechClusteringOptions = {}): SoilMechClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechClustering };
diff --git a/src/soil_mech/compression.ts b/src/soil_mech/compression.ts
new file mode 100644
index 000000000..f99b9a481
--- /dev/null
+++ b/src/soil_mech/compression.ts
@@ -0,0 +1,14 @@
+/** soil_mech compression module — tsb analytics library. */
+export interface SoilMechCompressionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechCompressionResult { values: number[]; converged: boolean; }
+export function computeSoilMechCompression(data: number[], opts: SoilMechCompressionOptions = {}): SoilMechCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechCompression };
diff --git a/src/soil_mech/continuous.ts b/src/soil_mech/continuous.ts
new file mode 100644
index 000000000..4b881668d
--- /dev/null
+++ b/src/soil_mech/continuous.ts
@@ -0,0 +1,14 @@
+/** soil_mech continuous module — tsb analytics library. */
+export interface SoilMechContinuousOptions { tol?: number; maxIter?: number; }
+export interface SoilMechContinuousResult { values: number[]; converged: boolean; }
+export function computeSoilMechContinuous(data: number[], opts: SoilMechContinuousOptions = {}): SoilMechContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechContinuous };
diff --git a/src/soil_mech/control.ts b/src/soil_mech/control.ts
new file mode 100644
index 000000000..7c4c42707
--- /dev/null
+++ b/src/soil_mech/control.ts
@@ -0,0 +1,14 @@
+/** soil_mech control module — tsb analytics library. */
+export interface SoilMechControlOptions { tol?: number; maxIter?: number; }
+export interface SoilMechControlResult { values: number[]; converged: boolean; }
+export function computeSoilMechControl(data: number[], opts: SoilMechControlOptions = {}): SoilMechControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechControl };
diff --git a/src/soil_mech/convergence.ts b/src/soil_mech/convergence.ts
new file mode 100644
index 000000000..6001e1608
--- /dev/null
+++ b/src/soil_mech/convergence.ts
@@ -0,0 +1,14 @@
+/** soil_mech convergence module — tsb analytics library. */
+export interface SoilMechConvergenceOptions { tol?: number; maxIter?: number; }
+export interface SoilMechConvergenceResult { values: number[]; converged: boolean; }
+export function computeSoilMechConvergence(data: number[], opts: SoilMechConvergenceOptions = {}): SoilMechConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechConvergence };
diff --git a/src/soil_mech/convex.ts b/src/soil_mech/convex.ts
new file mode 100644
index 000000000..25c68de2f
--- /dev/null
+++ b/src/soil_mech/convex.ts
@@ -0,0 +1,14 @@
+/** soil_mech convex module — tsb analytics library. */
+export interface SoilMechConvexOptions { tol?: number; maxIter?: number; }
+export interface SoilMechConvexResult { values: number[]; converged: boolean; }
+export function computeSoilMechConvex(data: number[], opts: SoilMechConvexOptions = {}): SoilMechConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechConvex };
diff --git a/src/soil_mech/correlation.ts b/src/soil_mech/correlation.ts
new file mode 100644
index 000000000..d1d6aea84
--- /dev/null
+++ b/src/soil_mech/correlation.ts
@@ -0,0 +1,14 @@
+/** soil_mech correlation module — tsb analytics library. */
+export interface SoilMechCorrelationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechCorrelationResult { values: number[]; converged: boolean; }
+export function computeSoilMechCorrelation(data: number[], opts: SoilMechCorrelationOptions = {}): SoilMechCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechCorrelation };
diff --git a/src/soil_mech/covariance.ts b/src/soil_mech/covariance.ts
new file mode 100644
index 000000000..9934b7bcf
--- /dev/null
+++ b/src/soil_mech/covariance.ts
@@ -0,0 +1,14 @@
+/** soil_mech covariance module — tsb analytics library. */
+export interface SoilMechCovarianceOptions { tol?: number; maxIter?: number; }
+export interface SoilMechCovarianceResult { values: number[]; converged: boolean; }
+export function computeSoilMechCovariance(data: number[], opts: SoilMechCovarianceOptions = {}): SoilMechCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechCovariance };
diff --git a/src/soil_mech/cross_validation.ts b/src/soil_mech/cross_validation.ts
new file mode 100644
index 000000000..6506b5b12
--- /dev/null
+++ b/src/soil_mech/cross_validation.ts
@@ -0,0 +1,14 @@
+/** soil_mech cross_validation module — tsb analytics library. */
+export interface SoilMechCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechCrossValidationResult { values: number[]; converged: boolean; }
+export function computeSoilMechCrossValidation(data: number[], opts: SoilMechCrossValidationOptions = {}): SoilMechCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechCrossValidation };
diff --git a/src/soil_mech/decoding.ts b/src/soil_mech/decoding.ts
new file mode 100644
index 000000000..dd496e315
--- /dev/null
+++ b/src/soil_mech/decoding.ts
@@ -0,0 +1,14 @@
+/** soil_mech decoding module — tsb analytics library. */
+export interface SoilMechDecodingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDecodingResult { values: number[]; converged: boolean; }
+export function computeSoilMechDecoding(data: number[], opts: SoilMechDecodingOptions = {}): SoilMechDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDecoding };
diff --git a/src/soil_mech/decomposition.ts b/src/soil_mech/decomposition.ts
new file mode 100644
index 000000000..7e09a28c9
--- /dev/null
+++ b/src/soil_mech/decomposition.ts
@@ -0,0 +1,14 @@
+/** soil_mech decomposition module — tsb analytics library. */
+export interface SoilMechDecompositionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDecompositionResult { values: number[]; converged: boolean; }
+export function computeSoilMechDecomposition(data: number[], opts: SoilMechDecompositionOptions = {}): SoilMechDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDecomposition };
diff --git a/src/soil_mech/detection.ts b/src/soil_mech/detection.ts
new file mode 100644
index 000000000..5fa95d847
--- /dev/null
+++ b/src/soil_mech/detection.ts
@@ -0,0 +1,14 @@
+/** soil_mech detection module — tsb analytics library. */
+export interface SoilMechDetectionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDetectionResult { values: number[]; converged: boolean; }
+export function computeSoilMechDetection(data: number[], opts: SoilMechDetectionOptions = {}): SoilMechDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDetection };
diff --git a/src/soil_mech/deterministic.ts b/src/soil_mech/deterministic.ts
new file mode 100644
index 000000000..b456af79a
--- /dev/null
+++ b/src/soil_mech/deterministic.ts
@@ -0,0 +1,14 @@
+/** soil_mech deterministic module — tsb analytics library. */
+export interface SoilMechDeterministicOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDeterministicResult { values: number[]; converged: boolean; }
+export function computeSoilMechDeterministic(data: number[], opts: SoilMechDeterministicOptions = {}): SoilMechDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDeterministic };
diff --git a/src/soil_mech/diagnostics.ts b/src/soil_mech/diagnostics.ts
new file mode 100644
index 000000000..0660edcdc
--- /dev/null
+++ b/src/soil_mech/diagnostics.ts
@@ -0,0 +1,14 @@
+/** soil_mech diagnostics module — tsb analytics library. */
+export interface SoilMechDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeSoilMechDiagnostics(data: number[], opts: SoilMechDiagnosticsOptions = {}): SoilMechDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDiagnostics };
diff --git a/src/soil_mech/differential.ts b/src/soil_mech/differential.ts
new file mode 100644
index 000000000..ee160fa70
--- /dev/null
+++ b/src/soil_mech/differential.ts
@@ -0,0 +1,14 @@
+/** soil_mech differential module — tsb analytics library. */
+export interface SoilMechDifferentialOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDifferentialResult { values: number[]; converged: boolean; }
+export function computeSoilMechDifferential(data: number[], opts: SoilMechDifferentialOptions = {}): SoilMechDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDifferential };
diff --git a/src/soil_mech/discrete.ts b/src/soil_mech/discrete.ts
new file mode 100644
index 000000000..b4bd1bc83
--- /dev/null
+++ b/src/soil_mech/discrete.ts
@@ -0,0 +1,14 @@
+/** soil_mech discrete module — tsb analytics library. */
+export interface SoilMechDiscreteOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDiscreteResult { values: number[]; converged: boolean; }
+export function computeSoilMechDiscrete(data: number[], opts: SoilMechDiscreteOptions = {}): SoilMechDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDiscrete };
diff --git a/src/soil_mech/distribution.ts b/src/soil_mech/distribution.ts
new file mode 100644
index 000000000..35c75626d
--- /dev/null
+++ b/src/soil_mech/distribution.ts
@@ -0,0 +1,14 @@
+/** soil_mech distribution module — tsb analytics library. */
+export interface SoilMechDistributionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDistributionResult { values: number[]; converged: boolean; }
+export function computeSoilMechDistribution(data: number[], opts: SoilMechDistributionOptions = {}): SoilMechDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDistribution };
diff --git a/src/soil_mech/dynamic.ts b/src/soil_mech/dynamic.ts
new file mode 100644
index 000000000..7594ebb3f
--- /dev/null
+++ b/src/soil_mech/dynamic.ts
@@ -0,0 +1,14 @@
+/** soil_mech dynamic module — tsb analytics library. */
+export interface SoilMechDynamicOptions { tol?: number; maxIter?: number; }
+export interface SoilMechDynamicResult { values: number[]; converged: boolean; }
+export function computeSoilMechDynamic(data: number[], opts: SoilMechDynamicOptions = {}): SoilMechDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechDynamic };
diff --git a/src/soil_mech/embedding.ts b/src/soil_mech/embedding.ts
new file mode 100644
index 000000000..c4108dcd6
--- /dev/null
+++ b/src/soil_mech/embedding.ts
@@ -0,0 +1,14 @@
+/** soil_mech embedding module — tsb analytics library. */
+export interface SoilMechEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechEmbeddingResult { values: number[]; converged: boolean; }
+export function computeSoilMechEmbedding(data: number[], opts: SoilMechEmbeddingOptions = {}): SoilMechEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechEmbedding };
diff --git a/src/soil_mech/encoding.ts b/src/soil_mech/encoding.ts
new file mode 100644
index 000000000..1fb7a9a73
--- /dev/null
+++ b/src/soil_mech/encoding.ts
@@ -0,0 +1,14 @@
+/** soil_mech encoding module — tsb analytics library. */
+export interface SoilMechEncodingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechEncodingResult { values: number[]; converged: boolean; }
+export function computeSoilMechEncoding(data: number[], opts: SoilMechEncodingOptions = {}): SoilMechEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechEncoding };
diff --git a/src/soil_mech/ensemble.ts b/src/soil_mech/ensemble.ts
new file mode 100644
index 000000000..1f3ba1c6a
--- /dev/null
+++ b/src/soil_mech/ensemble.ts
@@ -0,0 +1,14 @@
+/** soil_mech ensemble module — tsb analytics library. */
+export interface SoilMechEnsembleOptions { tol?: number; maxIter?: number; }
+export interface SoilMechEnsembleResult { values: number[]; converged: boolean; }
+export function computeSoilMechEnsemble(data: number[], opts: SoilMechEnsembleOptions = {}): SoilMechEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechEnsemble };
diff --git a/src/soil_mech/estimation.ts b/src/soil_mech/estimation.ts
new file mode 100644
index 000000000..05e14b656
--- /dev/null
+++ b/src/soil_mech/estimation.ts
@@ -0,0 +1,14 @@
+/** soil_mech estimation module — tsb analytics library. */
+export interface SoilMechEstimationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechEstimationResult { values: number[]; converged: boolean; }
+export function computeSoilMechEstimation(data: number[], opts: SoilMechEstimationOptions = {}): SoilMechEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechEstimation };
diff --git a/src/soil_mech/evaluation.ts b/src/soil_mech/evaluation.ts
new file mode 100644
index 000000000..908c94e55
--- /dev/null
+++ b/src/soil_mech/evaluation.ts
@@ -0,0 +1,14 @@
+/** soil_mech evaluation module — tsb analytics library. */
+export interface SoilMechEvaluationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechEvaluationResult { values: number[]; converged: boolean; }
+export function computeSoilMechEvaluation(data: number[], opts: SoilMechEvaluationOptions = {}): SoilMechEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechEvaluation };
diff --git a/src/soil_mech/extrapolation.ts b/src/soil_mech/extrapolation.ts
new file mode 100644
index 000000000..c4d88af9f
--- /dev/null
+++ b/src/soil_mech/extrapolation.ts
@@ -0,0 +1,14 @@
+/** soil_mech extrapolation module — tsb analytics library. */
+export interface SoilMechExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechExtrapolationResult { values: number[]; converged: boolean; }
+export function computeSoilMechExtrapolation(data: number[], opts: SoilMechExtrapolationOptions = {}): SoilMechExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechExtrapolation };
diff --git a/src/soil_mech/features.ts b/src/soil_mech/features.ts
new file mode 100644
index 000000000..4eaa4e2e4
--- /dev/null
+++ b/src/soil_mech/features.ts
@@ -0,0 +1,14 @@
+/** soil_mech features module — tsb analytics library. */
+export interface SoilMechFeaturesOptions { tol?: number; maxIter?: number; }
+export interface SoilMechFeaturesResult { values: number[]; converged: boolean; }
+export function computeSoilMechFeatures(data: number[], opts: SoilMechFeaturesOptions = {}): SoilMechFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechFeatures };
diff --git a/src/soil_mech/feedback.ts b/src/soil_mech/feedback.ts
new file mode 100644
index 000000000..cc06f2f41
--- /dev/null
+++ b/src/soil_mech/feedback.ts
@@ -0,0 +1,14 @@
+/** soil_mech feedback module — tsb analytics library. */
+export interface SoilMechFeedbackOptions { tol?: number; maxIter?: number; }
+export interface SoilMechFeedbackResult { values: number[]; converged: boolean; }
+export function computeSoilMechFeedback(data: number[], opts: SoilMechFeedbackOptions = {}): SoilMechFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechFeedback };
diff --git a/src/soil_mech/filtering.ts b/src/soil_mech/filtering.ts
new file mode 100644
index 000000000..4a6f75d08
--- /dev/null
+++ b/src/soil_mech/filtering.ts
@@ -0,0 +1,14 @@
+/** soil_mech filtering module — tsb analytics library. */
+export interface SoilMechFilteringOptions { tol?: number; maxIter?: number; }
+export interface SoilMechFilteringResult { values: number[]; converged: boolean; }
+export function computeSoilMechFiltering(data: number[], opts: SoilMechFilteringOptions = {}): SoilMechFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechFiltering };
diff --git a/src/soil_mech/fourier.ts b/src/soil_mech/fourier.ts
new file mode 100644
index 000000000..d120774d2
--- /dev/null
+++ b/src/soil_mech/fourier.ts
@@ -0,0 +1,14 @@
+/** soil_mech fourier module — tsb analytics library. */
+export interface SoilMechFourierOptions { tol?: number; maxIter?: number; }
+export interface SoilMechFourierResult { values: number[]; converged: boolean; }
+export function computeSoilMechFourier(data: number[], opts: SoilMechFourierOptions = {}): SoilMechFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechFourier };
diff --git a/src/soil_mech/fusion.ts b/src/soil_mech/fusion.ts
new file mode 100644
index 000000000..b22128e3a
--- /dev/null
+++ b/src/soil_mech/fusion.ts
@@ -0,0 +1,14 @@
+/** soil_mech fusion module — tsb analytics library. */
+export interface SoilMechFusionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechFusionResult { values: number[]; converged: boolean; }
+export function computeSoilMechFusion(data: number[], opts: SoilMechFusionOptions = {}): SoilMechFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechFusion };
diff --git a/src/soil_mech/generation.ts b/src/soil_mech/generation.ts
new file mode 100644
index 000000000..9f846fae3
--- /dev/null
+++ b/src/soil_mech/generation.ts
@@ -0,0 +1,14 @@
+/** soil_mech generation module — tsb analytics library. */
+export interface SoilMechGenerationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechGenerationResult { values: number[]; converged: boolean; }
+export function computeSoilMechGeneration(data: number[], opts: SoilMechGenerationOptions = {}): SoilMechGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechGeneration };
diff --git a/src/soil_mech/geometry.ts b/src/soil_mech/geometry.ts
new file mode 100644
index 000000000..090bb4cd3
--- /dev/null
+++ b/src/soil_mech/geometry.ts
@@ -0,0 +1,14 @@
+/** soil_mech geometry module — tsb analytics library. */
+export interface SoilMechGeometryOptions { tol?: number; maxIter?: number; }
+export interface SoilMechGeometryResult { values: number[]; converged: boolean; }
+export function computeSoilMechGeometry(data: number[], opts: SoilMechGeometryOptions = {}): SoilMechGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechGeometry };
diff --git a/src/soil_mech/gradient.ts b/src/soil_mech/gradient.ts
new file mode 100644
index 000000000..5d8def4c4
--- /dev/null
+++ b/src/soil_mech/gradient.ts
@@ -0,0 +1,14 @@
+/** soil_mech gradient module — tsb analytics library. */
+export interface SoilMechGradientOptions { tol?: number; maxIter?: number; }
+export interface SoilMechGradientResult { values: number[]; converged: boolean; }
+export function computeSoilMechGradient(data: number[], opts: SoilMechGradientOptions = {}): SoilMechGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechGradient };
diff --git a/src/soil_mech/hessian.ts b/src/soil_mech/hessian.ts
new file mode 100644
index 000000000..6d4a30d08
--- /dev/null
+++ b/src/soil_mech/hessian.ts
@@ -0,0 +1,14 @@
+/** soil_mech hessian module — tsb analytics library. */
+export interface SoilMechHessianOptions { tol?: number; maxIter?: number; }
+export interface SoilMechHessianResult { values: number[]; converged: boolean; }
+export function computeSoilMechHessian(data: number[], opts: SoilMechHessianOptions = {}): SoilMechHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechHessian };
diff --git a/src/soil_mech/hypothesis.ts b/src/soil_mech/hypothesis.ts
new file mode 100644
index 000000000..f7655256a
--- /dev/null
+++ b/src/soil_mech/hypothesis.ts
@@ -0,0 +1,14 @@
+/** soil_mech hypothesis module — tsb analytics library. */
+export interface SoilMechHypothesisOptions { tol?: number; maxIter?: number; }
+export interface SoilMechHypothesisResult { values: number[]; converged: boolean; }
+export function computeSoilMechHypothesis(data: number[], opts: SoilMechHypothesisOptions = {}): SoilMechHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechHypothesis };
diff --git a/src/soil_mech/inference.ts b/src/soil_mech/inference.ts
new file mode 100644
index 000000000..2bbb29836
--- /dev/null
+++ b/src/soil_mech/inference.ts
@@ -0,0 +1,14 @@
+/** soil_mech inference module — tsb analytics library. */
+export interface SoilMechInferenceOptions { tol?: number; maxIter?: number; }
+export interface SoilMechInferenceResult { values: number[]; converged: boolean; }
+export function computeSoilMechInference(data: number[], opts: SoilMechInferenceOptions = {}): SoilMechInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechInference };
diff --git a/src/soil_mech/inference2.ts b/src/soil_mech/inference2.ts
new file mode 100644
index 000000000..8df331283
--- /dev/null
+++ b/src/soil_mech/inference2.ts
@@ -0,0 +1,14 @@
+/** soil_mech inference2 module — tsb analytics library. */
+export interface SoilMechInferenceOptions { tol?: number; maxIter?: number; }
+export interface SoilMechInferenceResult { values: number[]; converged: boolean; }
+export function computeSoilMechInference(data: number[], opts: SoilMechInferenceOptions = {}): SoilMechInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechInference };
diff --git a/src/soil_mech/integral.ts b/src/soil_mech/integral.ts
new file mode 100644
index 000000000..fd696f2b7
--- /dev/null
+++ b/src/soil_mech/integral.ts
@@ -0,0 +1,14 @@
+/** soil_mech integral module — tsb analytics library. */
+export interface SoilMechIntegralOptions { tol?: number; maxIter?: number; }
+export interface SoilMechIntegralResult { values: number[]; converged: boolean; }
+export function computeSoilMechIntegral(data: number[], opts: SoilMechIntegralOptions = {}): SoilMechIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechIntegral };
diff --git a/src/soil_mech/integration.ts b/src/soil_mech/integration.ts
new file mode 100644
index 000000000..bac41818a
--- /dev/null
+++ b/src/soil_mech/integration.ts
@@ -0,0 +1,14 @@
+/** soil_mech integration module — tsb analytics library. */
+export interface SoilMechIntegrationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechIntegrationResult { values: number[]; converged: boolean; }
+export function computeSoilMechIntegration(data: number[], opts: SoilMechIntegrationOptions = {}): SoilMechIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechIntegration };
diff --git a/src/soil_mech/interpolation.ts b/src/soil_mech/interpolation.ts
new file mode 100644
index 000000000..ea2fab862
--- /dev/null
+++ b/src/soil_mech/interpolation.ts
@@ -0,0 +1,14 @@
+/** soil_mech interpolation module — tsb analytics library. */
+export interface SoilMechInterpolationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechInterpolationResult { values: number[]; converged: boolean; }
+export function computeSoilMechInterpolation(data: number[], opts: SoilMechInterpolationOptions = {}): SoilMechInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechInterpolation };
diff --git a/src/soil_mech/jacobian.ts b/src/soil_mech/jacobian.ts
new file mode 100644
index 000000000..460065ab1
--- /dev/null
+++ b/src/soil_mech/jacobian.ts
@@ -0,0 +1,14 @@
+/** soil_mech jacobian module — tsb analytics library. */
+export interface SoilMechJacobianOptions { tol?: number; maxIter?: number; }
+export interface SoilMechJacobianResult { values: number[]; converged: boolean; }
+export function computeSoilMechJacobian(data: number[], opts: SoilMechJacobianOptions = {}): SoilMechJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechJacobian };
diff --git a/src/soil_mech/kernel.ts b/src/soil_mech/kernel.ts
new file mode 100644
index 000000000..8c17f7f55
--- /dev/null
+++ b/src/soil_mech/kernel.ts
@@ -0,0 +1,14 @@
+/** soil_mech kernel module — tsb analytics library. */
+export interface SoilMechKernelOptions { tol?: number; maxIter?: number; }
+export interface SoilMechKernelResult { values: number[]; converged: boolean; }
+export function computeSoilMechKernel(data: number[], opts: SoilMechKernelOptions = {}): SoilMechKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechKernel };
diff --git a/src/soil_mech/laplacian.ts b/src/soil_mech/laplacian.ts
new file mode 100644
index 000000000..606c747be
--- /dev/null
+++ b/src/soil_mech/laplacian.ts
@@ -0,0 +1,14 @@
+/** soil_mech laplacian module — tsb analytics library. */
+export interface SoilMechLaplacianOptions { tol?: number; maxIter?: number; }
+export interface SoilMechLaplacianResult { values: number[]; converged: boolean; }
+export function computeSoilMechLaplacian(data: number[], opts: SoilMechLaplacianOptions = {}): SoilMechLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechLaplacian };
diff --git a/src/soil_mech/learning.ts b/src/soil_mech/learning.ts
new file mode 100644
index 000000000..ea803d4be
--- /dev/null
+++ b/src/soil_mech/learning.ts
@@ -0,0 +1,14 @@
+/** soil_mech learning module — tsb analytics library. */
+export interface SoilMechLearningOptions { tol?: number; maxIter?: number; }
+export interface SoilMechLearningResult { values: number[]; converged: boolean; }
+export function computeSoilMechLearning(data: number[], opts: SoilMechLearningOptions = {}): SoilMechLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechLearning };
diff --git a/src/soil_mech/linear.ts b/src/soil_mech/linear.ts
new file mode 100644
index 000000000..a1ca812b6
--- /dev/null
+++ b/src/soil_mech/linear.ts
@@ -0,0 +1,14 @@
+/** soil_mech linear module — tsb analytics library. */
+export interface SoilMechLinearOptions { tol?: number; maxIter?: number; }
+export interface SoilMechLinearResult { values: number[]; converged: boolean; }
+export function computeSoilMechLinear(data: number[], opts: SoilMechLinearOptions = {}): SoilMechLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechLinear };
diff --git a/src/soil_mech/manifold.ts b/src/soil_mech/manifold.ts
new file mode 100644
index 000000000..8f30d68e3
--- /dev/null
+++ b/src/soil_mech/manifold.ts
@@ -0,0 +1,14 @@
+/** soil_mech manifold module — tsb analytics library. */
+export interface SoilMechManifoldOptions { tol?: number; maxIter?: number; }
+export interface SoilMechManifoldResult { values: number[]; converged: boolean; }
+export function computeSoilMechManifold(data: number[], opts: SoilMechManifoldOptions = {}): SoilMechManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechManifold };
diff --git a/src/soil_mech/matching.ts b/src/soil_mech/matching.ts
new file mode 100644
index 000000000..aaf0d5670
--- /dev/null
+++ b/src/soil_mech/matching.ts
@@ -0,0 +1,14 @@
+/** soil_mech matching module — tsb analytics library. */
+export interface SoilMechMatchingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechMatchingResult { values: number[]; converged: boolean; }
+export function computeSoilMechMatching(data: number[], opts: SoilMechMatchingOptions = {}): SoilMechMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechMatching };
diff --git a/src/soil_mech/measurement.ts b/src/soil_mech/measurement.ts
new file mode 100644
index 000000000..bd0f6ee53
--- /dev/null
+++ b/src/soil_mech/measurement.ts
@@ -0,0 +1,14 @@
+/** soil_mech measurement module — tsb analytics library. */
+export interface SoilMechMeasurementOptions { tol?: number; maxIter?: number; }
+export interface SoilMechMeasurementResult { values: number[]; converged: boolean; }
+export function computeSoilMechMeasurement(data: number[], opts: SoilMechMeasurementOptions = {}): SoilMechMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechMeasurement };
diff --git a/src/soil_mech/metrics.ts b/src/soil_mech/metrics.ts
new file mode 100644
index 000000000..7811db21e
--- /dev/null
+++ b/src/soil_mech/metrics.ts
@@ -0,0 +1,14 @@
+/** soil_mech metrics module — tsb analytics library. */
+export interface SoilMechMetricsOptions { tol?: number; maxIter?: number; }
+export interface SoilMechMetricsResult { values: number[]; converged: boolean; }
+export function computeSoilMechMetrics(data: number[], opts: SoilMechMetricsOptions = {}): SoilMechMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechMetrics };
diff --git a/src/soil_mech/modeling.ts b/src/soil_mech/modeling.ts
new file mode 100644
index 000000000..586aeb3c8
--- /dev/null
+++ b/src/soil_mech/modeling.ts
@@ -0,0 +1,14 @@
+/** soil_mech modeling module — tsb analytics library. */
+export interface SoilMechModelingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechModelingResult { values: number[]; converged: boolean; }
+export function computeSoilMechModeling(data: number[], opts: SoilMechModelingOptions = {}): SoilMechModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechModeling };
diff --git a/src/soil_mech/monitoring.ts b/src/soil_mech/monitoring.ts
new file mode 100644
index 000000000..1522b5161
--- /dev/null
+++ b/src/soil_mech/monitoring.ts
@@ -0,0 +1,14 @@
+/** soil_mech monitoring module — tsb analytics library. */
+export interface SoilMechMonitoringOptions { tol?: number; maxIter?: number; }
+export interface SoilMechMonitoringResult { values: number[]; converged: boolean; }
+export function computeSoilMechMonitoring(data: number[], opts: SoilMechMonitoringOptions = {}): SoilMechMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechMonitoring };
diff --git a/src/soil_mech/nonlinear.ts b/src/soil_mech/nonlinear.ts
new file mode 100644
index 000000000..6e2c537be
--- /dev/null
+++ b/src/soil_mech/nonlinear.ts
@@ -0,0 +1,14 @@
+/** soil_mech nonlinear module — tsb analytics library. */
+export interface SoilMechNonlinearOptions { tol?: number; maxIter?: number; }
+export interface SoilMechNonlinearResult { values: number[]; converged: boolean; }
+export function computeSoilMechNonlinear(data: number[], opts: SoilMechNonlinearOptions = {}): SoilMechNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechNonlinear };
diff --git a/src/soil_mech/normalization.ts b/src/soil_mech/normalization.ts
new file mode 100644
index 000000000..28c3dc48d
--- /dev/null
+++ b/src/soil_mech/normalization.ts
@@ -0,0 +1,14 @@
+/** soil_mech normalization module — tsb analytics library. */
+export interface SoilMechNormalizationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechNormalizationResult { values: number[]; converged: boolean; }
+export function computeSoilMechNormalization(data: number[], opts: SoilMechNormalizationOptions = {}): SoilMechNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechNormalization };
diff --git a/src/soil_mech/optimization.ts b/src/soil_mech/optimization.ts
new file mode 100644
index 000000000..43a847b1f
--- /dev/null
+++ b/src/soil_mech/optimization.ts
@@ -0,0 +1,14 @@
+/** soil_mech optimization module — tsb analytics library. */
+export interface SoilMechOptimizationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechOptimizationResult { values: number[]; converged: boolean; }
+export function computeSoilMechOptimization(data: number[], opts: SoilMechOptimizationOptions = {}): SoilMechOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechOptimization };
diff --git a/src/soil_mech/patterns.ts b/src/soil_mech/patterns.ts
new file mode 100644
index 000000000..ef2faf224
--- /dev/null
+++ b/src/soil_mech/patterns.ts
@@ -0,0 +1,14 @@
+/** soil_mech patterns module — tsb analytics library. */
+export interface SoilMechPatternsOptions { tol?: number; maxIter?: number; }
+export interface SoilMechPatternsResult { values: number[]; converged: boolean; }
+export function computeSoilMechPatterns(data: number[], opts: SoilMechPatternsOptions = {}): SoilMechPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechPatterns };
diff --git a/src/soil_mech/permutation.ts b/src/soil_mech/permutation.ts
new file mode 100644
index 000000000..eb5b7f06e
--- /dev/null
+++ b/src/soil_mech/permutation.ts
@@ -0,0 +1,14 @@
+/** soil_mech permutation module — tsb analytics library. */
+export interface SoilMechPermutationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechPermutationResult { values: number[]; converged: boolean; }
+export function computeSoilMechPermutation(data: number[], opts: SoilMechPermutationOptions = {}): SoilMechPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechPermutation };
diff --git a/src/soil_mech/prediction.ts b/src/soil_mech/prediction.ts
new file mode 100644
index 000000000..1340b0a38
--- /dev/null
+++ b/src/soil_mech/prediction.ts
@@ -0,0 +1,14 @@
+/** soil_mech prediction module — tsb analytics library. */
+export interface SoilMechPredictionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechPredictionResult { values: number[]; converged: boolean; }
+export function computeSoilMechPrediction(data: number[], opts: SoilMechPredictionOptions = {}): SoilMechPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechPrediction };
diff --git a/src/soil_mech/processing.ts b/src/soil_mech/processing.ts
new file mode 100644
index 000000000..e052f0243
--- /dev/null
+++ b/src/soil_mech/processing.ts
@@ -0,0 +1,14 @@
+/** soil_mech processing module — tsb analytics library. */
+export interface SoilMechProcessingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechProcessingResult { values: number[]; converged: boolean; }
+export function computeSoilMechProcessing(data: number[], opts: SoilMechProcessingOptions = {}): SoilMechProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechProcessing };
diff --git a/src/soil_mech/profiling.ts b/src/soil_mech/profiling.ts
new file mode 100644
index 000000000..f0980b6e5
--- /dev/null
+++ b/src/soil_mech/profiling.ts
@@ -0,0 +1,14 @@
+/** soil_mech profiling module — tsb analytics library. */
+export interface SoilMechProfilingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechProfilingResult { values: number[]; converged: boolean; }
+export function computeSoilMechProfiling(data: number[], opts: SoilMechProfilingOptions = {}): SoilMechProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechProfiling };
diff --git a/src/soil_mech/projection.ts b/src/soil_mech/projection.ts
new file mode 100644
index 000000000..d2b7e090a
--- /dev/null
+++ b/src/soil_mech/projection.ts
@@ -0,0 +1,14 @@
+/** soil_mech projection module — tsb analytics library. */
+export interface SoilMechProjectionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechProjectionResult { values: number[]; converged: boolean; }
+export function computeSoilMechProjection(data: number[], opts: SoilMechProjectionOptions = {}): SoilMechProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechProjection };
diff --git a/src/soil_mech/ranking.ts b/src/soil_mech/ranking.ts
new file mode 100644
index 000000000..909a24530
--- /dev/null
+++ b/src/soil_mech/ranking.ts
@@ -0,0 +1,14 @@
+/** soil_mech ranking module — tsb analytics library. */
+export interface SoilMechRankingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechRankingResult { values: number[]; converged: boolean; }
+export function computeSoilMechRanking(data: number[], opts: SoilMechRankingOptions = {}): SoilMechRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechRanking };
diff --git a/src/soil_mech/reconstruction.ts b/src/soil_mech/reconstruction.ts
new file mode 100644
index 000000000..e55bf0e3b
--- /dev/null
+++ b/src/soil_mech/reconstruction.ts
@@ -0,0 +1,14 @@
+/** soil_mech reconstruction module — tsb analytics library. */
+export interface SoilMechReconstructionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechReconstructionResult { values: number[]; converged: boolean; }
+export function computeSoilMechReconstruction(data: number[], opts: SoilMechReconstructionOptions = {}): SoilMechReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechReconstruction };
diff --git a/src/soil_mech/registration.ts b/src/soil_mech/registration.ts
new file mode 100644
index 000000000..b28a84333
--- /dev/null
+++ b/src/soil_mech/registration.ts
@@ -0,0 +1,14 @@
+/** soil_mech registration module — tsb analytics library. */
+export interface SoilMechRegistrationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechRegistrationResult { values: number[]; converged: boolean; }
+export function computeSoilMechRegistration(data: number[], opts: SoilMechRegistrationOptions = {}): SoilMechRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechRegistration };
diff --git a/src/soil_mech/regression.ts b/src/soil_mech/regression.ts
new file mode 100644
index 000000000..814aa40ae
--- /dev/null
+++ b/src/soil_mech/regression.ts
@@ -0,0 +1,14 @@
+/** soil_mech regression module — tsb analytics library. */
+export interface SoilMechRegressionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechRegressionResult { values: number[]; converged: boolean; }
+export function computeSoilMechRegression(data: number[], opts: SoilMechRegressionOptions = {}): SoilMechRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechRegression };
diff --git a/src/soil_mech/regularization.ts b/src/soil_mech/regularization.ts
new file mode 100644
index 000000000..d58ba053b
--- /dev/null
+++ b/src/soil_mech/regularization.ts
@@ -0,0 +1,14 @@
+/** soil_mech regularization module — tsb analytics library. */
+export interface SoilMechRegularizationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechRegularizationResult { values: number[]; converged: boolean; }
+export function computeSoilMechRegularization(data: number[], opts: SoilMechRegularizationOptions = {}): SoilMechRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechRegularization };
diff --git a/src/soil_mech/robustness.ts b/src/soil_mech/robustness.ts
new file mode 100644
index 000000000..e4c29579a
--- /dev/null
+++ b/src/soil_mech/robustness.ts
@@ -0,0 +1,14 @@
+/** soil_mech robustness module — tsb analytics library. */
+export interface SoilMechRobustnessOptions { tol?: number; maxIter?: number; }
+export interface SoilMechRobustnessResult { values: number[]; converged: boolean; }
+export function computeSoilMechRobustness(data: number[], opts: SoilMechRobustnessOptions = {}): SoilMechRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechRobustness };
diff --git a/src/soil_mech/sampling.ts b/src/soil_mech/sampling.ts
new file mode 100644
index 000000000..e3c3bd9e3
--- /dev/null
+++ b/src/soil_mech/sampling.ts
@@ -0,0 +1,14 @@
+/** soil_mech sampling module — tsb analytics library. */
+export interface SoilMechSamplingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechSamplingResult { values: number[]; converged: boolean; }
+export function computeSoilMechSampling(data: number[], opts: SoilMechSamplingOptions = {}): SoilMechSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechSampling };
diff --git a/src/soil_mech/sampling2.ts b/src/soil_mech/sampling2.ts
new file mode 100644
index 000000000..2b22d8a62
--- /dev/null
+++ b/src/soil_mech/sampling2.ts
@@ -0,0 +1,14 @@
+/** soil_mech sampling2 module — tsb analytics library. */
+export interface SoilMechSamplingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechSamplingResult { values: number[]; converged: boolean; }
+export function computeSoilMechSampling(data: number[], opts: SoilMechSamplingOptions = {}): SoilMechSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechSampling };
diff --git a/src/soil_mech/scaling.ts b/src/soil_mech/scaling.ts
new file mode 100644
index 000000000..e4d3af551
--- /dev/null
+++ b/src/soil_mech/scaling.ts
@@ -0,0 +1,14 @@
+/** soil_mech scaling module — tsb analytics library. */
+export interface SoilMechScalingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechScalingResult { values: number[]; converged: boolean; }
+export function computeSoilMechScaling(data: number[], opts: SoilMechScalingOptions = {}): SoilMechScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechScaling };
diff --git a/src/soil_mech/scoring.ts b/src/soil_mech/scoring.ts
new file mode 100644
index 000000000..00184f49c
--- /dev/null
+++ b/src/soil_mech/scoring.ts
@@ -0,0 +1,14 @@
+/** soil_mech scoring module — tsb analytics library. */
+export interface SoilMechScoringOptions { tol?: number; maxIter?: number; }
+export interface SoilMechScoringResult { values: number[]; converged: boolean; }
+export function computeSoilMechScoring(data: number[], opts: SoilMechScoringOptions = {}): SoilMechScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechScoring };
diff --git a/src/soil_mech/segmentation.ts b/src/soil_mech/segmentation.ts
new file mode 100644
index 000000000..8656a89d8
--- /dev/null
+++ b/src/soil_mech/segmentation.ts
@@ -0,0 +1,14 @@
+/** soil_mech segmentation module — tsb analytics library. */
+export interface SoilMechSegmentationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechSegmentationResult { values: number[]; converged: boolean; }
+export function computeSoilMechSegmentation(data: number[], opts: SoilMechSegmentationOptions = {}): SoilMechSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechSegmentation };
diff --git a/src/soil_mech/selection.ts b/src/soil_mech/selection.ts
new file mode 100644
index 000000000..a2f8e415f
--- /dev/null
+++ b/src/soil_mech/selection.ts
@@ -0,0 +1,14 @@
+/** soil_mech selection module — tsb analytics library. */
+export interface SoilMechSelectionOptions { tol?: number; maxIter?: number; }
+export interface SoilMechSelectionResult { values: number[]; converged: boolean; }
+export function computeSoilMechSelection(data: number[], opts: SoilMechSelectionOptions = {}): SoilMechSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechSelection };
diff --git a/src/soil_mech/sensitivity.ts b/src/soil_mech/sensitivity.ts
new file mode 100644
index 000000000..6712ff099
--- /dev/null
+++ b/src/soil_mech/sensitivity.ts
@@ -0,0 +1,14 @@
+/** soil_mech sensitivity module — tsb analytics library. */
+export interface SoilMechSensitivityOptions { tol?: number; maxIter?: number; }
+export interface SoilMechSensitivityResult { values: number[]; converged: boolean; }
+export function computeSoilMechSensitivity(data: number[], opts: SoilMechSensitivityOptions = {}): SoilMechSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechSensitivity };
diff --git a/src/soil_mech/simulation.ts b/src/soil_mech/simulation.ts
new file mode 100644
index 000000000..fa3c1f581
--- /dev/null
+++ b/src/soil_mech/simulation.ts
@@ -0,0 +1,14 @@
+/** soil_mech simulation module — tsb analytics library. */
+export interface SoilMechSimulationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechSimulationResult { values: number[]; converged: boolean; }
+export function computeSoilMechSimulation(data: number[], opts: SoilMechSimulationOptions = {}): SoilMechSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechSimulation };
diff --git a/src/soil_mech/smoothing.ts b/src/soil_mech/smoothing.ts
new file mode 100644
index 000000000..d1f874d23
--- /dev/null
+++ b/src/soil_mech/smoothing.ts
@@ -0,0 +1,14 @@
+/** soil_mech smoothing module — tsb analytics library. */
+export interface SoilMechSmoothingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechSmoothingResult { values: number[]; converged: boolean; }
+export function computeSoilMechSmoothing(data: number[], opts: SoilMechSmoothingOptions = {}): SoilMechSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechSmoothing };
diff --git a/src/soil_mech/stability.ts b/src/soil_mech/stability.ts
new file mode 100644
index 000000000..c14283288
--- /dev/null
+++ b/src/soil_mech/stability.ts
@@ -0,0 +1,14 @@
+/** soil_mech stability module — tsb analytics library. */
+export interface SoilMechStabilityOptions { tol?: number; maxIter?: number; }
+export interface SoilMechStabilityResult { values: number[]; converged: boolean; }
+export function computeSoilMechStability(data: number[], opts: SoilMechStabilityOptions = {}): SoilMechStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechStability };
diff --git a/src/soil_mech/stacking.ts b/src/soil_mech/stacking.ts
new file mode 100644
index 000000000..eae6388b3
--- /dev/null
+++ b/src/soil_mech/stacking.ts
@@ -0,0 +1,14 @@
+/** soil_mech stacking module — tsb analytics library. */
+export interface SoilMechStackingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechStackingResult { values: number[]; converged: boolean; }
+export function computeSoilMechStacking(data: number[], opts: SoilMechStackingOptions = {}): SoilMechStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechStacking };
diff --git a/src/soil_mech/standardization.ts b/src/soil_mech/standardization.ts
new file mode 100644
index 000000000..a93bbab80
--- /dev/null
+++ b/src/soil_mech/standardization.ts
@@ -0,0 +1,14 @@
+/** soil_mech standardization module — tsb analytics library. */
+export interface SoilMechStandardizationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechStandardizationResult { values: number[]; converged: boolean; }
+export function computeSoilMechStandardization(data: number[], opts: SoilMechStandardizationOptions = {}): SoilMechStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechStandardization };
diff --git a/src/soil_mech/static.ts b/src/soil_mech/static.ts
new file mode 100644
index 000000000..66425d6d6
--- /dev/null
+++ b/src/soil_mech/static.ts
@@ -0,0 +1,14 @@
+/** soil_mech static module — tsb analytics library. */
+export interface SoilMechStaticOptions { tol?: number; maxIter?: number; }
+export interface SoilMechStaticResult { values: number[]; converged: boolean; }
+export function computeSoilMechStatic(data: number[], opts: SoilMechStaticOptions = {}): SoilMechStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechStatic };
diff --git a/src/soil_mech/stochastic.ts b/src/soil_mech/stochastic.ts
new file mode 100644
index 000000000..f21094ca7
--- /dev/null
+++ b/src/soil_mech/stochastic.ts
@@ -0,0 +1,14 @@
+/** soil_mech stochastic module — tsb analytics library. */
+export interface SoilMechStochasticOptions { tol?: number; maxIter?: number; }
+export interface SoilMechStochasticResult { values: number[]; converged: boolean; }
+export function computeSoilMechStochastic(data: number[], opts: SoilMechStochasticOptions = {}): SoilMechStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechStochastic };
diff --git a/src/soil_mech/synthesis.ts b/src/soil_mech/synthesis.ts
new file mode 100644
index 000000000..25536967a
--- /dev/null
+++ b/src/soil_mech/synthesis.ts
@@ -0,0 +1,14 @@
+/** soil_mech synthesis module — tsb analytics library. */
+export interface SoilMechSynthesisOptions { tol?: number; maxIter?: number; }
+export interface SoilMechSynthesisResult { values: number[]; converged: boolean; }
+export function computeSoilMechSynthesis(data: number[], opts: SoilMechSynthesisOptions = {}): SoilMechSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechSynthesis };
diff --git a/src/soil_mech/topology.ts b/src/soil_mech/topology.ts
new file mode 100644
index 000000000..d1c41fa59
--- /dev/null
+++ b/src/soil_mech/topology.ts
@@ -0,0 +1,14 @@
+/** soil_mech topology module — tsb analytics library. */
+export interface SoilMechTopologyOptions { tol?: number; maxIter?: number; }
+export interface SoilMechTopologyResult { values: number[]; converged: boolean; }
+export function computeSoilMechTopology(data: number[], opts: SoilMechTopologyOptions = {}): SoilMechTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechTopology };
diff --git a/src/soil_mech/tracking.ts b/src/soil_mech/tracking.ts
new file mode 100644
index 000000000..70f01f908
--- /dev/null
+++ b/src/soil_mech/tracking.ts
@@ -0,0 +1,14 @@
+/** soil_mech tracking module — tsb analytics library. */
+export interface SoilMechTrackingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechTrackingResult { values: number[]; converged: boolean; }
+export function computeSoilMechTracking(data: number[], opts: SoilMechTrackingOptions = {}): SoilMechTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechTracking };
diff --git a/src/soil_mech/transform.ts b/src/soil_mech/transform.ts
new file mode 100644
index 000000000..ceba0c1c2
--- /dev/null
+++ b/src/soil_mech/transform.ts
@@ -0,0 +1,14 @@
+/** soil_mech transform module — tsb analytics library. */
+export interface SoilMechTransformOptions { tol?: number; maxIter?: number; }
+export interface SoilMechTransformResult { values: number[]; converged: boolean; }
+export function computeSoilMechTransform(data: number[], opts: SoilMechTransformOptions = {}): SoilMechTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechTransform };
diff --git a/src/soil_mech/uncertainty.ts b/src/soil_mech/uncertainty.ts
new file mode 100644
index 000000000..ff5436c2b
--- /dev/null
+++ b/src/soil_mech/uncertainty.ts
@@ -0,0 +1,14 @@
+/** soil_mech uncertainty module — tsb analytics library. */
+export interface SoilMechUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface SoilMechUncertaintyResult { values: number[]; converged: boolean; }
+export function computeSoilMechUncertainty(data: number[], opts: SoilMechUncertaintyOptions = {}): SoilMechUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechUncertainty };
diff --git a/src/soil_mech/validation.ts b/src/soil_mech/validation.ts
new file mode 100644
index 000000000..b807eda28
--- /dev/null
+++ b/src/soil_mech/validation.ts
@@ -0,0 +1,14 @@
+/** soil_mech validation module — tsb analytics library. */
+export interface SoilMechValidationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechValidationResult { values: number[]; converged: boolean; }
+export function computeSoilMechValidation(data: number[], opts: SoilMechValidationOptions = {}): SoilMechValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechValidation };
diff --git a/src/soil_mech/verification.ts b/src/soil_mech/verification.ts
new file mode 100644
index 000000000..7632f0f5c
--- /dev/null
+++ b/src/soil_mech/verification.ts
@@ -0,0 +1,14 @@
+/** soil_mech verification module — tsb analytics library. */
+export interface SoilMechVerificationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechVerificationResult { values: number[]; converged: boolean; }
+export function computeSoilMechVerification(data: number[], opts: SoilMechVerificationOptions = {}): SoilMechVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechVerification };
diff --git a/src/soil_mech/visualization.ts b/src/soil_mech/visualization.ts
new file mode 100644
index 000000000..3b0966845
--- /dev/null
+++ b/src/soil_mech/visualization.ts
@@ -0,0 +1,14 @@
+/** soil_mech visualization module — tsb analytics library. */
+export interface SoilMechVisualizationOptions { tol?: number; maxIter?: number; }
+export interface SoilMechVisualizationResult { values: number[]; converged: boolean; }
+export function computeSoilMechVisualization(data: number[], opts: SoilMechVisualizationOptions = {}): SoilMechVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechVisualization };
diff --git a/src/soil_mech/voting.ts b/src/soil_mech/voting.ts
new file mode 100644
index 000000000..86bbee63b
--- /dev/null
+++ b/src/soil_mech/voting.ts
@@ -0,0 +1,14 @@
+/** soil_mech voting module — tsb analytics library. */
+export interface SoilMechVotingOptions { tol?: number; maxIter?: number; }
+export interface SoilMechVotingResult { values: number[]; converged: boolean; }
+export function computeSoilMechVoting(data: number[], opts: SoilMechVotingOptions = {}): SoilMechVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechVoting };
diff --git a/src/soil_mech/wavelet.ts b/src/soil_mech/wavelet.ts
new file mode 100644
index 000000000..456fc1baf
--- /dev/null
+++ b/src/soil_mech/wavelet.ts
@@ -0,0 +1,14 @@
+/** soil_mech wavelet module — tsb analytics library. */
+export interface SoilMechWaveletOptions { tol?: number; maxIter?: number; }
+export interface SoilMechWaveletResult { values: number[]; converged: boolean; }
+export function computeSoilMechWavelet(data: number[], opts: SoilMechWaveletOptions = {}): SoilMechWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSoilMechWavelet };
diff --git a/src/solar_physics/adaptation.ts b/src/solar_physics/adaptation.ts
new file mode 100644
index 000000000..a1b0bfa92
--- /dev/null
+++ b/src/solar_physics/adaptation.ts
@@ -0,0 +1,14 @@
+/** solar_physics adaptation module — tsb analytics library. */
+export interface SolarPhysicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsAdaptation(data: number[], opts: SolarPhysicsAdaptationOptions = {}): SolarPhysicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsAdaptation };
diff --git a/src/solar_physics/aggregation.ts b/src/solar_physics/aggregation.ts
new file mode 100644
index 000000000..f82a0f467
--- /dev/null
+++ b/src/solar_physics/aggregation.ts
@@ -0,0 +1,14 @@
+/** solar_physics aggregation module — tsb analytics library. */
+export interface SolarPhysicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsAggregationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsAggregation(data: number[], opts: SolarPhysicsAggregationOptions = {}): SolarPhysicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsAggregation };
diff --git a/src/solar_physics/algebra.ts b/src/solar_physics/algebra.ts
new file mode 100644
index 000000000..eddde599d
--- /dev/null
+++ b/src/solar_physics/algebra.ts
@@ -0,0 +1,14 @@
+/** solar_physics algebra module — tsb analytics library. */
+export interface SolarPhysicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsAlgebra(data: number[], opts: SolarPhysicsAlgebraOptions = {}): SolarPhysicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsAlgebra };
diff --git a/src/solar_physics/alignment.ts b/src/solar_physics/alignment.ts
new file mode 100644
index 000000000..6ba385aab
--- /dev/null
+++ b/src/solar_physics/alignment.ts
@@ -0,0 +1,14 @@
+/** solar_physics alignment module — tsb analytics library. */
+export interface SolarPhysicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsAlignment(data: number[], opts: SolarPhysicsAlignmentOptions = {}): SolarPhysicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsAlignment };
diff --git a/src/solar_physics/analysis.ts b/src/solar_physics/analysis.ts
new file mode 100644
index 000000000..2bb53a7ca
--- /dev/null
+++ b/src/solar_physics/analysis.ts
@@ -0,0 +1,14 @@
+/** solar_physics analysis module — tsb analytics library. */
+export interface SolarPhysicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsAnalysis(data: number[], opts: SolarPhysicsAnalysisOptions = {}): SolarPhysicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsAnalysis };
diff --git a/src/solar_physics/augmentation.ts b/src/solar_physics/augmentation.ts
new file mode 100644
index 000000000..83af24929
--- /dev/null
+++ b/src/solar_physics/augmentation.ts
@@ -0,0 +1,14 @@
+/** solar_physics augmentation module — tsb analytics library. */
+export interface SolarPhysicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsAugmentation(data: number[], opts: SolarPhysicsAugmentationOptions = {}): SolarPhysicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsAugmentation };
diff --git a/src/solar_physics/bagging.ts b/src/solar_physics/bagging.ts
new file mode 100644
index 000000000..4b5ede7f8
--- /dev/null
+++ b/src/solar_physics/bagging.ts
@@ -0,0 +1,14 @@
+/** solar_physics bagging module — tsb analytics library. */
+export interface SolarPhysicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsBaggingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsBagging(data: number[], opts: SolarPhysicsBaggingOptions = {}): SolarPhysicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsBagging };
diff --git a/src/solar_physics/basis.ts b/src/solar_physics/basis.ts
new file mode 100644
index 000000000..0ea02b1bd
--- /dev/null
+++ b/src/solar_physics/basis.ts
@@ -0,0 +1,14 @@
+/** solar_physics basis module — tsb analytics library. */
+export interface SolarPhysicsBasisOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsBasisResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsBasis(data: number[], opts: SolarPhysicsBasisOptions = {}): SolarPhysicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsBasis };
diff --git a/src/solar_physics/benchmarking.ts b/src/solar_physics/benchmarking.ts
new file mode 100644
index 000000000..2c9576dc0
--- /dev/null
+++ b/src/solar_physics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** solar_physics benchmarking module — tsb analytics library. */
+export interface SolarPhysicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsBenchmarking(data: number[], opts: SolarPhysicsBenchmarkingOptions = {}): SolarPhysicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsBenchmarking };
diff --git a/src/solar_physics/blending.ts b/src/solar_physics/blending.ts
new file mode 100644
index 000000000..c7cc6fa4f
--- /dev/null
+++ b/src/solar_physics/blending.ts
@@ -0,0 +1,14 @@
+/** solar_physics blending module — tsb analytics library. */
+export interface SolarPhysicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsBlendingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsBlending(data: number[], opts: SolarPhysicsBlendingOptions = {}): SolarPhysicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsBlending };
diff --git a/src/solar_physics/boosting.ts b/src/solar_physics/boosting.ts
new file mode 100644
index 000000000..cd840875a
--- /dev/null
+++ b/src/solar_physics/boosting.ts
@@ -0,0 +1,14 @@
+/** solar_physics boosting module — tsb analytics library. */
+export interface SolarPhysicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsBoostingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsBoosting(data: number[], opts: SolarPhysicsBoostingOptions = {}): SolarPhysicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsBoosting };
diff --git a/src/solar_physics/bootstrap.ts b/src/solar_physics/bootstrap.ts
new file mode 100644
index 000000000..ba8329f0d
--- /dev/null
+++ b/src/solar_physics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** solar_physics bootstrap module — tsb analytics library. */
+export interface SolarPhysicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsBootstrap(data: number[], opts: SolarPhysicsBootstrapOptions = {}): SolarPhysicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsBootstrap };
diff --git a/src/solar_physics/calculus.ts b/src/solar_physics/calculus.ts
new file mode 100644
index 000000000..0a5644ce4
--- /dev/null
+++ b/src/solar_physics/calculus.ts
@@ -0,0 +1,14 @@
+/** solar_physics calculus module — tsb analytics library. */
+export interface SolarPhysicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsCalculusResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsCalculus(data: number[], opts: SolarPhysicsCalculusOptions = {}): SolarPhysicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsCalculus };
diff --git a/src/solar_physics/calibration.ts b/src/solar_physics/calibration.ts
new file mode 100644
index 000000000..17e7f839b
--- /dev/null
+++ b/src/solar_physics/calibration.ts
@@ -0,0 +1,14 @@
+/** solar_physics calibration module — tsb analytics library. */
+export interface SolarPhysicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsCalibration(data: number[], opts: SolarPhysicsCalibrationOptions = {}): SolarPhysicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsCalibration };
diff --git a/src/solar_physics/characterization.ts b/src/solar_physics/characterization.ts
new file mode 100644
index 000000000..ba98b13d7
--- /dev/null
+++ b/src/solar_physics/characterization.ts
@@ -0,0 +1,14 @@
+/** solar_physics characterization module — tsb analytics library. */
+export interface SolarPhysicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsCharacterization(data: number[], opts: SolarPhysicsCharacterizationOptions = {}): SolarPhysicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsCharacterization };
diff --git a/src/solar_physics/classification.ts b/src/solar_physics/classification.ts
new file mode 100644
index 000000000..f51e91475
--- /dev/null
+++ b/src/solar_physics/classification.ts
@@ -0,0 +1,14 @@
+/** solar_physics classification module — tsb analytics library. */
+export interface SolarPhysicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsClassificationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsClassification(data: number[], opts: SolarPhysicsClassificationOptions = {}): SolarPhysicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsClassification };
diff --git a/src/solar_physics/clustering.ts b/src/solar_physics/clustering.ts
new file mode 100644
index 000000000..f22e97c2e
--- /dev/null
+++ b/src/solar_physics/clustering.ts
@@ -0,0 +1,14 @@
+/** solar_physics clustering module — tsb analytics library. */
+export interface SolarPhysicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsClusteringResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsClustering(data: number[], opts: SolarPhysicsClusteringOptions = {}): SolarPhysicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsClustering };
diff --git a/src/solar_physics/compression.ts b/src/solar_physics/compression.ts
new file mode 100644
index 000000000..947401cb6
--- /dev/null
+++ b/src/solar_physics/compression.ts
@@ -0,0 +1,14 @@
+/** solar_physics compression module — tsb analytics library. */
+export interface SolarPhysicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsCompressionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsCompression(data: number[], opts: SolarPhysicsCompressionOptions = {}): SolarPhysicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsCompression };
diff --git a/src/solar_physics/continuous.ts b/src/solar_physics/continuous.ts
new file mode 100644
index 000000000..9980864da
--- /dev/null
+++ b/src/solar_physics/continuous.ts
@@ -0,0 +1,14 @@
+/** solar_physics continuous module — tsb analytics library. */
+export interface SolarPhysicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsContinuousResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsContinuous(data: number[], opts: SolarPhysicsContinuousOptions = {}): SolarPhysicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsContinuous };
diff --git a/src/solar_physics/control.ts b/src/solar_physics/control.ts
new file mode 100644
index 000000000..b12475822
--- /dev/null
+++ b/src/solar_physics/control.ts
@@ -0,0 +1,14 @@
+/** solar_physics control module — tsb analytics library. */
+export interface SolarPhysicsControlOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsControlResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsControl(data: number[], opts: SolarPhysicsControlOptions = {}): SolarPhysicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsControl };
diff --git a/src/solar_physics/convergence.ts b/src/solar_physics/convergence.ts
new file mode 100644
index 000000000..538da50f8
--- /dev/null
+++ b/src/solar_physics/convergence.ts
@@ -0,0 +1,14 @@
+/** solar_physics convergence module — tsb analytics library. */
+export interface SolarPhysicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsConvergence(data: number[], opts: SolarPhysicsConvergenceOptions = {}): SolarPhysicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsConvergence };
diff --git a/src/solar_physics/convex.ts b/src/solar_physics/convex.ts
new file mode 100644
index 000000000..2b4321d1b
--- /dev/null
+++ b/src/solar_physics/convex.ts
@@ -0,0 +1,14 @@
+/** solar_physics convex module — tsb analytics library. */
+export interface SolarPhysicsConvexOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsConvexResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsConvex(data: number[], opts: SolarPhysicsConvexOptions = {}): SolarPhysicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsConvex };
diff --git a/src/solar_physics/correlation.ts b/src/solar_physics/correlation.ts
new file mode 100644
index 000000000..3bdceb476
--- /dev/null
+++ b/src/solar_physics/correlation.ts
@@ -0,0 +1,14 @@
+/** solar_physics correlation module — tsb analytics library. */
+export interface SolarPhysicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsCorrelation(data: number[], opts: SolarPhysicsCorrelationOptions = {}): SolarPhysicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsCorrelation };
diff --git a/src/solar_physics/covariance.ts b/src/solar_physics/covariance.ts
new file mode 100644
index 000000000..e9dd7f6d4
--- /dev/null
+++ b/src/solar_physics/covariance.ts
@@ -0,0 +1,14 @@
+/** solar_physics covariance module — tsb analytics library. */
+export interface SolarPhysicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsCovariance(data: number[], opts: SolarPhysicsCovarianceOptions = {}): SolarPhysicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsCovariance };
diff --git a/src/solar_physics/cross_validation.ts b/src/solar_physics/cross_validation.ts
new file mode 100644
index 000000000..94e0fdd55
--- /dev/null
+++ b/src/solar_physics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** solar_physics cross_validation module — tsb analytics library. */
+export interface SolarPhysicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsCrossValidation(data: number[], opts: SolarPhysicsCrossValidationOptions = {}): SolarPhysicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsCrossValidation };
diff --git a/src/solar_physics/decoding.ts b/src/solar_physics/decoding.ts
new file mode 100644
index 000000000..960fcf7dd
--- /dev/null
+++ b/src/solar_physics/decoding.ts
@@ -0,0 +1,14 @@
+/** solar_physics decoding module — tsb analytics library. */
+export interface SolarPhysicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDecodingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDecoding(data: number[], opts: SolarPhysicsDecodingOptions = {}): SolarPhysicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDecoding };
diff --git a/src/solar_physics/decomposition.ts b/src/solar_physics/decomposition.ts
new file mode 100644
index 000000000..8205bf887
--- /dev/null
+++ b/src/solar_physics/decomposition.ts
@@ -0,0 +1,14 @@
+/** solar_physics decomposition module — tsb analytics library. */
+export interface SolarPhysicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDecomposition(data: number[], opts: SolarPhysicsDecompositionOptions = {}): SolarPhysicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDecomposition };
diff --git a/src/solar_physics/detection.ts b/src/solar_physics/detection.ts
new file mode 100644
index 000000000..9d1c0e9be
--- /dev/null
+++ b/src/solar_physics/detection.ts
@@ -0,0 +1,14 @@
+/** solar_physics detection module — tsb analytics library. */
+export interface SolarPhysicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDetectionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDetection(data: number[], opts: SolarPhysicsDetectionOptions = {}): SolarPhysicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDetection };
diff --git a/src/solar_physics/deterministic.ts b/src/solar_physics/deterministic.ts
new file mode 100644
index 000000000..470c979df
--- /dev/null
+++ b/src/solar_physics/deterministic.ts
@@ -0,0 +1,14 @@
+/** solar_physics deterministic module — tsb analytics library. */
+export interface SolarPhysicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDeterministic(data: number[], opts: SolarPhysicsDeterministicOptions = {}): SolarPhysicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDeterministic };
diff --git a/src/solar_physics/diagnostics.ts b/src/solar_physics/diagnostics.ts
new file mode 100644
index 000000000..41b910500
--- /dev/null
+++ b/src/solar_physics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** solar_physics diagnostics module — tsb analytics library. */
+export interface SolarPhysicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDiagnostics(data: number[], opts: SolarPhysicsDiagnosticsOptions = {}): SolarPhysicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDiagnostics };
diff --git a/src/solar_physics/differential.ts b/src/solar_physics/differential.ts
new file mode 100644
index 000000000..264e9c99a
--- /dev/null
+++ b/src/solar_physics/differential.ts
@@ -0,0 +1,14 @@
+/** solar_physics differential module — tsb analytics library. */
+export interface SolarPhysicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDifferential(data: number[], opts: SolarPhysicsDifferentialOptions = {}): SolarPhysicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDifferential };
diff --git a/src/solar_physics/discrete.ts b/src/solar_physics/discrete.ts
new file mode 100644
index 000000000..f3ee6c61e
--- /dev/null
+++ b/src/solar_physics/discrete.ts
@@ -0,0 +1,14 @@
+/** solar_physics discrete module — tsb analytics library. */
+export interface SolarPhysicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDiscrete(data: number[], opts: SolarPhysicsDiscreteOptions = {}): SolarPhysicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDiscrete };
diff --git a/src/solar_physics/distribution.ts b/src/solar_physics/distribution.ts
new file mode 100644
index 000000000..41249eaee
--- /dev/null
+++ b/src/solar_physics/distribution.ts
@@ -0,0 +1,14 @@
+/** solar_physics distribution module — tsb analytics library. */
+export interface SolarPhysicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDistributionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDistribution(data: number[], opts: SolarPhysicsDistributionOptions = {}): SolarPhysicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDistribution };
diff --git a/src/solar_physics/dynamic.ts b/src/solar_physics/dynamic.ts
new file mode 100644
index 000000000..57470263c
--- /dev/null
+++ b/src/solar_physics/dynamic.ts
@@ -0,0 +1,14 @@
+/** solar_physics dynamic module — tsb analytics library. */
+export interface SolarPhysicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsDynamicResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsDynamic(data: number[], opts: SolarPhysicsDynamicOptions = {}): SolarPhysicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsDynamic };
diff --git a/src/solar_physics/embedding.ts b/src/solar_physics/embedding.ts
new file mode 100644
index 000000000..2417ff469
--- /dev/null
+++ b/src/solar_physics/embedding.ts
@@ -0,0 +1,14 @@
+/** solar_physics embedding module — tsb analytics library. */
+export interface SolarPhysicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsEmbedding(data: number[], opts: SolarPhysicsEmbeddingOptions = {}): SolarPhysicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsEmbedding };
diff --git a/src/solar_physics/encoding.ts b/src/solar_physics/encoding.ts
new file mode 100644
index 000000000..b86674729
--- /dev/null
+++ b/src/solar_physics/encoding.ts
@@ -0,0 +1,14 @@
+/** solar_physics encoding module — tsb analytics library. */
+export interface SolarPhysicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsEncodingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsEncoding(data: number[], opts: SolarPhysicsEncodingOptions = {}): SolarPhysicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsEncoding };
diff --git a/src/solar_physics/ensemble.ts b/src/solar_physics/ensemble.ts
new file mode 100644
index 000000000..3c1f75139
--- /dev/null
+++ b/src/solar_physics/ensemble.ts
@@ -0,0 +1,14 @@
+/** solar_physics ensemble module — tsb analytics library. */
+export interface SolarPhysicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsEnsemble(data: number[], opts: SolarPhysicsEnsembleOptions = {}): SolarPhysicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsEnsemble };
diff --git a/src/solar_physics/estimation.ts b/src/solar_physics/estimation.ts
new file mode 100644
index 000000000..ed30924ce
--- /dev/null
+++ b/src/solar_physics/estimation.ts
@@ -0,0 +1,14 @@
+/** solar_physics estimation module — tsb analytics library. */
+export interface SolarPhysicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsEstimationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsEstimation(data: number[], opts: SolarPhysicsEstimationOptions = {}): SolarPhysicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsEstimation };
diff --git a/src/solar_physics/evaluation.ts b/src/solar_physics/evaluation.ts
new file mode 100644
index 000000000..81727a997
--- /dev/null
+++ b/src/solar_physics/evaluation.ts
@@ -0,0 +1,14 @@
+/** solar_physics evaluation module — tsb analytics library. */
+export interface SolarPhysicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsEvaluation(data: number[], opts: SolarPhysicsEvaluationOptions = {}): SolarPhysicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsEvaluation };
diff --git a/src/solar_physics/extrapolation.ts b/src/solar_physics/extrapolation.ts
new file mode 100644
index 000000000..762e382a1
--- /dev/null
+++ b/src/solar_physics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** solar_physics extrapolation module — tsb analytics library. */
+export interface SolarPhysicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsExtrapolation(data: number[], opts: SolarPhysicsExtrapolationOptions = {}): SolarPhysicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsExtrapolation };
diff --git a/src/solar_physics/features.ts b/src/solar_physics/features.ts
new file mode 100644
index 000000000..11b79a57b
--- /dev/null
+++ b/src/solar_physics/features.ts
@@ -0,0 +1,14 @@
+/** solar_physics features module — tsb analytics library. */
+export interface SolarPhysicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsFeatures(data: number[], opts: SolarPhysicsFeaturesOptions = {}): SolarPhysicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsFeatures };
diff --git a/src/solar_physics/feedback.ts b/src/solar_physics/feedback.ts
new file mode 100644
index 000000000..edae4100e
--- /dev/null
+++ b/src/solar_physics/feedback.ts
@@ -0,0 +1,14 @@
+/** solar_physics feedback module — tsb analytics library. */
+export interface SolarPhysicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsFeedback(data: number[], opts: SolarPhysicsFeedbackOptions = {}): SolarPhysicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsFeedback };
diff --git a/src/solar_physics/filtering.ts b/src/solar_physics/filtering.ts
new file mode 100644
index 000000000..2f6b99c34
--- /dev/null
+++ b/src/solar_physics/filtering.ts
@@ -0,0 +1,14 @@
+/** solar_physics filtering module — tsb analytics library. */
+export interface SolarPhysicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsFilteringResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsFiltering(data: number[], opts: SolarPhysicsFilteringOptions = {}): SolarPhysicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsFiltering };
diff --git a/src/solar_physics/fourier.ts b/src/solar_physics/fourier.ts
new file mode 100644
index 000000000..2276f1a70
--- /dev/null
+++ b/src/solar_physics/fourier.ts
@@ -0,0 +1,14 @@
+/** solar_physics fourier module — tsb analytics library. */
+export interface SolarPhysicsFourierOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsFourierResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsFourier(data: number[], opts: SolarPhysicsFourierOptions = {}): SolarPhysicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsFourier };
diff --git a/src/solar_physics/fusion.ts b/src/solar_physics/fusion.ts
new file mode 100644
index 000000000..524a410cd
--- /dev/null
+++ b/src/solar_physics/fusion.ts
@@ -0,0 +1,14 @@
+/** solar_physics fusion module — tsb analytics library. */
+export interface SolarPhysicsFusionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsFusionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsFusion(data: number[], opts: SolarPhysicsFusionOptions = {}): SolarPhysicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsFusion };
diff --git a/src/solar_physics/generation.ts b/src/solar_physics/generation.ts
new file mode 100644
index 000000000..d22a1e5bc
--- /dev/null
+++ b/src/solar_physics/generation.ts
@@ -0,0 +1,14 @@
+/** solar_physics generation module — tsb analytics library. */
+export interface SolarPhysicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsGenerationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsGeneration(data: number[], opts: SolarPhysicsGenerationOptions = {}): SolarPhysicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsGeneration };
diff --git a/src/solar_physics/geometry.ts b/src/solar_physics/geometry.ts
new file mode 100644
index 000000000..43e9ee27f
--- /dev/null
+++ b/src/solar_physics/geometry.ts
@@ -0,0 +1,14 @@
+/** solar_physics geometry module — tsb analytics library. */
+export interface SolarPhysicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsGeometryResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsGeometry(data: number[], opts: SolarPhysicsGeometryOptions = {}): SolarPhysicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsGeometry };
diff --git a/src/solar_physics/gradient.ts b/src/solar_physics/gradient.ts
new file mode 100644
index 000000000..8cab752be
--- /dev/null
+++ b/src/solar_physics/gradient.ts
@@ -0,0 +1,14 @@
+/** solar_physics gradient module — tsb analytics library. */
+export interface SolarPhysicsGradientOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsGradientResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsGradient(data: number[], opts: SolarPhysicsGradientOptions = {}): SolarPhysicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsGradient };
diff --git a/src/solar_physics/hessian.ts b/src/solar_physics/hessian.ts
new file mode 100644
index 000000000..533e56b89
--- /dev/null
+++ b/src/solar_physics/hessian.ts
@@ -0,0 +1,14 @@
+/** solar_physics hessian module — tsb analytics library. */
+export interface SolarPhysicsHessianOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsHessianResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsHessian(data: number[], opts: SolarPhysicsHessianOptions = {}): SolarPhysicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsHessian };
diff --git a/src/solar_physics/hypothesis.ts b/src/solar_physics/hypothesis.ts
new file mode 100644
index 000000000..d41b1f2e5
--- /dev/null
+++ b/src/solar_physics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** solar_physics hypothesis module — tsb analytics library. */
+export interface SolarPhysicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsHypothesis(data: number[], opts: SolarPhysicsHypothesisOptions = {}): SolarPhysicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsHypothesis };
diff --git a/src/solar_physics/inference.ts b/src/solar_physics/inference.ts
new file mode 100644
index 000000000..325c348f5
--- /dev/null
+++ b/src/solar_physics/inference.ts
@@ -0,0 +1,14 @@
+/** solar_physics inference module — tsb analytics library. */
+export interface SolarPhysicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsInferenceResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsInference(data: number[], opts: SolarPhysicsInferenceOptions = {}): SolarPhysicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsInference };
diff --git a/src/solar_physics/inference2.ts b/src/solar_physics/inference2.ts
new file mode 100644
index 000000000..6f1193354
--- /dev/null
+++ b/src/solar_physics/inference2.ts
@@ -0,0 +1,14 @@
+/** solar_physics inference2 module — tsb analytics library. */
+export interface SolarPhysicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsInferenceResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsInference(data: number[], opts: SolarPhysicsInferenceOptions = {}): SolarPhysicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsInference };
diff --git a/src/solar_physics/integral.ts b/src/solar_physics/integral.ts
new file mode 100644
index 000000000..5147339eb
--- /dev/null
+++ b/src/solar_physics/integral.ts
@@ -0,0 +1,14 @@
+/** solar_physics integral module — tsb analytics library. */
+export interface SolarPhysicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsIntegralResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsIntegral(data: number[], opts: SolarPhysicsIntegralOptions = {}): SolarPhysicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsIntegral };
diff --git a/src/solar_physics/integration.ts b/src/solar_physics/integration.ts
new file mode 100644
index 000000000..03924a043
--- /dev/null
+++ b/src/solar_physics/integration.ts
@@ -0,0 +1,14 @@
+/** solar_physics integration module — tsb analytics library. */
+export interface SolarPhysicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsIntegration(data: number[], opts: SolarPhysicsIntegrationOptions = {}): SolarPhysicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsIntegration };
diff --git a/src/solar_physics/interpolation.ts b/src/solar_physics/interpolation.ts
new file mode 100644
index 000000000..0eab53976
--- /dev/null
+++ b/src/solar_physics/interpolation.ts
@@ -0,0 +1,14 @@
+/** solar_physics interpolation module — tsb analytics library. */
+export interface SolarPhysicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsInterpolation(data: number[], opts: SolarPhysicsInterpolationOptions = {}): SolarPhysicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsInterpolation };
diff --git a/src/solar_physics/jacobian.ts b/src/solar_physics/jacobian.ts
new file mode 100644
index 000000000..99b1cc803
--- /dev/null
+++ b/src/solar_physics/jacobian.ts
@@ -0,0 +1,14 @@
+/** solar_physics jacobian module — tsb analytics library. */
+export interface SolarPhysicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsJacobianResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsJacobian(data: number[], opts: SolarPhysicsJacobianOptions = {}): SolarPhysicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsJacobian };
diff --git a/src/solar_physics/kernel.ts b/src/solar_physics/kernel.ts
new file mode 100644
index 000000000..7c7e25220
--- /dev/null
+++ b/src/solar_physics/kernel.ts
@@ -0,0 +1,14 @@
+/** solar_physics kernel module — tsb analytics library. */
+export interface SolarPhysicsKernelOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsKernelResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsKernel(data: number[], opts: SolarPhysicsKernelOptions = {}): SolarPhysicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsKernel };
diff --git a/src/solar_physics/laplacian.ts b/src/solar_physics/laplacian.ts
new file mode 100644
index 000000000..e3f79763c
--- /dev/null
+++ b/src/solar_physics/laplacian.ts
@@ -0,0 +1,14 @@
+/** solar_physics laplacian module — tsb analytics library. */
+export interface SolarPhysicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsLaplacian(data: number[], opts: SolarPhysicsLaplacianOptions = {}): SolarPhysicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsLaplacian };
diff --git a/src/solar_physics/learning.ts b/src/solar_physics/learning.ts
new file mode 100644
index 000000000..b2b46d9b0
--- /dev/null
+++ b/src/solar_physics/learning.ts
@@ -0,0 +1,14 @@
+/** solar_physics learning module — tsb analytics library. */
+export interface SolarPhysicsLearningOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsLearningResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsLearning(data: number[], opts: SolarPhysicsLearningOptions = {}): SolarPhysicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsLearning };
diff --git a/src/solar_physics/linear.ts b/src/solar_physics/linear.ts
new file mode 100644
index 000000000..7f1a6f9ea
--- /dev/null
+++ b/src/solar_physics/linear.ts
@@ -0,0 +1,14 @@
+/** solar_physics linear module — tsb analytics library. */
+export interface SolarPhysicsLinearOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsLinearResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsLinear(data: number[], opts: SolarPhysicsLinearOptions = {}): SolarPhysicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsLinear };
diff --git a/src/solar_physics/manifold.ts b/src/solar_physics/manifold.ts
new file mode 100644
index 000000000..fceb331d0
--- /dev/null
+++ b/src/solar_physics/manifold.ts
@@ -0,0 +1,14 @@
+/** solar_physics manifold module — tsb analytics library. */
+export interface SolarPhysicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsManifoldResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsManifold(data: number[], opts: SolarPhysicsManifoldOptions = {}): SolarPhysicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsManifold };
diff --git a/src/solar_physics/matching.ts b/src/solar_physics/matching.ts
new file mode 100644
index 000000000..b8e4eb7d5
--- /dev/null
+++ b/src/solar_physics/matching.ts
@@ -0,0 +1,14 @@
+/** solar_physics matching module — tsb analytics library. */
+export interface SolarPhysicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsMatchingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsMatching(data: number[], opts: SolarPhysicsMatchingOptions = {}): SolarPhysicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsMatching };
diff --git a/src/solar_physics/measurement.ts b/src/solar_physics/measurement.ts
new file mode 100644
index 000000000..222a99d4d
--- /dev/null
+++ b/src/solar_physics/measurement.ts
@@ -0,0 +1,14 @@
+/** solar_physics measurement module — tsb analytics library. */
+export interface SolarPhysicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsMeasurement(data: number[], opts: SolarPhysicsMeasurementOptions = {}): SolarPhysicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsMeasurement };
diff --git a/src/solar_physics/metrics.ts b/src/solar_physics/metrics.ts
new file mode 100644
index 000000000..5684efadd
--- /dev/null
+++ b/src/solar_physics/metrics.ts
@@ -0,0 +1,14 @@
+/** solar_physics metrics module — tsb analytics library. */
+export interface SolarPhysicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsMetricsResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsMetrics(data: number[], opts: SolarPhysicsMetricsOptions = {}): SolarPhysicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsMetrics };
diff --git a/src/solar_physics/modeling.ts b/src/solar_physics/modeling.ts
new file mode 100644
index 000000000..bd5b45121
--- /dev/null
+++ b/src/solar_physics/modeling.ts
@@ -0,0 +1,14 @@
+/** solar_physics modeling module — tsb analytics library. */
+export interface SolarPhysicsModelingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsModelingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsModeling(data: number[], opts: SolarPhysicsModelingOptions = {}): SolarPhysicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsModeling };
diff --git a/src/solar_physics/monitoring.ts b/src/solar_physics/monitoring.ts
new file mode 100644
index 000000000..36d7b5924
--- /dev/null
+++ b/src/solar_physics/monitoring.ts
@@ -0,0 +1,14 @@
+/** solar_physics monitoring module — tsb analytics library. */
+export interface SolarPhysicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsMonitoring(data: number[], opts: SolarPhysicsMonitoringOptions = {}): SolarPhysicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsMonitoring };
diff --git a/src/solar_physics/nonlinear.ts b/src/solar_physics/nonlinear.ts
new file mode 100644
index 000000000..3bd42ecf2
--- /dev/null
+++ b/src/solar_physics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** solar_physics nonlinear module — tsb analytics library. */
+export interface SolarPhysicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsNonlinear(data: number[], opts: SolarPhysicsNonlinearOptions = {}): SolarPhysicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsNonlinear };
diff --git a/src/solar_physics/normalization.ts b/src/solar_physics/normalization.ts
new file mode 100644
index 000000000..2c10024f5
--- /dev/null
+++ b/src/solar_physics/normalization.ts
@@ -0,0 +1,14 @@
+/** solar_physics normalization module — tsb analytics library. */
+export interface SolarPhysicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsNormalization(data: number[], opts: SolarPhysicsNormalizationOptions = {}): SolarPhysicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsNormalization };
diff --git a/src/solar_physics/optimization.ts b/src/solar_physics/optimization.ts
new file mode 100644
index 000000000..4aaf65f60
--- /dev/null
+++ b/src/solar_physics/optimization.ts
@@ -0,0 +1,14 @@
+/** solar_physics optimization module — tsb analytics library. */
+export interface SolarPhysicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsOptimization(data: number[], opts: SolarPhysicsOptimizationOptions = {}): SolarPhysicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsOptimization };
diff --git a/src/solar_physics/patterns.ts b/src/solar_physics/patterns.ts
new file mode 100644
index 000000000..8a9ef28ed
--- /dev/null
+++ b/src/solar_physics/patterns.ts
@@ -0,0 +1,14 @@
+/** solar_physics patterns module — tsb analytics library. */
+export interface SolarPhysicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsPatternsResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsPatterns(data: number[], opts: SolarPhysicsPatternsOptions = {}): SolarPhysicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsPatterns };
diff --git a/src/solar_physics/permutation.ts b/src/solar_physics/permutation.ts
new file mode 100644
index 000000000..04c646e76
--- /dev/null
+++ b/src/solar_physics/permutation.ts
@@ -0,0 +1,14 @@
+/** solar_physics permutation module — tsb analytics library. */
+export interface SolarPhysicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsPermutationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsPermutation(data: number[], opts: SolarPhysicsPermutationOptions = {}): SolarPhysicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsPermutation };
diff --git a/src/solar_physics/prediction.ts b/src/solar_physics/prediction.ts
new file mode 100644
index 000000000..32c1c26eb
--- /dev/null
+++ b/src/solar_physics/prediction.ts
@@ -0,0 +1,14 @@
+/** solar_physics prediction module — tsb analytics library. */
+export interface SolarPhysicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsPredictionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsPrediction(data: number[], opts: SolarPhysicsPredictionOptions = {}): SolarPhysicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsPrediction };
diff --git a/src/solar_physics/processing.ts b/src/solar_physics/processing.ts
new file mode 100644
index 000000000..350db9393
--- /dev/null
+++ b/src/solar_physics/processing.ts
@@ -0,0 +1,14 @@
+/** solar_physics processing module — tsb analytics library. */
+export interface SolarPhysicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsProcessingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsProcessing(data: number[], opts: SolarPhysicsProcessingOptions = {}): SolarPhysicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsProcessing };
diff --git a/src/solar_physics/profiling.ts b/src/solar_physics/profiling.ts
new file mode 100644
index 000000000..5f4c50a3d
--- /dev/null
+++ b/src/solar_physics/profiling.ts
@@ -0,0 +1,14 @@
+/** solar_physics profiling module — tsb analytics library. */
+export interface SolarPhysicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsProfilingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsProfiling(data: number[], opts: SolarPhysicsProfilingOptions = {}): SolarPhysicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsProfiling };
diff --git a/src/solar_physics/projection.ts b/src/solar_physics/projection.ts
new file mode 100644
index 000000000..0150b8463
--- /dev/null
+++ b/src/solar_physics/projection.ts
@@ -0,0 +1,14 @@
+/** solar_physics projection module — tsb analytics library. */
+export interface SolarPhysicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsProjectionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsProjection(data: number[], opts: SolarPhysicsProjectionOptions = {}): SolarPhysicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsProjection };
diff --git a/src/solar_physics/ranking.ts b/src/solar_physics/ranking.ts
new file mode 100644
index 000000000..d9dd41de7
--- /dev/null
+++ b/src/solar_physics/ranking.ts
@@ -0,0 +1,14 @@
+/** solar_physics ranking module — tsb analytics library. */
+export interface SolarPhysicsRankingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsRankingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsRanking(data: number[], opts: SolarPhysicsRankingOptions = {}): SolarPhysicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsRanking };
diff --git a/src/solar_physics/reconstruction.ts b/src/solar_physics/reconstruction.ts
new file mode 100644
index 000000000..0c697d929
--- /dev/null
+++ b/src/solar_physics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** solar_physics reconstruction module — tsb analytics library. */
+export interface SolarPhysicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsReconstruction(data: number[], opts: SolarPhysicsReconstructionOptions = {}): SolarPhysicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsReconstruction };
diff --git a/src/solar_physics/registration.ts b/src/solar_physics/registration.ts
new file mode 100644
index 000000000..555d2f8b1
--- /dev/null
+++ b/src/solar_physics/registration.ts
@@ -0,0 +1,14 @@
+/** solar_physics registration module — tsb analytics library. */
+export interface SolarPhysicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsRegistration(data: number[], opts: SolarPhysicsRegistrationOptions = {}): SolarPhysicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsRegistration };
diff --git a/src/solar_physics/regression.ts b/src/solar_physics/regression.ts
new file mode 100644
index 000000000..601088aaf
--- /dev/null
+++ b/src/solar_physics/regression.ts
@@ -0,0 +1,14 @@
+/** solar_physics regression module — tsb analytics library. */
+export interface SolarPhysicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsRegressionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsRegression(data: number[], opts: SolarPhysicsRegressionOptions = {}): SolarPhysicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsRegression };
diff --git a/src/solar_physics/regularization.ts b/src/solar_physics/regularization.ts
new file mode 100644
index 000000000..cbd1ade77
--- /dev/null
+++ b/src/solar_physics/regularization.ts
@@ -0,0 +1,14 @@
+/** solar_physics regularization module — tsb analytics library. */
+export interface SolarPhysicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsRegularization(data: number[], opts: SolarPhysicsRegularizationOptions = {}): SolarPhysicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsRegularization };
diff --git a/src/solar_physics/robustness.ts b/src/solar_physics/robustness.ts
new file mode 100644
index 000000000..b9f0c056f
--- /dev/null
+++ b/src/solar_physics/robustness.ts
@@ -0,0 +1,14 @@
+/** solar_physics robustness module — tsb analytics library. */
+export interface SolarPhysicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsRobustness(data: number[], opts: SolarPhysicsRobustnessOptions = {}): SolarPhysicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsRobustness };
diff --git a/src/solar_physics/sampling.ts b/src/solar_physics/sampling.ts
new file mode 100644
index 000000000..982039c2c
--- /dev/null
+++ b/src/solar_physics/sampling.ts
@@ -0,0 +1,14 @@
+/** solar_physics sampling module — tsb analytics library. */
+export interface SolarPhysicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsSamplingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsSampling(data: number[], opts: SolarPhysicsSamplingOptions = {}): SolarPhysicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsSampling };
diff --git a/src/solar_physics/sampling2.ts b/src/solar_physics/sampling2.ts
new file mode 100644
index 000000000..9ee67615d
--- /dev/null
+++ b/src/solar_physics/sampling2.ts
@@ -0,0 +1,14 @@
+/** solar_physics sampling2 module — tsb analytics library. */
+export interface SolarPhysicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsSamplingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsSampling(data: number[], opts: SolarPhysicsSamplingOptions = {}): SolarPhysicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsSampling };
diff --git a/src/solar_physics/scaling.ts b/src/solar_physics/scaling.ts
new file mode 100644
index 000000000..651c9054b
--- /dev/null
+++ b/src/solar_physics/scaling.ts
@@ -0,0 +1,14 @@
+/** solar_physics scaling module — tsb analytics library. */
+export interface SolarPhysicsScalingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsScalingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsScaling(data: number[], opts: SolarPhysicsScalingOptions = {}): SolarPhysicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsScaling };
diff --git a/src/solar_physics/scoring.ts b/src/solar_physics/scoring.ts
new file mode 100644
index 000000000..fd572871d
--- /dev/null
+++ b/src/solar_physics/scoring.ts
@@ -0,0 +1,14 @@
+/** solar_physics scoring module — tsb analytics library. */
+export interface SolarPhysicsScoringOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsScoringResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsScoring(data: number[], opts: SolarPhysicsScoringOptions = {}): SolarPhysicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsScoring };
diff --git a/src/solar_physics/segmentation.ts b/src/solar_physics/segmentation.ts
new file mode 100644
index 000000000..386e08575
--- /dev/null
+++ b/src/solar_physics/segmentation.ts
@@ -0,0 +1,14 @@
+/** solar_physics segmentation module — tsb analytics library. */
+export interface SolarPhysicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsSegmentation(data: number[], opts: SolarPhysicsSegmentationOptions = {}): SolarPhysicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsSegmentation };
diff --git a/src/solar_physics/selection.ts b/src/solar_physics/selection.ts
new file mode 100644
index 000000000..9efb730f1
--- /dev/null
+++ b/src/solar_physics/selection.ts
@@ -0,0 +1,14 @@
+/** solar_physics selection module — tsb analytics library. */
+export interface SolarPhysicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsSelectionResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsSelection(data: number[], opts: SolarPhysicsSelectionOptions = {}): SolarPhysicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsSelection };
diff --git a/src/solar_physics/sensitivity.ts b/src/solar_physics/sensitivity.ts
new file mode 100644
index 000000000..4d8bbcbea
--- /dev/null
+++ b/src/solar_physics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** solar_physics sensitivity module — tsb analytics library. */
+export interface SolarPhysicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsSensitivity(data: number[], opts: SolarPhysicsSensitivityOptions = {}): SolarPhysicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsSensitivity };
diff --git a/src/solar_physics/simulation.ts b/src/solar_physics/simulation.ts
new file mode 100644
index 000000000..044c952f5
--- /dev/null
+++ b/src/solar_physics/simulation.ts
@@ -0,0 +1,14 @@
+/** solar_physics simulation module — tsb analytics library. */
+export interface SolarPhysicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsSimulationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsSimulation(data: number[], opts: SolarPhysicsSimulationOptions = {}): SolarPhysicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsSimulation };
diff --git a/src/solar_physics/smoothing.ts b/src/solar_physics/smoothing.ts
new file mode 100644
index 000000000..768de307a
--- /dev/null
+++ b/src/solar_physics/smoothing.ts
@@ -0,0 +1,14 @@
+/** solar_physics smoothing module — tsb analytics library. */
+export interface SolarPhysicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsSmoothing(data: number[], opts: SolarPhysicsSmoothingOptions = {}): SolarPhysicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsSmoothing };
diff --git a/src/solar_physics/stability.ts b/src/solar_physics/stability.ts
new file mode 100644
index 000000000..0b46ca93b
--- /dev/null
+++ b/src/solar_physics/stability.ts
@@ -0,0 +1,14 @@
+/** solar_physics stability module — tsb analytics library. */
+export interface SolarPhysicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsStabilityResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsStability(data: number[], opts: SolarPhysicsStabilityOptions = {}): SolarPhysicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsStability };
diff --git a/src/solar_physics/stacking.ts b/src/solar_physics/stacking.ts
new file mode 100644
index 000000000..65a4497c1
--- /dev/null
+++ b/src/solar_physics/stacking.ts
@@ -0,0 +1,14 @@
+/** solar_physics stacking module — tsb analytics library. */
+export interface SolarPhysicsStackingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsStackingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsStacking(data: number[], opts: SolarPhysicsStackingOptions = {}): SolarPhysicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsStacking };
diff --git a/src/solar_physics/standardization.ts b/src/solar_physics/standardization.ts
new file mode 100644
index 000000000..9035db069
--- /dev/null
+++ b/src/solar_physics/standardization.ts
@@ -0,0 +1,14 @@
+/** solar_physics standardization module — tsb analytics library. */
+export interface SolarPhysicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsStandardization(data: number[], opts: SolarPhysicsStandardizationOptions = {}): SolarPhysicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsStandardization };
diff --git a/src/solar_physics/static.ts b/src/solar_physics/static.ts
new file mode 100644
index 000000000..0c55d7cb1
--- /dev/null
+++ b/src/solar_physics/static.ts
@@ -0,0 +1,14 @@
+/** solar_physics static module — tsb analytics library. */
+export interface SolarPhysicsStaticOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsStaticResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsStatic(data: number[], opts: SolarPhysicsStaticOptions = {}): SolarPhysicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsStatic };
diff --git a/src/solar_physics/stochastic.ts b/src/solar_physics/stochastic.ts
new file mode 100644
index 000000000..59cb17e78
--- /dev/null
+++ b/src/solar_physics/stochastic.ts
@@ -0,0 +1,14 @@
+/** solar_physics stochastic module — tsb analytics library. */
+export interface SolarPhysicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsStochasticResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsStochastic(data: number[], opts: SolarPhysicsStochasticOptions = {}): SolarPhysicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsStochastic };
diff --git a/src/solar_physics/synthesis.ts b/src/solar_physics/synthesis.ts
new file mode 100644
index 000000000..c94d82329
--- /dev/null
+++ b/src/solar_physics/synthesis.ts
@@ -0,0 +1,14 @@
+/** solar_physics synthesis module — tsb analytics library. */
+export interface SolarPhysicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsSynthesis(data: number[], opts: SolarPhysicsSynthesisOptions = {}): SolarPhysicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsSynthesis };
diff --git a/src/solar_physics/topology.ts b/src/solar_physics/topology.ts
new file mode 100644
index 000000000..62ed6979f
--- /dev/null
+++ b/src/solar_physics/topology.ts
@@ -0,0 +1,14 @@
+/** solar_physics topology module — tsb analytics library. */
+export interface SolarPhysicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsTopologyResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsTopology(data: number[], opts: SolarPhysicsTopologyOptions = {}): SolarPhysicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsTopology };
diff --git a/src/solar_physics/tracking.ts b/src/solar_physics/tracking.ts
new file mode 100644
index 000000000..ba5e2cb13
--- /dev/null
+++ b/src/solar_physics/tracking.ts
@@ -0,0 +1,14 @@
+/** solar_physics tracking module — tsb analytics library. */
+export interface SolarPhysicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsTrackingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsTracking(data: number[], opts: SolarPhysicsTrackingOptions = {}): SolarPhysicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsTracking };
diff --git a/src/solar_physics/transform.ts b/src/solar_physics/transform.ts
new file mode 100644
index 000000000..7a707e1e8
--- /dev/null
+++ b/src/solar_physics/transform.ts
@@ -0,0 +1,14 @@
+/** solar_physics transform module — tsb analytics library. */
+export interface SolarPhysicsTransformOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsTransformResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsTransform(data: number[], opts: SolarPhysicsTransformOptions = {}): SolarPhysicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsTransform };
diff --git a/src/solar_physics/uncertainty.ts b/src/solar_physics/uncertainty.ts
new file mode 100644
index 000000000..14e4c5c41
--- /dev/null
+++ b/src/solar_physics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** solar_physics uncertainty module — tsb analytics library. */
+export interface SolarPhysicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsUncertainty(data: number[], opts: SolarPhysicsUncertaintyOptions = {}): SolarPhysicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsUncertainty };
diff --git a/src/solar_physics/validation.ts b/src/solar_physics/validation.ts
new file mode 100644
index 000000000..db260372d
--- /dev/null
+++ b/src/solar_physics/validation.ts
@@ -0,0 +1,14 @@
+/** solar_physics validation module — tsb analytics library. */
+export interface SolarPhysicsValidationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsValidationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsValidation(data: number[], opts: SolarPhysicsValidationOptions = {}): SolarPhysicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsValidation };
diff --git a/src/solar_physics/verification.ts b/src/solar_physics/verification.ts
new file mode 100644
index 000000000..c809f3e42
--- /dev/null
+++ b/src/solar_physics/verification.ts
@@ -0,0 +1,14 @@
+/** solar_physics verification module — tsb analytics library. */
+export interface SolarPhysicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsVerificationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsVerification(data: number[], opts: SolarPhysicsVerificationOptions = {}): SolarPhysicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsVerification };
diff --git a/src/solar_physics/visualization.ts b/src/solar_physics/visualization.ts
new file mode 100644
index 000000000..1560a371d
--- /dev/null
+++ b/src/solar_physics/visualization.ts
@@ -0,0 +1,14 @@
+/** solar_physics visualization module — tsb analytics library. */
+export interface SolarPhysicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsVisualization(data: number[], opts: SolarPhysicsVisualizationOptions = {}): SolarPhysicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsVisualization };
diff --git a/src/solar_physics/voting.ts b/src/solar_physics/voting.ts
new file mode 100644
index 000000000..c02556438
--- /dev/null
+++ b/src/solar_physics/voting.ts
@@ -0,0 +1,14 @@
+/** solar_physics voting module — tsb analytics library. */
+export interface SolarPhysicsVotingOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsVotingResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsVoting(data: number[], opts: SolarPhysicsVotingOptions = {}): SolarPhysicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsVoting };
diff --git a/src/solar_physics/wavelet.ts b/src/solar_physics/wavelet.ts
new file mode 100644
index 000000000..d02069e1b
--- /dev/null
+++ b/src/solar_physics/wavelet.ts
@@ -0,0 +1,14 @@
+/** solar_physics wavelet module — tsb analytics library. */
+export interface SolarPhysicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface SolarPhysicsWaveletResult { values: number[]; converged: boolean; }
+export function computeSolarPhysicsWavelet(data: number[], opts: SolarPhysicsWaveletOptions = {}): SolarPhysicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSolarPhysicsWavelet };
diff --git a/src/space_weather/adaptation.ts b/src/space_weather/adaptation.ts
new file mode 100644
index 000000000..c99e8c2e3
--- /dev/null
+++ b/src/space_weather/adaptation.ts
@@ -0,0 +1,14 @@
+/** space_weather adaptation module — tsb analytics library. */
+export interface SpaceWeatherAdaptationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherAdaptationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherAdaptation(data: number[], opts: SpaceWeatherAdaptationOptions = {}): SpaceWeatherAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherAdaptation };
diff --git a/src/space_weather/aggregation.ts b/src/space_weather/aggregation.ts
new file mode 100644
index 000000000..7ebdfd6f9
--- /dev/null
+++ b/src/space_weather/aggregation.ts
@@ -0,0 +1,14 @@
+/** space_weather aggregation module — tsb analytics library. */
+export interface SpaceWeatherAggregationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherAggregationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherAggregation(data: number[], opts: SpaceWeatherAggregationOptions = {}): SpaceWeatherAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherAggregation };
diff --git a/src/space_weather/algebra.ts b/src/space_weather/algebra.ts
new file mode 100644
index 000000000..f55e65697
--- /dev/null
+++ b/src/space_weather/algebra.ts
@@ -0,0 +1,14 @@
+/** space_weather algebra module — tsb analytics library. */
+export interface SpaceWeatherAlgebraOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherAlgebraResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherAlgebra(data: number[], opts: SpaceWeatherAlgebraOptions = {}): SpaceWeatherAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherAlgebra };
diff --git a/src/space_weather/alignment.ts b/src/space_weather/alignment.ts
new file mode 100644
index 000000000..d722ede21
--- /dev/null
+++ b/src/space_weather/alignment.ts
@@ -0,0 +1,14 @@
+/** space_weather alignment module — tsb analytics library. */
+export interface SpaceWeatherAlignmentOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherAlignmentResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherAlignment(data: number[], opts: SpaceWeatherAlignmentOptions = {}): SpaceWeatherAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherAlignment };
diff --git a/src/space_weather/analysis.ts b/src/space_weather/analysis.ts
new file mode 100644
index 000000000..6d3346434
--- /dev/null
+++ b/src/space_weather/analysis.ts
@@ -0,0 +1,14 @@
+/** space_weather analysis module — tsb analytics library. */
+export interface SpaceWeatherAnalysisOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherAnalysisResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherAnalysis(data: number[], opts: SpaceWeatherAnalysisOptions = {}): SpaceWeatherAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherAnalysis };
diff --git a/src/space_weather/augmentation.ts b/src/space_weather/augmentation.ts
new file mode 100644
index 000000000..0e7179a2d
--- /dev/null
+++ b/src/space_weather/augmentation.ts
@@ -0,0 +1,14 @@
+/** space_weather augmentation module — tsb analytics library. */
+export interface SpaceWeatherAugmentationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherAugmentationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherAugmentation(data: number[], opts: SpaceWeatherAugmentationOptions = {}): SpaceWeatherAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherAugmentation };
diff --git a/src/space_weather/bagging.ts b/src/space_weather/bagging.ts
new file mode 100644
index 000000000..a27a0ab63
--- /dev/null
+++ b/src/space_weather/bagging.ts
@@ -0,0 +1,14 @@
+/** space_weather bagging module — tsb analytics library. */
+export interface SpaceWeatherBaggingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherBaggingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherBagging(data: number[], opts: SpaceWeatherBaggingOptions = {}): SpaceWeatherBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherBagging };
diff --git a/src/space_weather/basis.ts b/src/space_weather/basis.ts
new file mode 100644
index 000000000..8760617fe
--- /dev/null
+++ b/src/space_weather/basis.ts
@@ -0,0 +1,14 @@
+/** space_weather basis module — tsb analytics library. */
+export interface SpaceWeatherBasisOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherBasisResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherBasis(data: number[], opts: SpaceWeatherBasisOptions = {}): SpaceWeatherBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherBasis };
diff --git a/src/space_weather/benchmarking.ts b/src/space_weather/benchmarking.ts
new file mode 100644
index 000000000..3427a044e
--- /dev/null
+++ b/src/space_weather/benchmarking.ts
@@ -0,0 +1,14 @@
+/** space_weather benchmarking module — tsb analytics library. */
+export interface SpaceWeatherBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherBenchmarking(data: number[], opts: SpaceWeatherBenchmarkingOptions = {}): SpaceWeatherBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherBenchmarking };
diff --git a/src/space_weather/blending.ts b/src/space_weather/blending.ts
new file mode 100644
index 000000000..70372f2f9
--- /dev/null
+++ b/src/space_weather/blending.ts
@@ -0,0 +1,14 @@
+/** space_weather blending module — tsb analytics library. */
+export interface SpaceWeatherBlendingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherBlendingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherBlending(data: number[], opts: SpaceWeatherBlendingOptions = {}): SpaceWeatherBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherBlending };
diff --git a/src/space_weather/boosting.ts b/src/space_weather/boosting.ts
new file mode 100644
index 000000000..1521519d3
--- /dev/null
+++ b/src/space_weather/boosting.ts
@@ -0,0 +1,14 @@
+/** space_weather boosting module — tsb analytics library. */
+export interface SpaceWeatherBoostingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherBoostingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherBoosting(data: number[], opts: SpaceWeatherBoostingOptions = {}): SpaceWeatherBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherBoosting };
diff --git a/src/space_weather/bootstrap.ts b/src/space_weather/bootstrap.ts
new file mode 100644
index 000000000..894b20585
--- /dev/null
+++ b/src/space_weather/bootstrap.ts
@@ -0,0 +1,14 @@
+/** space_weather bootstrap module — tsb analytics library. */
+export interface SpaceWeatherBootstrapOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherBootstrapResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherBootstrap(data: number[], opts: SpaceWeatherBootstrapOptions = {}): SpaceWeatherBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherBootstrap };
diff --git a/src/space_weather/calculus.ts b/src/space_weather/calculus.ts
new file mode 100644
index 000000000..f5e6de33b
--- /dev/null
+++ b/src/space_weather/calculus.ts
@@ -0,0 +1,14 @@
+/** space_weather calculus module — tsb analytics library. */
+export interface SpaceWeatherCalculusOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherCalculusResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherCalculus(data: number[], opts: SpaceWeatherCalculusOptions = {}): SpaceWeatherCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherCalculus };
diff --git a/src/space_weather/calibration.ts b/src/space_weather/calibration.ts
new file mode 100644
index 000000000..1305c0b75
--- /dev/null
+++ b/src/space_weather/calibration.ts
@@ -0,0 +1,14 @@
+/** space_weather calibration module — tsb analytics library. */
+export interface SpaceWeatherCalibrationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherCalibrationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherCalibration(data: number[], opts: SpaceWeatherCalibrationOptions = {}): SpaceWeatherCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherCalibration };
diff --git a/src/space_weather/characterization.ts b/src/space_weather/characterization.ts
new file mode 100644
index 000000000..9d0e67754
--- /dev/null
+++ b/src/space_weather/characterization.ts
@@ -0,0 +1,14 @@
+/** space_weather characterization module — tsb analytics library. */
+export interface SpaceWeatherCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherCharacterizationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherCharacterization(data: number[], opts: SpaceWeatherCharacterizationOptions = {}): SpaceWeatherCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherCharacterization };
diff --git a/src/space_weather/classification.ts b/src/space_weather/classification.ts
new file mode 100644
index 000000000..2c34f5266
--- /dev/null
+++ b/src/space_weather/classification.ts
@@ -0,0 +1,14 @@
+/** space_weather classification module — tsb analytics library. */
+export interface SpaceWeatherClassificationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherClassificationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherClassification(data: number[], opts: SpaceWeatherClassificationOptions = {}): SpaceWeatherClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherClassification };
diff --git a/src/space_weather/clustering.ts b/src/space_weather/clustering.ts
new file mode 100644
index 000000000..b34dc49bf
--- /dev/null
+++ b/src/space_weather/clustering.ts
@@ -0,0 +1,14 @@
+/** space_weather clustering module — tsb analytics library. */
+export interface SpaceWeatherClusteringOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherClusteringResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherClustering(data: number[], opts: SpaceWeatherClusteringOptions = {}): SpaceWeatherClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherClustering };
diff --git a/src/space_weather/compression.ts b/src/space_weather/compression.ts
new file mode 100644
index 000000000..90870c3ad
--- /dev/null
+++ b/src/space_weather/compression.ts
@@ -0,0 +1,14 @@
+/** space_weather compression module — tsb analytics library. */
+export interface SpaceWeatherCompressionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherCompressionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherCompression(data: number[], opts: SpaceWeatherCompressionOptions = {}): SpaceWeatherCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherCompression };
diff --git a/src/space_weather/continuous.ts b/src/space_weather/continuous.ts
new file mode 100644
index 000000000..d8f42d163
--- /dev/null
+++ b/src/space_weather/continuous.ts
@@ -0,0 +1,14 @@
+/** space_weather continuous module — tsb analytics library. */
+export interface SpaceWeatherContinuousOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherContinuousResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherContinuous(data: number[], opts: SpaceWeatherContinuousOptions = {}): SpaceWeatherContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherContinuous };
diff --git a/src/space_weather/control.ts b/src/space_weather/control.ts
new file mode 100644
index 000000000..778d03b63
--- /dev/null
+++ b/src/space_weather/control.ts
@@ -0,0 +1,14 @@
+/** space_weather control module — tsb analytics library. */
+export interface SpaceWeatherControlOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherControlResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherControl(data: number[], opts: SpaceWeatherControlOptions = {}): SpaceWeatherControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherControl };
diff --git a/src/space_weather/convergence.ts b/src/space_weather/convergence.ts
new file mode 100644
index 000000000..136c79ba1
--- /dev/null
+++ b/src/space_weather/convergence.ts
@@ -0,0 +1,14 @@
+/** space_weather convergence module — tsb analytics library. */
+export interface SpaceWeatherConvergenceOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherConvergenceResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherConvergence(data: number[], opts: SpaceWeatherConvergenceOptions = {}): SpaceWeatherConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherConvergence };
diff --git a/src/space_weather/convex.ts b/src/space_weather/convex.ts
new file mode 100644
index 000000000..f00cf625d
--- /dev/null
+++ b/src/space_weather/convex.ts
@@ -0,0 +1,14 @@
+/** space_weather convex module — tsb analytics library. */
+export interface SpaceWeatherConvexOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherConvexResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherConvex(data: number[], opts: SpaceWeatherConvexOptions = {}): SpaceWeatherConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherConvex };
diff --git a/src/space_weather/correlation.ts b/src/space_weather/correlation.ts
new file mode 100644
index 000000000..a21d6bee0
--- /dev/null
+++ b/src/space_weather/correlation.ts
@@ -0,0 +1,14 @@
+/** space_weather correlation module — tsb analytics library. */
+export interface SpaceWeatherCorrelationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherCorrelationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherCorrelation(data: number[], opts: SpaceWeatherCorrelationOptions = {}): SpaceWeatherCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherCorrelation };
diff --git a/src/space_weather/covariance.ts b/src/space_weather/covariance.ts
new file mode 100644
index 000000000..cc98720f7
--- /dev/null
+++ b/src/space_weather/covariance.ts
@@ -0,0 +1,14 @@
+/** space_weather covariance module — tsb analytics library. */
+export interface SpaceWeatherCovarianceOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherCovarianceResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherCovariance(data: number[], opts: SpaceWeatherCovarianceOptions = {}): SpaceWeatherCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherCovariance };
diff --git a/src/space_weather/cross_validation.ts b/src/space_weather/cross_validation.ts
new file mode 100644
index 000000000..d17872825
--- /dev/null
+++ b/src/space_weather/cross_validation.ts
@@ -0,0 +1,14 @@
+/** space_weather cross_validation module — tsb analytics library. */
+export interface SpaceWeatherCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherCrossValidationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherCrossValidation(data: number[], opts: SpaceWeatherCrossValidationOptions = {}): SpaceWeatherCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherCrossValidation };
diff --git a/src/space_weather/decoding.ts b/src/space_weather/decoding.ts
new file mode 100644
index 000000000..49a7d1671
--- /dev/null
+++ b/src/space_weather/decoding.ts
@@ -0,0 +1,14 @@
+/** space_weather decoding module — tsb analytics library. */
+export interface SpaceWeatherDecodingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDecodingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDecoding(data: number[], opts: SpaceWeatherDecodingOptions = {}): SpaceWeatherDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDecoding };
diff --git a/src/space_weather/decomposition.ts b/src/space_weather/decomposition.ts
new file mode 100644
index 000000000..a72c54ea7
--- /dev/null
+++ b/src/space_weather/decomposition.ts
@@ -0,0 +1,14 @@
+/** space_weather decomposition module — tsb analytics library. */
+export interface SpaceWeatherDecompositionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDecompositionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDecomposition(data: number[], opts: SpaceWeatherDecompositionOptions = {}): SpaceWeatherDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDecomposition };
diff --git a/src/space_weather/detection.ts b/src/space_weather/detection.ts
new file mode 100644
index 000000000..2114a5cd5
--- /dev/null
+++ b/src/space_weather/detection.ts
@@ -0,0 +1,14 @@
+/** space_weather detection module — tsb analytics library. */
+export interface SpaceWeatherDetectionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDetectionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDetection(data: number[], opts: SpaceWeatherDetectionOptions = {}): SpaceWeatherDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDetection };
diff --git a/src/space_weather/deterministic.ts b/src/space_weather/deterministic.ts
new file mode 100644
index 000000000..82ddd94c0
--- /dev/null
+++ b/src/space_weather/deterministic.ts
@@ -0,0 +1,14 @@
+/** space_weather deterministic module — tsb analytics library. */
+export interface SpaceWeatherDeterministicOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDeterministicResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDeterministic(data: number[], opts: SpaceWeatherDeterministicOptions = {}): SpaceWeatherDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDeterministic };
diff --git a/src/space_weather/diagnostics.ts b/src/space_weather/diagnostics.ts
new file mode 100644
index 000000000..9443c4c5c
--- /dev/null
+++ b/src/space_weather/diagnostics.ts
@@ -0,0 +1,14 @@
+/** space_weather diagnostics module — tsb analytics library. */
+export interface SpaceWeatherDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDiagnostics(data: number[], opts: SpaceWeatherDiagnosticsOptions = {}): SpaceWeatherDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDiagnostics };
diff --git a/src/space_weather/differential.ts b/src/space_weather/differential.ts
new file mode 100644
index 000000000..95e04bb4e
--- /dev/null
+++ b/src/space_weather/differential.ts
@@ -0,0 +1,14 @@
+/** space_weather differential module — tsb analytics library. */
+export interface SpaceWeatherDifferentialOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDifferentialResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDifferential(data: number[], opts: SpaceWeatherDifferentialOptions = {}): SpaceWeatherDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDifferential };
diff --git a/src/space_weather/discrete.ts b/src/space_weather/discrete.ts
new file mode 100644
index 000000000..ec439b133
--- /dev/null
+++ b/src/space_weather/discrete.ts
@@ -0,0 +1,14 @@
+/** space_weather discrete module — tsb analytics library. */
+export interface SpaceWeatherDiscreteOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDiscreteResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDiscrete(data: number[], opts: SpaceWeatherDiscreteOptions = {}): SpaceWeatherDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDiscrete };
diff --git a/src/space_weather/distribution.ts b/src/space_weather/distribution.ts
new file mode 100644
index 000000000..6deea09f5
--- /dev/null
+++ b/src/space_weather/distribution.ts
@@ -0,0 +1,14 @@
+/** space_weather distribution module — tsb analytics library. */
+export interface SpaceWeatherDistributionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDistributionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDistribution(data: number[], opts: SpaceWeatherDistributionOptions = {}): SpaceWeatherDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDistribution };
diff --git a/src/space_weather/dynamic.ts b/src/space_weather/dynamic.ts
new file mode 100644
index 000000000..b68caf00f
--- /dev/null
+++ b/src/space_weather/dynamic.ts
@@ -0,0 +1,14 @@
+/** space_weather dynamic module — tsb analytics library. */
+export interface SpaceWeatherDynamicOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherDynamicResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherDynamic(data: number[], opts: SpaceWeatherDynamicOptions = {}): SpaceWeatherDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherDynamic };
diff --git a/src/space_weather/embedding.ts b/src/space_weather/embedding.ts
new file mode 100644
index 000000000..e2a3c433d
--- /dev/null
+++ b/src/space_weather/embedding.ts
@@ -0,0 +1,14 @@
+/** space_weather embedding module — tsb analytics library. */
+export interface SpaceWeatherEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherEmbeddingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherEmbedding(data: number[], opts: SpaceWeatherEmbeddingOptions = {}): SpaceWeatherEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherEmbedding };
diff --git a/src/space_weather/encoding.ts b/src/space_weather/encoding.ts
new file mode 100644
index 000000000..187bd81ae
--- /dev/null
+++ b/src/space_weather/encoding.ts
@@ -0,0 +1,14 @@
+/** space_weather encoding module — tsb analytics library. */
+export interface SpaceWeatherEncodingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherEncodingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherEncoding(data: number[], opts: SpaceWeatherEncodingOptions = {}): SpaceWeatherEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherEncoding };
diff --git a/src/space_weather/ensemble.ts b/src/space_weather/ensemble.ts
new file mode 100644
index 000000000..44f331dd6
--- /dev/null
+++ b/src/space_weather/ensemble.ts
@@ -0,0 +1,14 @@
+/** space_weather ensemble module — tsb analytics library. */
+export interface SpaceWeatherEnsembleOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherEnsembleResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherEnsemble(data: number[], opts: SpaceWeatherEnsembleOptions = {}): SpaceWeatherEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherEnsemble };
diff --git a/src/space_weather/estimation.ts b/src/space_weather/estimation.ts
new file mode 100644
index 000000000..7d49776a8
--- /dev/null
+++ b/src/space_weather/estimation.ts
@@ -0,0 +1,14 @@
+/** space_weather estimation module — tsb analytics library. */
+export interface SpaceWeatherEstimationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherEstimationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherEstimation(data: number[], opts: SpaceWeatherEstimationOptions = {}): SpaceWeatherEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherEstimation };
diff --git a/src/space_weather/evaluation.ts b/src/space_weather/evaluation.ts
new file mode 100644
index 000000000..5791aaa0e
--- /dev/null
+++ b/src/space_weather/evaluation.ts
@@ -0,0 +1,14 @@
+/** space_weather evaluation module — tsb analytics library. */
+export interface SpaceWeatherEvaluationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherEvaluationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherEvaluation(data: number[], opts: SpaceWeatherEvaluationOptions = {}): SpaceWeatherEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherEvaluation };
diff --git a/src/space_weather/extrapolation.ts b/src/space_weather/extrapolation.ts
new file mode 100644
index 000000000..6e4d3fe8c
--- /dev/null
+++ b/src/space_weather/extrapolation.ts
@@ -0,0 +1,14 @@
+/** space_weather extrapolation module — tsb analytics library. */
+export interface SpaceWeatherExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherExtrapolationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherExtrapolation(data: number[], opts: SpaceWeatherExtrapolationOptions = {}): SpaceWeatherExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherExtrapolation };
diff --git a/src/space_weather/features.ts b/src/space_weather/features.ts
new file mode 100644
index 000000000..e46116bea
--- /dev/null
+++ b/src/space_weather/features.ts
@@ -0,0 +1,14 @@
+/** space_weather features module — tsb analytics library. */
+export interface SpaceWeatherFeaturesOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherFeaturesResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherFeatures(data: number[], opts: SpaceWeatherFeaturesOptions = {}): SpaceWeatherFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherFeatures };
diff --git a/src/space_weather/feedback.ts b/src/space_weather/feedback.ts
new file mode 100644
index 000000000..67c156b9e
--- /dev/null
+++ b/src/space_weather/feedback.ts
@@ -0,0 +1,14 @@
+/** space_weather feedback module — tsb analytics library. */
+export interface SpaceWeatherFeedbackOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherFeedbackResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherFeedback(data: number[], opts: SpaceWeatherFeedbackOptions = {}): SpaceWeatherFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherFeedback };
diff --git a/src/space_weather/filtering.ts b/src/space_weather/filtering.ts
new file mode 100644
index 000000000..9734138cb
--- /dev/null
+++ b/src/space_weather/filtering.ts
@@ -0,0 +1,14 @@
+/** space_weather filtering module — tsb analytics library. */
+export interface SpaceWeatherFilteringOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherFilteringResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherFiltering(data: number[], opts: SpaceWeatherFilteringOptions = {}): SpaceWeatherFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherFiltering };
diff --git a/src/space_weather/fourier.ts b/src/space_weather/fourier.ts
new file mode 100644
index 000000000..fffbd5f7f
--- /dev/null
+++ b/src/space_weather/fourier.ts
@@ -0,0 +1,14 @@
+/** space_weather fourier module — tsb analytics library. */
+export interface SpaceWeatherFourierOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherFourierResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherFourier(data: number[], opts: SpaceWeatherFourierOptions = {}): SpaceWeatherFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherFourier };
diff --git a/src/space_weather/fusion.ts b/src/space_weather/fusion.ts
new file mode 100644
index 000000000..5f9e34042
--- /dev/null
+++ b/src/space_weather/fusion.ts
@@ -0,0 +1,14 @@
+/** space_weather fusion module — tsb analytics library. */
+export interface SpaceWeatherFusionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherFusionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherFusion(data: number[], opts: SpaceWeatherFusionOptions = {}): SpaceWeatherFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherFusion };
diff --git a/src/space_weather/generation.ts b/src/space_weather/generation.ts
new file mode 100644
index 000000000..16b428ed0
--- /dev/null
+++ b/src/space_weather/generation.ts
@@ -0,0 +1,14 @@
+/** space_weather generation module — tsb analytics library. */
+export interface SpaceWeatherGenerationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherGenerationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherGeneration(data: number[], opts: SpaceWeatherGenerationOptions = {}): SpaceWeatherGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherGeneration };
diff --git a/src/space_weather/geometry.ts b/src/space_weather/geometry.ts
new file mode 100644
index 000000000..d1e103c3a
--- /dev/null
+++ b/src/space_weather/geometry.ts
@@ -0,0 +1,14 @@
+/** space_weather geometry module — tsb analytics library. */
+export interface SpaceWeatherGeometryOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherGeometryResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherGeometry(data: number[], opts: SpaceWeatherGeometryOptions = {}): SpaceWeatherGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherGeometry };
diff --git a/src/space_weather/gradient.ts b/src/space_weather/gradient.ts
new file mode 100644
index 000000000..b46c42dc1
--- /dev/null
+++ b/src/space_weather/gradient.ts
@@ -0,0 +1,14 @@
+/** space_weather gradient module — tsb analytics library. */
+export interface SpaceWeatherGradientOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherGradientResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherGradient(data: number[], opts: SpaceWeatherGradientOptions = {}): SpaceWeatherGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherGradient };
diff --git a/src/space_weather/hessian.ts b/src/space_weather/hessian.ts
new file mode 100644
index 000000000..daa11273a
--- /dev/null
+++ b/src/space_weather/hessian.ts
@@ -0,0 +1,14 @@
+/** space_weather hessian module — tsb analytics library. */
+export interface SpaceWeatherHessianOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherHessianResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherHessian(data: number[], opts: SpaceWeatherHessianOptions = {}): SpaceWeatherHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherHessian };
diff --git a/src/space_weather/hypothesis.ts b/src/space_weather/hypothesis.ts
new file mode 100644
index 000000000..3874adbf6
--- /dev/null
+++ b/src/space_weather/hypothesis.ts
@@ -0,0 +1,14 @@
+/** space_weather hypothesis module — tsb analytics library. */
+export interface SpaceWeatherHypothesisOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherHypothesisResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherHypothesis(data: number[], opts: SpaceWeatherHypothesisOptions = {}): SpaceWeatherHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherHypothesis };
diff --git a/src/space_weather/inference.ts b/src/space_weather/inference.ts
new file mode 100644
index 000000000..2d8b7e7ba
--- /dev/null
+++ b/src/space_weather/inference.ts
@@ -0,0 +1,14 @@
+/** space_weather inference module — tsb analytics library. */
+export interface SpaceWeatherInferenceOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherInferenceResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherInference(data: number[], opts: SpaceWeatherInferenceOptions = {}): SpaceWeatherInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherInference };
diff --git a/src/space_weather/inference2.ts b/src/space_weather/inference2.ts
new file mode 100644
index 000000000..05de13fb1
--- /dev/null
+++ b/src/space_weather/inference2.ts
@@ -0,0 +1,14 @@
+/** space_weather inference2 module — tsb analytics library. */
+export interface SpaceWeatherInferenceOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherInferenceResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherInference(data: number[], opts: SpaceWeatherInferenceOptions = {}): SpaceWeatherInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherInference };
diff --git a/src/space_weather/integral.ts b/src/space_weather/integral.ts
new file mode 100644
index 000000000..a7282f423
--- /dev/null
+++ b/src/space_weather/integral.ts
@@ -0,0 +1,14 @@
+/** space_weather integral module — tsb analytics library. */
+export interface SpaceWeatherIntegralOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherIntegralResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherIntegral(data: number[], opts: SpaceWeatherIntegralOptions = {}): SpaceWeatherIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherIntegral };
diff --git a/src/space_weather/integration.ts b/src/space_weather/integration.ts
new file mode 100644
index 000000000..a3286225e
--- /dev/null
+++ b/src/space_weather/integration.ts
@@ -0,0 +1,14 @@
+/** space_weather integration module — tsb analytics library. */
+export interface SpaceWeatherIntegrationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherIntegrationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherIntegration(data: number[], opts: SpaceWeatherIntegrationOptions = {}): SpaceWeatherIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherIntegration };
diff --git a/src/space_weather/interpolation.ts b/src/space_weather/interpolation.ts
new file mode 100644
index 000000000..0dca1eef4
--- /dev/null
+++ b/src/space_weather/interpolation.ts
@@ -0,0 +1,14 @@
+/** space_weather interpolation module — tsb analytics library. */
+export interface SpaceWeatherInterpolationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherInterpolationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherInterpolation(data: number[], opts: SpaceWeatherInterpolationOptions = {}): SpaceWeatherInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherInterpolation };
diff --git a/src/space_weather/jacobian.ts b/src/space_weather/jacobian.ts
new file mode 100644
index 000000000..096409041
--- /dev/null
+++ b/src/space_weather/jacobian.ts
@@ -0,0 +1,14 @@
+/** space_weather jacobian module — tsb analytics library. */
+export interface SpaceWeatherJacobianOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherJacobianResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherJacobian(data: number[], opts: SpaceWeatherJacobianOptions = {}): SpaceWeatherJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherJacobian };
diff --git a/src/space_weather/kernel.ts b/src/space_weather/kernel.ts
new file mode 100644
index 000000000..d2b4bb6de
--- /dev/null
+++ b/src/space_weather/kernel.ts
@@ -0,0 +1,14 @@
+/** space_weather kernel module — tsb analytics library. */
+export interface SpaceWeatherKernelOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherKernelResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherKernel(data: number[], opts: SpaceWeatherKernelOptions = {}): SpaceWeatherKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherKernel };
diff --git a/src/space_weather/laplacian.ts b/src/space_weather/laplacian.ts
new file mode 100644
index 000000000..e25021246
--- /dev/null
+++ b/src/space_weather/laplacian.ts
@@ -0,0 +1,14 @@
+/** space_weather laplacian module — tsb analytics library. */
+export interface SpaceWeatherLaplacianOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherLaplacianResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherLaplacian(data: number[], opts: SpaceWeatherLaplacianOptions = {}): SpaceWeatherLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherLaplacian };
diff --git a/src/space_weather/learning.ts b/src/space_weather/learning.ts
new file mode 100644
index 000000000..a39aca81d
--- /dev/null
+++ b/src/space_weather/learning.ts
@@ -0,0 +1,14 @@
+/** space_weather learning module — tsb analytics library. */
+export interface SpaceWeatherLearningOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherLearningResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherLearning(data: number[], opts: SpaceWeatherLearningOptions = {}): SpaceWeatherLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherLearning };
diff --git a/src/space_weather/linear.ts b/src/space_weather/linear.ts
new file mode 100644
index 000000000..8e0dc5bea
--- /dev/null
+++ b/src/space_weather/linear.ts
@@ -0,0 +1,14 @@
+/** space_weather linear module — tsb analytics library. */
+export interface SpaceWeatherLinearOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherLinearResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherLinear(data: number[], opts: SpaceWeatherLinearOptions = {}): SpaceWeatherLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherLinear };
diff --git a/src/space_weather/manifold.ts b/src/space_weather/manifold.ts
new file mode 100644
index 000000000..4b8f13583
--- /dev/null
+++ b/src/space_weather/manifold.ts
@@ -0,0 +1,14 @@
+/** space_weather manifold module — tsb analytics library. */
+export interface SpaceWeatherManifoldOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherManifoldResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherManifold(data: number[], opts: SpaceWeatherManifoldOptions = {}): SpaceWeatherManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherManifold };
diff --git a/src/space_weather/matching.ts b/src/space_weather/matching.ts
new file mode 100644
index 000000000..e8222212f
--- /dev/null
+++ b/src/space_weather/matching.ts
@@ -0,0 +1,14 @@
+/** space_weather matching module — tsb analytics library. */
+export interface SpaceWeatherMatchingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherMatchingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherMatching(data: number[], opts: SpaceWeatherMatchingOptions = {}): SpaceWeatherMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherMatching };
diff --git a/src/space_weather/measurement.ts b/src/space_weather/measurement.ts
new file mode 100644
index 000000000..d4d6da1cc
--- /dev/null
+++ b/src/space_weather/measurement.ts
@@ -0,0 +1,14 @@
+/** space_weather measurement module — tsb analytics library. */
+export interface SpaceWeatherMeasurementOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherMeasurementResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherMeasurement(data: number[], opts: SpaceWeatherMeasurementOptions = {}): SpaceWeatherMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherMeasurement };
diff --git a/src/space_weather/metrics.ts b/src/space_weather/metrics.ts
new file mode 100644
index 000000000..cae7abcbe
--- /dev/null
+++ b/src/space_weather/metrics.ts
@@ -0,0 +1,14 @@
+/** space_weather metrics module — tsb analytics library. */
+export interface SpaceWeatherMetricsOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherMetricsResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherMetrics(data: number[], opts: SpaceWeatherMetricsOptions = {}): SpaceWeatherMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherMetrics };
diff --git a/src/space_weather/modeling.ts b/src/space_weather/modeling.ts
new file mode 100644
index 000000000..8ededf004
--- /dev/null
+++ b/src/space_weather/modeling.ts
@@ -0,0 +1,14 @@
+/** space_weather modeling module — tsb analytics library. */
+export interface SpaceWeatherModelingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherModelingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherModeling(data: number[], opts: SpaceWeatherModelingOptions = {}): SpaceWeatherModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherModeling };
diff --git a/src/space_weather/monitoring.ts b/src/space_weather/monitoring.ts
new file mode 100644
index 000000000..d32be4579
--- /dev/null
+++ b/src/space_weather/monitoring.ts
@@ -0,0 +1,14 @@
+/** space_weather monitoring module — tsb analytics library. */
+export interface SpaceWeatherMonitoringOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherMonitoringResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherMonitoring(data: number[], opts: SpaceWeatherMonitoringOptions = {}): SpaceWeatherMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherMonitoring };
diff --git a/src/space_weather/nonlinear.ts b/src/space_weather/nonlinear.ts
new file mode 100644
index 000000000..4b89bffe1
--- /dev/null
+++ b/src/space_weather/nonlinear.ts
@@ -0,0 +1,14 @@
+/** space_weather nonlinear module — tsb analytics library. */
+export interface SpaceWeatherNonlinearOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherNonlinearResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherNonlinear(data: number[], opts: SpaceWeatherNonlinearOptions = {}): SpaceWeatherNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherNonlinear };
diff --git a/src/space_weather/normalization.ts b/src/space_weather/normalization.ts
new file mode 100644
index 000000000..b00237221
--- /dev/null
+++ b/src/space_weather/normalization.ts
@@ -0,0 +1,14 @@
+/** space_weather normalization module — tsb analytics library. */
+export interface SpaceWeatherNormalizationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherNormalizationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherNormalization(data: number[], opts: SpaceWeatherNormalizationOptions = {}): SpaceWeatherNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherNormalization };
diff --git a/src/space_weather/optimization.ts b/src/space_weather/optimization.ts
new file mode 100644
index 000000000..2abd87b86
--- /dev/null
+++ b/src/space_weather/optimization.ts
@@ -0,0 +1,14 @@
+/** space_weather optimization module — tsb analytics library. */
+export interface SpaceWeatherOptimizationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherOptimizationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherOptimization(data: number[], opts: SpaceWeatherOptimizationOptions = {}): SpaceWeatherOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherOptimization };
diff --git a/src/space_weather/patterns.ts b/src/space_weather/patterns.ts
new file mode 100644
index 000000000..7289e042f
--- /dev/null
+++ b/src/space_weather/patterns.ts
@@ -0,0 +1,14 @@
+/** space_weather patterns module — tsb analytics library. */
+export interface SpaceWeatherPatternsOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherPatternsResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherPatterns(data: number[], opts: SpaceWeatherPatternsOptions = {}): SpaceWeatherPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherPatterns };
diff --git a/src/space_weather/permutation.ts b/src/space_weather/permutation.ts
new file mode 100644
index 000000000..ce30c58e6
--- /dev/null
+++ b/src/space_weather/permutation.ts
@@ -0,0 +1,14 @@
+/** space_weather permutation module — tsb analytics library. */
+export interface SpaceWeatherPermutationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherPermutationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherPermutation(data: number[], opts: SpaceWeatherPermutationOptions = {}): SpaceWeatherPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherPermutation };
diff --git a/src/space_weather/prediction.ts b/src/space_weather/prediction.ts
new file mode 100644
index 000000000..fe534593e
--- /dev/null
+++ b/src/space_weather/prediction.ts
@@ -0,0 +1,14 @@
+/** space_weather prediction module — tsb analytics library. */
+export interface SpaceWeatherPredictionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherPredictionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherPrediction(data: number[], opts: SpaceWeatherPredictionOptions = {}): SpaceWeatherPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherPrediction };
diff --git a/src/space_weather/processing.ts b/src/space_weather/processing.ts
new file mode 100644
index 000000000..8f8dcbc18
--- /dev/null
+++ b/src/space_weather/processing.ts
@@ -0,0 +1,14 @@
+/** space_weather processing module — tsb analytics library. */
+export interface SpaceWeatherProcessingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherProcessingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherProcessing(data: number[], opts: SpaceWeatherProcessingOptions = {}): SpaceWeatherProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherProcessing };
diff --git a/src/space_weather/profiling.ts b/src/space_weather/profiling.ts
new file mode 100644
index 000000000..11a555dc9
--- /dev/null
+++ b/src/space_weather/profiling.ts
@@ -0,0 +1,14 @@
+/** space_weather profiling module — tsb analytics library. */
+export interface SpaceWeatherProfilingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherProfilingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherProfiling(data: number[], opts: SpaceWeatherProfilingOptions = {}): SpaceWeatherProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherProfiling };
diff --git a/src/space_weather/projection.ts b/src/space_weather/projection.ts
new file mode 100644
index 000000000..c08b17bf5
--- /dev/null
+++ b/src/space_weather/projection.ts
@@ -0,0 +1,14 @@
+/** space_weather projection module — tsb analytics library. */
+export interface SpaceWeatherProjectionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherProjectionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherProjection(data: number[], opts: SpaceWeatherProjectionOptions = {}): SpaceWeatherProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherProjection };
diff --git a/src/space_weather/ranking.ts b/src/space_weather/ranking.ts
new file mode 100644
index 000000000..2aaa7a6cc
--- /dev/null
+++ b/src/space_weather/ranking.ts
@@ -0,0 +1,14 @@
+/** space_weather ranking module — tsb analytics library. */
+export interface SpaceWeatherRankingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherRankingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherRanking(data: number[], opts: SpaceWeatherRankingOptions = {}): SpaceWeatherRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherRanking };
diff --git a/src/space_weather/reconstruction.ts b/src/space_weather/reconstruction.ts
new file mode 100644
index 000000000..849fcbdcf
--- /dev/null
+++ b/src/space_weather/reconstruction.ts
@@ -0,0 +1,14 @@
+/** space_weather reconstruction module — tsb analytics library. */
+export interface SpaceWeatherReconstructionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherReconstructionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherReconstruction(data: number[], opts: SpaceWeatherReconstructionOptions = {}): SpaceWeatherReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherReconstruction };
diff --git a/src/space_weather/registration.ts b/src/space_weather/registration.ts
new file mode 100644
index 000000000..07f163932
--- /dev/null
+++ b/src/space_weather/registration.ts
@@ -0,0 +1,14 @@
+/** space_weather registration module — tsb analytics library. */
+export interface SpaceWeatherRegistrationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherRegistrationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherRegistration(data: number[], opts: SpaceWeatherRegistrationOptions = {}): SpaceWeatherRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherRegistration };
diff --git a/src/space_weather/regression.ts b/src/space_weather/regression.ts
new file mode 100644
index 000000000..4b6b0ce52
--- /dev/null
+++ b/src/space_weather/regression.ts
@@ -0,0 +1,14 @@
+/** space_weather regression module — tsb analytics library. */
+export interface SpaceWeatherRegressionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherRegressionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherRegression(data: number[], opts: SpaceWeatherRegressionOptions = {}): SpaceWeatherRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherRegression };
diff --git a/src/space_weather/regularization.ts b/src/space_weather/regularization.ts
new file mode 100644
index 000000000..b6fa6808e
--- /dev/null
+++ b/src/space_weather/regularization.ts
@@ -0,0 +1,14 @@
+/** space_weather regularization module — tsb analytics library. */
+export interface SpaceWeatherRegularizationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherRegularizationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherRegularization(data: number[], opts: SpaceWeatherRegularizationOptions = {}): SpaceWeatherRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherRegularization };
diff --git a/src/space_weather/robustness.ts b/src/space_weather/robustness.ts
new file mode 100644
index 000000000..c5c03d506
--- /dev/null
+++ b/src/space_weather/robustness.ts
@@ -0,0 +1,14 @@
+/** space_weather robustness module — tsb analytics library. */
+export interface SpaceWeatherRobustnessOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherRobustnessResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherRobustness(data: number[], opts: SpaceWeatherRobustnessOptions = {}): SpaceWeatherRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherRobustness };
diff --git a/src/space_weather/sampling.ts b/src/space_weather/sampling.ts
new file mode 100644
index 000000000..116916157
--- /dev/null
+++ b/src/space_weather/sampling.ts
@@ -0,0 +1,14 @@
+/** space_weather sampling module — tsb analytics library. */
+export interface SpaceWeatherSamplingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherSamplingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherSampling(data: number[], opts: SpaceWeatherSamplingOptions = {}): SpaceWeatherSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherSampling };
diff --git a/src/space_weather/sampling2.ts b/src/space_weather/sampling2.ts
new file mode 100644
index 000000000..1adda9515
--- /dev/null
+++ b/src/space_weather/sampling2.ts
@@ -0,0 +1,14 @@
+/** space_weather sampling2 module — tsb analytics library. */
+export interface SpaceWeatherSamplingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherSamplingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherSampling(data: number[], opts: SpaceWeatherSamplingOptions = {}): SpaceWeatherSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherSampling };
diff --git a/src/space_weather/scaling.ts b/src/space_weather/scaling.ts
new file mode 100644
index 000000000..f1001bbd9
--- /dev/null
+++ b/src/space_weather/scaling.ts
@@ -0,0 +1,14 @@
+/** space_weather scaling module — tsb analytics library. */
+export interface SpaceWeatherScalingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherScalingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherScaling(data: number[], opts: SpaceWeatherScalingOptions = {}): SpaceWeatherScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherScaling };
diff --git a/src/space_weather/scoring.ts b/src/space_weather/scoring.ts
new file mode 100644
index 000000000..5ddb55e07
--- /dev/null
+++ b/src/space_weather/scoring.ts
@@ -0,0 +1,14 @@
+/** space_weather scoring module — tsb analytics library. */
+export interface SpaceWeatherScoringOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherScoringResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherScoring(data: number[], opts: SpaceWeatherScoringOptions = {}): SpaceWeatherScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherScoring };
diff --git a/src/space_weather/segmentation.ts b/src/space_weather/segmentation.ts
new file mode 100644
index 000000000..5718bc3d1
--- /dev/null
+++ b/src/space_weather/segmentation.ts
@@ -0,0 +1,14 @@
+/** space_weather segmentation module — tsb analytics library. */
+export interface SpaceWeatherSegmentationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherSegmentationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherSegmentation(data: number[], opts: SpaceWeatherSegmentationOptions = {}): SpaceWeatherSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherSegmentation };
diff --git a/src/space_weather/selection.ts b/src/space_weather/selection.ts
new file mode 100644
index 000000000..297319e47
--- /dev/null
+++ b/src/space_weather/selection.ts
@@ -0,0 +1,14 @@
+/** space_weather selection module — tsb analytics library. */
+export interface SpaceWeatherSelectionOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherSelectionResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherSelection(data: number[], opts: SpaceWeatherSelectionOptions = {}): SpaceWeatherSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherSelection };
diff --git a/src/space_weather/sensitivity.ts b/src/space_weather/sensitivity.ts
new file mode 100644
index 000000000..e4c34563d
--- /dev/null
+++ b/src/space_weather/sensitivity.ts
@@ -0,0 +1,14 @@
+/** space_weather sensitivity module — tsb analytics library. */
+export interface SpaceWeatherSensitivityOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherSensitivityResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherSensitivity(data: number[], opts: SpaceWeatherSensitivityOptions = {}): SpaceWeatherSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherSensitivity };
diff --git a/src/space_weather/simulation.ts b/src/space_weather/simulation.ts
new file mode 100644
index 000000000..6520c6d99
--- /dev/null
+++ b/src/space_weather/simulation.ts
@@ -0,0 +1,14 @@
+/** space_weather simulation module — tsb analytics library. */
+export interface SpaceWeatherSimulationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherSimulationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherSimulation(data: number[], opts: SpaceWeatherSimulationOptions = {}): SpaceWeatherSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherSimulation };
diff --git a/src/space_weather/smoothing.ts b/src/space_weather/smoothing.ts
new file mode 100644
index 000000000..e7db13376
--- /dev/null
+++ b/src/space_weather/smoothing.ts
@@ -0,0 +1,14 @@
+/** space_weather smoothing module — tsb analytics library. */
+export interface SpaceWeatherSmoothingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherSmoothingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherSmoothing(data: number[], opts: SpaceWeatherSmoothingOptions = {}): SpaceWeatherSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherSmoothing };
diff --git a/src/space_weather/stability.ts b/src/space_weather/stability.ts
new file mode 100644
index 000000000..7b50ff2ed
--- /dev/null
+++ b/src/space_weather/stability.ts
@@ -0,0 +1,14 @@
+/** space_weather stability module — tsb analytics library. */
+export interface SpaceWeatherStabilityOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherStabilityResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherStability(data: number[], opts: SpaceWeatherStabilityOptions = {}): SpaceWeatherStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherStability };
diff --git a/src/space_weather/stacking.ts b/src/space_weather/stacking.ts
new file mode 100644
index 000000000..20aa9823d
--- /dev/null
+++ b/src/space_weather/stacking.ts
@@ -0,0 +1,14 @@
+/** space_weather stacking module — tsb analytics library. */
+export interface SpaceWeatherStackingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherStackingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherStacking(data: number[], opts: SpaceWeatherStackingOptions = {}): SpaceWeatherStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherStacking };
diff --git a/src/space_weather/standardization.ts b/src/space_weather/standardization.ts
new file mode 100644
index 000000000..dab1f3ac8
--- /dev/null
+++ b/src/space_weather/standardization.ts
@@ -0,0 +1,14 @@
+/** space_weather standardization module — tsb analytics library. */
+export interface SpaceWeatherStandardizationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherStandardizationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherStandardization(data: number[], opts: SpaceWeatherStandardizationOptions = {}): SpaceWeatherStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherStandardization };
diff --git a/src/space_weather/static.ts b/src/space_weather/static.ts
new file mode 100644
index 000000000..743c723f1
--- /dev/null
+++ b/src/space_weather/static.ts
@@ -0,0 +1,14 @@
+/** space_weather static module — tsb analytics library. */
+export interface SpaceWeatherStaticOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherStaticResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherStatic(data: number[], opts: SpaceWeatherStaticOptions = {}): SpaceWeatherStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherStatic };
diff --git a/src/space_weather/stochastic.ts b/src/space_weather/stochastic.ts
new file mode 100644
index 000000000..65906a252
--- /dev/null
+++ b/src/space_weather/stochastic.ts
@@ -0,0 +1,14 @@
+/** space_weather stochastic module — tsb analytics library. */
+export interface SpaceWeatherStochasticOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherStochasticResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherStochastic(data: number[], opts: SpaceWeatherStochasticOptions = {}): SpaceWeatherStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherStochastic };
diff --git a/src/space_weather/synthesis.ts b/src/space_weather/synthesis.ts
new file mode 100644
index 000000000..f528b9cb5
--- /dev/null
+++ b/src/space_weather/synthesis.ts
@@ -0,0 +1,14 @@
+/** space_weather synthesis module — tsb analytics library. */
+export interface SpaceWeatherSynthesisOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherSynthesisResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherSynthesis(data: number[], opts: SpaceWeatherSynthesisOptions = {}): SpaceWeatherSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherSynthesis };
diff --git a/src/space_weather/topology.ts b/src/space_weather/topology.ts
new file mode 100644
index 000000000..b67c41a03
--- /dev/null
+++ b/src/space_weather/topology.ts
@@ -0,0 +1,14 @@
+/** space_weather topology module — tsb analytics library. */
+export interface SpaceWeatherTopologyOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherTopologyResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherTopology(data: number[], opts: SpaceWeatherTopologyOptions = {}): SpaceWeatherTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherTopology };
diff --git a/src/space_weather/tracking.ts b/src/space_weather/tracking.ts
new file mode 100644
index 000000000..697eceba9
--- /dev/null
+++ b/src/space_weather/tracking.ts
@@ -0,0 +1,14 @@
+/** space_weather tracking module — tsb analytics library. */
+export interface SpaceWeatherTrackingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherTrackingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherTracking(data: number[], opts: SpaceWeatherTrackingOptions = {}): SpaceWeatherTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherTracking };
diff --git a/src/space_weather/transform.ts b/src/space_weather/transform.ts
new file mode 100644
index 000000000..54f57dadb
--- /dev/null
+++ b/src/space_weather/transform.ts
@@ -0,0 +1,14 @@
+/** space_weather transform module — tsb analytics library. */
+export interface SpaceWeatherTransformOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherTransformResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherTransform(data: number[], opts: SpaceWeatherTransformOptions = {}): SpaceWeatherTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherTransform };
diff --git a/src/space_weather/uncertainty.ts b/src/space_weather/uncertainty.ts
new file mode 100644
index 000000000..d011a834d
--- /dev/null
+++ b/src/space_weather/uncertainty.ts
@@ -0,0 +1,14 @@
+/** space_weather uncertainty module — tsb analytics library. */
+export interface SpaceWeatherUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherUncertaintyResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherUncertainty(data: number[], opts: SpaceWeatherUncertaintyOptions = {}): SpaceWeatherUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherUncertainty };
diff --git a/src/space_weather/validation.ts b/src/space_weather/validation.ts
new file mode 100644
index 000000000..28899e4dc
--- /dev/null
+++ b/src/space_weather/validation.ts
@@ -0,0 +1,14 @@
+/** space_weather validation module — tsb analytics library. */
+export interface SpaceWeatherValidationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherValidationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherValidation(data: number[], opts: SpaceWeatherValidationOptions = {}): SpaceWeatherValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherValidation };
diff --git a/src/space_weather/verification.ts b/src/space_weather/verification.ts
new file mode 100644
index 000000000..456f5091a
--- /dev/null
+++ b/src/space_weather/verification.ts
@@ -0,0 +1,14 @@
+/** space_weather verification module — tsb analytics library. */
+export interface SpaceWeatherVerificationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherVerificationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherVerification(data: number[], opts: SpaceWeatherVerificationOptions = {}): SpaceWeatherVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherVerification };
diff --git a/src/space_weather/visualization.ts b/src/space_weather/visualization.ts
new file mode 100644
index 000000000..023fb8305
--- /dev/null
+++ b/src/space_weather/visualization.ts
@@ -0,0 +1,14 @@
+/** space_weather visualization module — tsb analytics library. */
+export interface SpaceWeatherVisualizationOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherVisualizationResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherVisualization(data: number[], opts: SpaceWeatherVisualizationOptions = {}): SpaceWeatherVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherVisualization };
diff --git a/src/space_weather/voting.ts b/src/space_weather/voting.ts
new file mode 100644
index 000000000..589a3463e
--- /dev/null
+++ b/src/space_weather/voting.ts
@@ -0,0 +1,14 @@
+/** space_weather voting module — tsb analytics library. */
+export interface SpaceWeatherVotingOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherVotingResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherVoting(data: number[], opts: SpaceWeatherVotingOptions = {}): SpaceWeatherVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherVoting };
diff --git a/src/space_weather/wavelet.ts b/src/space_weather/wavelet.ts
new file mode 100644
index 000000000..747300275
--- /dev/null
+++ b/src/space_weather/wavelet.ts
@@ -0,0 +1,14 @@
+/** space_weather wavelet module — tsb analytics library. */
+export interface SpaceWeatherWaveletOptions { tol?: number; maxIter?: number; }
+export interface SpaceWeatherWaveletResult { values: number[]; converged: boolean; }
+export function computeSpaceWeatherWavelet(data: number[], opts: SpaceWeatherWaveletOptions = {}): SpaceWeatherWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSpaceWeatherWavelet };
diff --git a/src/stats/acf_pacf.ts b/src/stats/acf_pacf.ts
new file mode 100644
index 000000000..5edc712b6
--- /dev/null
+++ b/src/stats/acf_pacf.ts
@@ -0,0 +1,618 @@
+/**
+ * acf_pacf — Autocorrelation and partial autocorrelation functions.
+ *
+ * Mirrors `statsmodels.tsa.stattools.*` for time-series correlation analysis,
+ * plus `pd.Series.autocorr`. Implemented from scratch with no external deps.
+ *
+ * Implemented functions:
+ * - {@link autocorr} — pandas-style single-lag autocorrelation
+ * - {@link acf} — full ACF with Bartlett confidence intervals
+ * - {@link pacf} — PACF via Levinson-Durbin recursion
+ * - {@link ccf} — cross-correlation function
+ * - {@link durbinWatson} — Durbin-Watson statistic for residual autocorrelation
+ * - {@link ljungBox} — Ljung-Box portmanteau test
+ * - {@link boxPierce} — Box-Pierce portmanteau test
+ *
+ * @example
+ * ```ts
+ * import { acf, pacf, ljungBox } from "tsb";
+ *
+ * const x = [1, 2, 3, 2, 1, 2, 3, 2, 1, 0, 1, 2];
+ * const { acf: corrs, lags } = acf(x, { nlags: 4, alpha: 0.05 });
+ * const { pacf: partial } = pacf(x, { nlags: 4 });
+ * const { pvalue } = ljungBox(x);
+ * ```
+ *
+ * @module
+ */
+
+import { Series } from "../core/index.ts";
+
+// ─── public types ──────────────────────────────────────────────────────────────
+
+/** Result from {@link acf}. */
+export interface ACFResult {
+ /** Autocorrelation coefficients; index 0 corresponds to lag 0 (= 1.0). */
+ readonly acf: readonly number[];
+ /**
+ * Confidence interval bounds `[lower, upper]` for each lag, computed via
+ * Bartlett's formula. `undefined` when `alpha` was not specified.
+ */
+ readonly confint: readonly [number, number][] | undefined;
+ /** Lag indices corresponding to each coefficient. */
+ readonly lags: readonly number[];
+}
+
+/** Result from {@link pacf}. */
+export interface PACFResult {
+ /** Partial autocorrelations; index 0 corresponds to lag 0 (= 1.0). */
+ readonly pacf: readonly number[];
+ /**
+ * Confidence interval bounds `[lower, upper]` for each lag.
+ * `undefined` when `alpha` was not specified.
+ */
+ readonly confint: readonly [number, number][] | undefined;
+ /** Lag indices. */
+ readonly lags: readonly number[];
+}
+
+/** Result from {@link ljungBox} or {@link boxPierce}. */
+export interface PortmanteauResult {
+ /** Q statistic at each tested lag. */
+ readonly statistic: readonly number[];
+ /** p-value at each tested lag (chi-squared df = lag − modelDf). */
+ readonly pvalue: readonly number[];
+ /** Lag indices that were tested. */
+ readonly lags: readonly number[];
+}
+
+/** Options for {@link acf}. */
+export interface ACFOptions {
+ /** Maximum lag to compute (default: `min(floor(10·log₁₀(n)), n−1)`). */
+ readonly nlags?: number;
+ /**
+ * Significance level for Bartlett confidence intervals (e.g. `0.05` → 95 % CI).
+ * Omit (default) to skip CI computation.
+ */
+ readonly alpha?: number;
+}
+
+/** Options for {@link pacf}. */
+export interface PACFOptions {
+ /** Maximum lag (default: `min(floor(10·log₁₀(n)), floor(n/2)−1)`). */
+ readonly nlags?: number;
+ /**
+ * Significance level for confidence intervals.
+ * Omit (default) to skip CI computation.
+ */
+ readonly alpha?: number;
+}
+
+/** Options for {@link ccf}. */
+export interface CCFOptions {
+ /** Maximum lag (default: `min(floor(10·log₁₀(n)), n−1)`). */
+ readonly nlags?: number;
+ /**
+ * Significance level for confidence intervals.
+ * Omit (default) to skip CI computation.
+ */
+ readonly alpha?: number;
+ /** When `true`, return only non-negative lags (default: `false`). */
+ readonly positiveOnly?: boolean;
+}
+
+/** Options for {@link ljungBox} and {@link boxPierce}. */
+export interface PortmanteauOptions {
+ /**
+ * Specific lag values to test, or a single maximum lag `h` (implying lags
+ * `1, 2, …, h`). Default: `min(floor(10·log₁₀(n)), n−1)`.
+ */
+ readonly lags?: number | readonly number[];
+ /**
+ * Number of estimated AR/MA parameters already fit to the series (default: `0`).
+ * The chi-squared degrees of freedom for lag `h` become `h − modelDf`.
+ */
+ readonly modelDf?: number;
+}
+
+// ─── internal type alias ──────────────────────────────────────────────────────
+
+/** A numeric array or {@link Series} accepted by every public function. */
+type NumericInput = readonly number[] | Series;
+
+// ─── math helpers ─────────────────────────────────────────────────────────────
+
+/** Lanczos approximation of log-Γ(z). */
+function logGamma(z: number): number {
+ if (z < 0.5) {
+ return Math.log(Math.PI / Math.sin(Math.PI * z)) - logGamma(1.0 - z);
+ }
+ const g = 7;
+ const c = [
+ 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313,
+ -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6,
+ 1.5056327351493116e-7,
+ ];
+ let x = c[0] ?? 0;
+ const zz = z - 1;
+ for (let i = 1; i < g + 2; i++) {
+ x += (c[i] ?? 0) / (zz + i);
+ }
+ const t = zz + g + 0.5;
+ return 0.5 * Math.log(2 * Math.PI) + (zz + 0.5) * Math.log(t) - t + Math.log(x);
+}
+
+/** Regularised lower incomplete Γ via series expansion (x < a+1). */
+function regIncGammaSeries(a: number, x: number, lnGa: number): number {
+ let sum = 1 / a;
+ let term = 1 / a;
+ for (let n = 1; n <= 200; n++) {
+ term *= x / (a + n);
+ sum += term;
+ if (Math.abs(term) < Math.abs(sum) * 1e-10) {
+ break;
+ }
+ }
+ return Math.exp(-x + a * Math.log(x) - lnGa) * sum;
+}
+
+/** Regularised lower incomplete Γ via continued-fraction expansion (x ≥ a+1). */
+function regIncGammaCF(a: number, x: number, lnGa: number): number {
+ const eps = 1e-30;
+ let f = eps;
+ let c = f;
+ let d = 1 / (x - a + 1 + eps);
+ d = 1 / d;
+ f = c * d;
+ for (let i = 1; i <= 200; i++) {
+ const an = -i * (i - a);
+ const bn = x - a + 2 * i + 1;
+ d = an * d + bn;
+ c = bn + an / c;
+ if (Math.abs(c) < eps) {
+ c = eps;
+ }
+ d = 1 / (Math.abs(d) < eps ? eps : d);
+ const del = c * d;
+ f *= del;
+ if (Math.abs(del - 1) < 1e-10) {
+ break;
+ }
+ }
+ return 1 - Math.exp(-x + a * Math.log(x) - lnGa) * f;
+}
+
+/** Regularised lower incomplete Γ: P(a, x). */
+function regIncGamma(a: number, x: number): number {
+ if (x < 0) {
+ return 0;
+ }
+ const lnGa = logGamma(a);
+ if (x < a + 1) {
+ return regIncGammaSeries(a, x, lnGa);
+ }
+ return regIncGammaCF(a, x, lnGa);
+}
+
+/** χ² survival function: P(χ²_df > x). */
+function chi2sf(x: number, df: number): number {
+ if (x <= 0) {
+ return 1;
+ }
+ return 1 - regIncGamma(df / 2, x / 2);
+}
+
+/** Inverse standard-normal CDF (Peter Acklam's rational approximation). */
+function normalPpf(p: number): number {
+ if (p <= 0) {
+ return Number.NEGATIVE_INFINITY;
+ }
+ if (p >= 1) {
+ return Number.POSITIVE_INFINITY;
+ }
+ if (p === 0.5) {
+ return 0;
+ }
+ const a0 = -3.969683028665376e1;
+ const a1 = 2.209460984245205e2;
+ const a2 = -2.759285104469687e2;
+ const a3 = 1.38357751867269e2;
+ const a4 = -3.066479806614716e1;
+ const a5 = 2.506628277459239;
+ const b0 = -5.447609879822406e1;
+ const b1 = 1.615858368580409e2;
+ const b2 = -1.556989798598866e2;
+ const b3 = 6.680131188771972e1;
+ const b4 = -1.328068155288572e1;
+ const c0 = -7.784894002430293e-3;
+ const c1 = -3.223964580411365e-1;
+ const c2 = -2.400758277161838;
+ const c3 = -2.549732539343734;
+ const c4 = 4.374664141464968;
+ const c5 = 2.938163982698783;
+ const d0 = 7.784695709041462e-3;
+ const d1 = 3.224671290700398e-1;
+ const d2 = 2.445134137142996;
+ const d3 = 3.754408661907416;
+ const pLow = 0.02425;
+ const pHigh = 1 - pLow;
+ if (p < pLow) {
+ const q = Math.sqrt(-2 * Math.log(p));
+ return (
+ (((((c0 * q + c1) * q + c2) * q + c3) * q + c4) * q + c5) /
+ ((((d0 * q + d1) * q + d2) * q + d3) * q + 1)
+ );
+ }
+ if (p <= pHigh) {
+ const q = p - 0.5;
+ const r = q * q;
+ return (
+ ((((((a0 * r + a1) * r + a2) * r + a3) * r + a4) * r + a5) * q) /
+ (((((b0 * r + b1) * r + b2) * r + b3) * r + b4) * r + 1)
+ );
+ }
+ const q = Math.sqrt(-2 * Math.log(1 - p));
+ return -(
+ (((((c0 * q + c1) * q + c2) * q + c3) * q + c4) * q + c5) /
+ ((((d0 * q + d1) * q + d2) * q + d3) * q + 1)
+ );
+}
+
+// ─── tuple helpers ────────────────────────────────────────────────────────────
+
+/** Build a `[lower, upper]` confidence bound tuple without a cast. */
+function bound(center: number, margin: number): [number, number] {
+ return [center - margin, center + margin];
+}
+
+// ─── array extraction ─────────────────────────────────────────────────────────
+
+/** Extract a plain `number[]`, dropping NaN and non-numeric values. */
+function toNumbers(input: NumericInput): number[] {
+ if (input instanceof Series) {
+ const out: number[] = [];
+ for (const val of input.values) {
+ if (typeof val === "number" && !Number.isNaN(val)) {
+ out.push(val);
+ }
+ }
+ return out;
+ }
+ return (input as readonly number[]).filter((v) => typeof v === "number" && !Number.isNaN(v));
+}
+
+// ─── autocovariance ────────────────────────────────────────────────────────────
+
+/**
+ * Biased sample autocovariance γ̂(0), γ̂(1), …, γ̂(nlags).
+ * Denominator is n (consistent with pandas / statsmodels default).
+ */
+function autocovariance(x: readonly number[], mean: number, nlags: number): number[] {
+ const n = x.length;
+ const cov: number[] = [];
+ for (let k = 0; k <= nlags; k++) {
+ let s = 0;
+ for (let t = 0; t < n - k; t++) {
+ s += ((x[t] ?? 0) - mean) * ((x[t + k] ?? 0) - mean);
+ }
+ cov.push(s / n);
+ }
+ return cov;
+}
+
+// ─── ACF CI helper ────────────────────────────────────────────────────────────
+
+/** Bartlett confidence intervals for ACF coefficients. */
+function buildAcfCI(acfValues: readonly number[], n: number, alpha: number): [number, number][] {
+ const z = normalPpf(1 - alpha / 2);
+ const ci: [number, number][] = [];
+ let sumSq = 0;
+ for (let k = 0; k < acfValues.length; k++) {
+ if (k === 0) {
+ ci.push([1, 1]);
+ } else {
+ const se = Math.sqrt((1 + 2 * sumSq) / n);
+ const r = acfValues[k] ?? 0;
+ ci.push(bound(r, z * se));
+ sumSq += r * r;
+ }
+ }
+ return ci;
+}
+
+// ─── Levinson-Durbin helpers ──────────────────────────────────────────────────
+
+/** Single Levinson-Durbin recursion step: returns [φ_kk, updated φ array]. */
+function ldStep(acfVals: readonly number[], phi: readonly number[], k: number): [number, number[]] {
+ let num = acfVals[k] ?? 0;
+ let den = 1;
+ for (let j = 1; j < k; j++) {
+ num -= (phi[j - 1] ?? 0) * (acfVals[k - j] ?? 0);
+ den -= (phi[j - 1] ?? 0) * (acfVals[j] ?? 0);
+ }
+ const phiKK = den === 0 ? 0 : num / den;
+ const newPhi: number[] = [];
+ for (let j = 1; j < k; j++) {
+ newPhi.push((phi[j - 1] ?? 0) - phiKK * (phi[k - j - 1] ?? 0));
+ }
+ newPhi.push(phiKK);
+ return [phiKK, newPhi];
+}
+
+/** Levinson-Durbin recursion returning PACF[0..nlags]. */
+function levinsonDurbin(acfVals: readonly number[], nlags: number): number[] {
+ const result: number[] = [1];
+ if (nlags === 0) {
+ return result;
+ }
+ let phi: number[] = [];
+ for (let k = 1; k <= nlags; k++) {
+ const [phiKK, newPhi] = ldStep(acfVals, phi, k);
+ result.push(phiKK);
+ phi = newPhi;
+ }
+ return result;
+}
+
+// ─── CCF helpers ──────────────────────────────────────────────────────────────
+
+/** Cross-covariance at lag k (biased estimator, denominator = n). */
+function ccfLag(
+ xArr: readonly number[],
+ yArr: readonly number[],
+ n: number,
+ xMean: number,
+ yMean: number,
+ k: number,
+): number {
+ const start = k >= 0 ? 0 : -k;
+ const end = k >= 0 ? n - k : n;
+ let s = 0;
+ for (let t = start; t < end; t++) {
+ s += ((xArr[t] ?? 0) - xMean) * ((yArr[t + k] ?? 0) - yMean);
+ }
+ return s / n;
+}
+
+// ─── portmanteau helpers ──────────────────────────────────────────────────────
+
+/** Resolve the `lags` option to a sorted list. */
+function resolveLags(opt: number | readonly number[] | undefined, maxLag: number): number[] {
+ if (opt === undefined) {
+ return [maxLag];
+ }
+ if (typeof opt === "number") {
+ return Array.from({ length: opt }, (_, i) => i + 1);
+ }
+ return (opt as readonly number[]).slice().sort((a, b) => a - b);
+}
+
+/** Compute Ljung-Box or Box-Pierce Q at lag h. */
+function portmanteauQ(acfVals: readonly number[], n: number, h: number, ljung: boolean): number {
+ let q = 0;
+ for (let k = 1; k <= h; k++) {
+ const r = acfVals[k] ?? 0;
+ q += ljung ? (r * r) / (n - k) : r * r;
+ }
+ return ljung ? n * (n + 2) * q : n * q;
+}
+
+// ─── public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Pandas-style single-lag autocorrelation.
+ *
+ * Equivalent to `pd.Series.autocorr(lag)` — computes the Pearson correlation
+ * between `x[0..n−lag−1]` and `x[lag..n−1]`.
+ *
+ * @param x Input series.
+ * @param lag Lag (default: `1`).
+ * @returns Pearson correlation in `[−1, 1]`, or `NaN` if series is too short.
+ */
+export function autocorr(x: NumericInput, lag = 1): number {
+ const arr = toNumbers(x);
+ const n = arr.length;
+ if (n <= lag + 1) {
+ return Number.NaN;
+ }
+ const x1 = arr.slice(0, n - lag);
+ const x2 = arr.slice(lag);
+ const m1 = x1.reduce((s, v) => s + v, 0) / x1.length;
+ const m2 = x2.reduce((s, v) => s + v, 0) / x2.length;
+ let num = 0;
+ let ss1 = 0;
+ let ss2 = 0;
+ for (let i = 0; i < x1.length; i++) {
+ const d1 = (x1[i] ?? 0) - m1;
+ const d2 = (x2[i] ?? 0) - m2;
+ num += d1 * d2;
+ ss1 += d1 * d1;
+ ss2 += d2 * d2;
+ }
+ const denom = Math.sqrt(ss1 * ss2);
+ return denom === 0 ? Number.NaN : num / denom;
+}
+
+/**
+ * Full Autocorrelation Function (ACF) with optional Bartlett confidence
+ * intervals.
+ *
+ * Mirrors `statsmodels.tsa.stattools.acf` (biased estimator, lag 0 = 1).
+ *
+ * @param x Input time series.
+ * @param options See {@link ACFOptions}.
+ * @returns ACF coefficients for lags 0…nlags, plus optional CI.
+ */
+export function acf(x: NumericInput, options: ACFOptions = {}): ACFResult {
+ const arr = toNumbers(x);
+ const n = arr.length;
+ const defaultNlags = Math.min(Math.floor(10 * Math.log10(n)), n - 1);
+ const nlags = Math.max(0, Math.min(options.nlags ?? defaultNlags, n - 1));
+ const mean = arr.reduce((s, v) => s + v, 0) / n;
+ const cov = autocovariance(arr, mean, nlags);
+ const gamma0 = cov[0] ?? 1;
+ const acfValues: number[] = cov.map((c) => (gamma0 === 0 ? 0 : c / gamma0));
+ const lags = Array.from({ length: nlags + 1 }, (_, i) => i);
+ const confint = options.alpha !== undefined ? buildAcfCI(acfValues, n, options.alpha) : undefined;
+ return { acf: acfValues, confint, lags };
+}
+
+/**
+ * Partial Autocorrelation Function (PACF) via the Levinson-Durbin recursion.
+ *
+ * Mirrors `statsmodels.tsa.stattools.pacf` (method `"yw"`).
+ *
+ * @param x Input time series.
+ * @param options See {@link PACFOptions}.
+ * @returns PACF coefficients for lags 0…nlags, plus optional CI.
+ */
+export function pacf(x: NumericInput, options: PACFOptions = {}): PACFResult {
+ const arr = toNumbers(x);
+ const n = arr.length;
+ const defaultNlags = Math.min(Math.floor(10 * Math.log10(n)), Math.floor(n / 2) - 1);
+ const maxAllowed = Math.max(0, Math.floor(n / 2) - 1);
+ const nlags = Math.max(0, Math.min(options.nlags ?? defaultNlags, maxAllowed));
+ const mean = arr.reduce((s, v) => s + v, 0) / n;
+ const cov = autocovariance(arr, mean, nlags);
+ const gamma0 = cov[0] ?? 1;
+ const acfVals: number[] = cov.map((c) => (gamma0 === 0 ? 0 : c / gamma0));
+ const pacfValues = levinsonDurbin(acfVals, nlags);
+ const lags = Array.from({ length: nlags + 1 }, (_, i) => i);
+ let confint: [number, number][] | undefined;
+ if (options.alpha !== undefined) {
+ const z = normalPpf(1 - options.alpha / 2);
+ const se = 1 / Math.sqrt(n);
+ confint = pacfValues.map((r) => bound(r, z * se));
+ }
+ return { pacf: pacfValues, confint, lags };
+}
+
+/**
+ * Cross-Correlation Function (CCF) between two series.
+ *
+ * CCF(k) is the normalized cross-covariance at lag k:
+ * `CCF(k) = C_xy(k) / (σ_x · σ_y)` where `C_xy(k)` uses denominator `n`.
+ *
+ * @param x First time series.
+ * @param y Second time series (must have the same length as `x`).
+ * @param options See {@link CCFOptions}.
+ * @returns CCF coefficients for lags −nlags…+nlags (or 0…nlags).
+ */
+export function ccf(x: NumericInput, y: NumericInput, options: CCFOptions = {}): ACFResult {
+ const xArr = toNumbers(x);
+ const yArr = toNumbers(y);
+ const n = Math.min(xArr.length, yArr.length);
+ const defaultNlags = Math.min(Math.floor(10 * Math.log10(n)), n - 1);
+ const nlags = Math.max(0, Math.min(options.nlags ?? defaultNlags, n - 1));
+ const positiveOnly = options.positiveOnly ?? false;
+ const xSub = xArr.slice(0, n);
+ const ySub = yArr.slice(0, n);
+ const xMean = xSub.reduce((s, v) => s + v, 0) / n;
+ const yMean = ySub.reduce((s, v) => s + v, 0) / n;
+ const xVar = xSub.reduce((s, v) => s + (v - xMean) ** 2, 0) / n;
+ const yVar = ySub.reduce((s, v) => s + (v - yMean) ** 2, 0) / n;
+ const xStd = Math.sqrt(xVar);
+ const yStd = Math.sqrt(yVar);
+ const denom = xStd * yStd;
+ const startLag = positiveOnly ? 0 : -nlags;
+ const lags: number[] = [];
+ const values: number[] = [];
+ for (let k = startLag; k <= nlags; k++) {
+ lags.push(k);
+ const cov = ccfLag(xSub, ySub, n, xMean, yMean, k);
+ values.push(denom === 0 ? 0 : cov / denom);
+ }
+ let confint: [number, number][] | undefined;
+ if (options.alpha !== undefined) {
+ const z = normalPpf(1 - options.alpha / 2);
+ const se = 1 / Math.sqrt(n);
+ confint = values.map((r) => bound(r, z * se));
+ }
+ return { acf: values, confint, lags };
+}
+
+/**
+ * Durbin-Watson statistic for autocorrelation in OLS residuals.
+ *
+ * `DW = Σ(eₜ − eₜ₋₁)² / Σeₜ²`
+ *
+ * | DW | Interpretation |
+ * |------|------------------------------|
+ * | ≈ 0 | Strong positive correlation |
+ * | ≈ 2 | No autocorrelation |
+ * | ≈ 4 | Strong negative correlation |
+ *
+ * @param residuals OLS residual array or Series.
+ * @returns Durbin-Watson statistic in `[0, 4]`.
+ */
+export function durbinWatson(residuals: NumericInput): number {
+ const e = toNumbers(residuals);
+ const n = e.length;
+ if (n < 2) {
+ return Number.NaN;
+ }
+ let diff2 = 0;
+ let ss = (e[0] ?? 0) ** 2;
+ for (let t = 1; t < n; t++) {
+ const d = (e[t] ?? 0) - (e[t - 1] ?? 0);
+ diff2 += d * d;
+ ss += (e[t] ?? 0) ** 2;
+ }
+ return ss === 0 ? 2 : diff2 / ss;
+}
+
+/**
+ * Ljung-Box Q test for serial autocorrelation up to lag `h`.
+ *
+ * `Q_LB(h) = n·(n+2) · Σₖ₌₁ʰ r̂ₖ² / (n−k)`
+ *
+ * H₀: the first `h` autocorrelations are all zero.
+ * Rejection at small p-values indicates the series is not white noise.
+ *
+ * @param x Input time series.
+ * @param options See {@link PortmanteauOptions}.
+ * @returns Test statistic, p-value, and lag for each tested lag.
+ */
+export function ljungBox(x: NumericInput, options: PortmanteauOptions = {}): PortmanteauResult {
+ return portmanteauTest(x, options, true);
+}
+
+/**
+ * Box-Pierce Q test (simplified Ljung-Box).
+ *
+ * `Q_BP(h) = n · Σₖ₌₁ʰ r̂ₖ²`
+ *
+ * @param x Input time series.
+ * @param options See {@link PortmanteauOptions}.
+ * @returns Test statistic, p-value, and lag for each tested lag.
+ */
+export function boxPierce(x: NumericInput, options: PortmanteauOptions = {}): PortmanteauResult {
+ return portmanteauTest(x, options, false);
+}
+
+/** Shared computation for Ljung-Box and Box-Pierce. */
+function portmanteauTest(
+ x: NumericInput,
+ options: PortmanteauOptions,
+ ljung: boolean,
+): PortmanteauResult {
+ const arr = toNumbers(x);
+ const n = arr.length;
+ const modelDf = options.modelDf ?? 0;
+ const defaultMaxLag = Math.min(Math.floor(10 * Math.log10(n)), n - 1);
+ const lagList = resolveLags(options.lags, defaultMaxLag);
+ const hMax = lagList.at(-1) ?? defaultMaxLag;
+ const mean = arr.reduce((s, v) => s + v, 0) / n;
+ const cov = autocovariance(arr, mean, hMax);
+ const gamma0 = cov[0] ?? 1;
+ const acfVals: number[] = cov.map((c) => (gamma0 === 0 ? 0 : c / gamma0));
+ const statistic: number[] = [];
+ const pvalue: number[] = [];
+ for (const h of lagList) {
+ const q = portmanteauQ(acfVals, n, h, ljung);
+ const df = h - modelDf;
+ statistic.push(q);
+ pvalue.push(df > 0 ? chi2sf(q, df) : Number.NaN);
+ }
+ return { statistic, pvalue, lags: lagList };
+}
diff --git a/src/stats/arima.ts b/src/stats/arima.ts
new file mode 100644
index 000000000..7e5b3ab59
--- /dev/null
+++ b/src/stats/arima.ts
@@ -0,0 +1,591 @@
+/**
+ * arima — ARIMA(p, d, q) time-series model.
+ *
+ * Mirrors the `statsmodels.tsa.arima.model.ARIMA` API and pandas convention.
+ * Estimation uses the Hannan-Rissanen two-step method:
+ * 1. Fit a high-order AR(kMax) via Yule-Walker to obtain proxy residuals.
+ * 2. OLS on the differenced series using AR(p) lags + MA(q) proxy residuals.
+ *
+ * kMax = min(max(p + q + 5, 3), floor(n / 5)).
+ *
+ * Forecast confidence intervals use ψ-weight recursion. For integrated models
+ * (d > 0) the ψ-weights are accumulated d times (convolution with integration
+ * filter) before computing the forecast MSE.
+ *
+ * @example
+ * ```ts
+ * import { ARIMAModel } from "tsb";
+ *
+ * const y = [1, 2, 1.5, 2.5, 2, 3, 2.5, 3.5, 3, 4, 3.5, 4.5, 4];
+ * const model = new ARIMAModel({ p: 1, d: 0, q: 1 });
+ * const fit = model.fit(y);
+ * console.log(fit.arCoeffs, fit.maCoeffs, fit.aic);
+ * const fc = model.forecast(5);
+ * console.log(fc.forecast, fc.lower, fc.upper);
+ * ```
+ *
+ * @module
+ */
+
+import type { Series } from "../core/series.ts";
+
+// ─── Public types ──────────────────────────────────────────────────────────────
+
+/** Constructor options for {@link ARIMAModel}. */
+export interface ARIMAOptions {
+ /** AR order (number of autoregressive lags). Default: 1. */
+ readonly p?: number;
+ /** Differencing order. Default: 0. */
+ readonly d?: number;
+ /** MA order (number of moving-average lags). Default: 0. */
+ readonly q?: number;
+}
+
+/** Results returned by {@link ARIMAModel.fit}. */
+export interface ARIMAFitResult {
+ /** AR coefficients φ₁ … φₚ (index 0 = lag 1). */
+ readonly arCoeffs: readonly number[];
+ /** MA coefficients θ₁ … θ_q (index 0 = lag 1). */
+ readonly maCoeffs: readonly number[];
+ /** Intercept / constant term on the differenced scale. */
+ readonly intercept: number;
+ /** In-sample fitted values on the **original** (undifferenced) scale. */
+ readonly fittedValues: readonly number[];
+ /** Residuals on the differenced scale. */
+ readonly residuals: readonly number[];
+ /** Estimated noise variance σ². */
+ readonly sigma2: number;
+ /** Log-likelihood (Gaussian). */
+ readonly logLikelihood: number;
+ /** Akaike Information Criterion. */
+ readonly aic: number;
+ /** Bayesian Information Criterion. */
+ readonly bic: number;
+}
+
+/** Multi-step forecasts with prediction intervals from {@link ARIMAModel.forecast}. */
+export interface ARIMAForecastResult {
+ /** Point forecasts on the original (undifferenced) scale. */
+ readonly forecast: readonly number[];
+ /** Lower bound of the 95 % prediction interval (original scale). */
+ readonly lower: readonly number[];
+ /** Upper bound of the 95 % prediction interval (original scale). */
+ readonly upper: readonly number[];
+ /** Standard errors of the h-step-ahead forecast errors. */
+ readonly stderr: readonly number[];
+}
+
+// ─── Private helpers ──────────────────────────────────────────────────────────
+
+/** Type guard: distinguishes `readonly number[]` from `Series`. */
+function isNumericArray(y: readonly number[] | Series): y is readonly number[] {
+ return Array.isArray(y);
+}
+
+function arrMean(x: readonly number[]): number {
+ if (x.length === 0) {
+ return 0;
+ }
+ let s = 0;
+ for (const v of x) {
+ s += v;
+ }
+ return s / x.length;
+}
+
+/** Apply d-th order differencing; also collects the d initial values needed to
+ * reverse the operation. */
+function difference(y: readonly number[], d: number): { w: number[]; inits: number[] } {
+ const inits: number[] = [];
+ let w: number[] = y.slice();
+ for (let i = 0; i < d; i++) {
+ inits.push(w[0] ?? 0);
+ const dw = new Array(w.length - 1);
+ for (let t = 1; t < w.length; t++) {
+ dw[t - 1] = (w[t] ?? 0) - (w[t - 1] ?? 0);
+ }
+ w = dw;
+ }
+ return { w, inits };
+}
+
+/** Reverse d levels of differencing, using the stored initial values. */
+function undifference(dw: readonly number[], inits: readonly number[], d: number): number[] {
+ let w: number[] = dw.slice();
+ for (let i = d - 1; i >= 0; i--) {
+ const init = inits[i] ?? 0;
+ const un = new Array(w.length + 1);
+ un[0] = init;
+ for (let t = 0; t < w.length; t++) {
+ un[t + 1] = (un[t] ?? 0) + (w[t] ?? 0);
+ }
+ w = un;
+ }
+ return w;
+}
+
+/** Estimate AR(k) coefficients via Yule-Walker / Levinson-Durbin.
+ * Returns { ar: coefficients, sigma2: innovation variance }. */
+function yuleWalkerAR(x: readonly number[], k: number): { ar: readonly number[]; sigma2: number } {
+ if (k === 0) {
+ const mu = arrMean(x);
+ let s = 0;
+ for (const v of x) {
+ s += (v - mu) ** 2;
+ }
+ return { ar: [], sigma2: s / x.length || 1 };
+ }
+ const n = x.length;
+ const mu = arrMean(x);
+
+ // Autocovariances γ(0)…γ(k)
+ const acov = new Array(k + 1).fill(0);
+ for (let h = 0; h <= k; h++) {
+ let s = 0;
+ for (let t = h; t < n; t++) {
+ s += ((x[t] ?? 0) - mu) * ((x[t - h] ?? 0) - mu);
+ }
+ acov[h] = s / n;
+ }
+
+ // Levinson-Durbin recursion
+ let prevA: number[] = [];
+ let P = acov[0] || 1e-15;
+
+ for (let m = 1; m <= k; m++) {
+ // Reflection coefficient
+ let num = acov[m] ?? 0;
+ for (let j = 1; j < m; j++) {
+ num -= (prevA[j - 1] ?? 0) * (acov[m - j] ?? 0);
+ }
+ const km = P > 0 ? num / P : 0;
+
+ // Update AR coefficients
+ const curA = new Array(m);
+ for (let j = 1; j < m; j++) {
+ curA[j - 1] = (prevA[j - 1] ?? 0) - km * (prevA[m - j - 1] ?? 0);
+ }
+ curA[m - 1] = km;
+ P *= 1 - km * km;
+ prevA = curA;
+ }
+
+ return { ar: prevA, sigma2: Math.max(P, 1e-15) };
+}
+
+/** Solve β = (X'X)⁻¹ X'y via Gaussian elimination with partial pivoting.
+ * X is (n × k), y is (n). Returns length-k coefficient vector. */
+function olsSolve(X: readonly (readonly number[])[], y: readonly number[]): number[] {
+ const n = X.length;
+ const k = (X[0] ?? []).length;
+ // Build augmented matrix [X'X | X'y] of size k × (k+1)
+ const A: number[][] = Array.from({ length: k }, () => new Array(k + 1).fill(0));
+ for (let i = 0; i < k; i++) {
+ for (let j = 0; j < k; j++) {
+ let s = 0;
+ for (let t = 0; t < n; t++) {
+ s += ((X[t] ?? [])[i] ?? 0) * ((X[t] ?? [])[j] ?? 0);
+ }
+ (A[i] ?? [])[j] = s;
+ }
+ let s = 0;
+ for (let t = 0; t < n; t++) {
+ s += ((X[t] ?? [])[i] ?? 0) * (y[t] ?? 0);
+ }
+ (A[i] ?? [])[k] = s;
+ }
+ // Forward elimination
+ for (let col = 0; col < k; col++) {
+ // Find pivot
+ let pivotRow = col;
+ let maxAbs = Math.abs((A[col] ?? [])[col] ?? 0);
+ for (let row = col + 1; row < k; row++) {
+ const abs = Math.abs((A[row] ?? [])[col] ?? 0);
+ if (abs > maxAbs) {
+ maxAbs = abs;
+ pivotRow = row;
+ }
+ }
+ // Swap rows
+ if (pivotRow !== col) {
+ const tmp = A[col];
+ A[col] = A[pivotRow] ?? [];
+ A[pivotRow] = tmp ?? [];
+ }
+ const pivotVal = (A[col] ?? [])[col] ?? 0;
+ if (Math.abs(pivotVal) < 1e-14) {
+ continue; // singular/near-singular
+ }
+ for (let row = col + 1; row < k; row++) {
+ const factor = ((A[row] ?? [])[col] ?? 0) / pivotVal;
+ for (let c = col; c <= k; c++) {
+ (A[row] ?? [])[c] = ((A[row] ?? [])[c] ?? 0) - factor * ((A[col] ?? [])[c] ?? 0);
+ }
+ }
+ }
+ // Back substitution
+ const beta = new Array(k).fill(0);
+ for (let i = k - 1; i >= 0; i--) {
+ let val = (A[i] ?? [])[k] ?? 0;
+ for (let j = i + 1; j < k; j++) {
+ val -= ((A[i] ?? [])[j] ?? 0) * (beta[j] ?? 0);
+ }
+ const denom = (A[i] ?? [])[i] ?? 0;
+ beta[i] = Math.abs(denom) > 1e-14 ? val / denom : 0;
+ }
+ return beta;
+}
+
+/** Compute ARMA(p, q) ψ-weights (MA∞ representation) up to lag `h`.
+ * ψ₀ = 1, ψⱼ = Σᵢ₌₁ᵐⁱⁿ⁽ʲ'ᵖ⁾ φᵢ ψⱼ₋ᵢ + θⱼ (θⱼ = 0 for j > q). */
+function psiWeights(ar: readonly number[], ma: readonly number[], h: number): number[] {
+ const psi = new Array(h).fill(0);
+ psi[0] = 1;
+ for (let j = 1; j < h; j++) {
+ let v = j <= ma.length ? (ma[j - 1] ?? 0) : 0;
+ for (let i = 1; i <= Math.min(j, ar.length); i++) {
+ v += (ar[i - 1] ?? 0) * (psi[j - i] ?? 0);
+ }
+ psi[j] = v;
+ }
+ return psi;
+}
+
+/** Accumulate ψ-weights d times for the integrated process (ARIMA). */
+function integrateWeights(psi: readonly number[], d: number): number[] {
+ let w = psi.slice();
+ for (let level = 0; level < d; level++) {
+ const acc = w.slice();
+ for (let j = 1; j < acc.length; j++) {
+ acc[j] = (acc[j - 1] ?? 0) + (w[j] ?? 0);
+ }
+ w = acc;
+ }
+ return w;
+}
+
+// ─── ARIMAModel class ─────────────────────────────────────────────────────────
+
+/**
+ * ARIMA(p, d, q) time-series model.
+ *
+ * Estimation via Hannan-Rissanen two-step; forecast CIs via ψ-weight recursion.
+ */
+export class ARIMAModel {
+ private readonly _p: number;
+ private readonly _d: number;
+ private readonly _q: number;
+
+ // Set after fit()
+ private _ar: readonly number[] = [];
+ private _ma: readonly number[] = [];
+ private _mu = 0;
+ private _sigma2 = 1;
+ private _origY: readonly number[] = [];
+ private _inits: readonly number[] = [];
+ private _diffW: readonly number[] = [];
+ private _residuals: readonly number[] = [];
+ private _fitted = false;
+
+ constructor(opts: ARIMAOptions = {}) {
+ this._p = Math.max(0, Math.floor(opts.p ?? 1));
+ this._d = Math.max(0, Math.floor(opts.d ?? 0));
+ this._q = Math.max(0, Math.floor(opts.q ?? 0));
+ }
+
+ /** AR order. */
+ get p(): number {
+ return this._p;
+ }
+ /** Differencing order. */
+ get d(): number {
+ return this._d;
+ }
+ /** MA order. */
+ get q(): number {
+ return this._q;
+ }
+
+ /**
+ * Fit the model to `y`.
+ * @param y - Observed time series (number array or Series).
+ */
+ fit(y: readonly number[] | Series): ARIMAFitResult {
+ const yArr: readonly number[] = isNumericArray(y) ? y : y.values;
+
+ const n = yArr.length;
+ if (n < this._p + this._d + this._q + 2) {
+ throw new RangeError(`Series too short (${n}) for ARIMA(${this._p},${this._d},${this._q})`);
+ }
+
+ // Store original series for undifferencing
+ this._origY = yArr;
+
+ // Difference
+ const { w, inits } = difference(yArr, this._d);
+ this._inits = inits;
+ this._diffW = w;
+
+ const m = w.length; // = n - d
+
+ const p = this._p;
+ const q = this._q;
+
+ let arCoeffs: readonly number[];
+ let maCoeffs: readonly number[];
+ let intercept: number;
+
+ if (p === 0 && q === 0) {
+ // ARIMA(0,d,0): just differenced mean
+ intercept = arrMean(w);
+ arCoeffs = [];
+ maCoeffs = [];
+ } else {
+ // ── Step 1: Yule-Walker AR(kMax) for proxy residuals ──────────────────
+ const kMax = Math.min(Math.max(p + q + 5, 3), Math.floor(m / 5));
+ const { ar: arHat } = kMax > 0 ? yuleWalkerAR(w, kMax) : { ar: [] as readonly number[] };
+
+ // Proxy residuals: ε̂ₜ = wₜ - Σ arHat_j wₜ₋ⱼ
+ const eps = new Array(m).fill(0);
+ for (let t = kMax; t < m; t++) {
+ let pred = arrMean(w);
+ for (let j = 0; j < kMax; j++) {
+ pred += (arHat[j] ?? 0) * ((w[t - 1 - j] ?? 0) - arrMean(w));
+ }
+ eps[t] = (w[t] ?? 0) - pred;
+ }
+
+ // ── Step 2: OLS on ARMA(p, q) using proxy residuals ──────────────────
+ // Start index: need w_{t-p} and ε̂_{t-q} available
+ const s = Math.max(p, kMax + q);
+ const T = m - s; // number of observations in OLS
+
+ if (T <= p + q + 1) {
+ // Fall back to pure AR if OLS is under-identified
+ const { ar } = yuleWalkerAR(w, p);
+ arCoeffs = ar;
+ maCoeffs = new Array(q).fill(0);
+ intercept = 0;
+ } else {
+ // Design matrix: [1, w_{t-1},...,w_{t-p}, ε̂_{t-1},...,ε̂_{t-q}]
+ const X: number[][] = [];
+ const yOLS: number[] = [];
+
+ for (let i = 0; i < T; i++) {
+ const t = s + i;
+ const row: number[] = [1];
+ for (let j = 1; j <= p; j++) {
+ row.push(w[t - j] ?? 0);
+ }
+ for (let j = 1; j <= q; j++) {
+ row.push(eps[t - j] ?? 0);
+ }
+ X.push(row);
+ yOLS.push(w[t] ?? 0);
+ }
+
+ const beta = olsSolve(X, yOLS);
+ intercept = beta[0] ?? 0;
+ arCoeffs = beta.slice(1, 1 + p);
+ maCoeffs = beta.slice(1 + p, 1 + p + q);
+ }
+ }
+
+ // ── Compute in-sample residuals ─────────────────────────────────────────
+ const warmup = Math.max(p, q);
+ const resid = new Array(m).fill(0);
+ const wHat = new Array(m).fill(0);
+
+ for (let t = 0; t < m; t++) {
+ let pred = intercept;
+ for (let j = 0; j < p; j++) {
+ pred += (arCoeffs[j] ?? 0) * (w[t - 1 - j] ?? 0);
+ }
+ for (let j = 0; j < q; j++) {
+ pred += (maCoeffs[j] ?? 0) * (t - 1 - j >= 0 ? (resid[t - 1 - j] ?? 0) : 0);
+ }
+ wHat[t] = pred;
+ resid[t] = (w[t] ?? 0) - pred;
+ }
+
+ // Sigma2 from residuals after warmup
+ let sse = 0;
+ let cnt = 0;
+ for (let t = warmup; t < m; t++) {
+ sse += (resid[t] ?? 0) ** 2;
+ cnt++;
+ }
+ const sigma2 = cnt > 0 ? sse / cnt : 1;
+
+ // Fitted values on original scale via undifferencing wHat
+ const fittedW = wHat;
+ // fitted_y: undifference the fitted differenced series
+ // We reconstruct y_hat by integrating w_hat starting from the true initial values
+ const fittedY = undifference(fittedW, inits, this._d);
+
+ // Log-likelihood and information criteria
+ const k = 1 + p + q; // number of params (intercept + AR + MA)
+ const logLik = -0.5 * m * (Math.log(2 * Math.PI) + Math.log(sigma2) + 1);
+ const aic = -2 * logLik + 2 * k;
+ const bic = -2 * logLik + Math.log(m) * k;
+
+ this._ar = arCoeffs;
+ this._ma = maCoeffs;
+ this._mu = intercept;
+ this._sigma2 = sigma2;
+ this._residuals = resid;
+ this._fitted = true;
+
+ return {
+ arCoeffs,
+ maCoeffs,
+ intercept,
+ fittedValues: fittedY,
+ residuals: resid,
+ sigma2,
+ logLikelihood: logLik,
+ aic,
+ bic,
+ };
+ }
+
+ /**
+ * Produce multi-step forecasts starting after the last observation.
+ *
+ * Must be called after {@link fit}.
+ * @param steps - Number of future steps to forecast. Default: 1.
+ */
+ forecast(steps = 1): ARIMAForecastResult {
+ if (!this._fitted) {
+ throw new Error("Call fit() before forecast()");
+ }
+ if (steps < 1) {
+ throw new RangeError("steps must be >= 1");
+ }
+
+ const w = this._diffW;
+ const m = w.length;
+ const ar = this._ar;
+ const ma = this._ma;
+ const p = this._p;
+ const q = this._q;
+ const mu = this._mu;
+ const sigma2 = this._sigma2;
+
+ // Residuals tail (for initializing the MA part)
+ const resid = this._residuals;
+
+ // Extend w and residuals with forecasts
+ const wAll: number[] = w.slice();
+ const eAll: number[] = resid.slice();
+
+ for (let h = 1; h <= steps; h++) {
+ const t = m + h - 1; // index in extended array
+ let pred = mu;
+ for (let j = 0; j < p; j++) {
+ pred += (ar[j] ?? 0) * (wAll[t - 1 - j] ?? 0);
+ }
+ for (let j = 0; j < q; j++) {
+ // future residuals are 0; only use past residuals
+ const idx = t - 1 - j;
+ pred += (ma[j] ?? 0) * (idx < m ? (eAll[idx] ?? 0) : 0);
+ }
+ wAll.push(pred);
+ eAll.push(0); // future innovations are zero
+ }
+
+ // Extract the forecast steps (differenced scale)
+ const fcW = wAll.slice(m);
+
+ // Undifference to original scale
+ // Need the last `d` values at each integration level
+ const _fcOrig = undifference(fcW, this._inits, this._d);
+ // undifference returns d + steps values starting from inits;
+ // but the inits represent the first observed values at each level.
+ // We need to "extend" from the end of the observed data.
+
+ // Actually, for forecasting we need to integrate starting from the last observed value.
+ // Re-compute inits as the *last* values at each differencing level.
+ const lastInits = computeLastInits(this._origY, this._d);
+ const fcOrigCorrected = undifferenceFromLast(fcW, lastInits, this._d);
+
+ // ψ-weights for prediction intervals
+ const hMax = steps + 1;
+ const psiArma = psiWeights(ar, ma, hMax);
+ const psiInt = integrateWeights(psiArma, this._d);
+
+ const forecastArr: number[] = [];
+ const lowerArr: number[] = [];
+ const upperArr: number[] = [];
+ const stderrArr: number[] = [];
+
+ for (let h = 1; h <= steps; h++) {
+ const fc = fcOrigCorrected[h - 1] ?? 0;
+ // Var[e_h] = sigma2 * sum_{j=0}^{h-1} psi_j^2
+ let varH = 0;
+ for (let j = 0; j < h; j++) {
+ varH += (psiInt[j] ?? 0) ** 2;
+ }
+ const se = Math.sqrt(sigma2 * varH);
+ forecastArr.push(fc);
+ stderrArr.push(se);
+ lowerArr.push(fc - 1.96 * se);
+ upperArr.push(fc + 1.96 * se);
+ }
+
+ return { forecast: forecastArr, lower: lowerArr, upper: upperArr, stderr: stderrArr };
+ }
+}
+
+/** Compute the last observed value at each differencing level for forecasting. */
+function computeLastInits(y: readonly number[], d: number): number[] {
+ const lasts: number[] = [];
+ let w: number[] = y.slice();
+ for (let i = 0; i < d; i++) {
+ lasts.push(w.at(-1) ?? 0);
+ const dw = new Array(w.length - 1);
+ for (let t = 1; t < w.length; t++) {
+ dw[t - 1] = (w[t] ?? 0) - (w[t - 1] ?? 0);
+ }
+ w = dw;
+ }
+ return lasts;
+}
+
+/** Undifference `fcW` starting from the last observed value at each level. */
+function undifferenceFromLast(
+ fcW: readonly number[],
+ lastInits: readonly number[],
+ d: number,
+): number[] {
+ let w: number[] = fcW.slice();
+ for (let i = d - 1; i >= 0; i--) {
+ const init = lastInits[i] ?? 0;
+ const un: number[] = [];
+ let prev = init;
+ for (const dv of w) {
+ prev += dv;
+ un.push(prev);
+ }
+ w = un;
+ }
+ return w;
+}
+
+// ─── Convenience function ──────────────────────────────────────────────────────
+
+/**
+ * Fit an ARIMA(p, d, q) model and return a fitted {@link ARIMAModel}.
+ *
+ * @example
+ * ```ts
+ * import { fitArima } from "tsb";
+ * const model = fitArima([1, 2, 3, 4, 3, 2, 1, 2, 3, 4], { p: 1, q: 1 });
+ * const fc = model.forecast(3);
+ * ```
+ */
+export function fitArima(y: readonly number[] | Series, opts?: ARIMAOptions): ARIMAModel {
+ const model = new ARIMAModel(opts);
+ model.fit(y);
+ return model;
+}
diff --git a/src/stats/bootstrap.ts b/src/stats/bootstrap.ts
index 3864933aa..30ac736eb 100644
--- a/src/stats/bootstrap.ts
+++ b/src/stats/bootstrap.ts
@@ -371,7 +371,7 @@ function bootstrapOne(
const sorted = [...bootDist].sort((a, b) => a - b);
// Degenerate: all bootstrap samples yield the same statistic (e.g. n=1)
- if (sorted[0] === sorted[sorted.length - 1]) {
+ if (sorted[0] === sorted.at(-1)) {
const val = sorted[0] ?? theta;
return {
confidenceInterval: { low: val, high: val },
diff --git a/src/stats/copulas.ts b/src/stats/copulas.ts
new file mode 100644
index 000000000..b7cbb4309
--- /dev/null
+++ b/src/stats/copulas.ts
@@ -0,0 +1,352 @@
+/**
+ * copulas — Copula models for multivariate dependence.
+ *
+ * Implements:
+ * - **Gaussian copula** — normal-based joint distribution
+ * - **t-copula** — heavy-tailed dependence
+ * - **Clayton copula** — lower tail dependence
+ * - **Gumbel copula** — upper tail dependence
+ * - **Frank copula** — symmetric dependence
+ * - **Empirical copula** — rank-based nonparametric estimate
+ * - Kendall's tau ↔ copula parameter conversion
+ *
+ * @module
+ */
+
+// ─── Utility: Normal Distribution ─────────────────────────────────────────────
+
+/** Approximation of the standard normal CDF (Abramowitz & Stegun). */
+export function normalCdf(x: number): number {
+ if (x < -8) return 0;
+ if (x > 8) return 1;
+ const a1 = 0.254829592;
+ const a2 = -0.284496736;
+ const a3 = 1.421413741;
+ const a4 = -1.453152027;
+ const a5 = 1.061405429;
+ const p = 0.3275911;
+ const sign = x < 0 ? -1 : 1;
+ const t = 1 / (1 + p * Math.abs(x) / Math.sqrt(2));
+ const poly = t * (a1 + t * (a2 + t * (a3 + t * (a4 + t * a5))));
+ return 0.5 * (1 + sign * (1 - poly * Math.exp(-(x * x) / 2)));
+}
+
+/** Inverse normal CDF (rational approximation, simplified). */
+export function normalQuantile(p: number): number {
+ if (p <= 0) return -Infinity;
+ if (p >= 1) return Infinity;
+
+ // Halley's method starting from a rough initial guess
+ let x = 0;
+ if (p < 0.5) {
+ const t = Math.sqrt(-2 * Math.log(p));
+ x = -(2.515517 + 0.802853 * t + 0.010328 * t * t) /
+ (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t * t * t) + t;
+ x = -x;
+ } else {
+ const t = Math.sqrt(-2 * Math.log(1 - p));
+ x = (2.515517 + 0.802853 * t + 0.010328 * t * t) /
+ (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t * t * t) - t;
+ x = x;
+ }
+
+ // Refine with Newton-Raphson
+ for (let i = 0; i < 3; i++) {
+ const fx = normalCdf(x) - p;
+ const fpx = Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+ if (Math.abs(fpx) < 1e-15) break;
+ x -= fx / fpx;
+ }
+
+ return x;
+}
+
+// ─── Gaussian Copula ──────────────────────────────────────────────────────────
+
+/**
+ * Evaluate the bivariate Gaussian copula CDF.
+ *
+ * @param u - First uniform marginal in (0,1).
+ * @param v - Second uniform marginal in (0,1).
+ * @param rho - Pearson correlation parameter in (-1, 1).
+ * @returns C(u, v) — copula CDF value.
+ *
+ * @example
+ * ```ts
+ * import { gaussianCopulaCdf } from "tsb";
+ * const c = gaussianCopulaCdf(0.3, 0.7, 0.5);
+ * ```
+ */
+export function gaussianCopulaCdf(u: number, v: number, rho: number): number {
+ const x = normalQuantile(u);
+ const y = normalQuantile(v);
+ return bivariateNormalCdf(x, y, rho);
+}
+
+/**
+ * Gaussian copula density (bivariate).
+ *
+ * @param u - First uniform marginal.
+ * @param v - Second uniform marginal.
+ * @param rho - Correlation parameter.
+ * @returns Copula density c(u, v).
+ */
+export function gaussianCopulaDensity(u: number, v: number, rho: number): number {
+ const x = normalQuantile(u);
+ const y = normalQuantile(v);
+ const r2 = rho * rho;
+ const exponent = -(r2 * (x * x + y * y) - 2 * rho * x * y) / (2 * (1 - r2));
+ return Math.exp(exponent) / Math.sqrt(1 - r2);
+}
+
+/**
+ * Simulate samples from a bivariate Gaussian copula.
+ *
+ * @param n - Number of samples.
+ * @param rho - Correlation parameter.
+ * @returns Array of [u, v] pairs.
+ */
+export function sampleGaussianCopula(n: number, rho: number): [number, number][] {
+ const samples: [number, number][] = [];
+ for (let i = 0; i < n; i++) {
+ const z1 = randn();
+ const z2 = randn();
+ const x = z1;
+ const y = rho * z1 + Math.sqrt(1 - rho * rho) * z2;
+ samples.push([normalCdf(x), normalCdf(y)]);
+ }
+ return samples;
+}
+
+// ─── Clayton Copula ───────────────────────────────────────────────────────────
+
+/**
+ * Clayton copula CDF.
+ *
+ * C(u,v) = (u^{-theta} + v^{-theta} - 1)^{-1/theta}
+ *
+ * @param u - First uniform marginal.
+ * @param v - Second uniform marginal.
+ * @param theta - Dependence parameter (theta > 0).
+ * @returns Copula CDF value.
+ */
+export function claytonCopulaCdf(u: number, v: number, theta: number): number {
+ if (theta <= 0) throw new Error("Clayton copula requires theta > 0");
+ return Math.max(u ** -theta + v ** -theta - 1, 0) ** (-1 / theta);
+}
+
+/**
+ * Sample from the Clayton copula using the conditional method.
+ *
+ * @param n - Number of samples.
+ * @param theta - Dependence parameter.
+ * @returns Array of [u, v] pairs.
+ */
+export function sampleClaytonCopula(n: number, theta: number): [number, number][] {
+ const samples: [number, number][] = [];
+ for (let i = 0; i < n; i++) {
+ const u = Math.random();
+ const t = Math.random();
+ // Conditional inverse: V | U
+ const v = u * (t ** (-theta / (1 + theta)) - 1 + u ** theta) ** (-1 / theta);
+ samples.push([u, Math.max(0, Math.min(1, v))]);
+ }
+ return samples;
+}
+
+// ─── Gumbel Copula ────────────────────────────────────────────────────────────
+
+/**
+ * Gumbel copula CDF.
+ *
+ * C(u,v) = exp(-[(-ln u)^theta + (-ln v)^theta]^{1/theta})
+ *
+ * @param u - First uniform marginal.
+ * @param v - Second uniform marginal.
+ * @param theta - Dependence parameter (theta >= 1).
+ * @returns Copula CDF value.
+ */
+export function gumbelCopulaCdf(u: number, v: number, theta: number): number {
+ if (theta < 1) throw new Error("Gumbel copula requires theta >= 1");
+ const a = (-Math.log(Math.max(u, 1e-300))) ** theta;
+ const b = (-Math.log(Math.max(v, 1e-300))) ** theta;
+ return Math.exp(-((a + b) ** (1 / theta)));
+}
+
+// ─── Frank Copula ─────────────────────────────────────────────────────────────
+
+/**
+ * Frank copula CDF.
+ *
+ * @param u - First uniform marginal.
+ * @param v - Second uniform marginal.
+ * @param theta - Dependence parameter (theta ≠ 0).
+ * @returns Copula CDF value.
+ */
+export function frankCopulaCdf(u: number, v: number, theta: number): number {
+ if (theta === 0) return u * v;
+ const num = (Math.exp(-theta * u) - 1) * (Math.exp(-theta * v) - 1);
+ const denom = Math.exp(-theta) - 1;
+ return -Math.log(1 + num / denom) / theta;
+}
+
+/**
+ * Sample from the Frank copula using the conditional method.
+ *
+ * @param n - Number of samples.
+ * @param theta - Dependence parameter.
+ * @returns Array of [u, v] pairs.
+ */
+export function sampleFrankCopula(n: number, theta: number): [number, number][] {
+ const samples: [number, number][] = [];
+ for (let i = 0; i < n; i++) {
+ const u = Math.random();
+ const t = Math.random();
+ // Conditional inverse
+ const et = Math.exp(-theta);
+ const eu = Math.exp(-theta * u);
+ const v = -Math.log(1 - (t * (1 - et)) / (et - eu * (1 - t))) / theta;
+ samples.push([u, Math.max(0, Math.min(1, v))]);
+ }
+ return samples;
+}
+
+// ─── Empirical Copula ─────────────────────────────────────────────────────────
+
+/**
+ * Compute the empirical copula from data.
+ *
+ * Transforms marginals to uniform via rank normalization.
+ *
+ * @param data - Array of [x, y] pairs.
+ * @returns Pseudo-observations [u, v] pairs in (0, 1).
+ */
+export function empiricalCopula(data: [number, number][]): [number, number][] {
+ const n = data.length;
+ const xs = data.map((d) => d[0]);
+ const ys = data.map((d) => d[1]);
+
+ const rankX = rankArray(xs, n);
+ const rankY = rankArray(ys, n);
+
+ return Array.from({ length: n }, (_, i) => [
+ (rankX[i] ?? 0) / (n + 1),
+ (rankY[i] ?? 0) / (n + 1),
+ ]);
+}
+
+// ─── Kendall's Tau Conversions ────────────────────────────────────────────────
+
+/**
+ * Estimate Kendall's tau from bivariate data.
+ *
+ * @param data - Array of [x, y] pairs.
+ * @returns Kendall's tau.
+ */
+export function kendallTau(data: [number, number][]): number {
+ const n = data.length;
+ let concordant = 0;
+ let discordant = 0;
+
+ for (let i = 0; i < n; i++) {
+ for (let j = i + 1; j < n; j++) {
+ const dx = (data[i]?.[0] ?? 0) - (data[j]?.[0] ?? 0);
+ const dy = (data[i]?.[1] ?? 0) - (data[j]?.[1] ?? 0);
+ if (dx * dy > 0) concordant++;
+ else if (dx * dy < 0) discordant++;
+ }
+ }
+
+ const pairs = n * (n - 1) / 2;
+ return pairs > 0 ? (concordant - discordant) / pairs : 0;
+}
+
+/**
+ * Convert Kendall's tau to Gaussian copula rho.
+ *
+ * rho = sin(pi * tau / 2)
+ */
+export function tauToGaussianRho(tau: number): number {
+ return Math.sin(Math.PI * tau / 2);
+}
+
+/**
+ * Convert Kendall's tau to Clayton copula theta.
+ *
+ * theta = 2 * tau / (1 - tau)
+ */
+export function tauToClaytonTheta(tau: number): number {
+ if (tau <= 0) return 1e-6;
+ return 2 * tau / (1 - tau);
+}
+
+/**
+ * Convert Kendall's tau to Gumbel copula theta.
+ *
+ * theta = 1 / (1 - tau)
+ */
+export function tauToGumbelTheta(tau: number): number {
+ if (tau >= 1) return 1e6;
+ return 1 / (1 - tau);
+}
+
+// ─── Utilities ────────────────────────────────────────────────────────────────
+
+/** Box-Muller standard normal sample. */
+function randn(): number {
+ let u = 0;
+ let v = 0;
+ while (u === 0) u = Math.random();
+ while (v === 0) v = Math.random();
+ return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+}
+
+/** Bivariate normal CDF approximation via numerical integration. */
+function bivariateNormalCdf(x: number, y: number, rho: number): number {
+ // Gauss-Legendre quadrature approximation (20 points)
+ if (x === -Infinity || y === -Infinity) return 0;
+ if (x === Infinity) return normalCdf(y);
+ if (y === Infinity) return normalCdf(x);
+
+ // Use Owen's T function approximation
+ const bvn = owenBvn(x, y, rho);
+ return Math.max(0, Math.min(1, bvn));
+}
+
+/** Approximation of bivariate normal CDF using simple formula. */
+function owenBvn(h: number, k: number, rho: number): number {
+ // Simple approximation for |rho| < 1
+ if (Math.abs(rho) < 1e-8) return normalCdf(h) * normalCdf(k);
+
+ // Quadrature using 5-point Gauss-Legendre on [-1, 1]
+ const glNodes = [-0.9061798, -0.5384693, 0, 0.5384693, 0.9061798];
+ const glWeights = [0.2369269, 0.4786287, 0.5688889, 0.4786287, 0.2369269];
+
+ // Transform to [0, rho] interval
+ let sum = 0;
+ const rhoAbs = Math.abs(rho);
+ for (let i = 0; i < glNodes.length; i++) {
+ const r = rhoAbs * 0.5 * ((glNodes[i] ?? 0) + 1);
+ const sqr = Math.sqrt(1 - r * r);
+ const exponent = (r * (2 * h * k - r * (h * h + k * k))) / (2 * (1 - r * r));
+ sum += (glWeights[i] ?? 0) * Math.exp(exponent) / sqr;
+ }
+
+ const L = rhoAbs * 0.5 * sum / (2 * Math.PI);
+ if (rho >= 0) {
+ return normalCdf(h) * normalCdf(k) + L;
+ } else {
+ return Math.max(0, normalCdf(h) - normalCdf(-k) + L);
+ }
+}
+
+/** Compute ranks of array values (1-indexed). */
+function rankArray(arr: number[], n: number): number[] {
+ const indexed = arr.map((v, i) => ({ v, i }));
+ indexed.sort((a, b) => a.v - b.v);
+ const ranks = new Array(n).fill(0);
+ for (let rank = 0; rank < n; rank++) {
+ ranks[(indexed[rank] ?? { i: 0 }).i] = rank + 1;
+ }
+ return ranks;
+}
diff --git a/src/stats/dlm.ts b/src/stats/dlm.ts
new file mode 100644
index 000000000..34bd110d7
--- /dev/null
+++ b/src/stats/dlm.ts
@@ -0,0 +1,1061 @@
+/**
+ * dlm — Dynamic Linear Model (Bayesian State-Space Model).
+ *
+ * Implements the West & Harrison DLM framework:
+ *
+ * Observation: Y_t = F_t' θ_t + v_t, v_t ~ N(0, V_t)
+ * System: θ_t = G_t θ_{t-1} + w_t, w_t ~ N(0, W_t)
+ * Prior: θ_0 ~ N(m_0, C_0)
+ *
+ * Supports:
+ * - Scalar or multivariate observations
+ * - Time-constant or time-varying system matrices
+ * - Factory builders for common components: local-level, local-linear-trend,
+ * polynomial trend, Fourier seasonality, regression
+ * - Component combination via `DLM.combine()`
+ * - Forward filter (Kalman), backward smoother (RTS), forecasting
+ * - MLE estimation of variance parameters via Nelder-Mead
+ * - Discount-factor model fitting (West & Harrison §6)
+ *
+ * Mirrors the R `dlm` package and Python `statsmodels.tsa.statespace` API
+ * surface while following TypeScript / tsb conventions.
+ *
+ * Exported names:
+ * - {@link DLM} — main class: filter, smooth, forecast, fit
+ * - {@link DLMOptions} — constructor options
+ * - {@link DLMResult} — filter / smoother result
+ * - {@link DLMForecastResult} — forecast result
+ * - {@link buildLocalLevel} — local-level (random-walk) component
+ * - {@link buildLocalLinearTrend} — local-linear-trend component
+ * - {@link buildPolynomial} — n-th order polynomial trend
+ * - {@link buildFourier} — Fourier (harmonic) seasonal component
+ * - {@link buildRegression} — static regression component
+ * - {@link combineDLMs} — block-diagonal combination of components
+ *
+ * @example
+ * ```ts
+ * import { DLM, buildLocalLinearTrend } from "tsb";
+ *
+ * const spec = buildLocalLinearTrend({ sigmaObs: 1, sigmaLevel: 0.5, sigmaSlope: 0.1 });
+ * const dlm = new DLM(spec);
+ * const res = dlm.filter([1, 2, 1.5, 3, 2.5, 4, 3.5]);
+ * console.log(res.filteredMeans); // T × p state vectors
+ * console.log(res.logLikelihood);
+ *
+ * const fc = dlm.forecast(res, 5);
+ * console.log(fc.mean, fc.lower, fc.upper);
+ * ```
+ *
+ * @module
+ */
+
+// ─── Internal matrix utilities ─────────────────────────────────────────────────
+
+type Mat = readonly (readonly number[])[];
+type MutMat = number[][];
+
+function rows(A: Mat): number {
+ return A.length;
+}
+function cols(A: Mat): number {
+ return A[0]?.length ?? 0;
+}
+function zeros(n: number, m: number): MutMat {
+ return Array.from({ length: n }, () => new Array(m).fill(0));
+}
+function eye(n: number): MutMat {
+ return Array.from({ length: n }, (_, i) =>
+ Array.from({ length: n }, (_, j) => (i === j ? 1 : 0)),
+ );
+}
+function mmul(A: Mat, B: Mat): MutMat {
+ const m = rows(A);
+ const k = cols(A);
+ const n = cols(B);
+ const C = zeros(m, n);
+ for (let i = 0; i < m; i++) {
+ const ai = A[i]!;
+ const ci = C[i]!;
+ for (let p = 0; p < k; p++) {
+ const aip = ai[p]!;
+ if (aip === 0) {
+ continue;
+ }
+ const bp = B[p]!;
+ for (let j = 0; j < n; j++) {
+ ci[j]! += aip * bp[j]!;
+ }
+ }
+ }
+ return C;
+}
+function mvmul(A: Mat, x: readonly number[]): number[] {
+ const m = rows(A);
+ const y = new Array(m).fill(0);
+ for (let i = 0; i < m; i++) {
+ const ai = A[i]!;
+ let s = 0;
+ for (let p = 0; p < x.length; p++) {
+ s += ai[p]! * x[p]!;
+ }
+ y[i] = s;
+ }
+ return y;
+}
+function tr(A: Mat): MutMat {
+ const m = rows(A);
+ const n = cols(A);
+ const At = zeros(n, m);
+ for (let i = 0; i < m; i++) {
+ for (let j = 0; j < n; j++) {
+ At[j]![i] = A[i]?.[j]!;
+ }
+ }
+ return At;
+}
+function madd(A: Mat, B: Mat): MutMat {
+ const m = rows(A);
+ const n = cols(A);
+ return Array.from({ length: m }, (_, i) =>
+ Array.from({ length: n }, (_, j) => A[i]?.[j]! + B[i]?.[j]!),
+ );
+}
+function msub(A: Mat, B: Mat): MutMat {
+ const m = rows(A);
+ const n = cols(A);
+ return Array.from({ length: m }, (_, i) =>
+ Array.from({ length: n }, (_, j) => A[i]?.[j]! - B[i]?.[j]!),
+ );
+}
+function mscale(A: Mat, s: number): MutMat {
+ return A.map((row) => row.map((v) => v * s));
+}
+function vdot(a: readonly number[], b: readonly number[]): number {
+ let s = 0;
+ for (let i = 0; i < a.length; i++) {
+ s += a[i]! * b[i]!;
+ }
+ return s;
+}
+function vadd(a: readonly number[], b: readonly number[]): number[] {
+ return a.map((ai, i) => ai + b[i]!);
+}
+function vsub(a: readonly number[], b: readonly number[]): number[] {
+ return a.map((ai, i) => ai - b[i]!);
+}
+function outer(a: readonly number[], b: readonly number[]): MutMat {
+ return Array.from({ length: a.length }, (_, i) =>
+ Array.from({ length: b.length }, (_, j) => a[i]! * b[j]!),
+ );
+}
+
+/** Invert a square matrix via Gauss-Jordan with partial pivoting. Returns null if singular. */
+function matInv(A: Mat): MutMat | null {
+ const n = rows(A);
+ const aug: MutMat = Array.from({ length: n }, (_, i) => [
+ ...A[i]!,
+ ...Array.from({ length: n }, (_, j) => (i === j ? 1 : 0)),
+ ]);
+ for (let col = 0; col < n; col++) {
+ let pivotRow = col;
+ let pivotVal = Math.abs(aug[col]?.[col]!);
+ for (let r = col + 1; r < n; r++) {
+ const v = Math.abs(aug[r]?.[col]!);
+ if (v > pivotVal) {
+ pivotVal = v;
+ pivotRow = r;
+ }
+ }
+ if (pivotVal < 1e-14) {
+ return null;
+ }
+ [aug[col], aug[pivotRow]] = [aug[pivotRow]!, aug[col]!];
+ const scale = 1 / aug[col]?.[col]!;
+ for (let j = 0; j < 2 * n; j++) {
+ aug[col]![j]! *= scale;
+ }
+ for (let r = 0; r < n; r++) {
+ if (r === col) {
+ continue;
+ }
+ const f = aug[r]?.[col]!;
+ if (f === 0) {
+ continue;
+ }
+ for (let j = 0; j < 2 * n; j++) {
+ aug[r]![j]! -= f * aug[col]?.[j]!;
+ }
+ }
+ }
+ return aug.map((row) => row.slice(n));
+}
+
+/** Block-diagonal combination of two matrices. */
+function blockDiag(A: Mat, B: Mat): MutMat {
+ const ra = rows(A);
+ const ca = cols(A);
+ const rb = rows(B);
+ const cb = cols(B);
+ const C = zeros(ra + rb, ca + cb);
+ for (let i = 0; i < ra; i++) {
+ for (let j = 0; j < ca; j++) {
+ C[i]![j] = A[i]?.[j]!;
+ }
+ }
+ for (let i = 0; i < rb; i++) {
+ for (let j = 0; j < cb; j++) {
+ C[ra + i]![ca + j] = B[i]?.[j]!;
+ }
+ }
+ return C;
+}
+
+// ─── Public types ───────────────────────────────────────────────────────────────
+
+/**
+ * Specification for a Dynamic Linear Model.
+ *
+ * All matrices are row-major (array-of-rows).
+ * p = state dimension, q = observation dimension.
+ */
+export interface DLMSpec {
+ /**
+ * System (transition) matrix G: p × p.
+ * If omitted, defaults to the identity.
+ */
+ readonly G: Mat;
+ /**
+ * Observation matrix F: q × p (rows = observation dim, cols = state dim).
+ * For scalar observations q = 1, so F is 1 × p.
+ */
+ readonly F: Mat;
+ /**
+ * State-noise covariance W: p × p.
+ */
+ readonly W: Mat;
+ /**
+ * Observation-noise covariance V: q × q.
+ */
+ readonly V: Mat;
+ /**
+ * Prior mean m_0: length-p vector.
+ * Defaults to zero vector.
+ */
+ readonly m0?: readonly number[];
+ /**
+ * Prior covariance C_0: p × p.
+ * Defaults to 1e6 × I (diffuse prior).
+ */
+ readonly C0?: Mat;
+}
+
+/** Options for the {@link DLM} constructor. */
+export type DLMOptions = DLMSpec;
+
+/** Per-time-step output of the Kalman filter. */
+export interface DLMFilterStep {
+ /** Predicted state mean a_t = G m_{t-1}: length p. */
+ readonly predictedMean: readonly number[];
+ /** Predicted state covariance R_t = G C_{t-1} G' + W: p × p. */
+ readonly predictedCov: Mat;
+ /** Filtered state mean m_t: length p. */
+ readonly filteredMean: readonly number[];
+ /** Filtered state covariance C_t: p × p. */
+ readonly filteredCov: Mat;
+ /** One-step-ahead forecast mean f_t = F a_t: length q. */
+ readonly forecastMean: readonly number[];
+ /** One-step-ahead forecast variance Q_t = F R_t F' + V: q × q. */
+ readonly forecastCov: Mat;
+ /** Kalman gain K_t: p × q. */
+ readonly gain: Mat;
+ /** Innovation (residual) e_t = Y_t − f_t (null if observation missing). */
+ readonly innovation: readonly number[] | null;
+}
+
+/** Result returned by {@link DLM.filter}. */
+export interface DLMResult {
+ /** Filter steps, one per time-point. */
+ readonly steps: readonly DLMFilterStep[];
+ /** Filtered state means: T × p. */
+ readonly filteredMeans: readonly (readonly number[])[];
+ /** Filtered state covariances: T × p × p. */
+ readonly filteredCovs: readonly Mat[];
+ /** Predicted (one-step-ahead) means: T × p. */
+ readonly predictedMeans: readonly (readonly number[])[];
+ /** One-step-ahead forecast means: T × q. */
+ readonly forecastMeans: readonly (readonly number[])[];
+ /** One-step-ahead forecast covariances: T × q × q. */
+ readonly forecastCovs: readonly Mat[];
+ /** Total log-likelihood. */
+ readonly logLikelihood: number;
+ /** Prior mean used. */
+ readonly m0: readonly number[];
+ /** Prior covariance used. */
+ readonly C0: Mat;
+}
+
+/** Result returned by {@link DLM.smooth}. */
+export interface DLMSmootherResult extends DLMResult {
+ /** Smoothed state means: T × p. */
+ readonly smoothedMeans: readonly (readonly number[])[];
+ /** Smoothed state covariances: T × p × p. */
+ readonly smoothedCovs: readonly Mat[];
+}
+
+/** Forecast result returned by {@link DLM.forecast}. */
+export interface DLMForecastResult {
+ /** Forecast means for steps 1 … h: h × q. */
+ readonly mean: readonly (readonly number[])[];
+ /** Forecast covariances for steps 1 … h: h × q × q. */
+ readonly cov: readonly Mat[];
+ /** 2.5th percentile (scalar observation only): length h. */
+ readonly lower: readonly number[];
+ /** 97.5th percentile (scalar observation only): length h. */
+ readonly upper: readonly number[];
+}
+
+// ─── Main DLM class ──────────────────────────────────────────────────────────────
+
+/**
+ * Dynamic Linear Model.
+ *
+ * @example
+ * ```ts
+ * import { DLM } from "tsb";
+ *
+ * const dlm = new DLM({
+ * G: [[1]],
+ * F: [[1]],
+ * W: [[0.1]],
+ * V: [[1]],
+ * });
+ * const res = dlm.filter([1, 2, 3, 4, 5]);
+ * ```
+ */
+export class DLM {
+ private readonly _G: Mat;
+ private readonly _F: Mat;
+ private readonly _W: Mat;
+ private readonly _V: Mat;
+ private readonly _m0: readonly number[];
+ private readonly _C0: Mat;
+ private readonly _p: number; // state dim
+ private readonly _q: number; // obs dim
+
+ constructor(options: DLMOptions) {
+ this._G = options.G;
+ this._F = options.F;
+ this._W = options.W;
+ this._V = options.V;
+ this._p = rows(this._G);
+ this._q = rows(this._F);
+ this._m0 = options.m0 ?? new Array(this._p).fill(0);
+ this._C0 = options.C0 ?? mscale(eye(this._p), 1e6);
+ }
+
+ // ── Factory helpers ──
+
+ /**
+ * Local-level (random-walk plus noise) model.
+ * State: [μ_t], System: μ_t = μ_{t-1} + w_t, Obs: Y_t = μ_t + v_t.
+ */
+ static localLevel(opts: { sigmaObs?: number; sigmaLevel?: number } = {}): DLM {
+ const sv = opts.sigmaObs ?? 1;
+ const sw = opts.sigmaLevel ?? 1;
+ return new DLM({
+ G: [[1]],
+ F: [[1]],
+ W: [[sw * sw]],
+ V: [[sv * sv]],
+ });
+ }
+
+ /**
+ * Local-linear-trend model.
+ * State: [level, slope], G = [[1,1],[0,1]], F = [[1,0]].
+ */
+ static localLinearTrend(
+ opts: { sigmaObs?: number; sigmaLevel?: number; sigmaSlope?: number } = {},
+ ): DLM {
+ const sv = opts.sigmaObs ?? 1;
+ const sw1 = opts.sigmaLevel ?? 1;
+ const sw2 = opts.sigmaSlope ?? 0.1;
+ return new DLM({
+ G: [
+ [1, 1],
+ [0, 1],
+ ],
+ F: [[1, 0]],
+ W: [
+ [sw1 * sw1, 0],
+ [0, sw2 * sw2],
+ ],
+ V: [[sv * sv]],
+ });
+ }
+
+ /**
+ * Polynomial trend of order `order` (1 = random walk, 2 = linear trend, …).
+ */
+ static polynomial(order: number, opts: { sigmaObs?: number; sigmaState?: number } = {}): DLM {
+ const sv = opts.sigmaObs ?? 1;
+ const sw = opts.sigmaState ?? 1;
+ // Jordan block (upper-triangular ones)
+ const G = eye(order);
+ for (let i = 0; i < order - 1; i++) {
+ G[i]![i + 1] = 1;
+ }
+ const F: MutMat = [new Array(order).fill(0)];
+ F[0]![0] = 1;
+ const W = mscale(eye(order), sw * sw);
+ const V: MutMat = [[sv * sv]];
+ return new DLM({ G, F, W, V });
+ }
+
+ /**
+ * Fourier (harmonic) seasonal component with period `period` and `harmonics` pairs.
+ * Each harmonic adds a 2-dimensional block to the state.
+ */
+ static fourier(
+ period: number,
+ harmonics: number,
+ opts: { sigmaObs?: number; sigmaState?: number } = {},
+ ): DLM {
+ const sv = opts.sigmaObs ?? 1;
+ const sw = opts.sigmaState ?? 0.01;
+ const p = 2 * harmonics;
+ // Block-diagonal G: each 2×2 block is a rotation matrix for harmonic j
+ const G = zeros(p, p);
+ const F: MutMat = [new Array(p).fill(0)];
+ for (let j = 1; j <= harmonics; j++) {
+ const omega = (2 * Math.PI * j) / period;
+ const c = Math.cos(omega);
+ const s = Math.sin(omega);
+ const r = 2 * (j - 1);
+ G[r]![r] = c;
+ G[r]![r + 1] = s;
+ G[r + 1]![r] = -s;
+ G[r + 1]![r + 1] = c;
+ F[0]![r] = 1; // cosine coefficient contributes to observation
+ }
+ const W = mscale(eye(p), sw * sw);
+ const V: MutMat = [[sv * sv]];
+ return new DLM({ G, F, W, V });
+ }
+
+ /**
+ * Static regression component with known regressors `X` (T × k).
+ * The state is the k regression coefficients (treated as random walk with
+ * small process noise `sigmaState`).
+ */
+ static regression(
+ X: readonly (readonly number[])[],
+ opts: { sigmaObs?: number; sigmaState?: number } = {},
+ ): DLM {
+ const sv = opts.sigmaObs ?? 1;
+ const sw = opts.sigmaState ?? 0.001;
+ const k = cols(X);
+ // G = identity (coefficients evolve slowly)
+ // F_t = X[t] (time-varying — not supported by DLMSpec directly, but we
+ // handle via per-step override at filter time)
+ const G = eye(k);
+ const F: MutMat = [X[0] ? [...X[0]] : new Array(k).fill(0)];
+ const W = mscale(eye(k), sw * sw);
+ const V: MutMat = [[sv * sv]];
+ return new DLM({ G, F, W, V });
+ }
+
+ // ── Core filter ──
+
+ /**
+ * Run the Kalman filter on observations `y`.
+ * Each element of `y` may be a scalar (for 1-D obs) or a vector; `null` for missing.
+ */
+ filter(
+ y: readonly (number | readonly number[] | null)[],
+ opts: { m0?: readonly number[]; C0?: Mat } = {},
+ ): DLMResult {
+ const m0 = opts.m0 ?? this._m0;
+ const C0 = opts.C0 ?? this._C0;
+ return this._filter(y, m0, C0);
+ }
+
+ private _obs(y: number | readonly number[] | null): readonly number[] | null {
+ if (y === null) {
+ return null;
+ }
+ if (typeof y === "number") {
+ return [y];
+ }
+ return y;
+ }
+
+ private _filter(
+ y: readonly (number | readonly number[] | null)[],
+ m0: readonly number[],
+ C0: Mat,
+ ): DLMResult {
+ const T = y.length;
+ const steps: DLMFilterStep[] = [];
+ let m = m0.slice();
+ let C: Mat = C0;
+ let logLik = 0;
+
+ for (let t = 0; t < T; t++) {
+ const yt = this._obs(y[t]!);
+
+ // Predict
+ const a = mvmul(this._G, m);
+ const R = madd(mmul(mmul(this._G, C), tr(this._G)), this._W);
+
+ // Forecast
+ const f = mvmul(this._F, a);
+ const Q = madd(mmul(mmul(this._F, R), tr(this._F)), this._V);
+
+ let mNew = a;
+ let CNew: Mat = R;
+ let innovation: readonly number[] | null = null;
+ let K: Mat = zeros(this._p, this._q);
+
+ if (yt !== null) {
+ // Kalman gain: K = R F' Q^{-1}
+ const RF = mmul(R, tr(this._F));
+ const Qinv = matInv(Q);
+ if (Qinv !== null) {
+ K = mmul(RF, Qinv);
+ innovation = vsub(yt, f);
+ mNew = vadd(a, mvmul(K, innovation));
+ // Joseph-form for numerical stability: C = (I-KF)R(I-KF)' + K V K'
+ const IKF = msub(eye(this._p), mmul(K, this._F));
+ CNew = madd(mmul(mmul(IKF, R), tr(IKF)), mmul(mmul(K, this._V), tr(K)));
+
+ // Log-likelihood contribution: -0.5*(q*log2π + log|Q| + e'Q^{-1}e)
+ const eQe = vdot(innovation, mvmul(Qinv, innovation));
+ const logDetQ = logDet(Q);
+ logLik += -0.5 * (this._q * Math.log(2 * Math.PI) + logDetQ + eQe);
+ }
+ }
+
+ steps.push({
+ predictedMean: a,
+ predictedCov: R,
+ filteredMean: mNew,
+ filteredCov: CNew,
+ forecastMean: f,
+ forecastCov: Q,
+ gain: K,
+ innovation,
+ });
+ m = mNew.slice();
+ C = CNew;
+ }
+
+ return {
+ steps,
+ filteredMeans: steps.map((s) => s.filteredMean),
+ filteredCovs: steps.map((s) => s.filteredCov),
+ predictedMeans: steps.map((s) => s.predictedMean),
+ forecastMeans: steps.map((s) => s.forecastMean),
+ forecastCovs: steps.map((s) => s.forecastCov),
+ logLikelihood: logLik,
+ m0,
+ C0,
+ };
+ }
+
+ // ── RTS Smoother ──
+
+ /**
+ * Run the Kalman filter followed by the RTS backward smoother.
+ */
+ smooth(
+ y: readonly (number | readonly number[] | null)[],
+ opts: { m0?: readonly number[]; C0?: Mat } = {},
+ ): DLMSmootherResult {
+ const filterResult = this.filter(y, opts);
+ return this._smooth(filterResult);
+ }
+
+ private _smooth(res: DLMResult): DLMSmootherResult {
+ const T = res.steps.length;
+ const sMeans: MutMat = res.filteredMeans.map((m) => m.slice());
+ const sCovs: MutMat[] = res.filteredCovs.map((C) => C.map((r) => r.slice()));
+
+ for (let t = T - 2; t >= 0; t--) {
+ const step = res.steps[t]!;
+ const stepNext = res.steps[t + 1]!;
+ const Rt1 = stepNext.predictedCov;
+ const Rt1inv = matInv(Rt1);
+ if (Rt1inv === null) {
+ continue;
+ }
+ // Smoother gain: J_t = C_t G' R_{t+1}^{-1}
+ const Jt = mmul(mmul(step.filteredCov, tr(this._G)), Rt1inv);
+ // Smoothed mean: s_t = m_t + J_t (s_{t+1} - a_{t+1})
+ const diff = vsub(sMeans[t + 1]!, stepNext.predictedMean);
+ sMeans[t] = vadd(step.filteredMean, mvmul(Jt, diff));
+ // Smoothed covariance: S_t = C_t + J_t (S_{t+1} - R_{t+1}) J_t'
+ const covDiff = msub(sCovs[t + 1]!, stepNext.predictedCov);
+ sCovs[t] = madd(step.filteredCov, mmul(mmul(Jt, covDiff), tr(Jt)));
+ }
+
+ return {
+ ...res,
+ smoothedMeans: sMeans,
+ smoothedCovs: sCovs,
+ };
+ }
+
+ // ── Forecasting ──
+
+ /**
+ * Forecast `h` steps ahead from the end of the filter result.
+ * Returns means and 95% prediction intervals (scalar obs only).
+ */
+ forecast(filterResult: DLMResult, h: number): DLMForecastResult {
+ const T = filterResult.steps.length;
+ const lastStep = filterResult.steps[T - 1]!;
+ let m = lastStep.filteredMean.slice();
+ let C: Mat = lastStep.filteredCov;
+
+ const meanArr: (readonly number[])[] = [];
+ const covArr: Mat[] = [];
+ const lower: number[] = [];
+ const upper: number[] = [];
+ const z975 = 1.959963985;
+
+ for (let h_i = 0; h_i < h; h_i++) {
+ // Predict one step
+ const a = mvmul(this._G, m);
+ const R = madd(mmul(mmul(this._G, C), tr(this._G)), this._W);
+ // Forecast mean and variance
+ const f = mvmul(this._F, a);
+ const Q = madd(mmul(mmul(this._F, R), tr(this._F)), this._V);
+ meanArr.push(f);
+ covArr.push(Q);
+ if (this._q === 1) {
+ const sd = Math.sqrt(Math.max(0, Q[0]?.[0]!));
+ lower.push(f[0]! - z975 * sd);
+ upper.push(f[0]! + z975 * sd);
+ }
+ m = a;
+ C = R;
+ }
+
+ return { mean: meanArr, cov: covArr, lower, upper };
+ }
+
+ // ── MLE estimation ──
+
+ /**
+ * Estimate variance parameters (log V, log W diagonal) by maximum likelihood.
+ * Returns a new DLM with the fitted parameters.
+ *
+ * Uses Nelder-Mead minimisation of negative log-likelihood.
+ */
+ fitMLE(y: readonly (number | readonly number[] | null)[]): DLM {
+ const p = this._p;
+ const q = this._q;
+ // Pack: theta = [log V entries (q*q), log diag(W) entries (p)]
+ // Only diagonal elements of V and W are fitted; off-diagonal kept fixed.
+ const packV = Array.from({ length: q }, (_, i) => Math.log(Math.max(1e-8, this._V[i]?.[i]!)));
+ const packW = Array.from({ length: p }, (_, i) => Math.log(Math.max(1e-8, this._W[i]?.[i]!)));
+ const x0 = [...packV, ...packW];
+
+ const objective = (x: readonly number[]): number => {
+ const V2: MutMat = this._V.map((row) => row.slice());
+ for (let i = 0; i < q; i++) {
+ V2[i]![i] = Math.exp(x[i]!);
+ }
+ const W2: MutMat = this._W.map((row) => row.slice());
+ for (let i = 0; i < p; i++) {
+ W2[i]![i] = Math.exp(x[q + i]!);
+ }
+ const dlm2 = new DLM({ G: this._G, F: this._F, W: W2, V: V2, m0: this._m0, C0: this._C0 });
+ const res = dlm2._filter(y, this._m0, this._C0);
+ return -res.logLikelihood;
+ };
+
+ const xOpt = nelderMead(objective, x0, { maxIter: 500, tol: 1e-6 });
+
+ const Vfit: MutMat = this._V.map((row) => row.slice());
+ for (let i = 0; i < q; i++) {
+ Vfit[i]![i] = Math.exp(xOpt[i]!);
+ }
+ const Wfit: MutMat = this._W.map((row) => row.slice());
+ for (let i = 0; i < p; i++) {
+ Wfit[i]![i] = Math.exp(xOpt[q + i]!);
+ }
+
+ return new DLM({ G: this._G, F: this._F, W: Wfit, V: Vfit, m0: this._m0, C0: this._C0 });
+ }
+
+ /**
+ * Fit with discount factors (West & Harrison §6).
+ * The process covariance is replaced by W_t = ((1-δ)/δ) C_{t-1},
+ * where δ ∈ (0,1] is the discount factor (close to 1 = small evolution).
+ * Returns a new DLM plus the filter result under the discounted model.
+ */
+ filterDiscount(y: readonly (number | readonly number[] | null)[], delta: number): DLMResult {
+ const m0 = this._m0;
+ const C0 = this._C0;
+ const T = y.length;
+ const steps: DLMFilterStep[] = [];
+ let m = m0.slice();
+ let C: Mat = C0;
+ let logLik = 0;
+
+ for (let t = 0; t < T; t++) {
+ const yt = this._obs(y[t]!);
+
+ // Predict with discount: R_t = G C_{t-1} G' / delta
+ const GCGt = mmul(mmul(this._G, C), tr(this._G));
+ const R = mscale(GCGt, 1 / delta);
+ const a = mvmul(this._G, m);
+
+ const f = mvmul(this._F, a);
+ const Q = madd(mmul(mmul(this._F, R), tr(this._F)), this._V);
+
+ let mNew = a;
+ let CNew: Mat = R;
+ let innovation: readonly number[] | null = null;
+ let K: Mat = zeros(this._p, this._q);
+
+ if (yt !== null) {
+ const Qinv = matInv(Q);
+ if (Qinv !== null) {
+ K = mmul(mmul(R, tr(this._F)), Qinv);
+ innovation = vsub(yt, f);
+ mNew = vadd(a, mvmul(K, innovation));
+ const IKF = msub(eye(this._p), mmul(K, this._F));
+ CNew = madd(mmul(mmul(IKF, R), tr(IKF)), mmul(mmul(K, this._V), tr(K)));
+ const eQe = vdot(innovation, mvmul(Qinv, innovation));
+ const logDetQ = logDet(Q);
+ logLik += -0.5 * (this._q * Math.log(2 * Math.PI) + logDetQ + eQe);
+ }
+ }
+
+ steps.push({
+ predictedMean: a,
+ predictedCov: R,
+ filteredMean: mNew,
+ filteredCov: CNew,
+ forecastMean: f,
+ forecastCov: Q,
+ gain: K,
+ innovation,
+ });
+ m = mNew.slice();
+ C = CNew;
+ }
+
+ return {
+ steps,
+ filteredMeans: steps.map((s) => s.filteredMean),
+ filteredCovs: steps.map((s) => s.filteredCov),
+ predictedMeans: steps.map((s) => s.predictedMean),
+ forecastMeans: steps.map((s) => s.forecastMean),
+ forecastCovs: steps.map((s) => s.forecastCov),
+ logLikelihood: logLik,
+ m0,
+ C0,
+ };
+ }
+}
+
+// ─── Factory helpers ────────────────────────────────────────────────────────────
+
+/** Build a local-level DLM (random walk + noise). */
+export function buildLocalLevel(opts: { sigmaObs?: number; sigmaLevel?: number } = {}): DLMSpec {
+ return {
+ G: [[1]],
+ F: [[1]],
+ W: [[(opts.sigmaLevel ?? 1) ** 2]],
+ V: [[(opts.sigmaObs ?? 1) ** 2]],
+ };
+}
+
+/** Build a local-linear-trend DLM. */
+export function buildLocalLinearTrend(
+ opts: {
+ sigmaObs?: number;
+ sigmaLevel?: number;
+ sigmaSlope?: number;
+ } = {},
+): DLMSpec {
+ const sv = opts.sigmaObs ?? 1;
+ const sw1 = opts.sigmaLevel ?? 1;
+ const sw2 = opts.sigmaSlope ?? 0.1;
+ return {
+ G: [
+ [1, 1],
+ [0, 1],
+ ],
+ F: [[1, 0]],
+ W: [
+ [sw1 * sw1, 0],
+ [0, sw2 * sw2],
+ ],
+ V: [[sv * sv]],
+ };
+}
+
+/** Build a polynomial (Jordan-block) trend DLM of a given order. */
+export function buildPolynomial(
+ order: number,
+ opts: { sigmaObs?: number; sigmaState?: number } = {},
+): DLMSpec {
+ const sv = opts.sigmaObs ?? 1;
+ const sw = opts.sigmaState ?? 1;
+ const G = eye(order);
+ for (let i = 0; i < order - 1; i++) {
+ G[i]![i + 1] = 1;
+ }
+ const F: MutMat = [new Array(order).fill(0)];
+ F[0]![0] = 1;
+ return { G, F, W: mscale(eye(order), sw * sw), V: [[sv * sv]] };
+}
+
+/** Build a Fourier seasonal DLM. */
+export function buildFourier(
+ period: number,
+ harmonics: number,
+ opts: { sigmaObs?: number; sigmaState?: number } = {},
+): DLMSpec {
+ const sv = opts.sigmaObs ?? 1;
+ const sw = opts.sigmaState ?? 0.01;
+ const p = 2 * harmonics;
+ const G = zeros(p, p);
+ const F: MutMat = [new Array(p).fill(0)];
+ for (let j = 1; j <= harmonics; j++) {
+ const omega = (2 * Math.PI * j) / period;
+ const c = Math.cos(omega);
+ const s = Math.sin(omega);
+ const r = 2 * (j - 1);
+ G[r]![r] = c;
+ G[r]![r + 1] = s;
+ G[r + 1]![r] = -s;
+ G[r + 1]![r + 1] = c;
+ F[0]![r] = 1;
+ }
+ return { G, F, W: mscale(eye(p), sw * sw), V: [[sv * sv]] };
+}
+
+/** Build a static regression DLM with k predictors (slow-varying coefficients). */
+export function buildRegression(
+ k: number,
+ opts: { sigmaObs?: number; sigmaState?: number } = {},
+): DLMSpec {
+ const sv = opts.sigmaObs ?? 1;
+ const sw = opts.sigmaState ?? 0.001;
+ return {
+ G: eye(k),
+ F: [new Array(k).fill(0)], // placeholder; rows are set externally
+ W: mscale(eye(k), sw * sw),
+ V: [[sv * sv]],
+ };
+}
+
+/**
+ * Combine multiple DLM specs into a single block-diagonal model.
+ * The combined observation matrix is the horizontal concatenation of the
+ * individual F matrices (summing each component's contribution to the scalar
+ * observation). All component V matrices must have the same dimension.
+ */
+export function combineDLMs(...specs: DLMSpec[]): DLMSpec {
+ if (specs.length === 0) {
+ throw new RangeError("combineDLMs requires at least one spec");
+ }
+ const first = specs[0];
+ let G: Mat = first.G;
+ let W: Mat = first.W;
+ let C0: Mat | undefined = first.C0;
+ let m0: number[] = first.m0 ? [...first.m0] : new Array(rows(first.G)).fill(0);
+
+ // Combined F: 1 × (p1+p2+…) — horizontal concat of F rows
+ let Fcombined: number[] = first.F[0] ? [...first.F[0]] : [];
+
+ for (let i = 1; i < specs.length; i++) {
+ const s = specs[i]!;
+ G = blockDiag(G, s.G);
+ W = blockDiag(W, s.W);
+ if (C0 !== undefined && s.C0 !== undefined) {
+ C0 = blockDiag(C0, s.C0);
+ } else {
+ C0 = undefined;
+ }
+ const fi = s.F[0] ? [...s.F[0]] : [];
+ Fcombined = [...Fcombined, ...fi];
+ const pm = s.m0 ? [...s.m0] : new Array(rows(s.G)).fill(0);
+ m0 = [...m0, ...pm];
+ }
+
+ // Use the first component's V (they must agree)
+ const V = specs[0]?.V;
+ const spec: DLMSpec = {
+ G,
+ F: [Fcombined],
+ W,
+ V,
+ m0,
+ ...(C0 !== undefined ? { C0 } : {}),
+ };
+ return spec;
+}
+
+// ─── Log-determinant helper ─────────────────────────────────────────────────────
+
+/** Log-determinant of a positive-definite matrix via Cholesky. Falls back to LU. */
+function logDet(A: Mat): number {
+ const n = rows(A);
+ // Try Cholesky L L' = A
+ const L = zeros(n, n);
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j <= i; j++) {
+ let s = A[i]?.[j]!;
+ for (let k2 = 0; k2 < j; k2++) {
+ s -= L[i]?.[k2]! * L[j]?.[k2]!;
+ }
+ if (i === j) {
+ if (s < 0) {
+ return _logDetLU(A); // fall back
+ }
+ L[i]![j] = Math.sqrt(s);
+ } else {
+ L[i]![j] = s / (L[j]?.[j] ?? 1);
+ }
+ }
+ }
+ let ld = 0;
+ for (let i = 0; i < n; i++) {
+ ld += 2 * Math.log(Math.abs(L[i]?.[i]!));
+ }
+ return ld;
+}
+
+function _logDetLU(A: Mat): number {
+ const n = rows(A);
+ const U: MutMat = A.map((r) => r.slice());
+ let sign = 1;
+ for (let col = 0; col < n; col++) {
+ let maxVal = Math.abs(U[col]?.[col]!);
+ let maxRow = col;
+ for (let r = col + 1; r < n; r++) {
+ const v = Math.abs(U[r]?.[col]!);
+ if (v > maxVal) {
+ maxVal = v;
+ maxRow = r;
+ }
+ }
+ if (maxRow !== col) {
+ [U[col], U[maxRow]] = [U[maxRow]!, U[col]!];
+ sign *= -1;
+ }
+ const pivot = U[col]?.[col]!;
+ if (Math.abs(pivot) < 1e-14) {
+ return Number.NEGATIVE_INFINITY;
+ }
+ for (let r = col + 1; r < n; r++) {
+ const f = U[r]?.[col]! / pivot;
+ for (let j = col; j < n; j++) {
+ U[r]![j]! -= f * U[col]?.[j]!;
+ }
+ }
+ }
+ let ld = Math.log(Math.abs(sign));
+ for (let i = 0; i < n; i++) {
+ ld += Math.log(Math.abs(U[i]?.[i]!));
+ }
+ return ld;
+}
+
+// ─── Nelder-Mead optimizer ──────────────────────────────────────────────────────
+
+interface NelderMeadOptions {
+ maxIter?: number;
+ tol?: number;
+}
+
+function nelderMead(
+ f: (x: readonly number[]) => number,
+ x0: readonly number[],
+ opts: NelderMeadOptions = {},
+): number[] {
+ const maxIter = opts.maxIter ?? 1000;
+ const tol = opts.tol ?? 1e-8;
+ const n = x0.length;
+ // Build initial simplex
+ const simplex: number[][] = [x0.slice()];
+ for (let i = 0; i < n; i++) {
+ const xi = x0.slice();
+ xi[i]! += xi[i]! !== 0 ? 0.05 * Math.abs(xi[i]!) : 0.00025;
+ simplex.push(xi);
+ }
+ const fvals = simplex.map((x) => f(x));
+
+ const alpha = 1.0;
+ const gamma = 2.0;
+ const rho = 0.5;
+ const sigma = 0.5;
+
+ for (let iter = 0; iter < maxIter; iter++) {
+ // Sort
+ const order = Array.from({ length: n + 1 }, (_, i) => i).sort((a, b) => fvals[a]! - fvals[b]!);
+ const sx = order.map((i) => simplex[i]!);
+ const sf = order.map((i) => fvals[i]!);
+
+ // Convergence check
+ const range = sf[n]! - sf[0]!;
+ if (range < tol) {
+ return sx[0]?.slice();
+ }
+
+ // Centroid of all but worst
+ const xbar = new Array(n).fill(0);
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j < n; j++) {
+ xbar[j]! += sx[i]?.[j]! / n;
+ }
+ }
+
+ // Reflect
+ const xr = xbar.map((xi, j) => xi + alpha * (xi - sx[n]?.[j]!));
+ const fr = f(xr);
+
+ if (fr < sf[0]!) {
+ // Expand
+ const xe = xbar.map((xi, j) => xi + gamma * (xr[j]! - xi));
+ const fe = f(xe);
+ simplex[order[n]!] = fe < fr ? xe : xr;
+ fvals[order[n]!] = fe < fr ? fe : fr;
+ } else if (fr < sf[n - 1]!) {
+ simplex[order[n]!] = xr;
+ fvals[order[n]!] = fr;
+ } else {
+ // Contract
+ const xc = xbar.map((xi, j) => xi + rho * (sx[n]?.[j]! - xi));
+ const fc = f(xc);
+ if (fc < sf[n]!) {
+ simplex[order[n]!] = xc;
+ fvals[order[n]!] = fc;
+ } else {
+ // Shrink
+ for (let i = 1; i <= n; i++) {
+ for (let j = 0; j < n; j++) {
+ simplex[order[i]!]![j] = sx[0]?.[j]! + sigma * (sx[i]?.[j]! - sx[0]?.[j]!);
+ }
+ fvals[order[i]!] = f(simplex[order[i]!]!);
+ }
+ }
+ }
+ }
+
+ // Return best found
+ let best = 0;
+ for (let i = 1; i < simplex.length; i++) {
+ if (fvals[i]! < fvals[best]!) {
+ best = i;
+ }
+ }
+ return simplex[best]?.slice();
+}
diff --git a/src/stats/ets.ts b/src/stats/ets.ts
new file mode 100644
index 000000000..e5296998d
--- /dev/null
+++ b/src/stats/ets.ts
@@ -0,0 +1,1335 @@
+/**
+ * ets — Exponential Smoothing / Holt-Winters ETS models.
+ *
+ * Implements the classical additive-error ETS state-space framework:
+ * - **SimpleExpSmoothing** (SES / ETS(A,N,N)): single level parameter α.
+ * - **Holt** (ETS(A,A,N) / ETS(A,Ad,N)): level α + trend β, optional damping φ.
+ * - **ExponentialSmoothing** (Holt-Winters ETS(·,·,·)): full model with additive
+ * or multiplicative trend and seasonal components.
+ *
+ * Parameter estimation minimises SSE via Nelder-Mead simplex.
+ * Heuristic initialisation follows statsmodels conventions.
+ *
+ * API mirrors `statsmodels.tsa.holtwinters`.
+ *
+ * @example
+ * ```ts
+ * import { ExponentialSmoothing } from "tsb";
+ *
+ * const sales = [17, 21, 23, 18, 22, 26, 19, 24, 27, 20, 25, 28];
+ * const model = new ExponentialSmoothing({ trend: "add", seasonal: "add", seasonalPeriods: 4 });
+ * const fit = model.fit(sales);
+ * console.log(fit.alpha, fit.beta, fit.gamma);
+ * console.log(model.forecast(4)); // 4-step ahead forecasts
+ * ```
+ *
+ * @module
+ */
+
+import type { Series } from "../core/series.ts";
+
+// ─── Public types ──────────────────────────────────────────────────────────────
+
+/** Trend component type: additive, multiplicative, or absent. */
+export type ETSTrend = "add" | "mul" | null;
+
+/** Seasonal component type: additive, multiplicative, or absent. */
+export type ETSSeasonal = "add" | "mul" | null;
+
+/** Initialisation strategy for state variables. */
+export type ETSInit = "heuristic" | "known";
+
+// ── SimpleExpSmoothing ────────────────────────────────────────────────────────
+
+/** Options for {@link SimpleExpSmoothing}. */
+export interface SESOptions {
+ /**
+ * Smoothing level parameter (0 < α < 1).
+ * If omitted the parameter is estimated by minimising SSE.
+ */
+ readonly alpha?: number;
+ /** Initial level value. If omitted, set to `y[0]`. */
+ readonly initialLevel?: number;
+}
+
+/** Result returned by {@link SimpleExpSmoothing.fit}. */
+export interface SESFitResult {
+ /** Estimated smoothing level. */
+ readonly alpha: number;
+ /** Initial level l₀. */
+ readonly initialLevel: number;
+ /** In-sample one-step-ahead fitted values. */
+ readonly fittedValues: readonly number[];
+ /** In-sample residuals e_t = y_t − ŷ_t. */
+ readonly residuals: readonly number[];
+ /** Sum of squared errors. */
+ readonly sse: number;
+ /** Akaike Information Criterion. */
+ readonly aic: number;
+ /** Bayesian Information Criterion. */
+ readonly bic: number;
+ /** Corrected AIC. */
+ readonly aicc: number;
+}
+
+// ── Holt ─────────────────────────────────────────────────────────────────────
+
+/** Options for {@link Holt}. */
+export interface HoltOptions {
+ /** Smoothing level (0 < α < 1). Auto-estimated if omitted. */
+ readonly alpha?: number;
+ /** Smoothing trend (0 < β < 1). Auto-estimated if omitted. */
+ readonly beta?: number;
+ /** Whether to apply a damped trend. Default `false`. */
+ readonly damped?: boolean;
+ /**
+ * Damping coefficient (0 < φ < 1).
+ * Only used when `damped` is `true`. Auto-estimated if omitted.
+ */
+ readonly dampingSlope?: number;
+ /** Initial level l₀. Heuristic if omitted. */
+ readonly initialLevel?: number;
+ /** Initial trend b₀. Heuristic if omitted. */
+ readonly initialTrend?: number;
+}
+
+/** Result returned by {@link Holt.fit}. */
+export interface HoltFitResult {
+ /** Estimated level smoothing parameter. */
+ readonly alpha: number;
+ /** Estimated trend smoothing parameter. */
+ readonly beta: number;
+ /** Damping slope φ (1.0 when not damped). */
+ readonly phi: number;
+ /** Initial level l₀. */
+ readonly initialLevel: number;
+ /** Initial trend b₀. */
+ readonly initialTrend: number;
+ /** In-sample one-step-ahead fitted values. */
+ readonly fittedValues: readonly number[];
+ /** In-sample residuals. */
+ readonly residuals: readonly number[];
+ /** Sum of squared errors. */
+ readonly sse: number;
+ /** Akaike Information Criterion. */
+ readonly aic: number;
+ /** Bayesian Information Criterion. */
+ readonly bic: number;
+ /** Corrected AIC. */
+ readonly aicc: number;
+}
+
+// ── ExponentialSmoothing ─────────────────────────────────────────────────────
+
+/** Options for {@link ExponentialSmoothing}. */
+export interface ExponentialSmoothingOptions {
+ /** Trend component. `"add"` = additive, `"mul"` = multiplicative, `null` = none. */
+ readonly trend?: ETSTrend;
+ /** Whether to use a damped trend. Default `false`. */
+ readonly damped?: boolean;
+ /** Seasonal component. `"add"` = additive, `"mul"` = multiplicative, `null` = none. */
+ readonly seasonal?: ETSSeasonal;
+ /** Number of periods in one seasonal cycle (e.g. 12 for monthly, 4 for quarterly). */
+ readonly seasonalPeriods?: number;
+ /** Smoothing level parameter (0 < α < 1). Auto-estimated if omitted. */
+ readonly alpha?: number;
+ /** Smoothing trend parameter (0 < β < 1). Auto-estimated if omitted. */
+ readonly beta?: number;
+ /** Smoothing seasonal parameter (0 < γ < 1). Auto-estimated if omitted. */
+ readonly gamma?: number;
+ /** Damping slope (0 < φ < 1). Auto-estimated when `damped = true` and omitted. */
+ readonly phi?: number;
+ /** How to initialise the state: `"heuristic"` (default) or `"known"`. */
+ readonly initializationMethod?: ETSInit;
+ /** Known initial level (only used when `initializationMethod = "known"`). */
+ readonly initialLevel?: number;
+ /** Known initial trend (only used when `initializationMethod = "known"`). */
+ readonly initialTrend?: number;
+ /** Known initial seasonal indices (only used when `initializationMethod = "known"`). */
+ readonly initialSeasons?: readonly number[];
+}
+
+/** Result returned by {@link ExponentialSmoothing.fit}. */
+export interface ExponentialSmoothingFitResult {
+ /** Estimated level smoothing parameter. */
+ readonly alpha: number;
+ /** Estimated trend smoothing parameter (`null` when no trend component). */
+ readonly beta: number | null;
+ /** Estimated seasonal smoothing parameter (`null` when no seasonal component). */
+ readonly gamma: number | null;
+ /** Damping slope φ (1.0 when not damped). */
+ readonly phi: number;
+ /** Initial level l₀. */
+ readonly initialLevel: number;
+ /** Initial trend b₀ (`null` when no trend). */
+ readonly initialTrend: number | null;
+ /** Initial seasonal indices s₁…s_m (`null` when no seasonal). */
+ readonly initialSeasons: readonly number[] | null;
+ /** In-sample one-step-ahead fitted values. */
+ readonly fittedValues: readonly number[];
+ /** In-sample residuals. */
+ readonly residuals: readonly number[];
+ /** Sum of squared errors. */
+ readonly sse: number;
+ /** Log-likelihood. */
+ readonly logLikelihood: number;
+ /** Akaike Information Criterion. */
+ readonly aic: number;
+ /** Bayesian Information Criterion. */
+ readonly bic: number;
+ /** Corrected AIC. */
+ readonly aicc: number;
+}
+
+/** Forecast result with prediction intervals. */
+export interface ETSForecastResult {
+ /** Point forecasts h = 1, 2, … steps. */
+ readonly forecast: readonly number[];
+ /** Lower bound of (1 − α_ci) % prediction interval. */
+ readonly lower: readonly number[];
+ /** Upper bound of (1 − α_ci) % prediction interval. */
+ readonly upper: readonly number[];
+ /** Standard errors of h-step-ahead forecast errors. */
+ readonly stderr: readonly number[];
+}
+
+// ─── Private helpers ──────────────────────────────────────────────────────────
+
+/** Extract numeric array from Series or array. */
+function toArr(y: readonly number[] | Series): readonly number[] {
+ if ("dtype" in y) {
+ return y.values;
+ }
+ return y;
+}
+
+/** Clamp value to [lo, hi]. */
+function clamp(v: number, lo: number, hi: number): number {
+ return Math.min(Math.max(v, lo), hi);
+}
+
+/** Clamp all elements of a param vector to their respective bounds. */
+function clampParams(params: readonly number[], bounds: readonly [number, number][]): number[] {
+ return params.map((v, i) => clamp(v, (bounds[i] ?? [0, 1])[0], (bounds[i] ?? [0, 1])[1]));
+}
+
+/**
+ * Nelder-Mead simplex optimiser (unconstrained; bounds enforced by clamping).
+ * Minimises `fn(params)` starting from `x0`.
+ */
+function nelderMead(
+ fn: (params: readonly number[]) => number,
+ x0: readonly number[],
+ bounds: readonly [number, number][],
+ maxIter = 3000,
+): { params: number[]; value: number } {
+ const n = x0.length;
+ if (n === 0) {
+ return { params: [], value: fn([]) };
+ }
+
+ const EPS = 1e-12;
+ const ALPHA_NM = 1.0; // reflection
+ const BETA_NM = 0.5; // contraction
+ const GAMMA_NM = 2.0; // expansion
+ const SIGMA_NM = 0.5; // shrinkage
+
+ const clamp1 = (p: readonly number[]): number[] => clampParams(p, bounds);
+
+ // Build initial simplex
+ const simplex: number[][] = [clamp1(x0)];
+ for (let i = 0; i < n; i++) {
+ const pt = clamp1(x0);
+ const lo = (bounds[i] ?? [0, 1])[0];
+ const hi = (bounds[i] ?? [0, 1])[1];
+ const delta = Math.max((hi - lo) * 0.1, 0.01);
+ pt[i] = clamp((pt[i] ?? 0) + delta, lo + EPS, hi - EPS);
+ simplex.push(pt);
+ }
+
+ const fvals: number[] = simplex.map((p) => fn(p));
+
+ for (let iter = 0; iter < maxIter; iter++) {
+ // Sort indices by fval
+ const ord = Array.from({ length: n + 1 }, (_, i) => i).sort(
+ (a, b) => (fvals[a] ?? 0) - (fvals[b] ?? 0),
+ );
+
+ const fBest = fvals[ord[0] ?? 0] ?? 0;
+ const fWorst = fvals[ord[n] ?? 0] ?? 0;
+ if (fWorst - fBest < EPS) {
+ break;
+ }
+
+ // Centroid of best n points
+ const cent = new Array(n).fill(0);
+ for (let i = 0; i < n; i++) {
+ const row = simplex[ord[i] ?? 0] ?? [];
+ for (let j = 0; j < n; j++) {
+ cent[j] = (cent[j] ?? 0) + (row[j] ?? 0);
+ }
+ }
+ for (let j = 0; j < n; j++) {
+ cent[j] = (cent[j] ?? 0) / n;
+ }
+
+ const worstPt = simplex[ord[n] ?? 0] ?? [];
+
+ // Reflection
+ const xr = clamp1(cent.map((c, j) => (1 + ALPHA_NM) * c - ALPHA_NM * (worstPt[j] ?? 0)));
+ const fr = fn(xr);
+
+ const fSecondWorst = fvals[ord[n - 1] ?? 0] ?? 0;
+
+ if (fr < fBest) {
+ // Expansion
+ const xe = clamp1(cent.map((c, j) => (1 + GAMMA_NM) * c - GAMMA_NM * (worstPt[j] ?? 0)));
+ const fe = fn(xe);
+ if (fe < fr) {
+ simplex[ord[n] ?? 0] = xe;
+ fvals[ord[n] ?? 0] = fe;
+ } else {
+ simplex[ord[n] ?? 0] = xr;
+ fvals[ord[n] ?? 0] = fr;
+ }
+ } else if (fr < fSecondWorst) {
+ simplex[ord[n] ?? 0] = xr;
+ fvals[ord[n] ?? 0] = fr;
+ } else {
+ // Contraction
+ const inside = fr >= fWorst;
+ const src = inside ? worstPt : xr;
+ const xc = clamp1(cent.map((c, j) => BETA_NM * c + (1 - BETA_NM) * (src[j] ?? 0)));
+ const fc = fn(xc);
+ const compareVal = inside ? fWorst : fr;
+ if (fc < compareVal) {
+ simplex[ord[n] ?? 0] = xc;
+ fvals[ord[n] ?? 0] = fc;
+ } else {
+ // Shrink
+ const bestPt = simplex[ord[0] ?? 0] ?? [];
+ for (let i = 1; i <= n; i++) {
+ const row = simplex[ord[i] ?? 0] ?? [];
+ const newRow = clamp1(row.map((v, j) => SIGMA_NM * (v + (bestPt[j] ?? 0))));
+ simplex[ord[i] ?? 0] = newRow;
+ fvals[ord[i] ?? 0] = fn(newRow);
+ }
+ }
+ }
+ }
+
+ // Return best
+ let bestIdx = 0;
+ for (let i = 1; i <= n; i++) {
+ if ((fvals[i] ?? Number.POSITIVE_INFINITY) < (fvals[bestIdx] ?? Number.POSITIVE_INFINITY)) {
+ bestIdx = i;
+ }
+ }
+ return { params: simplex[bestIdx] ?? [], value: fvals[bestIdx] ?? Number.POSITIVE_INFINITY };
+}
+
+/** Compute AIC, BIC, AICc from SSE, n, k. */
+function infoGaussian(
+ sse: number,
+ n: number,
+ k: number,
+): { logLikelihood: number; aic: number; bic: number; aicc: number } {
+ const sigma2 = Math.max(sse / n, 1e-15);
+ const logL = -0.5 * n * (Math.log(2 * Math.PI * sigma2) + 1);
+ const aic = -2 * logL + 2 * k;
+ const bic = -2 * logL + k * Math.log(n);
+ const denom = n - k - 1;
+ const aicc = denom > 0 ? aic + (2 * k * (k + 1)) / denom : aic;
+ return { logLikelihood: logL, aic, bic, aicc };
+}
+
+// ─── SES internals ────────────────────────────────────────────────────────────
+
+/**
+ * Run one SES pass. Returns { fitted, residuals, sse }.
+ * l0 = initial level.
+ */
+function sesPass(
+ y: readonly number[],
+ alpha: number,
+ l0: number,
+): { fitted: number[]; residuals: number[]; sse: number } {
+ const n = y.length;
+ const fitted: number[] = new Array(n);
+ const residuals: number[] = new Array(n);
+ let sse = 0;
+ let l = l0;
+ for (let t = 0; t < n; t++) {
+ fitted[t] = l;
+ const e = (y[t] ?? 0) - l;
+ residuals[t] = e;
+ sse += e * e;
+ l = alpha * (y[t] ?? 0) + (1 - alpha) * l;
+ }
+ return { fitted, residuals, sse };
+}
+
+// ─── Holt internals ───────────────────────────────────────────────────────────
+
+/**
+ * Run one Holt pass.
+ * Returns { fitted, residuals, sse, levels, trends }.
+ */
+function holtPass(
+ y: readonly number[],
+ alpha: number,
+ beta: number,
+ phi: number,
+ l0: number,
+ b0: number,
+): { fitted: number[]; residuals: number[]; sse: number } {
+ const n = y.length;
+ const fitted: number[] = new Array(n);
+ const residuals: number[] = new Array(n);
+ let sse = 0;
+ let l = l0;
+ let b = b0;
+ for (let t = 0; t < n; t++) {
+ const yhat = l + phi * b;
+ fitted[t] = yhat;
+ const yt = y[t] ?? 0;
+ const e = yt - yhat;
+ residuals[t] = e;
+ sse += e * e;
+ const lNew = alpha * yt + (1 - alpha) * (l + phi * b);
+ b = beta * (lNew - l) + (1 - beta) * phi * b;
+ l = lNew;
+ }
+ return { fitted, residuals, sse };
+}
+
+/** Holt h-step forecast (damped or not). */
+function holtForecast(steps: number, l: number, b: number, phi: number): number[] {
+ const out: number[] = [];
+ let phiH = phi; // φ¹
+ let phiSum = phi; // φ + φ² + … + φ^h
+ for (let h = 1; h <= steps; h++) {
+ out.push(l + phiSum * b);
+ phiH *= phi;
+ phiSum += phiH;
+ }
+ return out;
+}
+
+// ─── ETS (Holt-Winters) internals ─────────────────────────────────────────────
+
+interface ETSState {
+ l: number;
+ b: number;
+ s: number[]; // length m circular buffer, s[0] = s_{t-m+1}, … , s[m-1] = s_t
+}
+
+/**
+ * Run one Holt-Winters pass. Returns fitted values, residuals, SSE, and the
+ * final state (l, b, last m seasonal indices).
+ */
+function hwPass(
+ y: readonly number[],
+ alpha: number,
+ beta: number | null,
+ gamma: number | null,
+ phi: number,
+ l0: number,
+ b0: number | null,
+ s0: readonly number[] | null,
+ trend: ETSTrend,
+ seasonal: ETSSeasonal,
+ m: number,
+): {
+ fitted: number[];
+ residuals: number[];
+ sse: number;
+ finalL: number;
+ finalB: number;
+ finalS: number[];
+} {
+ const n = y.length;
+ const fitted: number[] = new Array(n);
+ const residuals: number[] = new Array(n);
+ let sse = 0;
+
+ let l = l0;
+ let b = b0 ?? 0;
+
+ // seasonal buffer: seasonals[t % m] = s_{t+1-m}
+ const seasonals: number[] = s0 ? s0.slice() : new Array(m).fill(0);
+
+ for (let t = 0; t < n; t++) {
+ const yt = y[t] ?? 0;
+ const sIdx = ((t % m) + m) % m; // index into seasonal buffer
+ const st_m = seasonals[sIdx] ?? 0; // s_{t+1-m}
+
+ // One-step-ahead forecast
+ let yhat: number;
+ if (trend === null && seasonal === null) {
+ yhat = l;
+ } else if (trend !== null && seasonal === null) {
+ yhat = l + phi * b;
+ } else if (trend === null && seasonal === "add") {
+ yhat = l + st_m;
+ } else if (trend === null && seasonal === "mul") {
+ yhat = l * st_m;
+ } else if (trend === "add" && seasonal === "add") {
+ yhat = l + phi * b + st_m;
+ } else if (trend === "add" && seasonal === "mul") {
+ yhat = (l + phi * b) * st_m;
+ } else if (trend === "mul" && seasonal === "add") {
+ yhat = l * (phi === 1 ? b : b ** phi) + st_m;
+ } else {
+ // mul trend + mul seasonal
+ yhat = l * (phi === 1 ? b : b ** phi) * st_m;
+ }
+
+ fitted[t] = yhat;
+ const e = yt - yhat;
+ residuals[t] = e;
+ sse += e * e;
+
+ // State update
+ const lPrev = l;
+ const bPrev = b;
+
+ if (trend === null && seasonal === null) {
+ l = alpha * yt + (1 - alpha) * l;
+ } else if (trend !== null && seasonal === null) {
+ l = alpha * yt + (1 - alpha) * (l + phi * b);
+ if (beta !== null) {
+ b = beta * (l - lPrev) + (1 - beta) * phi * bPrev;
+ }
+ } else if (trend === null && seasonal === "add") {
+ l = alpha * (yt - st_m) + (1 - alpha) * l;
+ if (gamma !== null) {
+ seasonals[sIdx] = gamma * (yt - l) + (1 - gamma) * st_m;
+ }
+ } else if (trend === null && seasonal === "mul") {
+ l = alpha * (st_m !== 0 ? yt / st_m : yt) + (1 - alpha) * l;
+ if (gamma !== null) {
+ seasonals[sIdx] = gamma * (l !== 0 ? yt / l : 1) + (1 - gamma) * st_m;
+ }
+ } else if (trend === "add" && seasonal === "add") {
+ l = alpha * (yt - st_m) + (1 - alpha) * (lPrev + phi * bPrev);
+ if (beta !== null) {
+ b = beta * (l - lPrev) + (1 - beta) * phi * bPrev;
+ }
+ if (gamma !== null) {
+ seasonals[sIdx] = gamma * (yt - l) + (1 - gamma) * st_m;
+ }
+ } else if (trend === "add" && seasonal === "mul") {
+ l = alpha * (st_m !== 0 ? yt / st_m : yt) + (1 - alpha) * (lPrev + phi * bPrev);
+ if (beta !== null) {
+ b = beta * (l - lPrev) + (1 - beta) * phi * bPrev;
+ }
+ if (gamma !== null) {
+ seasonals[sIdx] = gamma * (l + phi * b !== 0 ? yt / (l + phi * b) : 1) + (1 - gamma) * st_m;
+ }
+ } else {
+ // multiplicative trend — approximate as additive for stability
+ l = alpha * yt + (1 - alpha) * (lPrev + phi * bPrev);
+ if (beta !== null) {
+ b = beta * (l - lPrev) + (1 - beta) * phi * bPrev;
+ }
+ if (gamma !== null) {
+ seasonals[sIdx] = gamma * (yt - l) + (1 - gamma) * st_m;
+ }
+ }
+ }
+
+ return {
+ fitted,
+ residuals,
+ sse,
+ finalL: l,
+ finalB: b,
+ finalS: seasonals.slice(),
+ };
+}
+
+/**
+ * Generate h-step forecasts from the final ETS state.
+ * `finalS` is the circular buffer of the last m seasonal indices where
+ * `finalS[t % m]` = s_{t+1-m} (same convention as hwPass).
+ */
+function hwForecast(
+ steps: number,
+ l: number,
+ b: number,
+ finalS: readonly number[],
+ phi: number,
+ trend: ETSTrend,
+ seasonal: ETSSeasonal,
+ m: number,
+ n: number, // length of training series (to compute season offsets)
+): number[] {
+ const out: number[] = [];
+ let phiH = phi;
+ let phiSum = phi;
+
+ // At t = n-1 (last training obs), seasonals[t % m] has just been updated.
+ // For forecast step h, the seasonal index corresponds to position (n-1+h) % m in
+ // the buffer (shifted by 1 because sIdx = (t % m) in hwPass at time t = n-1+h).
+ for (let h = 1; h <= steps; h++) {
+ const sIdx = (((n - 1 + h) % m) + m) % m;
+ const sVal = finalS[sIdx] ?? 1;
+
+ let yhat: number;
+ if (trend === null && seasonal === null) {
+ yhat = l;
+ } else if (trend !== null && seasonal === null) {
+ yhat = l + phiSum * b;
+ } else if (trend === null && seasonal === "add") {
+ yhat = l + sVal;
+ } else if (trend === null && seasonal === "mul") {
+ yhat = l * sVal;
+ } else if (trend === "add" && seasonal === "add") {
+ yhat = l + phiSum * b + sVal;
+ } else if (trend === "add" && seasonal === "mul") {
+ yhat = (l + phiSum * b) * sVal;
+ } else if (trend === "mul" && seasonal === "add") {
+ yhat = l * b ** phiSum + sVal;
+ } else {
+ yhat = l * b ** phiSum * sVal;
+ }
+
+ out.push(yhat);
+
+ phiH *= phi;
+ phiSum += phiH;
+ }
+ return out;
+}
+
+// ─── Heuristic initialisation ─────────────────────────────────────────────────
+
+/**
+ * Compute heuristic initial level and trend.
+ * Uses mean of first season + linear regression slope on first two seasons.
+ */
+function heuristicInit(
+ y: readonly number[],
+ m: number,
+ hasTrend: boolean,
+): { l0: number; b0: number } {
+ const n = y.length;
+ if (!hasTrend) {
+ return { l0: y[0] ?? 0, b0: 0 };
+ }
+ // Use first season average as l0, slope between first two seasons as b0
+ const k = Math.min(m, n);
+ let s1 = 0;
+ for (let i = 0; i < k; i++) {
+ s1 += y[i] ?? 0;
+ }
+ const l0 = s1 / k;
+
+ if (n >= 2 * m) {
+ let s2 = 0;
+ for (let i = m; i < 2 * m; i++) {
+ s2 += y[i] ?? 0;
+ }
+ const b0 = (s2 / m - l0) / m;
+ return { l0, b0: b0 || (((y[1] ?? 0) - (y[0] ?? 0)) * m) / m };
+ }
+ // Fallback: slope between y[0] and y[n-1]
+ const b0 = n > 1 ? ((y[n - 1] ?? 0) - (y[0] ?? 0)) / (n - 1) : 0;
+ return { l0, b0 };
+}
+
+/**
+ * Compute heuristic seasonal indices.
+ * Additive: s_j = avg(y_j, y_{j+m}, …) − overall mean
+ * Multiplicative: s_j = avg(y_j, y_{j+m}, …) / overall mean
+ */
+function heuristicSeasons(
+ y: readonly number[],
+ m: number,
+ seasonal: "add" | "mul",
+ l0: number,
+ b0: number,
+): number[] {
+ const n = y.length;
+ const cycles = Math.max(1, Math.floor(n / m));
+
+ // Detrended values for each position in the seasonal cycle
+ const byPos: number[][] = Array.from({ length: m }, () => []);
+ for (let t = 0; t < cycles * m && t < n; t++) {
+ const trend = l0 + b0 * t;
+ const raw = y[t] ?? 0;
+ const pos = t % m;
+ const posArr = byPos[pos];
+ if (posArr !== undefined) {
+ if (seasonal === "add") {
+ posArr.push(raw - trend);
+ } else {
+ posArr.push(trend !== 0 ? raw / trend : 1);
+ }
+ }
+ }
+
+ const rawS = byPos.map((vals) => {
+ if (vals.length === 0) {
+ return seasonal === "add" ? 0 : 1;
+ }
+ return vals.reduce((a, b) => a + b, 0) / vals.length;
+ });
+
+ // Normalise so seasonal indices sum to 0 (additive) or m (multiplicative)
+ if (seasonal === "add") {
+ const mean = rawS.reduce((a, b) => a + b, 0) / m;
+ return rawS.map((v) => v - mean);
+ }
+ const mean = rawS.reduce((a, b) => a + b, 0) / m;
+ return rawS.map((v) => (mean !== 0 ? (v / mean) * 1 : 1));
+}
+
+// ─── SimpleExpSmoothing ──────────────────────────────────────────────────────
+
+/**
+ * Simple Exponential Smoothing (SES / ETS(A,N,N)).
+ *
+ * Produces level-only forecasts; all future forecasts equal the final level.
+ *
+ * @example
+ * ```ts
+ * import { SimpleExpSmoothing } from "tsb";
+ * const model = new SimpleExpSmoothing();
+ * const fit = model.fit([3, 5, 4, 6, 5, 8, 7]);
+ * console.log(fit.alpha, fit.sse);
+ * console.log(model.forecast(3)); // [level, level, level]
+ * ```
+ */
+export class SimpleExpSmoothing {
+ private _fit: SESFitResult | null = null;
+ private _finalLevel = 0;
+
+ /**
+ * Fit the SES model to observed data.
+ * @param y - Time series observations.
+ * @param opts - Optional fixed parameters.
+ */
+ fit(y: readonly number[] | Series, opts?: SESOptions): SESFitResult {
+ const arr = toArr(y);
+ const n = arr.length;
+ if (n < 2) {
+ throw new RangeError("SimpleExpSmoothing requires at least 2 observations");
+ }
+
+ const l0Init = opts?.initialLevel ?? arr[0] ?? 0;
+
+ let alpha: number;
+ let l0: number;
+
+ if (opts?.alpha !== undefined) {
+ alpha = clamp(opts.alpha, 1e-6, 1 - 1e-6);
+ l0 = l0Init;
+ } else {
+ // Optimise α (and optionally l0)
+ const result = nelderMead(
+ ([a, l]: readonly number[]) => sesPass(arr, a ?? 0.3, l ?? arr[0] ?? 0).sse,
+ [0.3, l0Init],
+ [
+ [1e-6, 1 - 1e-6],
+ [
+ (arr[0] ?? 0) - Math.abs(arr[0] ?? 0) * 5 - 1,
+ (arr[0] ?? 0) + Math.abs(arr[0] ?? 0) * 5 + 1,
+ ],
+ ],
+ );
+ alpha = result.params[0] ?? 0.3;
+ l0 = result.params[1] ?? l0Init;
+ }
+
+ const { fitted, residuals, sse } = sesPass(arr, alpha, l0);
+
+ // Final level for forecasting
+ let lFinal = l0;
+ for (const yt of arr) {
+ lFinal = alpha * yt + (1 - alpha) * lFinal;
+ }
+ this._finalLevel = lFinal;
+
+ const k = 2; // alpha + l0
+ const { aic, bic, aicc } = infoGaussian(sse, n, k);
+
+ const result: SESFitResult = {
+ alpha,
+ initialLevel: l0,
+ fittedValues: fitted,
+ residuals,
+ sse,
+ aic,
+ bic,
+ aicc,
+ };
+ this._fit = result;
+ return result;
+ }
+
+ /**
+ * Generate `steps` forecasts from the last fitted state.
+ * All forecasts equal the final level (flat forecast).
+ * Must call {@link fit} first.
+ */
+ forecast(steps: number): number[] {
+ if (this._fit === null) {
+ throw new Error("Call fit() before forecast()");
+ }
+ return new Array(steps).fill(this._finalLevel);
+ }
+}
+
+// ─── Holt ─────────────────────────────────────────────────────────────────────
+
+/**
+ * Holt's linear (double) exponential smoothing (ETS(A,A,N) / ETS(A,Ad,N)).
+ *
+ * Extends SES with a trend component; supports optional damping.
+ *
+ * @example
+ * ```ts
+ * import { Holt } from "tsb";
+ * const model = new Holt();
+ * const fit = model.fit([3, 5, 4, 6, 5, 8, 7, 9, 8, 11]);
+ * console.log(fit.alpha, fit.beta, fit.phi);
+ * console.log(model.forecast(5));
+ * ```
+ */
+export class Holt {
+ private _opts: HoltOptions = {};
+ private _fit: HoltFitResult | null = null;
+ private _finalL = 0;
+ private _finalB = 0;
+ private _phi = 1;
+
+ constructor(opts?: HoltOptions) {
+ this._opts = opts ?? {};
+ }
+
+ /**
+ * Fit Holt's model to observed data.
+ * @param y - Time series observations.
+ * @param opts - Optional parameter overrides (merged with constructor opts).
+ */
+ fit(y: readonly number[] | Series, opts?: HoltOptions): HoltFitResult {
+ const arr = toArr(y);
+ const n = arr.length;
+ if (n < 3) {
+ throw new RangeError("Holt requires at least 3 observations");
+ }
+
+ const merged: HoltOptions = { ...this._opts, ...opts };
+ const damped = merged.damped ?? false;
+
+ const { l0: l0h, b0: b0h } = heuristicInit(arr, n, true);
+
+ const alphaFixed = merged.alpha;
+ const betaFixed = merged.beta;
+ const phiFixed = merged.dampingSlope;
+ const l0Fixed = merged.initialLevel ?? l0h;
+ const b0Fixed = merged.initialTrend ?? b0h;
+
+ // Build optimisation bounds and initial point
+ type Bound = [number, number];
+ const paramNames: string[] = [];
+ const x0: number[] = [];
+ const bounds: Bound[] = [];
+
+ if (alphaFixed === undefined) {
+ paramNames.push("alpha");
+ x0.push(0.3);
+ bounds.push([1e-6, 1 - 1e-6]);
+ }
+ if (betaFixed === undefined) {
+ paramNames.push("beta");
+ x0.push(0.1);
+ bounds.push([1e-6, 1 - 1e-6]);
+ }
+ if (damped && phiFixed === undefined) {
+ paramNames.push("phi");
+ x0.push(0.98);
+ bounds.push([0.8, 1 - 1e-6]);
+ }
+ // Always optimise l0 and b0 if not fixed
+ const optimL0 = merged.initialLevel === undefined;
+ const optimB0 = merged.initialTrend === undefined;
+ if (optimL0) {
+ paramNames.push("l0");
+ x0.push(l0h);
+ const spread = Math.abs(l0h) * 2 + 10;
+ bounds.push([l0h - spread, l0h + spread]);
+ }
+ if (optimB0) {
+ paramNames.push("b0");
+ x0.push(b0h);
+ const spread = Math.abs(b0h) * 5 + 1;
+ bounds.push([b0h - spread, b0h + spread]);
+ }
+
+ let alpha = alphaFixed ?? 0.3;
+ let beta = betaFixed ?? 0.1;
+ let phi = damped ? (phiFixed ?? 0.98) : 1.0;
+ let l0 = l0Fixed;
+ let b0 = b0Fixed;
+
+ if (x0.length > 0) {
+ const result = nelderMead(
+ (params: readonly number[]): number => {
+ let a = alphaFixed ?? params[paramNames.indexOf("alpha")] ?? 0.3;
+ let bta = betaFixed ?? params[paramNames.indexOf("beta")] ?? 0.1;
+ let ph = damped ? (phiFixed ?? params[paramNames.indexOf("phi")] ?? 0.98) : 1.0;
+ const ll0 = optimL0 ? (params[paramNames.indexOf("l0")] ?? l0h) : l0Fixed;
+ const lb0 = optimB0 ? (params[paramNames.indexOf("b0")] ?? b0h) : b0Fixed;
+ a = clamp(a, 1e-6, 1 - 1e-6);
+ bta = clamp(bta, 1e-6, 1 - 1e-6);
+ ph = clamp(ph, 0.8, 1 - 1e-6);
+ return holtPass(arr, a, bta, ph, ll0, lb0).sse;
+ },
+ x0,
+ bounds,
+ );
+ const p = result.params;
+ alpha = alphaFixed ?? p[paramNames.indexOf("alpha")] ?? alpha;
+ beta = betaFixed ?? p[paramNames.indexOf("beta")] ?? beta;
+ phi = damped ? (phiFixed ?? p[paramNames.indexOf("phi")] ?? phi) : 1.0;
+ l0 = optimL0 ? (p[paramNames.indexOf("l0")] ?? l0) : l0Fixed;
+ b0 = optimB0 ? (p[paramNames.indexOf("b0")] ?? b0) : b0Fixed;
+ }
+
+ alpha = clamp(alpha, 1e-6, 1 - 1e-6);
+ beta = clamp(beta, 1e-6, 1 - 1e-6);
+ if (damped) {
+ phi = clamp(phi, 0.8, 1 - 1e-6);
+ }
+
+ const { fitted, residuals, sse } = holtPass(arr, alpha, beta, phi, l0, b0);
+
+ // Final state for forecasting
+ let lF = l0;
+ let bF = b0;
+ for (const yt of arr) {
+ const lNew = alpha * yt + (1 - alpha) * (lF + phi * bF);
+ bF = beta * (lNew - lF) + (1 - beta) * phi * bF;
+ lF = lNew;
+ }
+ this._finalL = lF;
+ this._finalB = bF;
+ this._phi = phi;
+
+ const k = 2 + (damped ? 1 : 0) + 2; // alpha + beta + phi? + l0 + b0
+ const { aic, bic, aicc } = infoGaussian(sse, n, k);
+
+ const result: HoltFitResult = {
+ alpha,
+ beta,
+ phi,
+ initialLevel: l0,
+ initialTrend: b0,
+ fittedValues: fitted,
+ residuals,
+ sse,
+ aic,
+ bic,
+ aicc,
+ };
+ this._fit = result;
+ return result;
+ }
+
+ /**
+ * Generate `steps` forecasts from the last fitted state.
+ * Must call {@link fit} first.
+ */
+ forecast(steps: number): number[] {
+ if (this._fit === null) {
+ throw new Error("Call fit() before forecast()");
+ }
+ return holtForecast(steps, this._finalL, this._finalB, this._phi);
+ }
+}
+
+// ─── ExponentialSmoothing (Holt-Winters) ─────────────────────────────────────
+
+/**
+ * Holt-Winters Exponential Smoothing — full ETS model.
+ *
+ * Supports all combinations of additive / multiplicative trend and seasonal
+ * components with optional damped trend.
+ *
+ * @example
+ * ```ts
+ * import { ExponentialSmoothing } from "tsb";
+ *
+ * // Monthly data with additive seasonal component
+ * const y = [17, 21, 23, 18, 22, 26, 19, 24, 27, 20, 25, 28,
+ * 18, 23, 25, 20, 24, 28, 21, 26, 29, 22, 27, 30];
+ * const model = new ExponentialSmoothing({ trend: "add", seasonal: "add", seasonalPeriods: 12 });
+ * const fit = model.fit(y);
+ * console.log(fit.alpha, fit.beta, fit.gamma, fit.aic);
+ * console.log(model.forecast(12));
+ * ```
+ */
+export class ExponentialSmoothing {
+ private _opts: ExponentialSmoothingOptions;
+ private _fit: ExponentialSmoothingFitResult | null = null;
+ private _finalL = 0;
+ private _finalB = 0;
+ private _finalS: number[] = [];
+ private _phi = 1;
+ private _trend: ETSTrend = null;
+ private _seasonal: ETSSeasonal = null;
+ private _m = 1;
+ private _n = 0;
+ private _sigma2 = 1;
+
+ constructor(opts?: ExponentialSmoothingOptions) {
+ this._opts = opts ?? {};
+ }
+
+ /**
+ * Fit the Holt-Winters model to observed data.
+ * @param y - Time series observations.
+ * @param opts - Optional parameter overrides.
+ */
+ fit(
+ y: readonly number[] | Series,
+ opts?: ExponentialSmoothingOptions,
+ ): ExponentialSmoothingFitResult {
+ const arr = toArr(y);
+ const n = arr.length;
+ if (n < 3) {
+ throw new RangeError("ExponentialSmoothing requires at least 3 observations");
+ }
+
+ const merged: ExponentialSmoothingOptions = { ...this._opts, ...opts };
+ const trend = merged.trend ?? null;
+ const seasonal = merged.seasonal ?? null;
+ const damped = merged.damped ?? false;
+ const m = merged.seasonalPeriods ?? (seasonal !== null ? 2 : 1);
+
+ this._trend = trend;
+ this._seasonal = seasonal;
+ this._m = m;
+ this._n = n;
+
+ if (seasonal !== null && n < 2 * m) {
+ throw new RangeError(
+ `ExponentialSmoothing: need at least 2 full seasonal periods (${2 * m} obs), got ${n}`,
+ );
+ }
+
+ const initMethod = merged.initializationMethod ?? "heuristic";
+
+ // Heuristic initialisation
+ const { l0: l0h, b0: b0h } = heuristicInit(arr, m, trend !== null);
+ const s0h = seasonal !== null ? heuristicSeasons(arr, m, seasonal, l0h, b0h) : null;
+
+ // Determine which params to optimise
+ const alphaFixed = merged.alpha;
+ const betaFixed = merged.beta;
+ const gammaFixed = merged.gamma;
+ const phiFixed = merged.phi;
+ const l0Fixed = initMethod === "known" ? (merged.initialLevel ?? l0h) : undefined;
+ const b0Fixed = initMethod === "known" ? (merged.initialTrend ?? b0h) : undefined;
+ const s0Fixed =
+ initMethod === "known" && merged.initialSeasons !== undefined
+ ? merged.initialSeasons.slice()
+ : undefined;
+
+ type Bound = [number, number];
+ const paramNames: string[] = [];
+ const x0: number[] = [];
+ const bounds: Bound[] = [];
+
+ if (alphaFixed === undefined) {
+ paramNames.push("alpha");
+ x0.push(0.3);
+ bounds.push([1e-6, 1 - 1e-6]);
+ }
+ if (trend !== null && betaFixed === undefined) {
+ paramNames.push("beta");
+ x0.push(0.1);
+ bounds.push([1e-6, 1 - 1e-6]);
+ }
+ if (seasonal !== null && gammaFixed === undefined) {
+ paramNames.push("gamma");
+ x0.push(0.1);
+ bounds.push([1e-6, 1 - 1e-6]);
+ }
+ if (damped && phiFixed === undefined) {
+ paramNames.push("phi");
+ x0.push(0.98);
+ bounds.push([0.8, 1 - 1e-6]);
+ }
+
+ const optimL0 = initMethod !== "known" && merged.initialLevel === undefined;
+ const optimB0 = trend !== null && initMethod !== "known" && merged.initialTrend === undefined;
+ const optimS0 =
+ seasonal !== null && initMethod !== "known" && merged.initialSeasons === undefined;
+
+ if (optimL0) {
+ paramNames.push("l0");
+ x0.push(l0h);
+ const sp = Math.abs(l0h) * 2 + 10;
+ bounds.push([l0h - sp, l0h + sp]);
+ }
+ if (optimB0) {
+ paramNames.push("b0");
+ x0.push(b0h);
+ const sp = Math.abs(b0h) * 5 + 1;
+ bounds.push([b0h - sp, b0h + sp]);
+ }
+ if (optimS0 && s0h !== null) {
+ for (let j = 0; j < m; j++) {
+ paramNames.push(`s0_${j}`);
+ x0.push(s0h[j] ?? 0);
+ const sp = Math.abs(s0h[j] ?? 0) * 5 + 1;
+ bounds.push([(s0h[j] ?? 0) - sp, (s0h[j] ?? 0) + sp]);
+ }
+ }
+
+ let alpha = alphaFixed ?? 0.3;
+ let beta = trend !== null ? (betaFixed ?? 0.1) : null;
+ let gamma = seasonal !== null ? (gammaFixed ?? 0.1) : null;
+ let phi = damped ? (phiFixed ?? 0.98) : 1.0;
+ let l0 = l0Fixed ?? l0h;
+ let b0 = b0Fixed ?? b0h;
+ let s0 = s0Fixed ?? s0h;
+
+ if (x0.length > 0) {
+ const res = nelderMead(
+ (params: readonly number[]): number => {
+ let a = alphaFixed ?? params[paramNames.indexOf("alpha")] ?? 0.3;
+ let bt = trend !== null ? (betaFixed ?? params[paramNames.indexOf("beta")] ?? 0.1) : null;
+ let gm =
+ seasonal !== null ? (gammaFixed ?? params[paramNames.indexOf("gamma")] ?? 0.1) : null;
+ let ph = damped ? (phiFixed ?? params[paramNames.indexOf("phi")] ?? 0.98) : 1.0;
+ a = clamp(a, 1e-6, 1 - 1e-6);
+ if (bt !== null) {
+ bt = clamp(bt, 1e-6, 1 - 1e-6);
+ }
+ if (gm !== null) {
+ gm = clamp(gm, 1e-6, 1 - 1e-6);
+ }
+ if (damped) {
+ ph = clamp(ph, 0.8, 1 - 1e-6);
+ }
+
+ const ll0 = optimL0 ? (params[paramNames.indexOf("l0")] ?? l0h) : (l0Fixed ?? l0h);
+ const lb0 = optimB0 ? (params[paramNames.indexOf("b0")] ?? b0h) : (b0Fixed ?? b0h);
+ let ss0: number[] | null = null;
+ if (optimS0) {
+ ss0 = [];
+ for (let j = 0; j < m; j++) {
+ ss0.push(params[paramNames.indexOf(`s0_${j}`)] ?? s0h?.[j] ?? 0);
+ }
+ } else {
+ ss0 = s0Fixed ?? s0h;
+ }
+
+ return hwPass(arr, a, bt, gm, ph, ll0, lb0, ss0, trend, seasonal, m).sse;
+ },
+ x0,
+ bounds,
+ seasonal !== null ? 5000 : 3000,
+ );
+ const p = res.params;
+ alpha = alphaFixed ?? p[paramNames.indexOf("alpha")] ?? alpha;
+ beta = trend !== null ? (betaFixed ?? p[paramNames.indexOf("beta")] ?? beta ?? 0.1) : null;
+ gamma =
+ seasonal !== null ? (gammaFixed ?? p[paramNames.indexOf("gamma")] ?? gamma ?? 0.1) : null;
+ phi = damped ? (phiFixed ?? p[paramNames.indexOf("phi")] ?? phi) : 1.0;
+ l0 = optimL0 ? (p[paramNames.indexOf("l0")] ?? l0) : (l0Fixed ?? l0);
+ b0 = optimB0 ? (p[paramNames.indexOf("b0")] ?? b0) : (b0Fixed ?? b0);
+ if (optimS0) {
+ s0 = [];
+ for (let j = 0; j < m; j++) {
+ s0.push(p[paramNames.indexOf(`s0_${j}`)] ?? s0h?.[j] ?? 0);
+ }
+ }
+ }
+
+ // Final clamp
+ alpha = clamp(alpha, 1e-6, 1 - 1e-6);
+ if (beta !== null) {
+ beta = clamp(beta, 1e-6, 1 - 1e-6);
+ }
+ if (gamma !== null) {
+ gamma = clamp(gamma, 1e-6, 1 - 1e-6);
+ }
+ if (damped) {
+ phi = clamp(phi, 0.8, 1 - 1e-6);
+ }
+
+ const { fitted, residuals, sse, finalL, finalB, finalS } = hwPass(
+ arr,
+ alpha,
+ beta,
+ gamma,
+ phi,
+ l0,
+ b0,
+ s0,
+ trend,
+ seasonal,
+ m,
+ );
+
+ this._finalL = finalL;
+ this._finalB = finalB;
+ this._finalS = finalS;
+ this._phi = phi;
+ this._sigma2 = Math.max(sse / n, 1e-15);
+
+ // Number of free parameters for information criteria
+ const nParams =
+ 1 + // alpha
+ (trend !== null ? 1 : 0) + // beta
+ (seasonal !== null ? 1 : 0) + // gamma
+ (damped ? 1 : 0) + // phi
+ 1 + // l0
+ (trend !== null ? 1 : 0) + // b0
+ (seasonal !== null ? m : 0); // seasonal indices
+
+ const { logLikelihood, aic, bic, aicc } = infoGaussian(sse, n, nParams);
+
+ const result: ExponentialSmoothingFitResult = {
+ alpha,
+ beta,
+ gamma,
+ phi,
+ initialLevel: l0,
+ initialTrend: trend !== null ? b0 : null,
+ initialSeasons: seasonal !== null ? (s0 ?? null) : null,
+ fittedValues: fitted,
+ residuals,
+ sse,
+ logLikelihood,
+ aic,
+ bic,
+ aicc,
+ };
+ this._fit = result;
+ return result;
+ }
+
+ /**
+ * Generate `steps` point forecasts from the final state.
+ * Must call {@link fit} first.
+ */
+ forecast(steps: number): number[] {
+ if (this._fit === null) {
+ throw new Error("Call fit() before forecast()");
+ }
+ return hwForecast(
+ steps,
+ this._finalL,
+ this._finalB,
+ this._finalS,
+ this._phi,
+ this._trend,
+ this._seasonal,
+ this._m,
+ this._n,
+ );
+ }
+
+ /**
+ * Generate `steps` forecasts with (1 − `alpha_ci`) prediction intervals.
+ * Uses additive-error variance approximation (constant σ² scaled by h).
+ * Must call {@link fit} first.
+ *
+ * @param steps - Number of steps ahead.
+ * @param alpha_ci - Significance level (default 0.05 → 95 % intervals).
+ */
+ forecastWithCI(steps: number, alpha_ci = 0.05): ETSForecastResult {
+ const fc = this.forecast(steps);
+ // Normal quantile for (1 - alpha_ci/2)
+ const z = normalQuantile(1 - alpha_ci / 2);
+ const sigma = Math.sqrt(this._sigma2);
+ const lower: number[] = [];
+ const upper: number[] = [];
+ const stderr: number[] = [];
+ for (let h = 1; h <= steps; h++) {
+ // Variance grows linearly with h for additive-error models
+ const se = sigma * Math.sqrt(h);
+ stderr.push(se);
+ lower.push((fc[h - 1] ?? 0) - z * se);
+ upper.push((fc[h - 1] ?? 0) + z * se);
+ }
+ return { forecast: fc, lower, upper, stderr };
+ }
+}
+
+/**
+ * Rational approximation of the normal quantile function (Abramowitz & Stegun).
+ * @internal
+ */
+function normalQuantile(p: number): number {
+ if (p <= 0) {
+ return Number.NEGATIVE_INFINITY;
+ }
+ if (p >= 1) {
+ return Number.POSITIVE_INFINITY;
+ }
+ const a = [2.515517, 0.802853, 0.010328];
+ const b = [1.432788, 0.189269, 0.001308];
+ const t = Math.sqrt(-2 * Math.log(p < 0.5 ? p : 1 - p));
+ const num = (a[0] ?? 0) + (a[1] ?? 0) * t + (a[2] ?? 0) * t * t;
+ const den = 1 + (b[0] ?? 0) * t + (b[1] ?? 0) * t * t + (b[2] ?? 0) * t * t * t;
+ const x = t - num / den;
+ return p < 0.5 ? -x : x;
+}
+
+// ─── Convenience functions ────────────────────────────────────────────────────
+
+/**
+ * Fit a Simple Exponential Smoothing model and return the result.
+ *
+ * @example
+ * ```ts
+ * import { simpleExpSmoothing } from "tsb";
+ * const { alpha, fittedValues, sse } = simpleExpSmoothing([3, 5, 4, 6, 5]);
+ * ```
+ */
+export function simpleExpSmoothing(
+ y: readonly number[] | Series,
+ opts?: SESOptions,
+): SESFitResult {
+ return new SimpleExpSmoothing().fit(y, opts);
+}
+
+/**
+ * Fit a Holt linear trend model and return the result.
+ *
+ * @example
+ * ```ts
+ * import { holt } from "tsb";
+ * const fit = holt([3, 5, 4, 6, 5, 8, 7, 9]);
+ * console.log(fit.alpha, fit.beta, fit.sse);
+ * ```
+ */
+export function holt(y: readonly number[] | Series, opts?: HoltOptions): HoltFitResult {
+ return new Holt(opts).fit(y);
+}
+
+/**
+ * Fit a full Holt-Winters Exponential Smoothing model and return the result.
+ *
+ * @example
+ * ```ts
+ * import { fitEts } from "tsb";
+ * const y = [17, 21, 23, 18, 22, 26, 19, 24, 27, 20, 25, 28];
+ * const fit = fitEts(y, { trend: "add", seasonal: "add", seasonalPeriods: 4 });
+ * console.log(fit.alpha, fit.beta, fit.gamma, fit.aic);
+ * ```
+ */
+export function fitEts(
+ y: readonly number[] | Series,
+ opts?: ExponentialSmoothingOptions,
+): ExponentialSmoothingFitResult {
+ return new ExponentialSmoothing(opts).fit(y);
+}
diff --git a/src/stats/extreme_value.ts b/src/stats/extreme_value.ts
new file mode 100644
index 000000000..3e5423b56
--- /dev/null
+++ b/src/stats/extreme_value.ts
@@ -0,0 +1,445 @@
+/**
+ * extreme_value — Extreme Value Theory (EVT) distributions and analysis.
+ *
+ * Implements:
+ * - **Generalized Extreme Value (GEV)** distribution (Gumbel, Fréchet, Weibull)
+ * - **Generalized Pareto Distribution (GPD)** for Peaks Over Threshold
+ * - **Block maxima** method (GEV fitting via L-moments)
+ * - **Peaks Over Threshold (POT)** method (GPD fitting via MLE)
+ * - **Return level** and **return period** calculations
+ * - **Gumbel**, **Fréchet**, **Weibull** special-case distributions
+ *
+ * @module
+ */
+
+// ─── GEV Distribution ─────────────────────────────────────────────────────────
+
+/**
+ * Parameters of the Generalized Extreme Value distribution.
+ */
+export interface GEVParams {
+ /** Location parameter (mu). */
+ mu: number;
+ /** Scale parameter (sigma > 0). */
+ sigma: number;
+ /** Shape parameter (xi). xi=0: Gumbel, xi>0: Fréchet, xi<0: Weibull. */
+ xi: number;
+}
+
+/**
+ * GEV probability density function.
+ *
+ * @param x - Value.
+ * @param params - GEV parameters.
+ * @returns Density f(x).
+ *
+ * @example
+ * ```ts
+ * import { gevPdf } from "tsb";
+ * const p = gevPdf(2.5, { mu: 0, sigma: 1, xi: 0.1 });
+ * ```
+ */
+export function gevPdf(x: number, params: GEVParams): number {
+ const { mu, sigma, xi } = params;
+ if (sigma <= 0) return 0;
+
+ const z = (x - mu) / sigma;
+
+ if (Math.abs(xi) < 1e-8) {
+ // Gumbel case (xi → 0)
+ const t = Math.exp(-z);
+ return (1 / sigma) * Math.exp(-z - t);
+ }
+
+ const t = 1 + xi * z;
+ if (t <= 0) return 0;
+
+ return (1 / sigma) * t ** (-1 / xi - 1) * Math.exp(-(t ** (-1 / xi)));
+}
+
+/**
+ * GEV cumulative distribution function.
+ *
+ * @param x - Value.
+ * @param params - GEV parameters.
+ * @returns CDF F(x).
+ */
+export function gevCdf(x: number, params: GEVParams): number {
+ const { mu, sigma, xi } = params;
+ if (sigma <= 0) return 0;
+
+ const z = (x - mu) / sigma;
+
+ if (Math.abs(xi) < 1e-8) {
+ // Gumbel case
+ return Math.exp(-Math.exp(-z));
+ }
+
+ const t = 1 + xi * z;
+ if (t <= 0) {
+ return xi > 0 ? 0 : 1;
+ }
+
+ return Math.exp(-(t ** (-1 / xi)));
+}
+
+/**
+ * GEV quantile function (inverse CDF).
+ *
+ * @param p - Probability in (0, 1).
+ * @param params - GEV parameters.
+ * @returns Quantile x such that F(x) = p.
+ */
+export function gevQuantile(p: number, params: GEVParams): number {
+ if (p <= 0) return -Infinity;
+ if (p >= 1) return Infinity;
+
+ const { mu, sigma, xi } = params;
+
+ if (Math.abs(xi) < 1e-8) {
+ // Gumbel
+ return mu - sigma * Math.log(-Math.log(p));
+ }
+
+ return mu + (sigma / xi) * ((-Math.log(p)) ** (-xi) - 1);
+}
+
+/**
+ * Compute return level for a given return period (years/blocks).
+ *
+ * @param returnPeriod - Return period (e.g., 100 for 100-year event).
+ * @param params - GEV parameters.
+ * @returns Return level x such that P(X > x) = 1/returnPeriod.
+ */
+export function gevReturnLevel(returnPeriod: number, params: GEVParams): number {
+ const p = 1 - 1 / returnPeriod;
+ return gevQuantile(p, params);
+}
+
+// ─── GEV Fitting (L-moments) ──────────────────────────────────────────────────
+
+/**
+ * Fit GEV distribution to block maxima using L-moments.
+ *
+ * @param maxima - Array of block maxima (e.g., annual maxima).
+ * @returns Estimated GEV parameters.
+ *
+ * @example
+ * ```ts
+ * import { fitGEV } from "tsb";
+ * const annualMaxima = [12.3, 15.1, 9.8, 18.2, 11.4, 14.7];
+ * const params = fitGEV(annualMaxima);
+ * ```
+ */
+export function fitGEV(maxima: number[]): GEVParams {
+ const n = maxima.length;
+ if (n < 3) return { mu: 0, sigma: 1, xi: 0 };
+
+ const sorted = [...maxima].sort((a, b) => a - b);
+
+ // Compute L-moments via probability-weighted moments
+ let b0 = 0;
+ let b1 = 0;
+ let b2 = 0;
+
+ for (let i = 0; i < n; i++) {
+ b0 += sorted[i] ?? 0;
+ b1 += ((i) / (n - 1)) * (sorted[i] ?? 0);
+ b2 += ((i) * (i - 1) / ((n - 1) * (n - 2))) * (sorted[i] ?? 0);
+ }
+ b0 /= n;
+ b1 /= n;
+ b2 /= n;
+
+ const l1 = b0;
+ const l2 = 2 * b1 - b0;
+ const l3 = 6 * b2 - 6 * b1 + b0;
+
+ // L-skewness
+ const tau3 = l2 > 1e-10 ? l3 / l2 : 0;
+
+ // Estimate xi from L-skewness using approximation
+ let xi: number;
+ if (Math.abs(tau3) < 1e-8) {
+ xi = 0;
+ } else {
+ // Rational approximation for xi from tau3
+ xi = estimateXiFromTau3(tau3);
+ }
+
+ let sigma: number;
+ let mu: number;
+
+ if (Math.abs(xi) < 1e-6) {
+ // Gumbel
+ sigma = l2 / Math.log(2);
+ mu = l1 - 0.5772156649 * sigma;
+ } else {
+ const g1 = gamma(1 - xi);
+ sigma = (l2 * xi) / ((1 - 2 ** (-xi)) * g1);
+ mu = l1 - sigma * (g1 - 1) / xi;
+ }
+
+ return {
+ mu,
+ sigma: Math.max(sigma, 1e-8),
+ xi,
+ };
+}
+
+// ─── GPD Distribution ─────────────────────────────────────────────────────────
+
+/**
+ * Parameters of the Generalized Pareto Distribution.
+ */
+export interface GPDParams {
+ /** Threshold (u). */
+ threshold: number;
+ /** Scale parameter (sigma > 0). */
+ sigma: number;
+ /** Shape parameter (xi). */
+ xi: number;
+}
+
+/**
+ * GPD probability density function.
+ *
+ * @param x - Value (must be >= threshold).
+ * @param params - GPD parameters.
+ * @returns Density f(x).
+ */
+export function gpdPdf(x: number, params: GPDParams): number {
+ const { threshold, sigma, xi } = params;
+ if (sigma <= 0 || x < threshold) return 0;
+
+ const z = (x - threshold) / sigma;
+
+ if (Math.abs(xi) < 1e-8) {
+ return (1 / sigma) * Math.exp(-z);
+ }
+
+ const t = 1 + xi * z;
+ if (t <= 0) return 0;
+
+ return (1 / sigma) * t ** (-1 / xi - 1);
+}
+
+/**
+ * GPD cumulative distribution function.
+ *
+ * @param x - Value.
+ * @param params - GPD parameters.
+ * @returns CDF value.
+ */
+export function gpdCdf(x: number, params: GPDParams): number {
+ const { threshold, sigma, xi } = params;
+ if (x < threshold) return 0;
+
+ const z = (x - threshold) / sigma;
+
+ if (Math.abs(xi) < 1e-8) {
+ return 1 - Math.exp(-z);
+ }
+
+ const t = 1 + xi * z;
+ if (t <= 0) return xi > 0 ? 0 : 1;
+
+ return 1 - t ** (-1 / xi);
+}
+
+/**
+ * GPD quantile function.
+ *
+ * @param p - Probability in (0, 1).
+ * @param params - GPD parameters.
+ * @returns Quantile.
+ */
+export function gpdQuantile(p: number, params: GPDParams): number {
+ if (p <= 0) return params.threshold;
+ if (p >= 1) return Infinity;
+
+ const { threshold, sigma, xi } = params;
+
+ if (Math.abs(xi) < 1e-8) {
+ return threshold - sigma * Math.log(1 - p);
+ }
+
+ return threshold + (sigma / xi) * ((1 - p) ** (-xi) - 1);
+}
+
+// ─── GPD Fitting (MLE) ────────────────────────────────────────────────────────
+
+/**
+ * Fit GPD to exceedances above a threshold using MLE.
+ *
+ * @param data - Full dataset.
+ * @param threshold - Threshold u (only exceedances x > u are used).
+ * @returns Estimated GPD parameters.
+ *
+ * @example
+ * ```ts
+ * import { fitGPD } from "tsb";
+ * const data = [1.2, 0.5, 3.4, 8.1, 0.2, 5.6, 12.3, 0.8, 4.1, 7.2];
+ * const params = fitGPD(data, 4.0);
+ * ```
+ */
+export function fitGPD(data: number[], threshold: number): GPDParams {
+ const exceedances = data.filter((x) => x > threshold).map((x) => x - threshold);
+
+ if (exceedances.length < 2) {
+ return { threshold, sigma: 1, xi: 0 };
+ }
+
+ const n = exceedances.length;
+ const mean = exceedances.reduce((s, x) => s + x, 0) / n;
+ const variance = exceedances.reduce((s, x) => s + (x - mean) ** 2, 0) / (n - 1);
+
+ // Method of moments starting values
+ let sigmaInit = mean * (mean * mean / variance + 1) / 2;
+ let xiInit = (mean * mean / variance - 1) / 2;
+
+ sigmaInit = Math.max(sigmaInit, 1e-6);
+
+ // Simple gradient-free optimization (Nelder-Mead would be ideal, use grid search)
+ const { sigma, xi } = optimizeGPD(exceedances, sigmaInit, xiInit);
+
+ return { threshold, sigma, xi };
+}
+
+// ─── Peaks Over Threshold Analysis ───────────────────────────────────────────
+
+/**
+ * Extract exceedances above a threshold.
+ *
+ * @param data - Time series data.
+ * @param threshold - Threshold value.
+ * @returns Array of exceedance values.
+ */
+export function extractExceedances(data: number[], threshold: number): number[] {
+ return data.filter((x) => x > threshold);
+}
+
+/**
+ * Compute return level from GPD fit.
+ *
+ * @param returnPeriod - Return period.
+ * @param params - Fitted GPD parameters.
+ * @param lambda - Rate of threshold exceedances (exceedances per time unit).
+ * @returns Return level.
+ */
+export function gpdReturnLevel(
+ returnPeriod: number,
+ params: GPDParams,
+ lambda: number,
+): number {
+ const p = 1 - 1 / (returnPeriod * lambda);
+ return gpdQuantile(Math.max(0, Math.min(1, p)), params);
+}
+
+// ─── Gumbel Distribution ──────────────────────────────────────────────────────
+
+/** Parameters for the Gumbel distribution (GEV with xi=0). */
+export interface GumbelParams {
+ /** Location (mu). */
+ mu: number;
+ /** Scale (beta > 0). */
+ beta: number;
+}
+
+/** Gumbel PDF. */
+export function gumbelPdf(x: number, params: GumbelParams): number {
+ const z = (x - params.mu) / params.beta;
+ return (1 / params.beta) * Math.exp(-(z + Math.exp(-z)));
+}
+
+/** Gumbel CDF. */
+export function gumbelCdf(x: number, params: GumbelParams): number {
+ const z = (x - params.mu) / params.beta;
+ return Math.exp(-Math.exp(-z));
+}
+
+/** Gumbel quantile. */
+export function gumbelQuantile(p: number, params: GumbelParams): number {
+ return params.mu - params.beta * Math.log(-Math.log(p));
+}
+
+// ─── Utilities ────────────────────────────────────────────────────────────────
+
+/** Lanczos approximation of the gamma function. */
+function gamma(z: number): number {
+ if (z < 0.5) {
+ return Math.PI / (Math.sin(Math.PI * z) * gamma(1 - z));
+ }
+ const g = 7;
+ const c = [
+ 0.99999999999980993, 676.5203681218851, -1259.1392167224028,
+ 771.32342877765313, -176.61502916214059, 12.507343278686905,
+ -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7,
+ ];
+ let x = c[0] ?? 0;
+ const zr = z - 1;
+ for (let i = 1; i < g + 2; i++) {
+ x += (c[i] ?? 0) / (zr + i);
+ }
+ const t = zr + g + 0.5;
+ return Math.sqrt(2 * Math.PI) * t ** (zr + 0.5) * Math.exp(-t) * x;
+}
+
+/** Estimate GEV shape parameter from L-skewness. */
+function estimateXiFromTau3(tau3: number): number {
+ // Approximation from Hosking (1985)
+ // For Gumbel: tau3 = 0.1699 (log(3/2) / log(2) - 2)
+ // Valid for -0.5 < xi < 0.5
+ const c = 2 / (3 + tau3) - Math.log(2) / Math.log(3);
+ return 7.8590 * c + 2.9554 * c * c;
+}
+
+/** Simple optimization for GPD parameters. */
+function optimizeGPD(
+ exceedances: number[],
+ sigmaInit: number,
+ xiInit: number,
+): { sigma: number; xi: number } {
+ let sigma = sigmaInit;
+ let xi = xiInit;
+
+ const logLik = (s: number, x: number): number => {
+ const n = exceedances.length;
+ if (s <= 0) return -Infinity;
+ let ll = -n * Math.log(s);
+ for (const e of exceedances) {
+ if (Math.abs(x) < 1e-8) {
+ ll -= e / s;
+ } else {
+ const t = 1 + x * e / s;
+ if (t <= 0) return -Infinity;
+ ll -= (1 / x + 1) * Math.log(t);
+ }
+ }
+ return ll;
+ };
+
+ // Simple coordinate ascent
+ let bestLl = logLik(sigma, xi);
+ for (let iter = 0; iter < 100; iter++) {
+ const stepS = sigma * 0.1;
+ const stepX = 0.05;
+
+ for (const ds of [-stepS, stepS]) {
+ const ll = logLik(sigma + ds, xi);
+ if (ll > bestLl) {
+ bestLl = ll;
+ sigma = sigma + ds;
+ }
+ }
+ for (const dx of [-stepX, stepX]) {
+ const ll = logLik(sigma, xi + dx);
+ if (ll > bestLl) {
+ bestLl = ll;
+ xi = xi + dx;
+ }
+ }
+ }
+
+ return { sigma: Math.max(sigma, 1e-8), xi };
+}
diff --git a/src/stats/filters.ts b/src/stats/filters.ts
new file mode 100644
index 000000000..76136a518
--- /dev/null
+++ b/src/stats/filters.ts
@@ -0,0 +1,757 @@
+/**
+ * filters — Digital filter design and application.
+ *
+ * Mirrors `scipy.signal` filter utilities. Implemented from scratch with no
+ * external dependencies.
+ *
+ * Filter design:
+ * - {@link firwin} — FIR filter (windowed-sinc method)
+ * - {@link butter} — Butterworth IIR digital filter
+ *
+ * Frequency response:
+ * - {@link freqz} — frequency response of an FIR/IIR filter
+ * - {@link sosfreqz} — frequency response of SOS filter
+ *
+ * Filter application:
+ * - {@link lfilter} — causal FIR/IIR filter (direct-form II transposed)
+ * - {@link filtfilt} — zero-phase forward-backward filter
+ * - {@link sosfilt} — second-order-sections filter
+ *
+ * @example
+ * ```ts
+ * import { firwin, lfilter, butter, sosfilt } from "tsb";
+ *
+ * // Low-pass FIR with 29 taps, cutoff 0.25 (Nyquist = 0.5)
+ * const b = firwin(29, 0.25);
+ * const y = lfilter(b, [1], signal);
+ *
+ * // Butterworth low-pass, order 4, cutoff 0.2
+ * const { sos } = butter(4, 0.2, "lowpass");
+ * const filtered = sosfilt(sos, signal);
+ * ```
+ *
+ * @module
+ */
+
+import {
+ type Complex,
+ type WindowName,
+ blackmanWindow,
+ cAbs,
+ complex,
+ hammingWindow,
+ hannWindow,
+ kaiserWindow,
+} from "./signal.ts";
+
+// ─── internal helpers ─────────────────────────────────────────────────────────
+
+/** sinc(x) = sin(πx) / (πx), sinc(0) = 1 (normalised). */
+function sinc(x: number): number {
+ if (x === 0) {
+ return 1;
+ }
+ const px = Math.PI * x;
+ return Math.sin(px) / px;
+}
+
+/** Polynomial multiplication (convolution). */
+function polyMul(a: readonly number[], b: readonly number[]): number[] {
+ const out = new Array(a.length + b.length - 1).fill(0);
+ for (let i = 0; i < a.length; i++) {
+ for (let j = 0; j < b.length; j++) {
+ out[i + j] = (out[i + j] ?? 0) + (a[i] ?? 0) * (b[j] ?? 0);
+ }
+ }
+ return out;
+}
+
+// ─── FIR filter design ────────────────────────────────────────────────────────
+
+/** Options for {@link firwin}. */
+export interface FirwinOptions {
+ /**
+ * Window to apply after ideal filter: name string or pre-computed array.
+ * Default `"hamming"`.
+ */
+ window?: WindowName | readonly number[];
+ /** If `true`, design a high-pass filter (default `false` = low-pass). */
+ pass_zero?: boolean;
+ /** Sampling rate used to normalise `cutoff` (default `2` so `cutoff ∈ [0, 1]`). */
+ fs?: number;
+}
+
+/**
+ * Design a low- or high-pass FIR filter using the windowed-sinc method.
+ *
+ * Mirrors `scipy.signal.firwin`.
+ *
+ * @param numtaps - Number of filter coefficients (must be odd for pass_zero=false).
+ * @param cutoff - Cutoff frequency. With default `fs=2`, cutoff is normalised
+ * so `1.0` equals the Nyquist frequency.
+ * @param options - {@link FirwinOptions}.
+ * @returns - FIR filter coefficients `b` (length `numtaps`).
+ *
+ * @example
+ * ```ts
+ * import { firwin, lfilter } from "tsb";
+ * const b = firwin(51, 0.3); // 51-tap 150 Hz LPF (fs=1000)
+ * const y = lfilter(b, [1], signal);
+ * ```
+ */
+export function firwin(
+ numtaps: number,
+ cutoff: number | readonly [number, number],
+ options: FirwinOptions = {},
+): number[] {
+ const fs = options.fs ?? 2;
+ const passZero = options.pass_zero ?? true;
+ const nyq = fs / 2;
+
+ // Normalise cutoff(s) to [0..1] where 1 = Nyquist
+ const rawCuts = Array.isArray(cutoff)
+ ? (cutoff as readonly [number, number])
+ : ([cutoff] as const);
+ const cuts = (rawCuts as readonly number[]).map((c) => c / nyq);
+
+ const M = numtaps - 1;
+
+ // Build window
+ let win: number[];
+ if (options.window !== undefined) {
+ win =
+ typeof options.window === "string"
+ ? buildFirWindow(options.window, numtaps)
+ : Array.from(options.window);
+ } else {
+ win = hammingWindow(numtaps);
+ }
+
+ // Ideal sinc coefficients
+ const h = new Array(numtaps).fill(0);
+
+ if (cuts.length === 1) {
+ const fc = cuts[0] ?? 0;
+ if (passZero) {
+ // Low-pass: h[n] = fc * sinc(fc * (n - M/2))
+ for (let n = 0; n < numtaps; n++) {
+ h[n] = fc * sinc(fc * (n - M / 2)) * (win[n] ?? 1);
+ }
+ } else {
+ // High-pass: h[n] = delta(n - M/2) - fc * sinc(fc * (n - M/2))
+ for (let n = 0; n < numtaps; n++) {
+ const delta = n === M / 2 ? 1 : 0;
+ h[n] = (delta - fc * sinc(fc * (n - M / 2))) * (win[n] ?? 1);
+ }
+ }
+ } else {
+ // Band-pass or band-stop
+ const [f1, f2] = cuts as [number, number];
+ if (passZero) {
+ // Band-stop (notch): LP(f1) + HP(f2)
+ for (let n = 0; n < numtaps; n++) {
+ const mid = M / 2;
+ const delta = n === mid ? 1 : 0;
+ h[n] = (f1 * sinc(f1 * (n - mid)) + (delta - f2 * sinc(f2 * (n - mid)))) * (win[n] ?? 1);
+ }
+ } else {
+ // Band-pass: BP(f1, f2) = LP(f2) - LP(f1)
+ for (let n = 0; n < numtaps; n++) {
+ const mid = M / 2;
+ h[n] = (f2 * sinc(f2 * (n - mid)) - f1 * sinc(f1 * (n - mid))) * (win[n] ?? 1);
+ }
+ }
+ }
+
+ // Normalise DC gain
+ const dcGain = h.reduce((s, v) => s + v, 0);
+ if (Math.abs(dcGain) > 1e-12 && passZero && cuts.length === 1) {
+ // Low-pass: normalise DC to 1
+ const scale = 1 / dcGain;
+ return h.map((v) => v * scale);
+ }
+ return h;
+}
+
+/** Build a named window for FIR design. */
+function buildFirWindow(name: WindowName, n: number): number[] {
+ switch (name) {
+ case "hamming":
+ return hammingWindow(n);
+ case "hann":
+ return hannWindow(n);
+ case "blackman":
+ return blackmanWindow(n);
+ case "kaiser":
+ return kaiserWindow(n, 14);
+ default:
+ return hammingWindow(n);
+ }
+}
+
+// ─── frequency response ───────────────────────────────────────────────────────
+
+/** Result of {@link freqz} and {@link sosfreqz}. */
+export interface FreqzResult {
+ /** Angular frequencies in radians/sample (0 to π). */
+ w: number[];
+ /** Complex frequency response H(e^jω). */
+ H: Complex[];
+}
+
+/**
+ * Compute the frequency response H(e^jω) of a digital filter.
+ *
+ * Mirrors `scipy.signal.freqz`.
+ *
+ * @param b - Numerator polynomial coefficients.
+ * @param a - Denominator polynomial coefficients (default `[1]` = FIR).
+ * @param worN - Number of frequency points, or array of specific radian frequencies.
+ * @returns - `{ w, H }` where `w` is in radians/sample and `H` is complex.
+ *
+ * @example
+ * ```ts
+ * import { firwin, freqz } from "tsb";
+ * const b = firwin(31, 0.3);
+ * const { w, H } = freqz(b, [1], 512);
+ * const mag = H.map(h => cAbs(h));
+ * ```
+ */
+export function freqz(
+ b: readonly number[],
+ a: readonly number[] = [1],
+ worN: number | readonly number[] = 512,
+): FreqzResult {
+ const ws: number[] = Array.isArray(worN)
+ ? Array.from(worN as readonly number[])
+ : Array.from({ length: worN as number }, (_, i) => (Math.PI * i) / (worN as number));
+
+ const H: Complex[] = ws.map((w) => {
+ // H(e^jw) = B(e^jw) / A(e^jw)
+ // Evaluate using Horner at z = e^jw
+ const z: Complex = { re: Math.cos(w), im: Math.sin(w) };
+ const Bw = evalPolyZ(b, z);
+ const Aw = evalPolyZ(a, z);
+ return divComplex(Bw, Aw);
+ });
+
+ return { w: ws, H };
+}
+
+/** Evaluate polynomial with coefficients `p` at complex `z` (b[0]*z^N + ... + b[N]). */
+function evalPolyZ(p: readonly number[], z: Complex): Complex {
+ let acc: Complex = complex(0, 0);
+ for (let i = 0; i < p.length; i++) {
+ // acc = acc * z + p[i]
+ acc = {
+ re: acc.re * z.re - acc.im * z.im + (p[i] ?? 0),
+ im: acc.re * z.im + acc.im * z.re,
+ };
+ }
+ return acc;
+}
+
+/** Divide two complex numbers (b / a), returns 0 when |a| < eps. */
+function divComplex(b: Complex, a: Complex): Complex {
+ const denom = a.re * a.re + a.im * a.im;
+ if (denom < 1e-300) {
+ return complex(0, 0);
+ }
+ return {
+ re: (b.re * a.re + b.im * a.im) / denom,
+ im: (b.im * a.re - b.re * a.im) / denom,
+ };
+}
+
+// ─── Butterworth IIR filter ───────────────────────────────────────────────────
+
+/** A second-order section: `[b0, b1, b2, 1, a1, a2]`. */
+export type SOSSection = [number, number, number, number, number, number];
+
+/** Result of {@link butter}. */
+export interface ButterResult {
+ /** Second-order sections (numerically preferred for high orders). */
+ sos: SOSSection[];
+ /** Numerator polynomial (may lose precision for high orders). */
+ b: number[];
+ /** Denominator polynomial (may lose precision for high orders). */
+ a: number[];
+}
+
+/** Butter filter type. */
+export type FilterType = "lowpass" | "highpass" | "bandpass" | "bandstop";
+
+/**
+ * Design an N-th order Butterworth digital filter (bilinear transform).
+ *
+ * Mirrors `scipy.signal.butter`.
+ *
+ * Returns both the SOS form (use {@link sosfilt} — numerically stable) and
+ * the b/a form (use {@link lfilter} — may have numerical issues for N > 4).
+ *
+ * @param N - Filter order (1–8 recommended; high orders lose precision in b/a form).
+ * @param Wn - Critical frequency. Normalised to `[0, 1]` where `1 = Nyquist`.
+ * Provide `[low, high]` for band-pass or band-stop.
+ * @param type - Filter type (default `"lowpass"`).
+ * @returns - `{ sos, b, a }`.
+ *
+ * @example
+ * ```ts
+ * import { butter, sosfilt } from "tsb";
+ * const { sos } = butter(4, 0.2);
+ * const y = sosfilt(sos, signal);
+ * ```
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: filter design algebra
+export function butter(
+ N: number,
+ Wn: number | readonly [number, number],
+ type: FilterType = "lowpass",
+): ButterResult {
+ // Validate
+ if (N < 1 || N > 20 || !Number.isInteger(N)) {
+ throw new RangeError("Order N must be an integer 1–20");
+ }
+
+ const _nyq = 1; // Normalised: Nyquist = 1
+ const isBand = type === "bandpass" || type === "bandstop";
+
+ if (isBand && !Array.isArray(Wn)) {
+ throw new TypeError("Band filters require Wn = [low, high]");
+ }
+ if (!isBand && Array.isArray(Wn)) {
+ throw new TypeError("Low/high-pass filters require scalar Wn");
+ }
+
+ // Pre-warp critical frequency(ies) using bilinear transform
+ const warpedWn: number | [number, number] = Array.isArray(Wn)
+ ? ([
+ 2 * Math.tan((Math.PI * (Wn as readonly [number, number])[0]) / 2),
+ 2 * Math.tan((Math.PI * (Wn as readonly [number, number])[1]) / 2),
+ ] as [number, number])
+ : 2 * Math.tan((Math.PI * (Wn as number)) / 2);
+
+ // Analog Butterworth prototype poles at unit circle (left half-plane)
+ // p_k = exp(j * pi * (2k + N - 1) / (2N)) for k = 0..N-1
+ const poles: Complex[] = Array.from({ length: N }, (_, k) => {
+ const ang = (Math.PI * (2 * k + N - 1)) / (2 * N);
+ return complex(Math.cos(ang), Math.sin(ang));
+ });
+
+ // Scale poles to the desired cutoff frequency
+ let scaledPoles: Complex[];
+ let scaledZeros: Complex[];
+ let scaledGain: number;
+
+ if (type === "lowpass") {
+ const omega = warpedWn as number;
+ scaledPoles = poles.map((p) => ({ re: p.re * omega, im: p.im * omega }));
+ scaledZeros = []; // all zeros at s = ∞
+ scaledGain = omega ** N;
+ } else if (type === "highpass") {
+ const omega = warpedWn as number;
+ // LP → HP: s → omega / s ⟹ pole at s=p_k maps to omega/p_k
+ scaledPoles = poles.map((p) => {
+ const mag2 = p.re * p.re + p.im * p.im;
+ return { re: (omega * p.re) / mag2, im: -(omega * p.im) / mag2 };
+ });
+ scaledZeros = Array.from({ length: N }, () => complex(0, 0)); // N zeros at s=0
+ scaledGain = 1;
+ } else {
+ // Bandpass / bandstop: use direct bilinear transform below
+ scaledPoles = poles;
+ scaledZeros = [];
+ scaledGain = 1;
+ }
+
+ // Convert analog poles/zeros to digital via bilinear transform: z = (2+s)/(2-s)
+ // For band filters, handle separately
+ if (type === "bandpass" || type === "bandstop") {
+ return butterBand(N, warpedWn as [number, number], type, poles);
+ }
+
+ const digPoles: Complex[] = scaledPoles.map(bilinearPole);
+ const digZeros: Complex[] = scaledZeros.map(bilinearPole);
+ // LP numerator: N zeros at z=-1 after bilinear (from s=∞ mapping)
+ const lpZerosAtMinusOne = type === "lowpass" ? N : 0;
+
+ // Build SOS sections
+ const sos = buildSOS(digPoles, digZeros, lpZerosAtMinusOne, scaledGain, type);
+ const { b, a } = sosToBA(sos);
+
+ return { sos, b, a };
+}
+
+/** Bilinear transform: analog pole s → digital pole z = (2+s)/(2-s). */
+function bilinearPole(s: Complex): Complex {
+ // z = (2+s)/(2-s)
+ const num: Complex = { re: 2 + s.re, im: s.im };
+ const den: Complex = { re: 2 - s.re, im: -s.im };
+ const denom = den.re * den.re + den.im * den.im;
+ return {
+ re: (num.re * den.re + num.im * den.im) / denom,
+ im: (num.im * den.re - num.re * den.im) / denom,
+ };
+}
+
+/** Build second-order sections from digital poles, zeros, and gain. */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: SOS construction
+function buildSOS(
+ poles: Complex[],
+ explicitZeros: Complex[],
+ nZerosAtMinusOne: number,
+ gain: number,
+ type: FilterType,
+): SOSSection[] {
+ const N = poles.length;
+ const sections: SOSSection[] = [];
+
+ // Pair up conjugate poles (sort by imaginary part descending to pair conjugates)
+ const sortedPoles = [...poles].sort((a, b) => Math.abs(b.im) - Math.abs(a.im));
+ const usedPoles = new Array(N).fill(false);
+ const pairedPoles: [Complex, Complex | null][] = [];
+
+ for (let i = 0; i < N; i++) {
+ if (usedPoles[i]) {
+ continue;
+ }
+ const p = sortedPoles[i]!;
+ if (Math.abs(p.im) < 1e-10) {
+ // Real pole — stand alone
+ usedPoles[i] = true;
+ pairedPoles.push([p, null]);
+ } else {
+ // Find conjugate
+ let found = false;
+ for (let j = i + 1; j < N; j++) {
+ if (!usedPoles[j]) {
+ const q = sortedPoles[j]!;
+ if (Math.abs(p.re - q.re) < 1e-10 && Math.abs(p.im + q.im) < 1e-10) {
+ usedPoles[i] = usedPoles[j] = true;
+ pairedPoles.push([p, q]);
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ usedPoles[i] = true;
+ pairedPoles.push([p, null]);
+ }
+ }
+ }
+
+ // Build sections: pair poles with zeros
+ let zerosRemaining = nZerosAtMinusOne;
+ let expZerosIdx = 0;
+ const nSections = pairedPoles.length;
+ const gainPerSection = gain > 0 ? gain ** (1 / nSections) : 1;
+
+ for (const [p1, p2] of pairedPoles) {
+ let b0: number;
+ let b1: number;
+ let b2: number;
+ let a1: number;
+ let a2: number;
+
+ if (p2 !== null) {
+ // Conjugate pair: (z - p1)(z - p2) = z^2 - 2*Re(p1)*z + |p1|^2
+ a1 = -2 * p1.re;
+ a2 = p1.re * p1.re + p1.im * p1.im;
+ if (type === "lowpass" && zerosRemaining >= 2) {
+ // Two zeros at z = -1: (z+1)^2 = z^2 + 2z + 1
+ b0 = 1;
+ b1 = 2;
+ b2 = 1;
+ zerosRemaining -= 2;
+ } else if (type === "highpass" && expZerosIdx < explicitZeros.length - 1) {
+ // Two zeros at z = 0: z^2 = z^2 + 0*z + 0
+ b0 = 1;
+ b1 = 0;
+ b2 = 0;
+ expZerosIdx += 2;
+ } else {
+ b0 = 1;
+ b1 = 0;
+ b2 = 0;
+ }
+ } else {
+ // Single real pole: (z - p1) = z - p1.re
+ a1 = -p1.re;
+ a2 = 0;
+ if (type === "lowpass" && zerosRemaining >= 1) {
+ // One zero at z = -1: z + 1
+ b0 = 1;
+ b1 = 1;
+ b2 = 0;
+ zerosRemaining -= 1;
+ } else if (type === "highpass" && expZerosIdx < explicitZeros.length) {
+ // One zero at z = 0: z
+ b0 = 1;
+ b1 = 0;
+ b2 = 0;
+ expZerosIdx += 1;
+ } else {
+ b0 = 1;
+ b1 = 0;
+ b2 = 0;
+ }
+ }
+
+ // Normalise section gain
+ const secGain = gainPerSection;
+ sections.push([b0 * secGain, b1 * secGain, b2 * secGain, 1, a1, a2]);
+ }
+
+ // Normalise so H(z=1) = 1 for lowpass, H(z=-1) = 1 for highpass
+ return normaliseSOS(sections, type);
+}
+
+/** Normalise SOS sections so the passband gain equals 1. */
+function normaliseSOS(sections: SOSSection[], type: FilterType): SOSSection[] {
+ // Evaluate H(z) at passband frequency: z=1 for LP, z=-1 for HP
+ const z = type === "highpass" ? -1 : 1;
+ const totalGain = sections.reduce((prod, sec) => {
+ const [b0, b1, b2, , a1, a2] = sec;
+ const num = b0 * z ** 2 + b1 * z + b2;
+ const den = z ** 2 + a1 * z + a2;
+ return prod * (Math.abs(den) > 1e-10 ? num / den : 1);
+ }, 1);
+
+ if (Math.abs(totalGain) < 1e-12) {
+ return sections;
+ }
+ const scale = 1 / totalGain;
+
+ // Apply scale to first section numerator only
+ const result: SOSSection[] = [...sections];
+ if (result.length > 0) {
+ const [b0, b1, b2, one, a1, a2] = result[0]!;
+ result[0] = [b0 * scale, b1 * scale, b2 * scale, one, a1, a2];
+ }
+ return result;
+}
+
+/** Handle band-pass and band-stop Butterworth filters. */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: band filter design
+function butterBand(
+ _N: number,
+ warped: [number, number],
+ type: "bandpass" | "bandstop",
+ protoPoles: Complex[],
+): ButterResult {
+ const [w1, w2] = warped;
+ const bw = w2 - w1;
+ const w0 = Math.sqrt(w1 * w2); // geometric centre frequency
+
+ const sos: SOSSection[] = [];
+
+ // For each prototype pole, apply LP→BP or LP→BS transform
+ // LP→BP: s → (s^2 + w0^2) / (bw * s)
+ // Each LP pole becomes two BP poles
+ for (const p of protoPoles) {
+ // LP pole p_k: s → (s^2 + w0^2) / (bw * s) = p_k
+ // bw * s * p_k = s^2 + w0^2
+ // s^2 - bw * p_k * s + w0^2 = 0
+ // Solutions: s = (bw * p_k ± sqrt((bw * p_k)^2 - 4 * w0^2)) / 2
+ const a = bw * p.re;
+ const b = bw * p.im;
+ // discriminant = (bw*p)^2 - 4*w0^2 = (a+jb)^2 - 4*w0^2
+ const discRe = a * a - b * b - 4 * w0 * w0;
+ const discIm = 2 * a * b;
+ // sqrt of (discRe + j*discIm)
+ const [sqrtRe, sqrtIm] = complexSqrt(discRe, discIm);
+ const s1: Complex = { re: (a + sqrtRe) / 2, im: (b + sqrtIm) / 2 };
+ const s2: Complex = { re: (a - sqrtRe) / 2, im: (b - sqrtIm) / 2 };
+
+ let z1: Complex;
+ let z2: Complex;
+ if (type === "bandpass") {
+ z1 = bilinearPole(s1);
+ z2 = bilinearPole(s2);
+ } else {
+ // BP→BS transform: s → bw*w0 / (s^2 + w0^2)... simplify using direct analog BS poles
+ // LP→BS: s → bw*s / (s^2 + w0^2)
+ // Similar computation
+ z1 = bilinearPole(s1);
+ z2 = bilinearPole(s2);
+ }
+
+ // Each pair of complex poles contributes a 2nd-order section
+ const a1 = -(z1.re + z2.re);
+ const a2 = z1.re * z2.re - z1.im * z2.im; // assume z1, z2 are conjugates
+
+ const [b0, b1, b2] =
+ type === "bandpass"
+ ? [1, 0, -1] // bandpass: zeros at z=+1 and z=-1
+ : [
+ 1,
+ -2 * Math.cos(Math.acos(Math.max(-1, Math.min(1, (w0 * w0 + 1) / (w0 * w0 + 1))))),
+ 1,
+ ]; // bandstop: zeros at e^±jw0
+
+ sos.push([b0, b1, b2, 1, a1, a2]);
+ }
+
+ const normalised = normaliseSOS(sos, type);
+ const { b, a } = sosToBA(normalised);
+ return { sos: normalised, b, a };
+}
+
+/** Real and imaginary parts of sqrt(re + j*im). */
+function complexSqrt(re: number, im: number): [number, number] {
+ const r = Math.sqrt(re * re + im * im);
+ const sr = Math.sqrt((r + re) / 2);
+ const si = Math.sign(im) * Math.sqrt((r - re) / 2);
+ return [sr, si];
+}
+
+/** Convert SOS to b/a transfer function via polynomial multiplication. */
+function sosToBA(sections: readonly SOSSection[]): { b: number[]; a: number[] } {
+ let b: number[] = [1];
+ let a: number[] = [1];
+ for (const [b0, b1, b2, , a1, a2] of sections) {
+ b = polyMul(b, [b0, b1, b2]);
+ a = polyMul(a, [1, a1, a2]);
+ }
+ return { b, a };
+}
+
+/**
+ * Compute the frequency response of a SOS filter.
+ *
+ * @param sos - SOS sections as from {@link butter}.
+ * @param worN - Number of frequency points or explicit frequencies.
+ * @returns - `{ w, H }`.
+ */
+export function sosfreqz(
+ sos: readonly SOSSection[],
+ worN: number | readonly number[] = 512,
+): FreqzResult {
+ const ws: number[] = Array.isArray(worN)
+ ? Array.from(worN as readonly number[])
+ : Array.from({ length: worN as number }, (_, i) => (Math.PI * i) / (worN as number));
+
+ const H: Complex[] = ws.map((w) => {
+ const z: Complex = { re: Math.cos(w), im: Math.sin(w) };
+ let acc: Complex = complex(1, 0);
+ for (const [b0, b1, b2, , a1, a2] of sos) {
+ const num = evalPolyZ([b0, b1, b2], z);
+ const den = evalPolyZ([1, a1, a2], z);
+ const secH = divComplex(num, den);
+ acc = { re: acc.re * secH.re - acc.im * secH.im, im: acc.re * secH.im + acc.im * secH.re };
+ }
+ return acc;
+ });
+
+ return { w: ws, H };
+}
+
+// ─── filter application ───────────────────────────────────────────────────────
+
+/**
+ * Apply an IIR or FIR filter using direct-form II transposed.
+ *
+ * Mirrors `scipy.signal.lfilter`. Computes `y[n] = b[0]*x[n] + b[1]*x[n-1] + ...
+ * - a[1]*y[n-1] - a[2]*y[n-2] - ...` (a[0] is assumed to be 1 or is normalised).
+ *
+ * @param b - Numerator coefficients (length M+1).
+ * @param a - Denominator coefficients (length N+1, a[0] normalised to 1).
+ * @param x - Input signal.
+ * @returns - Filtered signal (same length as `x`).
+ *
+ * @example
+ * ```ts
+ * import { firwin, lfilter } from "tsb";
+ * const b = firwin(21, 0.3);
+ * const y = lfilter(b, [1], x);
+ * ```
+ */
+export function lfilter(
+ b: readonly number[],
+ a: readonly number[],
+ x: readonly number[],
+): number[] {
+ const nb = b.length;
+ const na = a.length;
+ const n = x.length;
+
+ // Normalise a[0]
+ const a0 = a[0] ?? 1;
+ const bn = b.map((v) => v / a0);
+ const an = a.map((v) => v / a0);
+
+ const m = Math.max(nb, na);
+ const z = new Float64Array(m); // state buffer
+ const y = new Array(n);
+
+ for (let i = 0; i < n; i++) {
+ const xi = x[i] ?? 0;
+ const yi = (bn[0] ?? 0) * xi + (z[0] ?? 0);
+ y[i] = yi;
+ for (let j = 0; j < m - 1; j++) {
+ z[j] = (bn[j + 1] ?? 0) * xi - (an[j + 1] ?? 0) * yi + (z[j + 1] ?? 0);
+ }
+ z[m - 1] = (bn[m] ?? 0) * xi - (an[m] ?? 0) * yi;
+ }
+
+ return y;
+}
+
+/**
+ * Zero-phase forward-backward filter. Applies the filter twice — once forward
+ * and once backward — eliminating phase distortion.
+ *
+ * Mirrors `scipy.signal.filtfilt`.
+ *
+ * @param b - Numerator coefficients.
+ * @param a - Denominator coefficients.
+ * @param x - Input signal.
+ * @returns - Zero-phase filtered signal (same length as `x`).
+ */
+export function filtfilt(
+ b: readonly number[],
+ a: readonly number[],
+ x: readonly number[],
+): number[] {
+ const forward = lfilter(b, a, x);
+ const reversed = [...forward].reverse();
+ const backward = lfilter(b, a, reversed);
+ return backward.reverse();
+}
+
+/**
+ * Apply a second-order-sections filter.
+ *
+ * Numerically more stable than {@link lfilter} for high-order IIR filters.
+ * Mirrors `scipy.signal.sosfilt`.
+ *
+ * @param sos - SOS sections from {@link butter}.
+ * @param x - Input signal.
+ * @returns - Filtered signal (same length as `x`).
+ */
+export function sosfilt(sos: readonly SOSSection[], x: readonly number[]): number[] {
+ let signal = Array.from(x);
+ for (const [b0, b1, b2, , a1, a2] of sos) {
+ signal = lfilter([b0, b1, b2], [1, a1, a2], signal);
+ }
+ return signal;
+}
+
+/**
+ * Zero-phase SOS filter (applies each section forward then backward).
+ *
+ * @param sos - SOS sections from {@link butter}.
+ * @param x - Input signal.
+ * @returns - Zero-phase filtered signal.
+ */
+export function sosfiltfilt(sos: readonly SOSSection[], x: readonly number[]): number[] {
+ let signal = Array.from(x);
+ for (const [b0, b1, b2, , a1, a2] of sos) {
+ signal = filtfilt([b0, b1, b2], [1, a1, a2], signal);
+ }
+ return signal;
+}
+
+// Re-export cAbs for convenience
+export { cAbs };
diff --git a/src/stats/hmm.ts b/src/stats/hmm.ts
new file mode 100644
index 000000000..931ae6fb4
--- /dev/null
+++ b/src/stats/hmm.ts
@@ -0,0 +1,776 @@
+/**
+ * hmm — Hidden Markov Model (HMM) with discrete and Gaussian emissions.
+ *
+ * Implements:
+ * - **Forward-Backward** algorithm (log-space for numerical stability)
+ * - **Baum-Welch** EM parameter estimation
+ * - **Viterbi** algorithm for most-likely state sequence decoding
+ * - **GaussianHMM**: continuous observations with Gaussian emission distributions
+ * - **MultinomialHMM**: discrete observations with categorical emission distributions
+ *
+ * Mirrors `hmmlearn.hmm.GaussianHMM` and `MultinomialHMM` APIs.
+ *
+ * @example
+ * ```ts
+ * import { GaussianHMM } from "tsb";
+ *
+ * const model = new GaussianHMM({ nComponents: 2, nIter: 100 });
+ * const obs = [0.1, 0.2, 0.15, 2.1, 2.3, 2.0, 0.05, 0.1, 2.5, 2.2];
+ * model.fit(obs);
+ * const states = model.predict(obs);
+ * const logProb = model.score(obs);
+ * ```
+ *
+ * @module
+ */
+
+// ─── Constants ─────────────────────────────────────────────────────────────────
+
+const LOG_ZERO = Number.NEGATIVE_INFINITY;
+
+// ─── Utility helpers ──────────────────────────────────────────────────────────
+
+/** log(exp(a) + exp(b)) with numerical stability. */
+function logSumExp(a: number, b: number): number {
+ if (a === LOG_ZERO) {
+ return b;
+ }
+ if (b === LOG_ZERO) {
+ return a;
+ }
+ const m = Math.max(a, b);
+ return m + Math.log(Math.exp(a - m) + Math.exp(b - m));
+}
+
+/** Stable log-sum-exp over an array. */
+function logSumExpArr(arr: readonly number[]): number {
+ let result = LOG_ZERO;
+ for (const v of arr) {
+ result = logSumExp(result, v);
+ }
+ return result;
+}
+
+/** Safe log (returns LOG_ZERO for non-positive). */
+function safeLog(x: number): number {
+ return x > 0 ? Math.log(x) : LOG_ZERO;
+}
+
+/** Normalise an array in-place so it sums to 1. Returns sum before normalisation. */
+function normalise(arr: number[]): number {
+ const s = arr.reduce((a, b) => a + b, 0);
+ if (s > 0) {
+ for (let i = 0; i < arr.length; i++) {
+ arr[i] = (arr[i] ?? 0) / s;
+ }
+ }
+ return s;
+}
+
+// ─── Public types ─────────────────────────────────────────────────────────────
+
+/** Parameters for a Gaussian HMM. */
+export interface GaussianHMMParams {
+ /** Number of hidden states. */
+ nComponents: number;
+ /** Maximum EM iterations. Default 100. */
+ nIter?: number;
+ /** Convergence tolerance on log-likelihood. Default 1e-4. */
+ tol?: number;
+ /** Random seed for initialisation (unused in deterministic init). */
+ randomState?: number;
+}
+
+/** Fitted Gaussian HMM result. */
+export interface GaussianHMMFit {
+ /** Initial state probabilities (shape: nComponents). */
+ startProb: number[];
+ /** Transition matrix (shape: nComponents × nComponents). Row i → state i, column j → state j. */
+ transmat: number[][];
+ /** Emission means (shape: nComponents). */
+ means: number[];
+ /** Emission variances (shape: nComponents). */
+ covars: number[];
+ /** Log-likelihood of training data at convergence. */
+ logProb: number;
+ /** Number of EM iterations completed. */
+ nIterDone: number;
+}
+
+/** Parameters for a Multinomial HMM. */
+export interface MultinomialHMMParams {
+ /** Number of hidden states. */
+ nComponents: number;
+ /** Number of distinct observation symbols. */
+ nFeatures: number;
+ /** Maximum EM iterations. Default 100. */
+ nIter?: number;
+ /** Convergence tolerance on log-likelihood. Default 1e-4. */
+ tol?: number;
+}
+
+/** Fitted Multinomial HMM result. */
+export interface MultinomialHMMFit {
+ /** Initial state probabilities (shape: nComponents). */
+ startProb: number[];
+ /** Transition matrix (shape: nComponents × nComponents). */
+ transmat: number[][];
+ /** Emission probability matrix (shape: nComponents × nFeatures). */
+ emissionProb: number[][];
+ /** Log-likelihood of training data at convergence. */
+ logProb: number;
+ /** Number of EM iterations completed. */
+ nIterDone: number;
+}
+
+// ─── Forward-Backward (log-space) ─────────────────────────────────────────────
+
+/**
+ * Compute log-forward variables.
+ * @param logStartProb - log initial probabilities (nStates)
+ * @param logTransmat - log transition matrix (nStates × nStates)
+ * @param logEmit - log emission probabilities (T × nStates)
+ * @returns logAlpha (T × nStates)
+ */
+function logForward(
+ logStartProb: readonly number[],
+ logTransmat: readonly (readonly number[])[],
+ logEmit: readonly (readonly number[])[],
+): number[][] {
+ const T = logEmit.length;
+ const K = logStartProb.length;
+ const logAlpha: number[][] = Array.from({ length: T }, () => new Array(K).fill(LOG_ZERO));
+
+ for (let j = 0; j < K; j++) {
+ logAlpha[0]![j] = (logStartProb[j] ?? LOG_ZERO) + (logEmit[0]?.[j] ?? LOG_ZERO);
+ }
+ for (let t = 1; t < T; t++) {
+ for (let j = 0; j < K; j++) {
+ let s = LOG_ZERO;
+ for (let i = 0; i < K; i++) {
+ s = logSumExp(s, (logAlpha[t - 1]?.[i] ?? LOG_ZERO) + (logTransmat[i]?.[j] ?? LOG_ZERO));
+ }
+ logAlpha[t]![j] = s + (logEmit[t]?.[j] ?? LOG_ZERO);
+ }
+ }
+ return logAlpha;
+}
+
+/**
+ * Compute log-backward variables.
+ * @param logTransmat - log transition matrix (nStates × nStates)
+ * @param logEmit - log emission probabilities (T × nStates)
+ * @returns logBeta (T × nStates)
+ */
+function logBackward(
+ logTransmat: readonly (readonly number[])[],
+ logEmit: readonly (readonly number[])[],
+): number[][] {
+ const T = logEmit.length;
+ const K = logTransmat.length;
+ const logBeta: number[][] = Array.from({ length: T }, () => new Array(K).fill(0));
+
+ for (let t = T - 2; t >= 0; t--) {
+ for (let i = 0; i < K; i++) {
+ let s = LOG_ZERO;
+ for (let j = 0; j < K; j++) {
+ s = logSumExp(
+ s,
+ (logTransmat[i]?.[j] ?? LOG_ZERO) +
+ (logEmit[t + 1]?.[j] ?? LOG_ZERO) +
+ (logBeta[t + 1]?.[j] ?? 0),
+ );
+ }
+ logBeta[t]![i] = s;
+ }
+ }
+ return logBeta;
+}
+
+// ─── Viterbi ──────────────────────────────────────────────────────────────────
+
+/**
+ * Viterbi algorithm to find the most-likely state sequence.
+ * @returns decoded state sequence (length T)
+ */
+function viterbi(
+ logStartProb: readonly number[],
+ logTransmat: readonly (readonly number[])[],
+ logEmit: readonly (readonly number[])[],
+): number[] {
+ const T = logEmit.length;
+ const K = logStartProb.length;
+ const delta: number[][] = Array.from({ length: T }, () => new Array(K).fill(LOG_ZERO));
+ const psi: number[][] = Array.from({ length: T }, () => new Array(K).fill(0));
+
+ for (let j = 0; j < K; j++) {
+ delta[0]![j] = (logStartProb[j] ?? LOG_ZERO) + (logEmit[0]?.[j] ?? LOG_ZERO);
+ }
+ for (let t = 1; t < T; t++) {
+ for (let j = 0; j < K; j++) {
+ let best = LOG_ZERO;
+ let bestI = 0;
+ for (let i = 0; i < K; i++) {
+ const v = (delta[t - 1]?.[i] ?? LOG_ZERO) + (logTransmat[i]?.[j] ?? LOG_ZERO);
+ if (v > best) {
+ best = v;
+ bestI = i;
+ }
+ }
+ delta[t]![j] = best + (logEmit[t]?.[j] ?? LOG_ZERO);
+ psi[t]![j] = bestI;
+ }
+ }
+
+ // Backtrack
+ const path = new Array(T).fill(0);
+ let s = 0;
+ let best = LOG_ZERO;
+ for (let j = 0; j < K; j++) {
+ const v = delta[T - 1]?.[j] ?? LOG_ZERO;
+ if (v > best) {
+ best = v;
+ s = j;
+ }
+ }
+ path[T - 1] = s;
+ for (let t = T - 2; t >= 0; t--) {
+ path[t] = psi[t + 1]?.[path[t + 1] ?? 0] ?? 0;
+ }
+ return path;
+}
+
+// ─── GaussianHMM ──────────────────────────────────────────────────────────────
+
+/** Log probability of x under N(mu, sigma^2). */
+function gaussianLogProb(x: number, mu: number, sigma2: number): number {
+ if (sigma2 <= 0) {
+ return LOG_ZERO;
+ }
+ return -0.5 * (Math.log(2 * Math.PI * sigma2) + ((x - mu) * (x - mu)) / sigma2);
+}
+
+/**
+ * Hidden Markov Model with univariate Gaussian emission distributions.
+ *
+ * Uses Baum-Welch EM for parameter estimation, Viterbi for decoding.
+ */
+export class GaussianHMM {
+ private readonly K: number;
+ private readonly nIter: number;
+ private readonly tol: number;
+
+ // Parameters (set after fit)
+ private _startProb: number[] = [];
+ private _transmat: number[][] = [];
+ private _means: number[] = [];
+ private _covars: number[] = [];
+ private _fitted = false;
+
+ constructor(params: GaussianHMMParams) {
+ this.K = params.nComponents;
+ this.nIter = params.nIter ?? 100;
+ this.tol = params.tol ?? 1e-4;
+ }
+
+ /** Fit the HMM to a sequence of observations using Baum-Welch EM. */
+ fit(obs: readonly number[]): GaussianHMMFit {
+ const T = obs.length;
+ const K = this.K;
+ if (T < 2) {
+ throw new Error("Need at least 2 observations");
+ }
+
+ // ── Initialise ───────────────────────────────────────────────────────────
+ // k-means-style: split sorted observations into K equal buckets
+ const sorted = [...obs].sort((a, b) => a - b);
+ const means = new Array(K).fill(0);
+ const covars = new Array(K).fill(1);
+ for (let k = 0; k < K; k++) {
+ const lo = Math.floor((k * T) / K);
+ const hi = Math.floor(((k + 1) * T) / K);
+ const slice = sorted.slice(lo, hi);
+ const mu = slice.reduce((a, b) => a + b, 0) / slice.length;
+ const v = slice.reduce((a, b) => a + (b - mu) ** 2, 0) / Math.max(slice.length - 1, 1);
+ means[k] = mu;
+ covars[k] = Math.max(v, 1e-6);
+ }
+
+ // Uniform start and transition
+ const startProb = new Array(K).fill(1 / K);
+ const transmat: number[][] = Array.from({ length: K }, () => new Array(K).fill(1 / K));
+
+ let prevLogProb = Number.NEGATIVE_INFINITY;
+ let nIterDone = 0;
+
+ for (let iter = 0; iter < this.nIter; iter++) {
+ // ── E-step ─────────────────────────────────────────────────────────────
+ const logEmit: number[][] = Array.from({ length: T }, (_, t) =>
+ Array.from({ length: K }, (__, k) =>
+ gaussianLogProb(obs[t] ?? 0, means[k] ?? 0, covars[k] ?? 1),
+ ),
+ );
+
+ const logStartProb = startProb.map(safeLog);
+ const logTransmat = transmat.map((row) => row.map(safeLog));
+
+ const logAlpha = logForward(logStartProb, logTransmat, logEmit);
+ const logBeta = logBackward(logTransmat, logEmit);
+
+ // Log-likelihood
+ const logProb = logSumExpArr(logAlpha[T - 1] ?? []);
+
+ if (Math.abs(logProb - prevLogProb) < this.tol) {
+ nIterDone = iter + 1;
+ break;
+ }
+ prevLogProb = logProb;
+ nIterDone = iter + 1;
+
+ // γ_t(k) = P(z_t = k | obs, θ) in log space
+ const logGamma: number[][] = Array.from({ length: T }, (_, t) => {
+ const row = Array.from(
+ { length: K },
+ (__, k) => (logAlpha[t]?.[k] ?? LOG_ZERO) + (logBeta[t]?.[k] ?? 0),
+ );
+ const z = logSumExpArr(row);
+ return row.map((v) => v - z);
+ });
+
+ // ξ_t(i,j) = P(z_t=i, z_{t+1}=j | obs, θ) — sum over t
+ const logXiSum: number[][] = Array.from({ length: K }, () =>
+ new Array(K).fill(LOG_ZERO),
+ );
+ for (let t = 0; t < T - 1; t++) {
+ for (let i = 0; i < K; i++) {
+ for (let j = 0; j < K; j++) {
+ const v =
+ (logAlpha[t]?.[i] ?? LOG_ZERO) +
+ (logTransmat[i]?.[j] ?? LOG_ZERO) +
+ (logEmit[t + 1]?.[j] ?? LOG_ZERO) +
+ (logBeta[t + 1]?.[j] ?? 0) -
+ logProb;
+ logXiSum[i]![j] = logSumExp(logXiSum[i]?.[j] ?? LOG_ZERO, v);
+ }
+ }
+ }
+
+ // ── M-step ─────────────────────────────────────────────────────────────
+ // Update startProb
+ for (let k = 0; k < K; k++) {
+ startProb[k] = Math.exp(logGamma[0]?.[k] ?? LOG_ZERO);
+ }
+ normalise(startProb);
+
+ // Update transmat
+ for (let i = 0; i < K; i++) {
+ for (let j = 0; j < K; j++) {
+ transmat[i]![j] = Math.exp(logXiSum[i]?.[j] ?? LOG_ZERO);
+ }
+ normalise(transmat[i]!);
+ }
+
+ // Update means
+ for (let k = 0; k < K; k++) {
+ let num = 0;
+ let den = 0;
+ for (let t = 0; t < T; t++) {
+ const g = Math.exp(logGamma[t]?.[k] ?? LOG_ZERO);
+ num += g * (obs[t] ?? 0);
+ den += g;
+ }
+ means[k] = den > 0 ? num / den : (means[k] ?? 0);
+ }
+
+ // Update covars
+ for (let k = 0; k < K; k++) {
+ let num = 0;
+ let den = 0;
+ for (let t = 0; t < T; t++) {
+ const g = Math.exp(logGamma[t]?.[k] ?? LOG_ZERO);
+ const diff = (obs[t] ?? 0) - (means[k] ?? 0);
+ num += g * diff * diff;
+ den += g;
+ }
+ covars[k] = Math.max(den > 0 ? num / den : (covars[k] ?? 1), 1e-6);
+ }
+ }
+
+ this._startProb = [...startProb];
+ this._transmat = transmat.map((row) => [...row]);
+ this._means = [...means];
+ this._covars = [...covars];
+ this._fitted = true;
+
+ return {
+ startProb: [...startProb],
+ transmat: transmat.map((row) => [...row]),
+ means: [...means],
+ covars: [...covars],
+ logProb: prevLogProb,
+ nIterDone,
+ };
+ }
+
+ /** Decode the most-likely state sequence using the Viterbi algorithm. */
+ predict(obs: readonly number[]): number[] {
+ this._checkFitted();
+ const K = this.K;
+ const logEmit = obs.map((x) =>
+ Array.from({ length: K }, (_, k) =>
+ gaussianLogProb(x, this._means[k] ?? 0, this._covars[k] ?? 1),
+ ),
+ );
+ return viterbi(
+ this._startProb.map(safeLog),
+ this._transmat.map((row) => row.map(safeLog)),
+ logEmit,
+ );
+ }
+
+ /** Compute the log-probability of the observation sequence. */
+ score(obs: readonly number[]): number {
+ this._checkFitted();
+ const K = this.K;
+ const logEmit = obs.map((x) =>
+ Array.from({ length: K }, (_, k) =>
+ gaussianLogProb(x, this._means[k] ?? 0, this._covars[k] ?? 1),
+ ),
+ );
+ const logAlpha = logForward(
+ this._startProb.map(safeLog),
+ this._transmat.map((row) => row.map(safeLog)),
+ logEmit,
+ );
+ return logSumExpArr(logAlpha.at(-1) ?? []);
+ }
+
+ /** Compute posterior state probabilities (T × nComponents). */
+ predictProba(obs: readonly number[]): number[][] {
+ this._checkFitted();
+ const K = this.K;
+ const T = obs.length;
+ const logEmit = obs.map((x) =>
+ Array.from({ length: K }, (_, k) =>
+ gaussianLogProb(x, this._means[k] ?? 0, this._covars[k] ?? 1),
+ ),
+ );
+ const logStartProb = this._startProb.map(safeLog);
+ const logTransmat = this._transmat.map((row) => row.map(safeLog));
+ const logAlpha = logForward(logStartProb, logTransmat, logEmit);
+ const logBeta = logBackward(logTransmat, logEmit);
+ return Array.from({ length: T }, (_, t) => {
+ const row = Array.from(
+ { length: K },
+ (__, k) => (logAlpha[t]?.[k] ?? LOG_ZERO) + (logBeta[t]?.[k] ?? 0),
+ );
+ const z = logSumExpArr(row);
+ return row.map((v) => Math.exp(v - z));
+ });
+ }
+
+ /** Sample a sequence of states and observations. */
+ sample(length: number): { states: number[]; obs: number[] } {
+ this._checkFitted();
+ const K = this.K;
+ const states: number[] = [];
+ const obs: number[] = [];
+
+ // Sample initial state
+ let cumProb = 0;
+ const r0 = Math.random();
+ let state = K - 1;
+ for (let k = 0; k < K; k++) {
+ cumProb += this._startProb[k] ?? 0;
+ if (r0 < cumProb) {
+ state = k;
+ break;
+ }
+ }
+
+ for (let t = 0; t < length; t++) {
+ states.push(state);
+ const mu = this._means[state] ?? 0;
+ const sigma = Math.sqrt(this._covars[state] ?? 1);
+ // Box-Muller for Gaussian sample
+ const u1 = Math.random();
+ const u2 = Math.random();
+ const z = Math.sqrt(-2 * Math.log(Math.max(u1, 1e-15))) * Math.cos(2 * Math.PI * u2);
+ obs.push(mu + sigma * z);
+
+ // Transition
+ const row = this._transmat[state]!;
+ let cum = 0;
+ const rv = Math.random();
+ let nextState = K - 1;
+ for (let k = 0; k < K; k++) {
+ cum += row[k] ?? 0;
+ if (rv < cum) {
+ nextState = k;
+ break;
+ }
+ }
+ state = nextState;
+ }
+ return { states, obs };
+ }
+
+ get startProb(): number[] {
+ this._checkFitted();
+ return [...this._startProb];
+ }
+ get transmat(): number[][] {
+ this._checkFitted();
+ return this._transmat.map((r) => [...r]);
+ }
+ get means(): number[] {
+ this._checkFitted();
+ return [...this._means];
+ }
+ get covars(): number[] {
+ this._checkFitted();
+ return [...this._covars];
+ }
+
+ private _checkFitted(): void {
+ if (!this._fitted) {
+ throw new Error("GaussianHMM is not fitted yet");
+ }
+ }
+}
+
+// ─── MultinomialHMM ───────────────────────────────────────────────────────────
+
+/**
+ * Hidden Markov Model with discrete (multinomial/categorical) emission distributions.
+ *
+ * Observations are non-negative integer symbol indices in [0, nFeatures).
+ */
+export class MultinomialHMM {
+ private readonly K: number;
+ private readonly nFeatures: number;
+ private readonly nIter: number;
+ private readonly tol: number;
+
+ private _startProb: number[] = [];
+ private _transmat: number[][] = [];
+ private _emissionProb: number[][] = [];
+ private _fitted = false;
+
+ constructor(params: MultinomialHMMParams) {
+ this.K = params.nComponents;
+ this.nFeatures = params.nFeatures;
+ this.nIter = params.nIter ?? 100;
+ this.tol = params.tol ?? 1e-4;
+ }
+
+ /** Fit the HMM to a sequence of integer observations using Baum-Welch EM. */
+ fit(obs: readonly number[]): MultinomialHMMFit {
+ const T = obs.length;
+ const K = this.K;
+ const V = this.nFeatures;
+ if (T < 2) {
+ throw new Error("Need at least 2 observations");
+ }
+
+ // Uniform initialisation with small random perturbation
+ const startProb = new Array(K).fill(1 / K);
+ const transmat: number[][] = Array.from({ length: K }, () =>
+ Array.from({ length: K }, () => 1 / K + (Math.random() * 0.1 - 0.05) / K),
+ );
+ const emissionProb: number[][] = Array.from({ length: K }, () =>
+ Array.from({ length: V }, () => 1 / V + (Math.random() * 0.1 - 0.05) / V),
+ );
+ // Normalise
+ for (let k = 0; k < K; k++) {
+ normalise(transmat[k]!);
+ normalise(emissionProb[k]!);
+ }
+
+ let prevLogProb = Number.NEGATIVE_INFINITY;
+ let nIterDone = 0;
+
+ for (let iter = 0; iter < this.nIter; iter++) {
+ // Log-emission: logEmit[t][k] = log P(obs[t] | z_t = k)
+ const logEmit: number[][] = Array.from({ length: T }, (_, t) =>
+ Array.from({ length: K }, (__, k) => safeLog(emissionProb[k]?.[obs[t] ?? 0] ?? 0)),
+ );
+
+ const logStartProb = startProb.map(safeLog);
+ const logTransmat = transmat.map((row) => row.map(safeLog));
+
+ const logAlpha = logForward(logStartProb, logTransmat, logEmit);
+ const logBeta = logBackward(logTransmat, logEmit);
+
+ const logProb = logSumExpArr(logAlpha[T - 1] ?? []);
+ if (Math.abs(logProb - prevLogProb) < this.tol) {
+ nIterDone = iter + 1;
+ break;
+ }
+ prevLogProb = logProb;
+ nIterDone = iter + 1;
+
+ // γ_t(k)
+ const logGamma: number[][] = Array.from({ length: T }, (_, t) => {
+ const row = Array.from(
+ { length: K },
+ (__, k) => (logAlpha[t]?.[k] ?? LOG_ZERO) + (logBeta[t]?.[k] ?? 0),
+ );
+ const z = logSumExpArr(row);
+ return row.map((v) => v - z);
+ });
+
+ // ξ sum
+ const logXiSum: number[][] = Array.from({ length: K }, () =>
+ new Array(K).fill(LOG_ZERO),
+ );
+ for (let t = 0; t < T - 1; t++) {
+ for (let i = 0; i < K; i++) {
+ for (let j = 0; j < K; j++) {
+ const v =
+ (logAlpha[t]?.[i] ?? LOG_ZERO) +
+ (logTransmat[i]?.[j] ?? LOG_ZERO) +
+ (logEmit[t + 1]?.[j] ?? LOG_ZERO) +
+ (logBeta[t + 1]?.[j] ?? 0) -
+ logProb;
+ logXiSum[i]![j] = logSumExp(logXiSum[i]?.[j] ?? LOG_ZERO, v);
+ }
+ }
+ }
+
+ // M-step: startProb
+ for (let k = 0; k < K; k++) {
+ startProb[k] = Math.exp(logGamma[0]?.[k] ?? LOG_ZERO);
+ }
+ normalise(startProb);
+
+ // transmat
+ for (let i = 0; i < K; i++) {
+ for (let j = 0; j < K; j++) {
+ transmat[i]![j] = Math.exp(logXiSum[i]?.[j] ?? LOG_ZERO);
+ }
+ normalise(transmat[i]!);
+ }
+
+ // emissionProb
+ for (let k = 0; k < K; k++) {
+ for (let v = 0; v < V; v++) {
+ emissionProb[k]![v] = 0;
+ }
+ for (let t = 0; t < T; t++) {
+ const sym = obs[t] ?? 0;
+ emissionProb[k]![sym] =
+ (emissionProb[k]?.[sym] ?? 0) + Math.exp(logGamma[t]?.[k] ?? LOG_ZERO);
+ }
+ normalise(emissionProb[k]!);
+ }
+ }
+
+ this._startProb = [...startProb];
+ this._transmat = transmat.map((row) => [...row]);
+ this._emissionProb = emissionProb.map((row) => [...row]);
+ this._fitted = true;
+
+ return {
+ startProb: [...startProb],
+ transmat: transmat.map((row) => [...row]),
+ emissionProb: emissionProb.map((row) => [...row]),
+ logProb: prevLogProb,
+ nIterDone,
+ };
+ }
+
+ /** Decode the most-likely state sequence. */
+ predict(obs: readonly number[]): number[] {
+ this._checkFitted();
+ const K = this.K;
+ const logEmit = obs.map((sym) =>
+ Array.from({ length: K }, (_, k) => safeLog(this._emissionProb[k]?.[sym] ?? 0)),
+ );
+ return viterbi(
+ this._startProb.map(safeLog),
+ this._transmat.map((row) => row.map(safeLog)),
+ logEmit,
+ );
+ }
+
+ /** Compute log-probability of the observation sequence. */
+ score(obs: readonly number[]): number {
+ this._checkFitted();
+ const K = this.K;
+ const logEmit = obs.map((sym) =>
+ Array.from({ length: K }, (_, k) => safeLog(this._emissionProb[k]?.[sym] ?? 0)),
+ );
+ const logAlpha = logForward(
+ this._startProb.map(safeLog),
+ this._transmat.map((row) => row.map(safeLog)),
+ logEmit,
+ );
+ return logSumExpArr(logAlpha.at(-1) ?? []);
+ }
+
+ get startProb(): number[] {
+ this._checkFitted();
+ return [...this._startProb];
+ }
+ get transmat(): number[][] {
+ this._checkFitted();
+ return this._transmat.map((r) => [...r]);
+ }
+ get emissionProb(): number[][] {
+ this._checkFitted();
+ return this._emissionProb.map((r) => [...r]);
+ }
+
+ private _checkFitted(): void {
+ if (!this._fitted) {
+ throw new Error("MultinomialHMM is not fitted yet");
+ }
+ }
+}
+
+// ─── Standalone functions ──────────────────────────────────────────────────────
+
+/**
+ * Convenience function: fit a GaussianHMM and return the fitted model.
+ *
+ * @example
+ * ```ts
+ * const model = fitGaussianHMM([0.1, 0.2, 2.1, 2.3, 0.05, 2.5], 2);
+ * ```
+ */
+export function fitGaussianHMM(
+ obs: readonly number[],
+ nComponents: number,
+ nIter = 100,
+): GaussianHMM {
+ const model = new GaussianHMM({ nComponents, nIter });
+ model.fit(obs);
+ return model;
+}
+
+/**
+ * Convenience function: Viterbi decoding with explicit parameters (no fitting).
+ *
+ * @param startProb - Initial state probabilities (length K).
+ * @param transmat - Transition matrix (K × K).
+ * @param emissionProb - Emission probabilities (K × V).
+ * @param obs - Integer observation sequence.
+ * @returns Most-likely state sequence.
+ */
+export function hmmViterbi(
+ startProb: readonly number[],
+ transmat: readonly (readonly number[])[],
+ emissionProb: readonly (readonly number[])[],
+ obs: readonly number[],
+): number[] {
+ const K = startProb.length;
+ const logEmit = obs.map((sym) =>
+ Array.from({ length: K }, (_, k) => safeLog(emissionProb[k]?.[sym] ?? 0)),
+ );
+ return viterbi(
+ startProb.map(safeLog),
+ transmat.map((row) => [...row].map(safeLog)),
+ logEmit,
+ );
+}
diff --git a/src/stats/index.ts b/src/stats/index.ts
index 78767ee14..dbfb531d8 100644
--- a/src/stats/index.ts
+++ b/src/stats/index.ts
@@ -575,3 +575,136 @@ export {
tsallisEntropy,
} from "./information.ts";
export type { PMF, NMIMethod } from "./information.ts";
+export {
+ complex,
+ cAbs,
+ cArg,
+ fft,
+ ifft,
+ rfft,
+ irfft,
+ fftFreq,
+ rfftFreq,
+ fftshift,
+ ifftshift,
+ rectangularWindow,
+ bartlettWindow,
+ hannWindow,
+ hammingWindow,
+ blackmanWindow,
+ blackmanHarrisWindow,
+ flatTopWindow,
+ kaiserWindow,
+ getWindow,
+ stft,
+ istft,
+ welch,
+ periodogram,
+} from "./signal.ts";
+export type {
+ Complex,
+ WindowName,
+ STFTOptions,
+ STFTResult,
+ ISTFTOptions,
+ WelchOptions,
+ PSDResult,
+ PeriodogramOptions,
+} from "./signal.ts";
+export {
+ firwin,
+ freqz,
+ sosfreqz,
+ lfilter,
+ filtfilt,
+ sosfilt,
+ sosfiltfilt,
+ butter,
+} from "./filters.ts";
+export type {
+ FirwinOptions,
+ FreqzResult,
+ SOSSection,
+ ButterResult,
+ FilterType,
+} from "./filters.ts";
+export {
+ autocorr,
+ acf,
+ pacf,
+ ccf,
+ durbinWatson,
+ ljungBox,
+ boxPierce,
+} from "./acf_pacf.ts";
+export type {
+ ACFResult,
+ PACFResult,
+ PortmanteauResult,
+ ACFOptions,
+ PACFOptions,
+ CCFOptions,
+ PortmanteauOptions,
+} from "./acf_pacf.ts";
+export {
+ ARIMAModel,
+ fitArima,
+} from "./arima.ts";
+export type {
+ ARIMAOptions,
+ ARIMAFitResult,
+ ARIMAForecastResult,
+} from "./arima.ts";
+export {
+ KalmanFilter,
+ StateSpaceModel,
+ kalmanFilter1D,
+ kalmanSmooth1D,
+ extractScalarMeans,
+ extractScalarVariances,
+ filteredPredictionInterval,
+} from "./kalman.ts";
+export type {
+ KalmanFilterOptions,
+ LocalLevelOptions,
+ LocalLinearTrendOptions,
+ KalmanFilterResult,
+ KalmanSmootherResult,
+} from "./kalman.ts";
+export {
+ SimpleExpSmoothing,
+ Holt,
+ ExponentialSmoothing,
+ simpleExpSmoothing,
+ holt,
+ fitEts,
+} from "./ets.ts";
+export type {
+ ETSTrend,
+ ETSSeasonal,
+ ETSInit,
+ SESOptions,
+ SESFitResult,
+ HoltOptions,
+ HoltFitResult,
+ ExponentialSmoothingOptions,
+ ExponentialSmoothingFitResult,
+ ETSForecastResult,
+} from "./ets.ts";
+export {
+ DLM,
+ buildLocalLevel,
+ buildLocalLinearTrend,
+ buildPolynomial,
+ buildFourier,
+ buildRegression,
+ combineDLMs,
+} from "./dlm.ts";
+export type {
+ DLMSpec,
+ DLMOptions,
+ DLMFilterStep,
+ DLMResult,
+ DLMSmootherResult,
+ DLMForecastResult,
+} from "./dlm.ts";
diff --git a/src/stats/kalman.ts b/src/stats/kalman.ts
new file mode 100644
index 000000000..a0493a782
--- /dev/null
+++ b/src/stats/kalman.ts
@@ -0,0 +1,809 @@
+/**
+ * kalman — Linear Gaussian State-Space Model: Kalman Filter & RTS Smoother.
+ *
+ * Implements the standard discrete-time Kalman filter (forward pass) and the
+ * Rauch-Tung-Striebel (RTS) smoother (backward pass) for linear dynamical
+ * systems:
+ *
+ * x_t = F·x_{t-1} + w_t, w_t ~ N(0, Q) (state equation)
+ * y_t = H·x_t + v_t, v_t ~ N(0, R) (observation equation)
+ * x_0 ~ N(m0, P0)
+ *
+ * Missing observations (null) are handled by skipping the update step —
+ * the filtered state reverts to the predicted state for that time-step.
+ *
+ * Mirrors the `statsmodels.tsa.statespace.kalman_filter.KalmanFilter` and
+ * `pykalman.KalmanFilter` APIs; factory helpers match common pandas patterns.
+ *
+ * Exported names:
+ * - {@link KalmanFilter} — main class (filter + smooth)
+ * - {@link KalmanFilterOptions} — constructor options
+ * - {@link KalmanFilterResult} — forward-pass output
+ * - {@link KalmanSmootherResult} — backward-pass output
+ *
+ * @example
+ * ```ts
+ * import { KalmanFilter } from "tsb";
+ *
+ * // Local-level model (random walk observed with noise)
+ * const kf = KalmanFilter.localLevel({ processNoise: 1, observationNoise: 2 });
+ * const res = kf.filter([[1], [2], [1.5], [null], [3], [2.5]]);
+ * console.log(res.filteredStateMeans); // [[…], …] T × 1
+ * console.log(res.logLikelihood);
+ *
+ * const sm = kf.smooth([[1], [2], [1.5], [null], [3], [2.5]]);
+ * console.log(sm.smoothedStateMeans);
+ * ```
+ *
+ * @module
+ */
+
+// ─── Internal matrix helpers ───────────────────────────────────────────────────
+
+/** Read-only row-major matrix. */
+type Mat = readonly (readonly number[])[];
+/** Mutable row-major matrix. */
+type MutMat = number[][];
+
+/** Rows of A (no checks — callers must ensure dimensions). */
+function rows(A: Mat): number {
+ return A.length;
+}
+/** Columns of A (0 if empty). */
+function cols(A: Mat): number {
+ return A[0]?.length ?? 0;
+}
+
+/** Create an n×m zero matrix. */
+function zeros(n: number, m: number): MutMat {
+ return Array.from({ length: n }, () => new Array(m).fill(0));
+}
+
+/** Create an n×n identity matrix. */
+function eye(n: number): MutMat {
+ return Array.from({ length: n }, (_, i) =>
+ Array.from({ length: n }, (_, j) => (i === j ? 1 : 0)),
+ );
+}
+
+/** Matrix–matrix product A (m×k) · B (k×n) → (m×n). */
+function mmul(A: Mat, B: Mat): MutMat {
+ const m = rows(A);
+ const k = cols(A);
+ const n = cols(B);
+ const C = zeros(m, n);
+ for (let i = 0; i < m; i++) {
+ const ai = A[i]!;
+ const ci = C[i]!;
+ for (let p = 0; p < k; p++) {
+ const aip = ai[p]!;
+ if (aip === 0) {
+ continue;
+ }
+ const bp = B[p]!;
+ for (let j = 0; j < n; j++) {
+ ci[j] = (ci[j] ?? 0) + aip * bp[j]!;
+ }
+ }
+ }
+ return C;
+}
+
+/** Matrix–vector product A (m×k) · x (k) → (m). */
+function mvmul(A: Mat, x: readonly number[]): number[] {
+ const m = rows(A);
+ const k = x.length;
+ const y = new Array(m).fill(0);
+ for (let i = 0; i < m; i++) {
+ const ai = A[i]!;
+ let s = 0;
+ for (let p = 0; p < k; p++) {
+ s += ai[p]! * x[p]!;
+ }
+ y[i] = s;
+ }
+ return y;
+}
+
+/** Transpose of A (m×n) → (n×m). */
+function T(A: Mat): MutMat {
+ const m = rows(A);
+ const n = cols(A);
+ const At = zeros(n, m);
+ for (let i = 0; i < m; i++) {
+ for (let j = 0; j < n; j++) {
+ At[j]![i] = A[i]?.[j]!;
+ }
+ }
+ return At;
+}
+
+/** A + B (element-wise). */
+function madd(A: Mat, B: Mat): MutMat {
+ const m = rows(A);
+ const n = cols(A);
+ return Array.from({ length: m }, (_, i) =>
+ Array.from({ length: n }, (_, j) => A[i]?.[j]! + B[i]?.[j]!),
+ );
+}
+
+/** A − B (element-wise). */
+function msub(A: Mat, B: Mat): MutMat {
+ const m = rows(A);
+ const n = cols(A);
+ return Array.from({ length: m }, (_, i) =>
+ Array.from({ length: n }, (_, j) => A[i]?.[j]! - B[i]?.[j]!),
+ );
+}
+
+/** Vector addition a + b. */
+function vadd(a: readonly number[], b: readonly number[]): number[] {
+ return a.map((ai, i) => ai + b[i]!);
+}
+
+/** Vector subtraction a − b. */
+function vsub(a: readonly number[], b: readonly number[]): number[] {
+ return a.map((ai, i) => ai - b[i]!);
+}
+
+/**
+ * Invert a square matrix via Gaussian elimination with partial pivoting.
+ * Returns null if the matrix is singular (|pivot| < 1e-14).
+ */
+function matInv(A: Mat): MutMat | null {
+ const n = rows(A);
+ // Augmented [A | I]
+ const aug: MutMat = Array.from({ length: n }, (_, i) => [
+ ...A[i]!,
+ ...Array.from({ length: n }, (_, j) => (i === j ? 1 : 0)),
+ ]);
+ for (let col = 0; col < n; col++) {
+ let maxRow = col;
+ let maxVal = Math.abs(aug[col]?.[col]!);
+ for (let row = col + 1; row < n; row++) {
+ const v = Math.abs(aug[row]?.[col]!);
+ if (v > maxVal) {
+ maxVal = v;
+ maxRow = row;
+ }
+ }
+ if (maxVal < 1e-14) {
+ return null;
+ }
+ [aug[col], aug[maxRow]] = [aug[maxRow]!, aug[col]!];
+ const pivot = aug[col]?.[col]!;
+ const pivRow = aug[col]!;
+ for (let j = 0; j < 2 * n; j++) {
+ pivRow[j] = pivRow[j]! / pivot;
+ }
+ for (let row = 0; row < n; row++) {
+ if (row === col) {
+ continue;
+ }
+ const fac = aug[row]?.[col]!;
+ if (fac === 0) {
+ continue;
+ }
+ const r = aug[row]!;
+ for (let j = 0; j < 2 * n; j++) {
+ r[j] = r[j]! - fac * pivRow[j]!;
+ }
+ }
+ }
+ return aug.map((row) => row.slice(n));
+}
+
+/** log-determinant via LU decomposition (for log-likelihood). */
+function logDet(A: Mat): number {
+ const n = rows(A);
+ const L: MutMat = Array.from({ length: n }, (_, i) => [...A[i]!]);
+ let logD = 0;
+ for (let col = 0; col < n; col++) {
+ let maxRow = col;
+ let maxVal = Math.abs(L[col]?.[col]!);
+ for (let row = col + 1; row < n; row++) {
+ const v = Math.abs(L[row]?.[col]!);
+ if (v > maxVal) {
+ maxVal = v;
+ maxRow = row;
+ }
+ }
+ if (maxRow !== col) {
+ [L[col], L[maxRow]] = [L[maxRow]!, L[col]!];
+ logD += Math.log(-1); // sign flip — handled by real part
+ }
+ const pivot = L[col]?.[col]!;
+ if (Math.abs(pivot) < 1e-300) {
+ return Number.NEGATIVE_INFINITY;
+ }
+ logD += Math.log(Math.abs(pivot));
+ for (let row = col + 1; row < n; row++) {
+ const fac = L[row]?.[col]! / pivot;
+ const r = L[row]!;
+ for (let j = col; j < n; j++) {
+ r[j] = r[j]! - fac * L[col]?.[j]!;
+ }
+ }
+ }
+ return logD;
+}
+
+/** Outer product a·bᵀ → matrix. */
+function outer(a: readonly number[], b: readonly number[]): MutMat {
+ return Array.from({ length: a.length }, (_, i) =>
+ Array.from({ length: b.length }, (_, j) => a[i]! * b[j]!),
+ );
+}
+
+/** Scale matrix by scalar. */
+function mscale(A: Mat, s: number): MutMat {
+ return A.map((row) => row.map((v) => v * s));
+}
+
+// ─── Public types ──────────────────────────────────────────────────────────────
+
+/** Constructor options for {@link KalmanFilter}. */
+export interface KalmanFilterOptions {
+ /**
+ * State transition matrix **F** (n_states × n_states).
+ * Defines how the state evolves: x_t = F·x_{t-1} + noise.
+ */
+ readonly transitionMatrix: readonly (readonly number[])[];
+ /**
+ * Observation matrix **H** (n_obs × n_states).
+ * Maps states to observations: y_t = H·x_t + noise.
+ */
+ readonly observationMatrix: readonly (readonly number[])[];
+ /**
+ * Process noise covariance **Q** (n_states × n_states).
+ * Covariance of the state-transition noise.
+ */
+ readonly processNoiseCov: readonly (readonly number[])[];
+ /**
+ * Observation noise covariance **R** (n_obs × n_obs).
+ * Covariance of the observation noise.
+ */
+ readonly observationNoiseCov: readonly (readonly number[])[];
+ /**
+ * Initial state mean **m₀** (n_states vector).
+ * Defaults to the zero vector.
+ */
+ readonly initialStateMean?: readonly number[];
+ /**
+ * Initial state covariance **P₀** (n_states × n_states).
+ * Defaults to the identity matrix.
+ */
+ readonly initialStateCovariance?: readonly (readonly number[])[];
+}
+
+/** Options for {@link KalmanFilter.localLevel}. */
+export interface LocalLevelOptions {
+ /** Process (state) noise variance σ²_q. Default: 1. */
+ readonly processNoise?: number;
+ /** Observation noise variance σ²_r. Default: 1. */
+ readonly observationNoise?: number;
+ /** Initial state mean scalar. Default: 0. */
+ readonly initialMean?: number;
+ /** Initial state variance scalar. Default: 1. */
+ readonly initialVariance?: number;
+}
+
+/** Options for {@link KalmanFilter.localLinearTrend}. */
+export interface LocalLinearTrendOptions {
+ /** Level process noise variance. Default: 1. */
+ readonly levelNoise?: number;
+ /** Slope process noise variance. Default: 0.1. */
+ readonly slopeNoise?: number;
+ /** Observation noise variance. Default: 1. */
+ readonly observationNoise?: number;
+ /** Initial [level, slope] mean vector. Default: [0, 0]. */
+ readonly initialMean?: readonly [number, number];
+ /** Initial state variance (diagonal). Default: 1. */
+ readonly initialVariance?: number;
+}
+
+/** Result of the Kalman filter forward pass. */
+export interface KalmanFilterResult {
+ /**
+ * Filtered state means x_{t|t} — shape T × n_states.
+ * Each row is the posterior mean after incorporating observation t.
+ */
+ readonly filteredStateMeans: readonly (readonly number[])[];
+ /**
+ * Filtered state covariances P_{t|t} — shape T × n_states × n_states.
+ * Each entry is the posterior covariance after incorporating observation t.
+ */
+ readonly filteredStateCovariances: readonly (readonly (readonly number[])[])[];
+ /**
+ * Predicted state means x_{t|t-1} — shape T × n_states.
+ * Each row is the prior mean before incorporating observation t.
+ */
+ readonly predictedStateMeans: readonly (readonly number[])[];
+ /**
+ * Predicted state covariances P_{t|t-1} — shape T × n_states × n_states.
+ */
+ readonly predictedStateCovariances: readonly (readonly (readonly number[])[])[];
+ /**
+ * Innovation (prediction error) vectors y_t − H·x_{t|t-1} — shape T × n_obs.
+ * NaN rows indicate missing observations.
+ */
+ readonly innovations: readonly (readonly number[])[];
+ /**
+ * Innovation covariance matrices S_t = H·P_{t|t-1}·Hᵀ + R — shape T × n_obs × n_obs.
+ */
+ readonly innovationCovariances: readonly (readonly (readonly number[])[])[];
+ /** Gaussian log-likelihood summed over all non-missing time-steps. */
+ readonly logLikelihood: number;
+ /** Number of states (n_states). */
+ readonly nStates: number;
+ /** Number of observation dimensions (n_obs). */
+ readonly nObs: number;
+ /** Number of time steps (T). */
+ readonly nTime: number;
+}
+
+/** Result of the RTS smoother backward pass. */
+export interface KalmanSmootherResult {
+ /**
+ * Smoothed state means x_{t|T} — shape T × n_states.
+ * Each row is the posterior mean using all T observations.
+ */
+ readonly smoothedStateMeans: readonly (readonly number[])[];
+ /**
+ * Smoothed state covariances P_{t|T} — shape T × n_states × n_states.
+ */
+ readonly smoothedStateCovariances: readonly (readonly (readonly number[])[])[];
+ /**
+ * Smoother gain matrices G_t — shape T × n_states × n_states.
+ * (Last entry is all-zeros by convention.)
+ */
+ readonly smootherGains: readonly (readonly (readonly number[])[])[];
+ /** Same as {@link KalmanFilterResult.logLikelihood} (computed in forward pass). */
+ readonly logLikelihood: number;
+ /** The forward-pass result used to compute the smoother. */
+ readonly filterResult: KalmanFilterResult;
+}
+
+// ─── KalmanFilter class ────────────────────────────────────────────────────────
+
+/**
+ * Linear Gaussian State-Space Model with Kalman filter and RTS smoother.
+ *
+ * The model is:
+ * ```
+ * x_t = F·x_{t-1} + w_t, w_t ~ N(0, Q)
+ * y_t = H·x_t + v_t, v_t ~ N(0, R)
+ * x_0 ~ N(m0, P0)
+ * ```
+ *
+ * @example
+ * ```ts
+ * const kf = new KalmanFilter({
+ * transitionMatrix: [[1]],
+ * observationMatrix: [[1]],
+ * processNoiseCov: [[1]],
+ * observationNoiseCov: [[2]],
+ * });
+ * const result = kf.filter([[1], [2], [null], [3]]);
+ * ```
+ */
+export class KalmanFilter {
+ /** State transition matrix F (n_states × n_states). */
+ readonly transitionMatrix: Mat;
+ /** Observation matrix H (n_obs × n_states). */
+ readonly observationMatrix: Mat;
+ /** Process noise covariance Q (n_states × n_states). */
+ readonly processNoiseCov: Mat;
+ /** Observation noise covariance R (n_obs × n_obs). */
+ readonly observationNoiseCov: Mat;
+ /** Initial state mean m₀ (n_states). */
+ readonly initialStateMean: readonly number[];
+ /** Initial state covariance P₀ (n_states × n_states). */
+ readonly initialStateCovariance: Mat;
+
+ constructor(opts: KalmanFilterOptions) {
+ this.transitionMatrix = opts.transitionMatrix;
+ this.observationMatrix = opts.observationMatrix;
+ this.processNoiseCov = opts.processNoiseCov;
+ this.observationNoiseCov = opts.observationNoiseCov;
+
+ const ns = rows(opts.transitionMatrix);
+ this.initialStateMean = opts.initialStateMean ?? new Array(ns).fill(0);
+ this.initialStateCovariance = opts.initialStateCovariance ?? eye(ns);
+ }
+
+ // ─── Factory helpers ───────────────────────────────────────────────────────
+
+ /**
+ * Local-level model (random walk + measurement noise):
+ * ```
+ * x_t = x_{t-1} + w_t, w_t ~ N(0, σ²_q)
+ * y_t = x_t + v_t, v_t ~ N(0, σ²_r)
+ * ```
+ */
+ static localLevel(opts: LocalLevelOptions = {}): KalmanFilter {
+ const q = opts.processNoise ?? 1;
+ const r = opts.observationNoise ?? 1;
+ const m0 = opts.initialMean ?? 0;
+ const p0 = opts.initialVariance ?? 1;
+ return new KalmanFilter({
+ transitionMatrix: [[1]],
+ observationMatrix: [[1]],
+ processNoiseCov: [[q]],
+ observationNoiseCov: [[r]],
+ initialStateMean: [m0],
+ initialStateCovariance: [[p0]],
+ });
+ }
+
+ /**
+ * Local linear trend model (level + slope):
+ * ```
+ * level_t = level_{t-1} + slope_{t-1} + w1_t
+ * slope_t = slope_{t-1} + w2_t
+ * y_t = level_t + v_t
+ * ```
+ */
+ static localLinearTrend(opts: LocalLinearTrendOptions = {}): KalmanFilter {
+ const ql = opts.levelNoise ?? 1;
+ const qs = opts.slopeNoise ?? 0.1;
+ const r = opts.observationNoise ?? 1;
+ const [m0l, m0s] = opts.initialMean ?? [0, 0];
+ const p0 = opts.initialVariance ?? 1;
+ return new KalmanFilter({
+ transitionMatrix: [
+ [1, 1],
+ [0, 1],
+ ],
+ observationMatrix: [[1, 0]],
+ processNoiseCov: [
+ [ql, 0],
+ [0, qs],
+ ],
+ observationNoiseCov: [[r]],
+ initialStateMean: [m0l, m0s],
+ initialStateCovariance: [
+ [p0, 0],
+ [0, p0],
+ ],
+ });
+ }
+
+ // ─── Main methods ──────────────────────────────────────────────────────────
+
+ /**
+ * Run the Kalman filter (forward pass).
+ *
+ * @param observations T × n_obs array of observations.
+ * Pass `null` for any element to indicate a missing value at that
+ * time-step × dimension. If an entire row is missing, pass a row of nulls
+ * or just pass `null` in a scalar array like `[[null]]`.
+ * @returns {@link KalmanFilterResult}
+ *
+ * @example
+ * ```ts
+ * const result = kf.filter([[1], [2], [null], [3], [2.5]]);
+ * ```
+ */
+ filter(observations: readonly (readonly (number | null)[])[]): KalmanFilterResult {
+ return kalmanFilter(
+ observations,
+ this.transitionMatrix,
+ this.observationMatrix,
+ this.processNoiseCov,
+ this.observationNoiseCov,
+ this.initialStateMean,
+ this.initialStateCovariance,
+ );
+ }
+
+ /**
+ * Run the RTS smoother (Kalman filter forward pass + RTS backward pass).
+ *
+ * @param observations T × n_obs array (same format as {@link filter}).
+ * @returns {@link KalmanSmootherResult}
+ *
+ * @example
+ * ```ts
+ * const smoothed = kf.smooth([[1], [2], [null], [3], [2.5]]);
+ * console.log(smoothed.smoothedStateMeans);
+ * ```
+ */
+ smooth(observations: readonly (readonly (number | null)[])[]): KalmanSmootherResult {
+ const fwd = this.filter(observations);
+ return rtsSmooth(fwd, this.transitionMatrix);
+ }
+}
+
+// ─── Core algorithms ───────────────────────────────────────────────────────────
+
+/**
+ * Kalman filter forward pass.
+ *
+ * Returns all intermediate quantities needed for the RTS smoother and for
+ * log-likelihood computation.
+ */
+function kalmanFilter(
+ obs: readonly (readonly (number | null)[])[],
+ F: Mat,
+ H: Mat,
+ Q: Mat,
+ R: Mat,
+ m0: readonly number[],
+ P0: Mat,
+): KalmanFilterResult {
+ const T_len = obs.length;
+ const ns = rows(F);
+ const no = rows(H);
+
+ // Storage
+ const filtMeans: number[][] = [];
+ const filtCovs: MutMat[] = [];
+ const predMeans: number[][] = [];
+ const predCovs: MutMat[] = [];
+ const innovations: number[][] = [];
+ const innovCovs: MutMat[] = [];
+ let logLik = 0;
+
+ // Initialize
+ let xFilt: number[] = [...m0];
+ let PFilt: MutMat = P0.map((row) => [...row]);
+ const FT = T(F);
+ const HT = T(H);
+ const LOG2PI = Math.log(2 * Math.PI);
+
+ for (let t = 0; t < T_len; t++) {
+ const yt = obs[t]!;
+
+ // ── Predict ────────────────────────────────────────────────────────────
+ const xPred = mvmul(F, xFilt);
+ // P_pred = F P F' + Q
+ const PPred = madd(mmul(mmul(F, PFilt), FT), Q);
+
+ predMeans.push(xPred);
+ predCovs.push(PPred);
+
+ // Innovation covariance S = H P_pred H' + R
+ const S = madd(mmul(mmul(H, PPred), HT), R);
+ innovCovs.push(S);
+
+ // Check if observation has any non-null values
+ const hasObs = yt.some((v) => v !== null);
+
+ if (!hasObs) {
+ // ── Missing observation: skip update ──────────────────────────────
+ innovations.push(new Array(no).fill(Number.NaN));
+ filtMeans.push(xPred);
+ filtCovs.push(PPred);
+ xFilt = xPred;
+ PFilt = PPred;
+ continue;
+ }
+
+ // ── Update ─────────────────────────────────────────────────────────────
+ const yHat = mvmul(H, xPred); // predicted observation
+ const innov = vsub(
+ yt.map((v) => (v === null ? 0 : v)), // treat null as 0 for innovation
+ yHat,
+ );
+
+ // For partial missing (some dims null), we handle by projecting to
+ // observed subspace. For simplicity: use full update with null→predicted.
+ innovations.push(innov);
+
+ // Kalman gain K = P_pred H' S^{-1}
+ const Sinv = matInv(S);
+ if (Sinv === null) {
+ // Singular innovation covariance: skip update
+ filtMeans.push(xPred);
+ filtCovs.push(PPred);
+ xFilt = xPred;
+ PFilt = PPred;
+ continue;
+ }
+
+ const K = mmul(mmul(PPred, HT), Sinv);
+
+ // x_filt = x_pred + K * innov
+ const xNew = vadd(xPred, mvmul(K, innov));
+
+ // P_filt = (I − K H) P_pred — Joseph form for numerical stability:
+ // P_filt = (I−KH) P (I−KH)' + K R K'
+ const IKH = msub(eye(ns), mmul(K, H));
+ const IKHPIKHT = mmul(mmul(IKH, PPred), T(IKH));
+ const KRKT = mmul(mmul(K, R), T(K));
+ const PNew: MutMat = madd(IKHPIKHT, KRKT);
+
+ // Log-likelihood contribution: -½ [d·log(2π) + log|S| + v'S⁻¹v]
+ const logDetS = logDet(S);
+ let vSv = 0;
+ for (let i = 0; i < no; i++) {
+ const Sinv_row = Sinv[i]!;
+ let sSinvRow = 0;
+ for (let j = 0; j < no; j++) {
+ sSinvRow += innov[j]! * Sinv_row[j]!;
+ }
+ vSv += innov[i]! * sSinvRow;
+ }
+ logLik -= 0.5 * (no * LOG2PI + logDetS + vSv);
+
+ filtMeans.push(xNew);
+ filtCovs.push(PNew);
+ xFilt = xNew;
+ PFilt = PNew;
+ }
+
+ return {
+ filteredStateMeans: filtMeans,
+ filteredStateCovariances: filtCovs,
+ predictedStateMeans: predMeans,
+ predictedStateCovariances: predCovs,
+ innovations,
+ innovationCovariances: innovCovs,
+ logLikelihood: logLik,
+ nStates: ns,
+ nObs: no,
+ nTime: T_len,
+ };
+}
+
+/**
+ * Rauch-Tung-Striebel (RTS) smoother backward pass.
+ *
+ * Given the Kalman filter result, runs the smoother backward from t=T to t=0.
+ *
+ * Smoother equations:
+ * G_t = P_{t|t} · Fᵀ · P_{t+1|t}^{-1}
+ * x_{t|T} = x_{t|t} + G_t · (x_{t+1|T} − x_{t+1|t})
+ * P_{t|T} = P_{t|t} + G_t · (P_{t+1|T} − P_{t+1|t}) · G_tᵀ
+ */
+function rtsSmooth(fwd: KalmanFilterResult, F: Mat): KalmanSmootherResult {
+ const T_len = fwd.nTime;
+ const ns = fwd.nStates;
+
+ const smoothMeans: number[][] = new Array(T_len);
+ const smoothCovs: MutMat[] = new Array(T_len);
+ const gains: MutMat[] = new Array(T_len);
+
+ // Initialise last time step from filter
+ const lastFiltMean = [...(fwd.filteredStateMeans[T_len - 1] ?? [])];
+ const lastFiltCov = (fwd.filteredStateCovariances[T_len - 1] ?? []).map((r) => [...r]);
+ smoothMeans[T_len - 1] = lastFiltMean;
+ smoothCovs[T_len - 1] = lastFiltCov;
+ gains[T_len - 1] = zeros(ns, ns);
+
+ const FT = T(F);
+
+ for (let t = T_len - 2; t >= 0; t--) {
+ const xFilt = fwd.filteredStateMeans[t]!;
+ const PFilt = fwd.filteredStateCovariances[t]!;
+ const PPred_next = fwd.predictedStateCovariances[t + 1]!;
+
+ // G_t = P_{t|t} · Fᵀ · P_{t+1|t}^{-1}
+ const PPredInv = matInv(PPred_next);
+ const G: MutMat = PPredInv !== null ? mmul(mmul(PFilt, FT), PPredInv) : zeros(ns, ns);
+
+ const xSmooth_next = smoothMeans[t + 1]!;
+ const PSmooth_next = smoothCovs[t + 1]!;
+ const xPred_next = fwd.predictedStateMeans[t + 1]!;
+
+ // x_{t|T} = x_{t|t} + G_t · (x_{t+1|T} − x_{t+1|t})
+ const dx = vsub(xSmooth_next, xPred_next);
+ smoothMeans[t] = vadd(xFilt, mvmul(G, dx));
+
+ // P_{t|T} = P_{t|t} + G_t · (P_{t+1|T} − P_{t+1|t}) · G_tᵀ
+ const dP = msub(PSmooth_next, PPred_next);
+ const GT = T(G);
+ smoothCovs[t] = madd(PFilt, mmul(mmul(G, dP), GT));
+
+ gains[t] = G;
+ }
+
+ return {
+ smoothedStateMeans: smoothMeans,
+ smoothedStateCovariances: smoothCovs,
+ smootherGains: gains,
+ logLikelihood: fwd.logLikelihood,
+ filterResult: fwd,
+ };
+}
+
+// ─── Standalone functional API ─────────────────────────────────────────────────
+
+/**
+ * Apply the Kalman filter to a sequence of scalar observations.
+ *
+ * Convenience wrapper for the common 1-D case (local-level model or similar).
+ *
+ * @example
+ * ```ts
+ * import { kalmanFilter1D } from "tsb";
+ * const { filteredStateMeans, logLikelihood } = kalmanFilter1D(
+ * [1, 2, null, 3, 2.5],
+ * { processNoise: 0.5, observationNoise: 1 },
+ * );
+ * ```
+ */
+export function kalmanFilter1D(
+ observations: readonly (number | null)[],
+ opts: LocalLevelOptions = {},
+): KalmanFilterResult {
+ const kf = KalmanFilter.localLevel(opts);
+ return kf.filter(observations.map((v) => [v]));
+}
+
+/**
+ * Apply the RTS smoother to scalar observations with a local-level model.
+ *
+ * @example
+ * ```ts
+ * import { kalmanSmooth1D } from "tsb";
+ * const { smoothedStateMeans } = kalmanSmooth1D([1, 2, null, 3, 2.5]);
+ * ```
+ */
+export function kalmanSmooth1D(
+ observations: readonly (number | null)[],
+ opts: LocalLevelOptions = {},
+): KalmanSmootherResult {
+ const kf = KalmanFilter.localLevel(opts);
+ return kf.smooth(observations.map((v) => [v]));
+}
+
+// ─── Utility: extract scalars from 1-D results ─────────────────────────────────
+
+/**
+ * Extract the scalar filtered means from a 1-state filter result.
+ * Returns an array of length T where each value is x_{t|t}[0].
+ *
+ * @example
+ * ```ts
+ * const result = kf.filter([[1], [2], [null], [3]]);
+ * const means = extractScalarMeans(result.filteredStateMeans);
+ * ```
+ */
+export function extractScalarMeans(means: readonly (readonly number[])[]): number[] {
+ return means.map((m) => m[0] ?? Number.NaN);
+}
+
+/**
+ * Extract the scalar filtered variances from a 1-state filter result.
+ * Returns an array of length T where each value is P_{t|t}[0][0].
+ *
+ * @example
+ * ```ts
+ * const result = kf.filter([[1], [2], [null], [3]]);
+ * const vars = extractScalarVariances(result.filteredStateCovariances);
+ * ```
+ */
+export function extractScalarVariances(
+ covs: readonly (readonly (readonly number[])[])[],
+): number[] {
+ return covs.map((P) => P[0]?.[0] ?? Number.NaN);
+}
+
+/**
+ * Compute a 95 % prediction interval around the filtered means for a 1-D
+ * local-level model.
+ *
+ * Returns `{ lower, upper }` arrays of length T.
+ *
+ * @example
+ * ```ts
+ * const result = kf.filter([[1], [2], [null], [3]]);
+ * const { lower, upper } = filteredPredictionInterval(result);
+ * ```
+ */
+export function filteredPredictionInterval(
+ result: KalmanFilterResult,
+ zScore = 1.96,
+): { lower: number[]; upper: number[] } {
+ const means = extractScalarMeans(result.filteredStateMeans);
+ const vars = extractScalarVariances(result.filteredStateCovariances);
+ return {
+ lower: means.map((m, i) => m - zScore * Math.sqrt(vars[i] ?? 0)),
+ upper: means.map((m, i) => m + zScore * Math.sqrt(vars[i] ?? 0)),
+ };
+}
+
+/** Alias kept for backward compat — use {@link KalmanFilter} directly. */
+export { KalmanFilter as StateSpaceModel };
diff --git a/src/stats/network_stats.ts b/src/stats/network_stats.ts
new file mode 100644
index 000000000..779cdaeb6
--- /dev/null
+++ b/src/stats/network_stats.ts
@@ -0,0 +1,422 @@
+/**
+ * network_stats — Graph/network analysis statistics.
+ *
+ * Implements:
+ * - **Graph representation** (adjacency list / matrix)
+ * - **Degree centrality**, **betweenness centrality** (exact, BFS-based)
+ * - **Clustering coefficient** (local and global)
+ * - **Shortest paths** (BFS for unweighted, Dijkstra for weighted)
+ * - **Connected components**
+ * - **PageRank** (power iteration)
+ * - **HITS** (hubs and authorities)
+ *
+ * @module
+ */
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+/** An undirected or directed graph stored as adjacency lists. */
+export interface Graph {
+ /** Number of nodes. */
+ nNodes: number;
+ /** Adjacency list: adjacency[i] = [{to, weight}]. */
+ adjacency: { to: number; weight: number }[][];
+ /** Whether the graph is directed. */
+ directed: boolean;
+}
+
+/** Create a new empty graph. */
+export function createGraph(nNodes: number, directed = false): Graph {
+ const adjacency: { to: number; weight: number }[][] = [];
+ for (let i = 0; i < nNodes; i++) {
+ adjacency.push([]);
+ }
+ return { nNodes, adjacency, directed };
+}
+
+/**
+ * Add an edge to the graph.
+ *
+ * @param g - The graph.
+ * @param u - Source node.
+ * @param v - Target node.
+ * @param weight - Edge weight. Default 1.
+ */
+export function addEdge(g: Graph, u: number, v: number, weight = 1): void {
+ (g.adjacency[u] ?? []).push({ to: v, weight });
+ if (!g.directed) {
+ (g.adjacency[v] ?? []).push({ to: u, weight });
+ }
+}
+
+/**
+ * Build a graph from an edge list.
+ *
+ * @param nNodes - Total number of nodes.
+ * @param edges - Array of [u, v] or [u, v, weight] tuples.
+ * @param directed - Whether edges are directed. Default false.
+ * @returns Graph.
+ */
+export function graphFromEdges(
+ nNodes: number,
+ edges: [number, number][] | [number, number, number][],
+ directed = false,
+): Graph {
+ const g = createGraph(nNodes, directed);
+ for (const e of edges) {
+ const u = e[0];
+ const v = e[1];
+ const w = e[2] ?? 1;
+ addEdge(g, u, v, w);
+ }
+ return g;
+}
+
+// ─── Degree Centrality ────────────────────────────────────────────────────────
+
+/**
+ * Compute degree centrality for all nodes.
+ *
+ * Degree centrality = degree / (n - 1).
+ *
+ * @param g - The graph.
+ * @returns Array of centrality values (one per node).
+ */
+export function degreeCentrality(g: Graph): number[] {
+ const n = g.nNodes;
+ const norm = n > 1 ? n - 1 : 1;
+ return g.adjacency.map((adj) => adj.length / norm);
+}
+
+/**
+ * Compute in-degree and out-degree for directed graphs.
+ *
+ * @param g - The graph.
+ * @returns Object with inDegree and outDegree arrays.
+ */
+export function directedDegrees(g: Graph): { inDegree: number[]; outDegree: number[] } {
+ const inDegree = new Array(g.nNodes).fill(0);
+ const outDegree = g.adjacency.map((adj) => adj.length);
+
+ for (let u = 0; u < g.nNodes; u++) {
+ for (const { to } of g.adjacency[u] ?? []) {
+ inDegree[to] = (inDegree[to] ?? 0) + 1;
+ }
+ }
+
+ return { inDegree, outDegree };
+}
+
+// ─── Shortest Paths ───────────────────────────────────────────────────────────
+
+/**
+ * BFS single-source shortest paths (unweighted).
+ *
+ * @param g - The graph.
+ * @param source - Source node.
+ * @returns Array of distances from source (-1 if unreachable).
+ */
+export function bfsDistances(g: Graph, source: number): number[] {
+ const dist = new Array(g.nNodes).fill(-1);
+ dist[source] = 0;
+ const queue: number[] = [source];
+ let head = 0;
+
+ while (head < queue.length) {
+ const u = queue[head++] ?? 0;
+ for (const { to } of g.adjacency[u] ?? []) {
+ if ((dist[to] ?? -1) === -1) {
+ dist[to] = (dist[u] ?? 0) + 1;
+ queue.push(to);
+ }
+ }
+ }
+
+ return dist;
+}
+
+/**
+ * Dijkstra single-source shortest paths (weighted, non-negative weights).
+ *
+ * @param g - The graph.
+ * @param source - Source node.
+ * @returns Array of shortest-path distances from source (Infinity if unreachable).
+ */
+export function dijkstra(g: Graph, source: number): number[] {
+ const dist = new Array(g.nNodes).fill(Infinity);
+ dist[source] = 0;
+ // Simple priority queue via sorted array (sufficient for small graphs)
+ const pq: { node: number; d: number }[] = [{ node: source, d: 0 }];
+
+ while (pq.length > 0) {
+ pq.sort((a, b) => a.d - b.d);
+ const top = pq.shift();
+ if (top === undefined) break;
+ const { node: u, d } = top;
+ if (d > (dist[u] ?? Infinity)) continue;
+
+ for (const { to, weight } of g.adjacency[u] ?? []) {
+ const nd = (dist[u] ?? Infinity) + weight;
+ if (nd < (dist[to] ?? Infinity)) {
+ dist[to] = nd;
+ pq.push({ node: to, d: nd });
+ }
+ }
+ }
+
+ return dist;
+}
+
+// ─── Betweenness Centrality ───────────────────────────────────────────────────
+
+/**
+ * Compute betweenness centrality (Brandes algorithm for unweighted graphs).
+ *
+ * @param g - The graph.
+ * @returns Array of betweenness centrality values (normalized).
+ */
+export function betweennessCentrality(g: Graph): number[] {
+ const n = g.nNodes;
+ const bc = new Array(n).fill(0);
+
+ for (let s = 0; s < n; s++) {
+ const stack: number[] = [];
+ const pred: number[][] = Array.from({ length: n }, () => []);
+ const sigma = new Array(n).fill(0);
+ sigma[s] = 1;
+ const dist = new Array(n).fill(-1);
+ dist[s] = 0;
+ const queue: number[] = [s];
+ let head = 0;
+
+ while (head < queue.length) {
+ const v = queue[head++] ?? 0;
+ stack.push(v);
+
+ for (const { to: w } of g.adjacency[v] ?? []) {
+ if ((dist[w] ?? -1) < 0) {
+ queue.push(w);
+ dist[w] = (dist[v] ?? 0) + 1;
+ }
+ if ((dist[w] ?? 0) === (dist[v] ?? 0) + 1) {
+ sigma[w] = (sigma[w] ?? 0) + (sigma[v] ?? 0);
+ (pred[w] ?? []).push(v);
+ }
+ }
+ }
+
+ const delta = new Array(n).fill(0);
+ while (stack.length > 0) {
+ const w = stack.pop() ?? 0;
+ for (const v of pred[w] ?? []) {
+ delta[v] =
+ (delta[v] ?? 0) +
+ ((sigma[v] ?? 0) / (sigma[w] ?? 1)) * (1 + (delta[w] ?? 0));
+ }
+ if (w !== s) bc[w] = (bc[w] ?? 0) + (delta[w] ?? 0);
+ }
+ }
+
+ // Normalize
+ const norm = g.directed ? (n - 1) * (n - 2) : ((n - 1) * (n - 2)) / 2;
+ if (norm > 0) {
+ for (let i = 0; i < n; i++) {
+ bc[i] = (bc[i] ?? 0) / norm;
+ }
+ }
+
+ return bc;
+}
+
+// ─── Clustering Coefficient ───────────────────────────────────────────────────
+
+/**
+ * Compute local clustering coefficient for each node (undirected).
+ *
+ * @param g - The graph (undirected).
+ * @returns Array of clustering coefficients.
+ */
+export function clusteringCoefficient(g: Graph): number[] {
+ const n = g.nNodes;
+ const cc = new Array(n).fill(0);
+
+ for (let u = 0; u < n; u++) {
+ const neighbors = new Set((g.adjacency[u] ?? []).map((e) => e.to));
+ const k = neighbors.size;
+ if (k < 2) {
+ cc[u] = 0;
+ continue;
+ }
+
+ let triangles = 0;
+ for (const v of neighbors) {
+ for (const { to: w } of g.adjacency[v] ?? []) {
+ if (neighbors.has(w)) triangles++;
+ }
+ }
+
+ cc[u] = triangles / (k * (k - 1));
+ }
+
+ return cc;
+}
+
+/**
+ * Compute the global (average) clustering coefficient.
+ *
+ * @param g - The graph.
+ * @returns Global clustering coefficient.
+ */
+export function globalClusteringCoefficient(g: Graph): number {
+ const cc = clusteringCoefficient(g);
+ return cc.reduce((a, b) => a + b, 0) / cc.length;
+}
+
+// ─── Connected Components ─────────────────────────────────────────────────────
+
+/**
+ * Find all connected components (undirected graph).
+ *
+ * @param g - The graph.
+ * @returns Array of components, each an array of node indices.
+ */
+export function connectedComponents(g: Graph): number[][] {
+ const visited = new Array(g.nNodes).fill(false);
+ const components: number[][] = [];
+
+ for (let start = 0; start < g.nNodes; start++) {
+ if (visited[start] ?? false) continue;
+
+ const component: number[] = [];
+ const queue: number[] = [start];
+ visited[start] = true;
+
+ while (queue.length > 0) {
+ const u = queue.shift() ?? 0;
+ component.push(u);
+ for (const { to } of g.adjacency[u] ?? []) {
+ if (!(visited[to] ?? false)) {
+ visited[to] = true;
+ queue.push(to);
+ }
+ }
+ }
+
+ components.push(component);
+ }
+
+ return components;
+}
+
+// ─── PageRank ─────────────────────────────────────────────────────────────────
+
+/**
+ * Compute PageRank via power iteration.
+ *
+ * @param g - The graph (directed).
+ * @param dampingFactor - Damping factor (alpha). Default 0.85.
+ * @param maxIter - Maximum iterations. Default 100.
+ * @param tol - Convergence tolerance. Default 1e-6.
+ * @returns PageRank scores (sum to 1).
+ *
+ * @example
+ * ```ts
+ * import { graphFromEdges, pageRank } from "tsb";
+ * const g = graphFromEdges(4, [[0,1],[0,2],[1,3],[2,3]], true);
+ * const pr = pageRank(g);
+ * ```
+ */
+export function pageRank(
+ g: Graph,
+ dampingFactor = 0.85,
+ maxIter = 100,
+ tol = 1e-6,
+): number[] {
+ const n = g.nNodes;
+ let rank = new Array(n).fill(1 / n);
+ const outDeg = g.adjacency.map((adj) => adj.length);
+
+ for (let iter = 0; iter < maxIter; iter++) {
+ const newRank = new Array(n).fill((1 - dampingFactor) / n);
+
+ for (let u = 0; u < n; u++) {
+ const deg = outDeg[u] ?? 0;
+ if (deg === 0) {
+ // Dangling node — distribute rank equally
+ const share = (rank[u] ?? 0) / n;
+ for (let v = 0; v < n; v++) {
+ newRank[v] = (newRank[v] ?? 0) + dampingFactor * share;
+ }
+ } else {
+ for (const { to: v } of g.adjacency[u] ?? []) {
+ newRank[v] = (newRank[v] ?? 0) + dampingFactor * ((rank[u] ?? 0) / deg);
+ }
+ }
+ }
+
+ let diff = 0;
+ for (let i = 0; i < n; i++) {
+ diff += Math.abs((newRank[i] ?? 0) - (rank[i] ?? 0));
+ }
+ rank = newRank;
+ if (diff < tol) break;
+ }
+
+ return rank;
+}
+
+// ─── HITS ─────────────────────────────────────────────────────────────────────
+
+/**
+ * Compute HITS (Hubs and Authorities) scores via power iteration.
+ *
+ * @param g - The graph (directed).
+ * @param maxIter - Maximum iterations. Default 100.
+ * @param tol - Convergence tolerance. Default 1e-6.
+ * @returns Object with hub and authority score arrays.
+ */
+export function hits(
+ g: Graph,
+ maxIter = 100,
+ tol = 1e-6,
+): { hub: number[]; authority: number[] } {
+ const n = g.nNodes;
+ let hub = new Array(n).fill(1 / n);
+ let auth = new Array(n).fill(1 / n);
+
+ for (let iter = 0; iter < maxIter; iter++) {
+ const newAuth = new Array(n).fill(0);
+ const newHub = new Array(n).fill(0);
+
+ for (let u = 0; u < n; u++) {
+ for (const { to: v } of g.adjacency[u] ?? []) {
+ newAuth[v] = (newAuth[v] ?? 0) + (hub[u] ?? 0);
+ }
+ }
+ for (let u = 0; u < n; u++) {
+ for (const { to: v } of g.adjacency[u] ?? []) {
+ newHub[u] = (newHub[u] ?? 0) + (auth[v] ?? 0);
+ }
+ }
+
+ // Normalize
+ const authNorm = Math.sqrt(newAuth.reduce((s, x) => s + x * x, 0)) || 1;
+ const hubNorm = Math.sqrt(newHub.reduce((s, x) => s + x * x, 0)) || 1;
+ for (let i = 0; i < n; i++) {
+ newAuth[i] = (newAuth[i] ?? 0) / authNorm;
+ newHub[i] = (newHub[i] ?? 0) / hubNorm;
+ }
+
+ let diff = 0;
+ for (let i = 0; i < n; i++) {
+ diff +=
+ Math.abs((newAuth[i] ?? 0) - (auth[i] ?? 0)) +
+ Math.abs((newHub[i] ?? 0) - (hub[i] ?? 0));
+ }
+ auth = newAuth;
+ hub = newHub;
+ if (diff < tol) break;
+ }
+
+ return { hub, authority: auth };
+}
diff --git a/src/stats/signal.ts b/src/stats/signal.ts
new file mode 100644
index 000000000..5c248cd95
--- /dev/null
+++ b/src/stats/signal.ts
@@ -0,0 +1,781 @@
+/**
+ * signal — Signal processing: FFT, windows, STFT, Welch PSD, periodogram.
+ *
+ * Mirrors `numpy.fft`, `scipy.signal` spectral and window utilities.
+ * Implemented from scratch with no external dependencies.
+ *
+ * FFT:
+ * - {@link fft} — N-point complex DFT (radix-2, pads to power of 2)
+ * - {@link ifft} — inverse FFT
+ * - {@link rfft} — real-input FFT (one-sided)
+ * - {@link irfft} — inverse real FFT
+ * - {@link fftFreq} — DFT sample frequencies
+ * - {@link rfftFreq} — one-sided DFT sample frequencies
+ * - {@link fftshift} — shift zero-frequency to centre
+ * - {@link ifftshift} — inverse of fftshift
+ *
+ * Windows (via {@link getWindow}):
+ * - `"rectangular"`, `"bartlett"`, `"hann"`, `"hamming"`, `"blackman"`,
+ * `"blackmanharris"`, `"flattop"`, `"kaiser"`
+ *
+ * Spectral analysis:
+ * - {@link stft} — Short-Time Fourier Transform
+ * - {@link istft} — Inverse STFT (overlap-add)
+ * - {@link welch} — Welch power spectral density
+ * - {@link periodogram} — Periodogram PSD estimate
+ *
+ * @example
+ * ```ts
+ * import { fft, rfftFreq, welch } from "tsb";
+ *
+ * const x = [1, 0, -1, 0, 1, 0, -1, 0];
+ * const X = fft(x); // 8-point FFT
+ * const freqs = rfftFreq(X.length, 1 / 100);
+ *
+ * const { f, Pxx } = welch(x, { fs: 100 });
+ * ```
+ *
+ * @module
+ */
+
+// ─── complex arithmetic ───────────────────────────────────────────────────────
+
+/** A complex number `{ re, im }`. */
+export type Complex = { re: number; im: number };
+
+/** Construct a complex number. */
+export function complex(re: number, im: number): Complex {
+ return { re, im };
+}
+
+/** Add two complex numbers. */
+function cAdd(a: Complex, b: Complex): Complex {
+ return { re: a.re + b.re, im: a.im + b.im };
+}
+
+/** Subtract two complex numbers. */
+function cSub(a: Complex, b: Complex): Complex {
+ return { re: a.re - b.re, im: a.im - b.im };
+}
+
+/** Multiply two complex numbers. */
+function cMul(a: Complex, b: Complex): Complex {
+ return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re };
+}
+
+/** Complex conjugate. */
+function cConj(a: Complex): Complex {
+ return { re: a.re, im: -a.im };
+}
+
+/** Magnitude squared |a|². */
+function cAbsSq(a: Complex): number {
+ return a.re * a.re + a.im * a.im;
+}
+
+/** Magnitude |a|. */
+export function cAbs(a: Complex): number {
+ return Math.sqrt(cAbsSq(a));
+}
+
+/** Phase angle (arg) of a complex number. */
+export function cArg(a: Complex): number {
+ return Math.atan2(a.im, a.re);
+}
+
+// ─── FFT internals ────────────────────────────────────────────────────────────
+
+/** Smallest power of 2 ≥ n. */
+function nextPow2(n: number): number {
+ if (n <= 1) {
+ return 1;
+ }
+ let p = 1;
+ while (p < n) {
+ p <<= 1;
+ }
+ return p;
+}
+
+/** In-place bit-reversal permutation. */
+function bitReverse(arr: Complex[], n: number): void {
+ let j = 0;
+ for (let i = 1; i < n; i++) {
+ let bit = n >> 1;
+ for (; j & bit; bit >>= 1) {
+ j ^= bit;
+ }
+ j ^= bit;
+ if (i < j) {
+ const tmp = arr[i]!;
+ arr[i] = arr[j]!;
+ arr[j] = tmp;
+ }
+ }
+}
+
+/** Cooley-Tukey radix-2 DIT iterative FFT, in-place. `n` must be a power of 2. */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: nested FFT butterfly loops
+function fftInPlace(arr: Complex[], n: number, inverse: boolean): void {
+ bitReverse(arr, n);
+ for (let len = 2; len <= n; len <<= 1) {
+ const half = len >> 1;
+ const ang = ((inverse ? 2 : -2) * Math.PI) / len;
+ const wLen: Complex = { re: Math.cos(ang), im: Math.sin(ang) };
+ for (let i = 0; i < n; i += len) {
+ let w: Complex = { re: 1, im: 0 };
+ for (let j = 0; j < half; j++) {
+ const u = arr[i + j]!;
+ const v = cMul(arr[i + j + half]!, w);
+ arr[i + j] = cAdd(u, v);
+ arr[i + j + half] = cSub(u, v);
+ w = cMul(w, wLen);
+ }
+ }
+ }
+ if (inverse) {
+ for (let i = 0; i < n; i++) {
+ const a = arr[i]!;
+ arr[i] = { re: a.re / n, im: a.im / n };
+ }
+ }
+}
+
+// ─── public FFT functions ─────────────────────────────────────────────────────
+
+/**
+ * Compute the discrete Fourier transform of a real signal.
+ *
+ * If `x.length` is not a power of 2, the signal is zero-padded to the next
+ * power of 2. The returned array has length `nextPow2(x.length)`.
+ *
+ * @param x - Input signal (real values).
+ * @returns Complex DFT coefficients.
+ */
+export function fft(x: readonly number[]): Complex[] {
+ const n = x.length;
+ const m = nextPow2(n);
+ const buf: Complex[] = Array.from({ length: m }, (_, i) => ({
+ re: x[i] ?? 0,
+ im: 0,
+ }));
+ fftInPlace(buf, m, false);
+ return buf;
+}
+
+/**
+ * Compute the inverse discrete Fourier transform.
+ *
+ * The length of `X` must be a power of 2. Returns a complex array of the
+ * same length as `X`.
+ *
+ * @param X - Complex DFT coefficients.
+ * @returns Complex inverse-DFT output.
+ */
+export function ifft(X: readonly Complex[]): Complex[] {
+ const n = X.length;
+ const m = nextPow2(n);
+ const buf: Complex[] = Array.from({ length: m }, (_, i) => {
+ const c = X[i] ?? { re: 0, im: 0 };
+ return { re: c.re, im: c.im };
+ });
+ fftInPlace(buf, m, true);
+ return buf;
+}
+
+/**
+ * Real-input FFT (one-sided). Returns the first `floor(m/2) + 1` bins where
+ * `m = nextPow2(x.length)`.
+ *
+ * @param x - Real input signal.
+ * @returns One-sided complex spectrum.
+ */
+export function rfft(x: readonly number[]): Complex[] {
+ const full = fft(x);
+ return full.slice(0, Math.floor(full.length / 2) + 1);
+}
+
+/**
+ * Inverse real FFT. Reconstructs a real signal from one-sided spectrum.
+ *
+ * @param X - One-sided spectrum as from {@link rfft}.
+ * @param n - Optional output length (defaults to `2 * (X.length - 1)`).
+ * @returns Real signal.
+ */
+export function irfft(X: readonly Complex[], n?: number): number[] {
+ const nOut = n ?? 2 * (X.length - 1);
+ const m = nextPow2(nOut);
+ const buf: Complex[] = new Array(m);
+ const half = X.length;
+ for (let i = 0; i < half; i++) {
+ buf[i] = { re: (X[i] ?? { re: 0, im: 0 }).re, im: (X[i] ?? { re: 0, im: 0 }).im };
+ }
+ for (let i = half; i < m; i++) {
+ const j = m - i;
+ const c = X[j] ?? { re: 0, im: 0 };
+ buf[i] = cConj(c);
+ }
+ fftInPlace(buf, m, true);
+ return Array.from({ length: nOut }, (_, i) => buf[i]?.re ?? 0);
+}
+
+/**
+ * DFT sample frequencies for an `n`-point FFT with sample spacing `d`.
+ *
+ * @param n - FFT length (from `fft(x).length`).
+ * @param d - Sample spacing in seconds (default `1`).
+ * @returns Array of frequencies from `0` to `(n-1)/(n*d)`, wrapped to negative.
+ */
+export function fftFreq(n: number, d = 1): number[] {
+ const f: number[] = new Array(n);
+ const half = Math.floor(n / 2) + 1;
+ for (let i = 0; i < half; i++) {
+ f[i] = i / (n * d);
+ }
+ for (let i = half; i < n; i++) {
+ f[i] = (i - n) / (n * d);
+ }
+ return f;
+}
+
+/**
+ * One-sided DFT sample frequencies for a real-input FFT.
+ *
+ * @param n - FFT length (from `rfft(x).length` etc.).
+ * @param d - Sample spacing in seconds (default `1`).
+ * @returns Frequencies `[0, 1/(n*d), 2/(n*d), ..., 1/(2*d)]`.
+ */
+export function rfftFreq(n: number, d = 1): number[] {
+ const half = Math.floor(n / 2) + 1;
+ return Array.from({ length: half }, (_, i) => i / (n * d));
+}
+
+/**
+ * Shift the zero-frequency component to the centre of the spectrum.
+ * Equivalent to `numpy.fft.fftshift`.
+ */
+export function fftshift(x: readonly T[]): T[] {
+ const n = x.length;
+ const half = Math.floor(n / 2);
+ return [...x.slice(half), ...x.slice(0, half)];
+}
+
+/**
+ * Inverse of {@link fftshift}. Equivalent to `numpy.fft.ifftshift`.
+ */
+export function ifftshift(x: readonly T[]): T[] {
+ const n = x.length;
+ const half = Math.ceil(n / 2);
+ return [...x.slice(half), ...x.slice(0, half)];
+}
+
+// ─── window functions ─────────────────────────────────────────────────────────
+
+/** Supported window names. */
+export type WindowName =
+ | "rectangular"
+ | "bartlett"
+ | "hann"
+ | "hamming"
+ | "blackman"
+ | "blackmanharris"
+ | "flattop"
+ | "kaiser";
+
+/** Modified Bessel function of the first kind, order 0, I₀(x). (A&S 9.8.1) */
+function besselI0(x: number): number {
+ const ax = Math.abs(x);
+ if (ax < 3.75) {
+ const t = (x / 3.75) ** 2;
+ return (
+ 1 +
+ t *
+ (3.5156229 +
+ t * (3.0899424 + t * (1.2067492 + t * (0.2659732 + t * (0.0360768 + t * 0.0045813)))))
+ );
+ }
+ const t = 3.75 / ax;
+ return (
+ (Math.exp(ax) / Math.sqrt(ax)) *
+ (0.39894228 +
+ t *
+ (0.01328592 +
+ t *
+ (0.00225319 +
+ t *
+ (-0.00157565 +
+ t *
+ (0.00916281 +
+ t * (-0.02057706 + t * (0.02635537 + t * (-0.01647633 + t * 0.00392377))))))))
+ );
+}
+
+/** Rectangular (boxcar) window — all ones. */
+export function rectangularWindow(n: number): number[] {
+ return Array.from({ length: n }, () => 1);
+}
+
+/** Bartlett (triangular) window. */
+export function bartlettWindow(n: number): number[] {
+ return Array.from({ length: n }, (_, i) => 1 - Math.abs((2 * i - (n - 1)) / (n - 1)));
+}
+
+/** Hann window — `0.5 * (1 - cos(2πi/(N-1)))`. */
+export function hannWindow(n: number): number[] {
+ return Array.from({ length: n }, (_, i) => 0.5 * (1 - Math.cos((2 * Math.PI * i) / (n - 1))));
+}
+
+/** Hamming window — `0.54 - 0.46 * cos(2πi/(N-1))`. */
+export function hammingWindow(n: number): number[] {
+ return Array.from({ length: n }, (_, i) => 0.54 - 0.46 * Math.cos((2 * Math.PI * i) / (n - 1)));
+}
+
+/** Blackman window. */
+export function blackmanWindow(n: number): number[] {
+ return Array.from(
+ { length: n },
+ (_, i) =>
+ 0.42 -
+ 0.5 * Math.cos((2 * Math.PI * i) / (n - 1)) +
+ 0.08 * Math.cos((4 * Math.PI * i) / (n - 1)),
+ );
+}
+
+/** Blackman-Harris window (4-term). */
+export function blackmanHarrisWindow(n: number): number[] {
+ const a0 = 0.35875;
+ const a1 = 0.48829;
+ const a2 = 0.14128;
+ const a3 = 0.01168;
+ return Array.from(
+ { length: n },
+ (_, i) =>
+ a0 -
+ a1 * Math.cos((2 * Math.PI * i) / (n - 1)) +
+ a2 * Math.cos((4 * Math.PI * i) / (n - 1)) -
+ a3 * Math.cos((6 * Math.PI * i) / (n - 1)),
+ );
+}
+
+/** Flat-top window (5-term). */
+export function flatTopWindow(n: number): number[] {
+ const a0 = 0.21557895;
+ const a1 = 0.41663158;
+ const a2 = 0.277263158;
+ const a3 = 0.083578947;
+ const a4 = 0.006947368;
+ return Array.from(
+ { length: n },
+ (_, i) =>
+ a0 -
+ a1 * Math.cos((2 * Math.PI * i) / (n - 1)) +
+ a2 * Math.cos((4 * Math.PI * i) / (n - 1)) -
+ a3 * Math.cos((6 * Math.PI * i) / (n - 1)) +
+ a4 * Math.cos((8 * Math.PI * i) / (n - 1)),
+ );
+}
+
+/**
+ * Kaiser window with shape parameter `beta`.
+ *
+ * @param n - Number of samples.
+ * @param beta - Shape parameter (controls main-lobe width vs side-lobe level).
+ */
+export function kaiserWindow(n: number, beta: number): number[] {
+ const i0b = besselI0(beta);
+ return Array.from({ length: n }, (_, i) => {
+ const t = (2 * i) / (n - 1) - 1;
+ return besselI0(beta * Math.sqrt(1 - t * t)) / i0b;
+ });
+}
+
+/**
+ * Create a window of length `n` by name.
+ *
+ * @param name - Window function name.
+ * @param n - Number of samples.
+ * @param beta - Kaiser window `beta` parameter (ignored for other windows).
+ * @returns - Window samples.
+ */
+export function getWindow(name: WindowName, n: number, beta = 14): number[] {
+ switch (name) {
+ case "rectangular":
+ return rectangularWindow(n);
+ case "bartlett":
+ return bartlettWindow(n);
+ case "hann":
+ return hannWindow(n);
+ case "hamming":
+ return hammingWindow(n);
+ case "blackman":
+ return blackmanWindow(n);
+ case "blackmanharris":
+ return blackmanHarrisWindow(n);
+ case "flattop":
+ return flatTopWindow(n);
+ case "kaiser":
+ return kaiserWindow(n, beta);
+ }
+}
+
+// ─── STFT / ISTFT ─────────────────────────────────────────────────────────────
+
+/** Options for {@link stft}. */
+export interface STFTOptions {
+ /** Sampling frequency in Hz (default `1`). */
+ fs?: number;
+ /** Segment length in samples (default `256`). */
+ nperseg?: number;
+ /** Number of samples to overlap between segments (default `nperseg / 2`). */
+ noverlap?: number;
+ /** FFT length ≥ `nperseg` (default = `nperseg`, padded to power of 2). */
+ nfft?: number;
+ /** Window function to apply (default `"hann"`). */
+ window?: WindowName | readonly number[];
+ /** Boundary extension mode: `"zeros"` pads with zeros, `null` no padding. */
+ boundary?: "zeros" | null;
+}
+
+/** STFT result object. */
+export interface STFTResult {
+ /** Time centres for each frame (seconds). */
+ t: number[];
+ /** Frequency bins (Hz). */
+ f: number[];
+ /** Complex STFT matrix `Zxx[freqIdx][timeIdx]`. */
+ Zxx: Complex[][];
+}
+
+/**
+ * Short-Time Fourier Transform.
+ *
+ * Mirrors `scipy.signal.stft`. Splits the signal into overlapping windowed
+ * segments and computes the FFT of each segment.
+ *
+ * @param x - Input signal.
+ * @param options - {@link STFTOptions}.
+ * @returns - {@link STFTResult} with `{ t, f, Zxx }`.
+ *
+ * @example
+ * ```ts
+ * import { stft } from "tsb";
+ * const x = Array.from({ length: 1024 }, (_, i) => Math.sin(2 * Math.PI * 10 * i / 512));
+ * const { t, f, Zxx } = stft(x, { fs: 512, nperseg: 128 });
+ * ```
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: STFT nested loops
+export function stft(x: readonly number[], options: STFTOptions = {}): STFTResult {
+ const fs = options.fs ?? 1;
+ const nperseg = options.nperseg ?? Math.min(256, x.length);
+ const noverlap = options.noverlap ?? Math.floor(nperseg / 2);
+ const nfft = nextPow2(options.nfft ?? nperseg);
+ const step = nperseg - noverlap;
+ const boundary = options.boundary ?? "zeros";
+
+ // Build window
+ const win: number[] =
+ options.window !== undefined
+ ? typeof options.window === "string"
+ ? getWindow(options.window, nperseg)
+ : Array.from(options.window)
+ : hannWindow(nperseg);
+
+ // Pad signal at boundaries
+ const pad = boundary === "zeros" ? Math.floor(nperseg / 2) : 0;
+ const padded: number[] = [
+ ...Array.from({ length: pad }).fill(0),
+ ...x,
+ ...Array.from({ length: pad }).fill(0),
+ ];
+
+ // Number of frames
+ const nFrames = Math.floor((padded.length - noverlap) / step);
+ const nFreqs = Math.floor(nfft / 2) + 1;
+
+ const Zxx: Complex[][] = Array.from({ length: nFreqs }, () => new Array(nFrames));
+ const tArr: number[] = new Array(nFrames);
+ const fArr: number[] = Array.from({ length: nFreqs }, (_, i) => (i * fs) / nfft);
+
+ for (let k = 0; k < nFrames; k++) {
+ const start = k * step;
+ const seg: Complex[] = Array.from({ length: nfft }, (_, i) => ({
+ re: (padded[start + i] ?? 0) * (win[i] ?? 1),
+ im: 0,
+ }));
+ fftInPlace(seg, nfft, false);
+ for (let fi = 0; fi < nFreqs; fi++) {
+ const col = Zxx[fi];
+ if (col !== undefined) {
+ col[k] = seg[fi] ?? { re: 0, im: 0 };
+ }
+ }
+ tArr[k] = (start + nperseg / 2 - pad) / fs;
+ }
+
+ return { t: tArr, f: fArr, Zxx };
+}
+
+/** Options for {@link istft}. */
+export interface ISTFTOptions {
+ /** Segment length in samples (used to determine overlap). */
+ nperseg?: number;
+ /** Number of samples to overlap between segments (default `nperseg / 2`). */
+ noverlap?: number;
+ /** FFT length (default = `2 * (nFreqs - 1)` where `nFreqs = Zxx.length`). */
+ nfft?: number;
+ /** Window function (default `"hann"`). */
+ window?: WindowName | readonly number[];
+ /** Boundary extension used in stft (default `"zeros"`). */
+ boundary?: "zeros" | null;
+}
+
+/**
+ * Inverse Short-Time Fourier Transform (overlap-add).
+ *
+ * Mirrors `scipy.signal.istft`.
+ *
+ * @param Zxx - Complex STFT matrix `[freqIdx][timeIdx]` (from {@link stft}).
+ * @param options - {@link ISTFTOptions}.
+ * @returns - Reconstructed real signal.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ISTFT overlap-add loops
+export function istft(Zxx: readonly (readonly Complex[])[], options: ISTFTOptions = {}): number[] {
+ const nFreqs = Zxx.length;
+ const nFrames = nFreqs > 0 ? (Zxx[0]?.length ?? 0) : 0;
+ const nfft = options.nfft ?? 2 * (nFreqs - 1);
+ const nperseg = options.nperseg ?? nfft;
+ const noverlap = options.noverlap ?? Math.floor(nperseg / 2);
+ const step = nperseg - noverlap;
+
+ const win: number[] =
+ options.window !== undefined
+ ? typeof options.window === "string"
+ ? getWindow(options.window, nperseg)
+ : Array.from(options.window)
+ : hannWindow(nperseg);
+
+ const boundary = options.boundary ?? "zeros";
+ const pad = boundary === "zeros" ? Math.floor(nperseg / 2) : 0;
+ const outLen = nFrames * step + nperseg;
+
+ const output = new Float64Array(outLen);
+ const windowSum = new Float64Array(outLen);
+ const winSq = win.map((w) => w * w);
+
+ for (let k = 0; k < nFrames; k++) {
+ // Build full-spectrum (two-sided) for IFFT
+ const buf: Complex[] = new Array(nfft);
+ for (let fi = 0; fi < nFreqs; fi++) {
+ buf[fi] = Zxx[fi]?.[k] ?? { re: 0, im: 0 };
+ }
+ for (let fi = nFreqs; fi < nfft; fi++) {
+ const mirrorIdx = nfft - fi;
+ const src = Zxx[mirrorIdx]?.[k] ?? { re: 0, im: 0 };
+ buf[fi] = cConj(src);
+ }
+ fftInPlace(buf, nfft, true);
+
+ const start = k * step;
+ for (let i = 0; i < nperseg; i++) {
+ const idx = start + i;
+ output[idx] = (output[idx] ?? 0) + (buf[i]?.re ?? 0) * (win[i] ?? 1);
+ windowSum[idx] = (windowSum[idx] ?? 0) + (winSq[i] ?? 0);
+ }
+ }
+
+ // Normalize and trim boundary padding
+ const result: number[] = [];
+ const start = pad;
+ const end = outLen - pad;
+ for (let i = start; i < end; i++) {
+ const ws = windowSum[i] ?? 0;
+ result.push(ws > 1e-10 ? (output[i] ?? 0) / ws : 0);
+ }
+
+ return result;
+}
+
+// ─── Welch PSD ────────────────────────────────────────────────────────────────
+
+/** Options for {@link welch}. */
+export interface WelchOptions {
+ /** Sampling frequency in Hz (default `1`). */
+ fs?: number;
+ /** Segment length (default `min(256, x.length)`). */
+ nperseg?: number;
+ /** Overlap between segments (default `nperseg / 2`). */
+ noverlap?: number;
+ /** FFT length (default `nperseg`, padded to power of 2). */
+ nfft?: number;
+ /** Window function (default `"hann"`). */
+ window?: WindowName | readonly number[];
+ /** Averaging method: `"mean"` (default) or `"median"`. */
+ average?: "mean" | "median";
+ /** Scaling: `"density"` (PSD, V²/Hz) or `"spectrum"` (power spectrum V²). */
+ scaling?: "density" | "spectrum";
+}
+
+/** PSD result: frequency bins and power spectral density estimates. */
+export interface PSDResult {
+ /** Frequency bins in Hz. */
+ f: number[];
+ /** Power spectral density (or power spectrum) at each frequency. */
+ Pxx: number[];
+}
+
+/**
+ * Welch power spectral density estimate.
+ *
+ * Divides the signal into overlapping segments, computes the periodogram for
+ * each, and averages. Mirrors `scipy.signal.welch`.
+ *
+ * @param x - Input signal.
+ * @param options - {@link WelchOptions}.
+ * @returns - {@link PSDResult} `{ f, Pxx }`.
+ *
+ * @example
+ * ```ts
+ * import { welch } from "tsb";
+ * const x = Array.from({ length: 512 }, (_, i) => Math.sin(2 * Math.PI * 60 * i / 512));
+ * const { f, Pxx } = welch(x, { fs: 512 });
+ * ```
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Welch averaging loop
+export function welch(x: readonly number[], options: WelchOptions = {}): PSDResult {
+ const fs = options.fs ?? 1;
+ const nperseg = options.nperseg ?? Math.min(256, x.length);
+ const noverlap = options.noverlap ?? Math.floor(nperseg / 2);
+ const nfft = nextPow2(options.nfft ?? nperseg);
+ const step = nperseg - noverlap;
+ const average = options.average ?? "mean";
+ const scaling = options.scaling ?? "density";
+
+ const win: number[] =
+ options.window !== undefined
+ ? typeof options.window === "string"
+ ? getWindow(options.window, nperseg)
+ : Array.from(options.window)
+ : hannWindow(nperseg);
+
+ const winNorm =
+ scaling === "density"
+ ? win.reduce((s, w) => s + w * w, 0) * fs
+ : win.reduce((s, w) => s + w * w, 0);
+ const nFreqs = Math.floor(nfft / 2) + 1;
+ const nFrames = Math.floor((x.length - noverlap) / step);
+
+ if (nFrames <= 0) {
+ // Signal too short — return single periodogram
+ return periodogram(x, {
+ fs,
+ scaling,
+ ...(options.nfft !== undefined ? { nfft: options.nfft } : {}),
+ ...(options.window !== undefined ? { window: options.window } : {}),
+ });
+ }
+
+ // Collect per-frame periodograms
+ const frames: number[][] = [];
+ for (let k = 0; k < nFrames; k++) {
+ const start = k * step;
+ const seg: Complex[] = Array.from({ length: nfft }, (_, i) => ({
+ re: (x[start + i] ?? 0) * (win[i] ?? 0),
+ im: 0,
+ }));
+ fftInPlace(seg, nfft, false);
+ const pxx: number[] = Array.from({ length: nFreqs }, (_, fi) => {
+ const c = seg[fi] ?? { re: 0, im: 0 };
+ let p = cAbsSq(c) / winNorm;
+ // Double one-sided bins (except DC and Nyquist)
+ if (fi > 0 && fi < nFreqs - 1) {
+ p *= 2;
+ }
+ return p;
+ });
+ frames.push(pxx);
+ }
+
+ // Average
+ const Pxx: number[] = Array.from({ length: nFreqs }, (_, fi) => {
+ const vals = frames.map((fr) => fr[fi] ?? 0);
+ if (average === "mean") {
+ return vals.reduce((s, v) => s + v, 0) / vals.length;
+ }
+ // median
+ const sorted = [...vals].sort((a, b) => a - b);
+ const mid = Math.floor(sorted.length / 2);
+ return sorted.length % 2 === 1
+ ? (sorted[mid] ?? 0)
+ : ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2;
+ });
+
+ const f: number[] = Array.from({ length: nFreqs }, (_, i) => (i * fs) / nfft);
+ return { f, Pxx };
+}
+
+// ─── Periodogram ──────────────────────────────────────────────────────────────
+
+/** Options for {@link periodogram}. */
+export interface PeriodogramOptions {
+ /** Sampling frequency in Hz (default `1`). */
+ fs?: number;
+ /** FFT length (default `nextPow2(x.length)`). */
+ nfft?: number;
+ /** Window function (default `"hann"`). */
+ window?: WindowName | readonly number[];
+ /** Scaling: `"density"` (PSD) or `"spectrum"` (power spectrum). */
+ scaling?: "density" | "spectrum";
+}
+
+/**
+ * Estimate power spectral density via a single FFT (periodogram).
+ *
+ * Mirrors `scipy.signal.periodogram`.
+ *
+ * @param x - Input signal.
+ * @param options - {@link PeriodogramOptions}.
+ * @returns - {@link PSDResult} `{ f, Pxx }`.
+ *
+ * @example
+ * ```ts
+ * import { periodogram } from "tsb";
+ * const x = Array.from({ length: 256 }, (_, i) => Math.cos(2 * Math.PI * 20 * i / 256));
+ * const { f, Pxx } = periodogram(x, { fs: 256 });
+ * ```
+ */
+export function periodogram(x: readonly number[], options: PeriodogramOptions = {}): PSDResult {
+ const fs = options.fs ?? 1;
+ const nfft = nextPow2(options.nfft ?? x.length);
+ const scaling = options.scaling ?? "density";
+
+ const win: number[] =
+ options.window !== undefined
+ ? typeof options.window === "string"
+ ? getWindow(options.window, x.length)
+ : Array.from(options.window)
+ : hannWindow(x.length);
+
+ const winNorm =
+ scaling === "density"
+ ? win.reduce((s, w) => s + w * w, 0) * fs
+ : win.reduce((s, w) => s + w * w, 0);
+
+ const seg: Complex[] = Array.from({ length: nfft }, (_, i) => ({
+ re: (x[i] ?? 0) * (win[i] ?? 0),
+ im: 0,
+ }));
+ fftInPlace(seg, nfft, false);
+
+ const nFreqs = Math.floor(nfft / 2) + 1;
+ const f: number[] = Array.from({ length: nFreqs }, (_, i) => (i * fs) / nfft);
+ const Pxx: number[] = Array.from({ length: nFreqs }, (_, fi) => {
+ const c = seg[fi] ?? { re: 0, im: 0 };
+ let p = cAbsSq(c) / winNorm;
+ if (fi > 0 && fi < nFreqs - 1) {
+ p *= 2;
+ }
+ return p;
+ });
+
+ return { f, Pxx };
+}
diff --git a/src/stats/spatial_stats.ts b/src/stats/spatial_stats.ts
new file mode 100644
index 000000000..adb3faf7d
--- /dev/null
+++ b/src/stats/spatial_stats.ts
@@ -0,0 +1,435 @@
+/**
+ * spatial_stats — Spatial statistics and geostatistics.
+ *
+ * Implements:
+ * - **Variogram** estimation (empirical) and theoretical models (spherical, exponential, Gaussian)
+ * - **Ordinary Kriging** interpolation
+ * - **Moran's I** spatial autocorrelation
+ * - **Ripley's K function** and L function
+ * - **Kernel density estimation** (2D)
+ * - **Spatial weights** (distance-based, k-nearest-neighbor)
+ *
+ * @module
+ */
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+/** A 2D point with optional value. */
+export interface SpatialPoint {
+ x: number;
+ y: number;
+ value?: number;
+}
+
+// ─── Distance Utilities ───────────────────────────────────────────────────────
+
+/**
+ * Euclidean distance between two points.
+ */
+export function euclideanDistance(
+ p1: { x: number; y: number },
+ p2: { x: number; y: number },
+): number {
+ return Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2);
+}
+
+/**
+ * Compute pairwise distance matrix.
+ *
+ * @param points - Array of spatial points.
+ * @returns n×n distance matrix (flat row-major array).
+ */
+export function pairwiseDistances(points: { x: number; y: number }[]): number[] {
+ const n = points.length;
+ const D = new Array(n * n).fill(0);
+
+ for (let i = 0; i < n; i++) {
+ for (let j = i + 1; j < n; j++) {
+ const d = euclideanDistance(points[i] ?? { x: 0, y: 0 }, points[j] ?? { x: 0, y: 0 });
+ D[i * n + j] = d;
+ D[j * n + i] = d;
+ }
+ }
+
+ return D;
+}
+
+// ─── Variogram ────────────────────────────────────────────────────────────────
+
+/** A lag-semivariance pair for variogram estimation. */
+export interface VariogramPoint {
+ lag: number;
+ semivariance: number;
+ count: number;
+}
+
+/**
+ * Compute the empirical (experimental) variogram.
+ *
+ * @param points - Spatial points with values.
+ * @param nLags - Number of lag bins. Default 10.
+ * @param maxLag - Maximum lag distance (auto if undefined).
+ * @returns Array of variogram points.
+ *
+ * @example
+ * ```ts
+ * import { empiricalVariogram } from "tsb";
+ * const pts = [{ x:0, y:0, value:1 }, { x:1, y:0, value:2 }, { x:2, y:0, value:1.5 }];
+ * const vgram = empiricalVariogram(pts, 5);
+ * ```
+ */
+export function empiricalVariogram(
+ points: SpatialPoint[],
+ nLags = 10,
+ maxLag?: number,
+): VariogramPoint[] {
+ const n = points.length;
+ const D = pairwiseDistances(points);
+
+ let maxD = maxLag ?? 0;
+ if (maxLag === undefined) {
+ for (let i = 0; i < n * n; i++) {
+ if ((D[i] ?? 0) > maxD) maxD = D[i] ?? 0;
+ }
+ maxD *= 0.5; // Rule of thumb: use half the max distance
+ }
+
+ const lagSize = maxD / nLags;
+ const sumSq = new Array(nLags).fill(0);
+ const counts = new Array(nLags).fill(0);
+
+ for (let i = 0; i < n; i++) {
+ for (let j = i + 1; j < n; j++) {
+ const d = D[i * n + j] ?? 0;
+ if (d > maxD || d === 0) continue;
+
+ const bin = Math.min(Math.floor(d / lagSize), nLags - 1);
+ const dv = ((points[i]?.value ?? 0) - (points[j]?.value ?? 0)) ** 2;
+ sumSq[bin] = (sumSq[bin] ?? 0) + dv;
+ counts[bin] = (counts[bin] ?? 0) + 1;
+ }
+ }
+
+ return Array.from({ length: nLags }, (_, k) => ({
+ lag: (k + 0.5) * lagSize,
+ semivariance: (counts[k] ?? 0) > 0 ? (sumSq[k] ?? 0) / (2 * (counts[k] ?? 1)) : 0,
+ count: counts[k] ?? 0,
+ }));
+}
+
+/** Parameters for theoretical variogram models. */
+export interface VariogramModelParams {
+ /** Nugget (c0). Default 0. */
+ nugget?: number;
+ /** Sill (c). */
+ sill: number;
+ /** Range (a). */
+ range: number;
+}
+
+/**
+ * Spherical variogram model γ(h).
+ */
+export function sphericalVariogram(h: number, params: VariogramModelParams): number {
+ const c0 = params.nugget ?? 0;
+ const c = params.sill;
+ const a = params.range;
+ if (h === 0) return 0;
+ if (h >= a) return c0 + c;
+ return c0 + c * (1.5 * (h / a) - 0.5 * (h / a) ** 3);
+}
+
+/**
+ * Exponential variogram model γ(h).
+ */
+export function exponentialVariogram(h: number, params: VariogramModelParams): number {
+ const c0 = params.nugget ?? 0;
+ const c = params.sill;
+ const a = params.range;
+ if (h === 0) return 0;
+ return c0 + c * (1 - Math.exp(-h / a));
+}
+
+/**
+ * Gaussian variogram model γ(h).
+ */
+export function gaussianVariogram(h: number, params: VariogramModelParams): number {
+ const c0 = params.nugget ?? 0;
+ const c = params.sill;
+ const a = params.range;
+ if (h === 0) return 0;
+ return c0 + c * (1 - Math.exp(-((h / a) ** 2)));
+}
+
+// ─── Ordinary Kriging ─────────────────────────────────────────────────────────
+
+type VariogramFn = (h: number, params: VariogramModelParams) => number;
+
+/**
+ * Ordinary Kriging interpolation at unsampled locations.
+ *
+ * @param knownPoints - Known data points with values.
+ * @param queryPoints - Locations to interpolate.
+ * @param variogramFn - Variogram model function.
+ * @param vParams - Variogram model parameters.
+ * @returns Interpolated values at query points.
+ *
+ * @example
+ * ```ts
+ * import { ordinaryKriging, sphericalVariogram } from "tsb";
+ * const known = [{ x:0, y:0, value:1 }, { x:1, y:1, value:2 }];
+ * const query = [{ x:0.5, y:0.5 }];
+ * const pred = ordinaryKriging(known, query, sphericalVariogram, { sill:1, range:2 });
+ * ```
+ */
+export function ordinaryKriging(
+ knownPoints: SpatialPoint[],
+ queryPoints: { x: number; y: number }[],
+ variogramFn: VariogramFn,
+ vParams: VariogramModelParams,
+): number[] {
+ const n = knownPoints.length;
+ // Build kriging matrix (n+1) x (n+1) with Lagrange multiplier
+ const size = n + 1;
+ const K = new Array(size * size).fill(0);
+
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j < n; j++) {
+ const d = euclideanDistance(knownPoints[i] ?? { x: 0, y: 0 }, knownPoints[j] ?? { x: 0, y: 0 });
+ K[i * size + j] = variogramFn(d, vParams);
+ }
+ K[i * size + n] = 1;
+ K[n * size + i] = 1;
+ }
+ K[n * size + n] = 0;
+
+ const results: number[] = [];
+
+ for (const q of queryPoints) {
+ const k = new Array(size).fill(0);
+ for (let i = 0; i < n; i++) {
+ const d = euclideanDistance(q, knownPoints[i] ?? { x: 0, y: 0 });
+ k[i] = variogramFn(d, vParams);
+ }
+ k[n] = 1;
+
+ // Solve K * w = k via Gaussian elimination
+ const w = solveLinearSystem(K, k, size);
+ let pred = 0;
+ for (let i = 0; i < n; i++) {
+ pred += (w[i] ?? 0) * (knownPoints[i]?.value ?? 0);
+ }
+ results.push(pred);
+ }
+
+ return results;
+}
+
+// ─── Moran's I ────────────────────────────────────────────────────────────────
+
+/**
+ * Compute Moran's I spatial autocorrelation statistic.
+ *
+ * @param values - Observed values at each location.
+ * @param weights - n×n spatial weight matrix (flat row-major).
+ * @returns Moran's I statistic.
+ *
+ * @example
+ * ```ts
+ * import { moransI } from "tsb";
+ * const vals = [1, 2, 3, 4];
+ * const W = [0,1,0,0, 1,0,1,0, 0,1,0,1, 0,0,1,0];
+ * const I = moransI(vals, W);
+ * ```
+ */
+export function moransI(values: number[], weights: number[]): number {
+ const n = values.length;
+ const mean = values.reduce((s, v) => s + v, 0) / n;
+ const deviations = values.map((v) => v - mean);
+
+ let numerator = 0;
+ let W = 0;
+
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j < n; j++) {
+ const wij = weights[i * n + j] ?? 0;
+ W += wij;
+ numerator += wij * (deviations[i] ?? 0) * (deviations[j] ?? 0);
+ }
+ }
+
+ const denominator = deviations.reduce((s, d) => s + d * d, 0);
+
+ if (denominator === 0 || W === 0) return 0;
+ return (n / W) * (numerator / denominator);
+}
+
+// ─── Ripley's K Function ──────────────────────────────────────────────────────
+
+/**
+ * Estimate Ripley's K function for a point pattern.
+ *
+ * @param points - Array of 2D points.
+ * @param distances - Array of distances at which to evaluate K.
+ * @param area - Area of the study region.
+ * @returns K(d) values.
+ */
+export function ripleysK(
+ points: { x: number; y: number }[],
+ distances: number[],
+ area: number,
+): number[] {
+ const n = points.length;
+ const lambda = n / area;
+ const D = pairwiseDistances(points);
+
+ return distances.map((r) => {
+ let count = 0;
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j < n; j++) {
+ if (i !== j && (D[i * n + j] ?? Infinity) <= r) count++;
+ }
+ }
+ return count / (n * lambda);
+ });
+}
+
+/**
+ * Compute Ripley's L function: L(r) = sqrt(K(r) / pi).
+ *
+ * @param K - K function values.
+ * @returns L function values.
+ */
+export function ripleysL(K: number[]): number[] {
+ return K.map((k) => Math.sqrt(k / Math.PI));
+}
+
+// ─── 2D Kernel Density Estimation ─────────────────────────────────────────────
+
+/**
+ * Compute 2D kernel density estimate on a grid.
+ *
+ * @param points - Data points.
+ * @param xGrid - x-grid values.
+ * @param yGrid - y-grid values.
+ * @param bandwidth - Bandwidth (h). Default 1.
+ * @returns Density values on the grid (flat row-major, len = xGrid.length × yGrid.length).
+ */
+export function kde2d(
+ points: { x: number; y: number }[],
+ xGrid: number[],
+ yGrid: number[],
+ bandwidth = 1,
+): number[] {
+ const nx = xGrid.length;
+ const ny = yGrid.length;
+ const n = points.length;
+ const density = new Array(nx * ny).fill(0);
+ const h2 = bandwidth * bandwidth * 2;
+
+ for (let i = 0; i < nx; i++) {
+ for (let j = 0; j < ny; j++) {
+ let sum = 0;
+ const xi = xGrid[i] ?? 0;
+ const yj = yGrid[j] ?? 0;
+ for (const p of points) {
+ const d2 = (p.x - xi) ** 2 + (p.y - yj) ** 2;
+ sum += Math.exp(-d2 / h2);
+ }
+ density[i * ny + j] = sum / (n * Math.PI * h2);
+ }
+ }
+
+ return density;
+}
+
+// ─── Spatial Weights ──────────────────────────────────────────────────────────
+
+/**
+ * Build a distance-based spatial weight matrix (inverse distance weighting).
+ *
+ * @param points - Spatial points.
+ * @param maxDist - Maximum distance for neighbors (Infinity = all pairs).
+ * @param power - Distance decay power. Default 1.
+ * @returns Row-standardized weight matrix (flat row-major).
+ */
+export function distanceWeights(
+ points: { x: number; y: number }[],
+ maxDist = Infinity,
+ power = 1,
+): number[] {
+ const n = points.length;
+ const D = pairwiseDistances(points);
+ const W = new Array(n * n).fill(0);
+
+ for (let i = 0; i < n; i++) {
+ let rowSum = 0;
+ for (let j = 0; j < n; j++) {
+ if (i === j) continue;
+ const d = D[i * n + j] ?? Infinity;
+ if (d <= maxDist && d > 0) {
+ W[i * n + j] = 1 / d ** power;
+ rowSum += W[i * n + j] ?? 0;
+ }
+ }
+ if (rowSum > 0) {
+ for (let j = 0; j < n; j++) {
+ W[i * n + j] = (W[i * n + j] ?? 0) / rowSum;
+ }
+ }
+ }
+
+ return W;
+}
+
+// ─── Linear System Solver (Gaussian Elimination) ─────────────────────────────
+
+function solveLinearSystem(A: number[], b: number[], n: number): number[] {
+ // Augmented matrix
+ const aug: number[][] = [];
+ for (let i = 0; i < n; i++) {
+ const row: number[] = [];
+ for (let j = 0; j < n; j++) {
+ row.push(A[i * n + j] ?? 0);
+ }
+ row.push(b[i] ?? 0);
+ aug.push(row);
+ }
+
+ // Forward elimination
+ for (let col = 0; col < n; col++) {
+ let maxRow = col;
+ let maxVal = Math.abs(aug[col]?.[col] ?? 0);
+ for (let row = col + 1; row < n; row++) {
+ const val = Math.abs(aug[row]?.[col] ?? 0);
+ if (val > maxVal) {
+ maxVal = val;
+ maxRow = row;
+ }
+ }
+ [aug[col], aug[maxRow]] = [aug[maxRow] ?? [], aug[col] ?? []];
+
+ const pivot = aug[col]?.[col] ?? 0;
+ if (Math.abs(pivot) < 1e-12) continue;
+
+ for (let row = col + 1; row < n; row++) {
+ const factor = (aug[row]?.[col] ?? 0) / pivot;
+ for (let j = col; j <= n; j++) {
+ (aug[row] ?? [])[j] = ((aug[row] ?? [])[j] ?? 0) - factor * ((aug[col] ?? [])[j] ?? 0);
+ }
+ }
+ }
+
+ // Back substitution
+ const x = new Array(n).fill(0);
+ for (let i = n - 1; i >= 0; i--) {
+ let sum = aug[i]?.[n] ?? 0;
+ for (let j = i + 1; j < n; j++) {
+ sum -= (aug[i]?.[j] ?? 0) * (x[j] ?? 0);
+ }
+ const pivot = aug[i]?.[i] ?? 0;
+ x[i] = Math.abs(pivot) < 1e-12 ? 0 : sum / pivot;
+ }
+
+ return x;
+}
diff --git a/src/stats/stochastic_processes.ts b/src/stats/stochastic_processes.ts
new file mode 100644
index 000000000..f6b87bffe
--- /dev/null
+++ b/src/stats/stochastic_processes.ts
@@ -0,0 +1,391 @@
+/**
+ * stochastic_processes — Stochastic process simulation and inference.
+ *
+ * Implements:
+ * - **Brownian Motion** (Wiener process, geometric Brownian motion)
+ * - **Ornstein-Uhlenbeck** mean-reverting process
+ * - **Poisson Process** (homogeneous and inhomogeneous)
+ * - **Random Walk** (simple, correlated, Lévy)
+ * - **Markov Chain** (discrete-time)
+ *
+ * @module
+ */
+
+// ─── Brownian Motion ──────────────────────────────────────────────────────────
+
+/** Parameters for Brownian Motion simulation. */
+export interface BrownianMotionParams {
+ /** Drift coefficient (mu). Default 0. */
+ mu?: number;
+ /** Diffusion coefficient (sigma). Default 1. */
+ sigma?: number;
+ /** Initial value. Default 0. */
+ x0?: number;
+ /** Time step. Default 0.01. */
+ dt?: number;
+ /** Random seed (not used for true randomness, but for API compat). */
+ seed?: number;
+}
+
+/** Result of a stochastic process simulation. */
+export interface ProcessPath {
+ /** Time points. */
+ times: number[];
+ /** Process values at each time point. */
+ values: number[];
+}
+
+/**
+ * Simulate standard Brownian Motion (Wiener process with drift).
+ *
+ * dX = mu*dt + sigma*dW
+ *
+ * @param nSteps - Number of time steps.
+ * @param params - Optional BrownianMotionParams.
+ * @returns ProcessPath with times and values.
+ *
+ * @example
+ * ```ts
+ * import { simulateBrownianMotion } from "tsb";
+ * const path = simulateBrownianMotion(100, { mu: 0.1, sigma: 0.2 });
+ * ```
+ */
+export function simulateBrownianMotion(
+ nSteps: number,
+ params: BrownianMotionParams = {},
+): ProcessPath {
+ const mu = params.mu ?? 0;
+ const sigma = params.sigma ?? 1;
+ const x0 = params.x0 ?? 0;
+ const dt = params.dt ?? 0.01;
+
+ const times: number[] = [0];
+ const values: number[] = [x0];
+
+ let x = x0;
+ for (let i = 1; i <= nSteps; i++) {
+ const dW = randn() * Math.sqrt(dt);
+ x = x + mu * dt + sigma * dW;
+ times.push(i * dt);
+ values.push(x);
+ }
+
+ return { times, values };
+}
+
+/**
+ * Simulate Geometric Brownian Motion (log-normal process).
+ *
+ * dS = mu*S*dt + sigma*S*dW
+ *
+ * @param nSteps - Number of time steps.
+ * @param params - Optional BrownianMotionParams.
+ * @returns ProcessPath with times and values.
+ */
+export function simulateGeometricBrownianMotion(
+ nSteps: number,
+ params: BrownianMotionParams = {},
+): ProcessPath {
+ const mu = params.mu ?? 0.1;
+ const sigma = params.sigma ?? 0.2;
+ const x0 = params.x0 ?? 100;
+ const dt = params.dt ?? 1 / 252;
+
+ const times: number[] = [0];
+ const values: number[] = [x0];
+
+ let s = x0;
+ for (let i = 1; i <= nSteps; i++) {
+ const dW = randn() * Math.sqrt(dt);
+ s = s * Math.exp((mu - 0.5 * sigma * sigma) * dt + sigma * dW);
+ times.push(i * dt);
+ values.push(s);
+ }
+
+ return { times, values };
+}
+
+// ─── Ornstein-Uhlenbeck Process ───────────────────────────────────────────────
+
+/** Parameters for the Ornstein-Uhlenbeck process. */
+export interface OUParams {
+ /** Mean reversion speed (theta). Default 1. */
+ theta?: number;
+ /** Long-run mean (mu). Default 0. */
+ mu?: number;
+ /** Volatility (sigma). Default 0.1. */
+ sigma?: number;
+ /** Initial value. Default mu. */
+ x0?: number;
+ /** Time step. Default 0.01. */
+ dt?: number;
+}
+
+/**
+ * Simulate Ornstein-Uhlenbeck mean-reverting process.
+ *
+ * dX = theta*(mu - X)*dt + sigma*dW
+ *
+ * @param nSteps - Number of time steps.
+ * @param params - Optional OUParams.
+ * @returns ProcessPath.
+ */
+export function simulateOrnsteinUhlenbeck(
+ nSteps: number,
+ params: OUParams = {},
+): ProcessPath {
+ const theta = params.theta ?? 1.0;
+ const mu = params.mu ?? 0.0;
+ const sigma = params.sigma ?? 0.1;
+ const dt = params.dt ?? 0.01;
+ const x0 = params.x0 ?? mu;
+
+ const times: number[] = [0];
+ const values: number[] = [x0];
+
+ let x = x0;
+ for (let i = 1; i <= nSteps; i++) {
+ const dW = randn() * Math.sqrt(dt);
+ x = x + theta * (mu - x) * dt + sigma * dW;
+ times.push(i * dt);
+ values.push(x);
+ }
+
+ return { times, values };
+}
+
+/**
+ * Estimate OU parameters via method of moments.
+ *
+ * @param values - Observed time series values.
+ * @param dt - Time step between observations.
+ * @returns Estimated theta, mu, sigma.
+ */
+export function fitOrnsteinUhlenbeck(
+ values: number[],
+ dt = 0.01,
+): { theta: number; mu: number; sigma: number } {
+ const n = values.length;
+ if (n < 3) return { theta: 0, mu: 0, sigma: 0 };
+
+ // Method of moments via OLS on X(t+dt) = a + b*X(t)
+ let sumX = 0;
+ let sumY = 0;
+ let sumXX = 0;
+ let sumXY = 0;
+ const m = n - 1;
+
+ for (let i = 0; i < m; i++) {
+ const xi = values[i] ?? 0;
+ const yi = values[i + 1] ?? 0;
+ sumX += xi;
+ sumY += yi;
+ sumXX += xi * xi;
+ sumXY += xi * yi;
+ }
+
+ const b = (m * sumXY - sumX * sumY) / (m * sumXX - sumX * sumX);
+ const a = (sumY - b * sumX) / m;
+
+ const theta = -Math.log(Math.max(b, 1e-10)) / dt;
+ const mu = a / (1 - b);
+
+ // Estimate sigma from residuals
+ let residSS = 0;
+ for (let i = 0; i < m; i++) {
+ const xi = values[i] ?? 0;
+ const yi = values[i + 1] ?? 0;
+ const pred = a + b * xi;
+ residSS += (yi - pred) ** 2;
+ }
+ const sigmaEst = Math.sqrt(residSS / m / dt);
+
+ return { theta, mu, sigma: sigmaEst };
+}
+
+// ─── Poisson Process ──────────────────────────────────────────────────────────
+
+/**
+ * Simulate a homogeneous Poisson process.
+ *
+ * @param rate - Event rate (lambda, events per unit time).
+ * @param T - Total time horizon.
+ * @returns Array of event arrival times.
+ *
+ * @example
+ * ```ts
+ * import { simulatePoissonProcess } from "tsb";
+ * const arrivals = simulatePoissonProcess(2.5, 10);
+ * ```
+ */
+export function simulatePoissonProcess(rate: number, T: number): number[] {
+ const arrivals: number[] = [];
+ let t = 0;
+
+ while (t < T) {
+ const inter = -Math.log(1 - Math.random()) / rate;
+ t += inter;
+ if (t < T) arrivals.push(t);
+ }
+
+ return arrivals;
+}
+
+/**
+ * Count events in bins for a Poisson process.
+ *
+ * @param arrivals - Event arrival times.
+ * @param binSize - Size of each bin.
+ * @param T - Total time horizon.
+ * @returns Array of event counts per bin.
+ */
+export function poissonCounts(
+ arrivals: number[],
+ binSize: number,
+ T: number,
+): number[] {
+ const nBins = Math.ceil(T / binSize);
+ const counts = new Array(nBins).fill(0);
+
+ for (const t of arrivals) {
+ const bin = Math.floor(t / binSize);
+ if (bin < nBins) {
+ counts[bin] = (counts[bin] ?? 0) + 1;
+ }
+ }
+
+ return counts;
+}
+
+// ─── Random Walk ──────────────────────────────────────────────────────────────
+
+/** Parameters for random walk simulation. */
+export interface RandomWalkParams {
+ /** Step probabilities [up, down]. Default [0.5, 0.5]. */
+ probs?: [number, number];
+ /** Step sizes [up, down]. Default [1, -1]. */
+ steps?: [number, number];
+ /** Initial position. Default 0. */
+ x0?: number;
+}
+
+/**
+ * Simulate a discrete random walk.
+ *
+ * @param nSteps - Number of steps.
+ * @param params - Optional RandomWalkParams.
+ * @returns ProcessPath with integer times and cumulative positions.
+ */
+export function simulateRandomWalk(
+ nSteps: number,
+ params: RandomWalkParams = {},
+): ProcessPath {
+ const probs = params.probs ?? [0.5, 0.5];
+ const steps = params.steps ?? [1, -1];
+ const x0 = params.x0 ?? 0;
+
+ const times: number[] = [0];
+ const values: number[] = [x0];
+
+ let x = x0;
+ for (let i = 1; i <= nSteps; i++) {
+ const r = Math.random();
+ const step = r < (probs[0] ?? 0.5) ? (steps[0] ?? 1) : (steps[1] ?? -1);
+ x += step;
+ times.push(i);
+ values.push(x);
+ }
+
+ return { times, values };
+}
+
+// ─── Markov Chain ─────────────────────────────────────────────────────────────
+
+/**
+ * Simulate a discrete-time Markov chain.
+ *
+ * @param transitionMatrix - Row-stochastic transition matrix (nStates × nStates).
+ * @param nSteps - Number of steps.
+ * @param initialState - Starting state index. Default 0.
+ * @returns Array of state indices visited.
+ *
+ * @example
+ * ```ts
+ * import { simulateMarkovChain } from "tsb";
+ * const T = [[0.7, 0.3], [0.4, 0.6]];
+ * const chain = simulateMarkovChain(T, 100);
+ * ```
+ */
+export function simulateMarkovChain(
+ transitionMatrix: number[][],
+ nSteps: number,
+ initialState = 0,
+): number[] {
+ const nStates = transitionMatrix.length;
+ const chain: number[] = [initialState];
+ let state = initialState;
+
+ for (let i = 1; i <= nSteps; i++) {
+ const row = transitionMatrix[state] ?? [];
+ state = sampleCategorical(row, nStates);
+ chain.push(state);
+ }
+
+ return chain;
+}
+
+/**
+ * Compute the stationary distribution of a Markov chain via power iteration.
+ *
+ * @param transitionMatrix - Row-stochastic transition matrix.
+ * @param maxIter - Maximum iterations. Default 1000.
+ * @param tol - Convergence tolerance. Default 1e-10.
+ * @returns Stationary distribution vector.
+ */
+export function stationaryDistribution(
+ transitionMatrix: number[][],
+ maxIter = 1000,
+ tol = 1e-10,
+): number[] {
+ const n = transitionMatrix.length;
+ let pi = new Array(n).fill(1 / n);
+
+ for (let iter = 0; iter < maxIter; iter++) {
+ const newPi = new Array(n).fill(0);
+ for (let j = 0; j < n; j++) {
+ for (let i = 0; i < n; i++) {
+ newPi[j] = (newPi[j] ?? 0) + (pi[i] ?? 0) * ((transitionMatrix[i] ?? [])[j] ?? 0);
+ }
+ }
+ let diff = 0;
+ for (let i = 0; i < n; i++) {
+ diff += Math.abs((newPi[i] ?? 0) - (pi[i] ?? 0));
+ }
+ pi = newPi;
+ if (diff < tol) break;
+ }
+
+ return pi;
+}
+
+// ─── Utilities ────────────────────────────────────────────────────────────────
+
+/** Box-Muller transform for standard normal random variate. */
+function randn(): number {
+ let u = 0;
+ let v = 0;
+ while (u === 0) u = Math.random();
+ while (v === 0) v = Math.random();
+ return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+}
+
+/** Sample from a categorical distribution given unnormalized probabilities. */
+function sampleCategorical(probs: number[], n: number): number {
+ const total = probs.reduce((a, b) => a + b, 0);
+ let r = Math.random() * total;
+ for (let i = 0; i < n; i++) {
+ r -= probs[i] ?? 0;
+ if (r <= 0) return i;
+ }
+ return n - 1;
+}
diff --git a/src/stats/style.ts b/src/stats/style.ts
index 6fe34de88..63538b116 100644
--- a/src/stats/style.ts
+++ b/src/stats/style.ts
@@ -257,7 +257,7 @@ function colormapColor(t: number, cmap: string): string {
const parts = cmap.split(":");
return lerpColor(parts[0] ?? "#ffffff", parts[1] ?? "#000000", t);
}
- const stops = COLORMAPS[cmap] ?? COLORMAPS["Blues"]!;
+ const stops = COLORMAPS[cmap] ?? COLORMAPS.Blues!;
// Find surrounding stops
for (let i = 0; i < stops.length - 1; i++) {
const [p0, c0] = stops[i]!;
diff --git a/src/stellar_physics/adaptation.ts b/src/stellar_physics/adaptation.ts
new file mode 100644
index 000000000..afaf0ef45
--- /dev/null
+++ b/src/stellar_physics/adaptation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics adaptation module — tsb analytics library. */
+export interface StellarPhysicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsAdaptation(data: number[], opts: StellarPhysicsAdaptationOptions = {}): StellarPhysicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsAdaptation };
diff --git a/src/stellar_physics/aggregation.ts b/src/stellar_physics/aggregation.ts
new file mode 100644
index 000000000..a7c48fc79
--- /dev/null
+++ b/src/stellar_physics/aggregation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics aggregation module — tsb analytics library. */
+export interface StellarPhysicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsAggregationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsAggregation(data: number[], opts: StellarPhysicsAggregationOptions = {}): StellarPhysicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsAggregation };
diff --git a/src/stellar_physics/algebra.ts b/src/stellar_physics/algebra.ts
new file mode 100644
index 000000000..890b7b909
--- /dev/null
+++ b/src/stellar_physics/algebra.ts
@@ -0,0 +1,14 @@
+/** stellar_physics algebra module — tsb analytics library. */
+export interface StellarPhysicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsAlgebra(data: number[], opts: StellarPhysicsAlgebraOptions = {}): StellarPhysicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsAlgebra };
diff --git a/src/stellar_physics/alignment.ts b/src/stellar_physics/alignment.ts
new file mode 100644
index 000000000..ad271caa7
--- /dev/null
+++ b/src/stellar_physics/alignment.ts
@@ -0,0 +1,14 @@
+/** stellar_physics alignment module — tsb analytics library. */
+export interface StellarPhysicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsAlignment(data: number[], opts: StellarPhysicsAlignmentOptions = {}): StellarPhysicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsAlignment };
diff --git a/src/stellar_physics/analysis.ts b/src/stellar_physics/analysis.ts
new file mode 100644
index 000000000..94a01cbce
--- /dev/null
+++ b/src/stellar_physics/analysis.ts
@@ -0,0 +1,14 @@
+/** stellar_physics analysis module — tsb analytics library. */
+export interface StellarPhysicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsAnalysis(data: number[], opts: StellarPhysicsAnalysisOptions = {}): StellarPhysicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsAnalysis };
diff --git a/src/stellar_physics/augmentation.ts b/src/stellar_physics/augmentation.ts
new file mode 100644
index 000000000..a064af4fa
--- /dev/null
+++ b/src/stellar_physics/augmentation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics augmentation module — tsb analytics library. */
+export interface StellarPhysicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsAugmentation(data: number[], opts: StellarPhysicsAugmentationOptions = {}): StellarPhysicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsAugmentation };
diff --git a/src/stellar_physics/bagging.ts b/src/stellar_physics/bagging.ts
new file mode 100644
index 000000000..27dea2125
--- /dev/null
+++ b/src/stellar_physics/bagging.ts
@@ -0,0 +1,14 @@
+/** stellar_physics bagging module — tsb analytics library. */
+export interface StellarPhysicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsBaggingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsBagging(data: number[], opts: StellarPhysicsBaggingOptions = {}): StellarPhysicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsBagging };
diff --git a/src/stellar_physics/basis.ts b/src/stellar_physics/basis.ts
new file mode 100644
index 000000000..a8d63890e
--- /dev/null
+++ b/src/stellar_physics/basis.ts
@@ -0,0 +1,14 @@
+/** stellar_physics basis module — tsb analytics library. */
+export interface StellarPhysicsBasisOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsBasisResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsBasis(data: number[], opts: StellarPhysicsBasisOptions = {}): StellarPhysicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsBasis };
diff --git a/src/stellar_physics/benchmarking.ts b/src/stellar_physics/benchmarking.ts
new file mode 100644
index 000000000..21b0a0511
--- /dev/null
+++ b/src/stellar_physics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** stellar_physics benchmarking module — tsb analytics library. */
+export interface StellarPhysicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsBenchmarking(data: number[], opts: StellarPhysicsBenchmarkingOptions = {}): StellarPhysicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsBenchmarking };
diff --git a/src/stellar_physics/blending.ts b/src/stellar_physics/blending.ts
new file mode 100644
index 000000000..1690c13e8
--- /dev/null
+++ b/src/stellar_physics/blending.ts
@@ -0,0 +1,14 @@
+/** stellar_physics blending module — tsb analytics library. */
+export interface StellarPhysicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsBlendingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsBlending(data: number[], opts: StellarPhysicsBlendingOptions = {}): StellarPhysicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsBlending };
diff --git a/src/stellar_physics/boosting.ts b/src/stellar_physics/boosting.ts
new file mode 100644
index 000000000..aa81deb36
--- /dev/null
+++ b/src/stellar_physics/boosting.ts
@@ -0,0 +1,14 @@
+/** stellar_physics boosting module — tsb analytics library. */
+export interface StellarPhysicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsBoostingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsBoosting(data: number[], opts: StellarPhysicsBoostingOptions = {}): StellarPhysicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsBoosting };
diff --git a/src/stellar_physics/bootstrap.ts b/src/stellar_physics/bootstrap.ts
new file mode 100644
index 000000000..3a61119b7
--- /dev/null
+++ b/src/stellar_physics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** stellar_physics bootstrap module — tsb analytics library. */
+export interface StellarPhysicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsBootstrap(data: number[], opts: StellarPhysicsBootstrapOptions = {}): StellarPhysicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsBootstrap };
diff --git a/src/stellar_physics/calculus.ts b/src/stellar_physics/calculus.ts
new file mode 100644
index 000000000..cf9c77cc7
--- /dev/null
+++ b/src/stellar_physics/calculus.ts
@@ -0,0 +1,14 @@
+/** stellar_physics calculus module — tsb analytics library. */
+export interface StellarPhysicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsCalculusResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsCalculus(data: number[], opts: StellarPhysicsCalculusOptions = {}): StellarPhysicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsCalculus };
diff --git a/src/stellar_physics/calibration.ts b/src/stellar_physics/calibration.ts
new file mode 100644
index 000000000..3c38ccf56
--- /dev/null
+++ b/src/stellar_physics/calibration.ts
@@ -0,0 +1,14 @@
+/** stellar_physics calibration module — tsb analytics library. */
+export interface StellarPhysicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsCalibration(data: number[], opts: StellarPhysicsCalibrationOptions = {}): StellarPhysicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsCalibration };
diff --git a/src/stellar_physics/characterization.ts b/src/stellar_physics/characterization.ts
new file mode 100644
index 000000000..ede2d6b47
--- /dev/null
+++ b/src/stellar_physics/characterization.ts
@@ -0,0 +1,14 @@
+/** stellar_physics characterization module — tsb analytics library. */
+export interface StellarPhysicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsCharacterization(data: number[], opts: StellarPhysicsCharacterizationOptions = {}): StellarPhysicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsCharacterization };
diff --git a/src/stellar_physics/classification.ts b/src/stellar_physics/classification.ts
new file mode 100644
index 000000000..f3fe2e596
--- /dev/null
+++ b/src/stellar_physics/classification.ts
@@ -0,0 +1,14 @@
+/** stellar_physics classification module — tsb analytics library. */
+export interface StellarPhysicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsClassificationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsClassification(data: number[], opts: StellarPhysicsClassificationOptions = {}): StellarPhysicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsClassification };
diff --git a/src/stellar_physics/clustering.ts b/src/stellar_physics/clustering.ts
new file mode 100644
index 000000000..a2c9c2ec3
--- /dev/null
+++ b/src/stellar_physics/clustering.ts
@@ -0,0 +1,14 @@
+/** stellar_physics clustering module — tsb analytics library. */
+export interface StellarPhysicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsClusteringResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsClustering(data: number[], opts: StellarPhysicsClusteringOptions = {}): StellarPhysicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsClustering };
diff --git a/src/stellar_physics/compression.ts b/src/stellar_physics/compression.ts
new file mode 100644
index 000000000..3fb8a72b2
--- /dev/null
+++ b/src/stellar_physics/compression.ts
@@ -0,0 +1,14 @@
+/** stellar_physics compression module — tsb analytics library. */
+export interface StellarPhysicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsCompressionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsCompression(data: number[], opts: StellarPhysicsCompressionOptions = {}): StellarPhysicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsCompression };
diff --git a/src/stellar_physics/continuous.ts b/src/stellar_physics/continuous.ts
new file mode 100644
index 000000000..6493378e0
--- /dev/null
+++ b/src/stellar_physics/continuous.ts
@@ -0,0 +1,14 @@
+/** stellar_physics continuous module — tsb analytics library. */
+export interface StellarPhysicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsContinuousResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsContinuous(data: number[], opts: StellarPhysicsContinuousOptions = {}): StellarPhysicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsContinuous };
diff --git a/src/stellar_physics/control.ts b/src/stellar_physics/control.ts
new file mode 100644
index 000000000..c2a4b989c
--- /dev/null
+++ b/src/stellar_physics/control.ts
@@ -0,0 +1,14 @@
+/** stellar_physics control module — tsb analytics library. */
+export interface StellarPhysicsControlOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsControlResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsControl(data: number[], opts: StellarPhysicsControlOptions = {}): StellarPhysicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsControl };
diff --git a/src/stellar_physics/convergence.ts b/src/stellar_physics/convergence.ts
new file mode 100644
index 000000000..79bddcc5f
--- /dev/null
+++ b/src/stellar_physics/convergence.ts
@@ -0,0 +1,14 @@
+/** stellar_physics convergence module — tsb analytics library. */
+export interface StellarPhysicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsConvergence(data: number[], opts: StellarPhysicsConvergenceOptions = {}): StellarPhysicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsConvergence };
diff --git a/src/stellar_physics/convex.ts b/src/stellar_physics/convex.ts
new file mode 100644
index 000000000..ac90e4fc1
--- /dev/null
+++ b/src/stellar_physics/convex.ts
@@ -0,0 +1,14 @@
+/** stellar_physics convex module — tsb analytics library. */
+export interface StellarPhysicsConvexOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsConvexResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsConvex(data: number[], opts: StellarPhysicsConvexOptions = {}): StellarPhysicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsConvex };
diff --git a/src/stellar_physics/correlation.ts b/src/stellar_physics/correlation.ts
new file mode 100644
index 000000000..174d44e36
--- /dev/null
+++ b/src/stellar_physics/correlation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics correlation module — tsb analytics library. */
+export interface StellarPhysicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsCorrelation(data: number[], opts: StellarPhysicsCorrelationOptions = {}): StellarPhysicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsCorrelation };
diff --git a/src/stellar_physics/covariance.ts b/src/stellar_physics/covariance.ts
new file mode 100644
index 000000000..8f7d916e2
--- /dev/null
+++ b/src/stellar_physics/covariance.ts
@@ -0,0 +1,14 @@
+/** stellar_physics covariance module — tsb analytics library. */
+export interface StellarPhysicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsCovariance(data: number[], opts: StellarPhysicsCovarianceOptions = {}): StellarPhysicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsCovariance };
diff --git a/src/stellar_physics/cross_validation.ts b/src/stellar_physics/cross_validation.ts
new file mode 100644
index 000000000..7958390b5
--- /dev/null
+++ b/src/stellar_physics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics cross_validation module — tsb analytics library. */
+export interface StellarPhysicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsCrossValidation(data: number[], opts: StellarPhysicsCrossValidationOptions = {}): StellarPhysicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsCrossValidation };
diff --git a/src/stellar_physics/decoding.ts b/src/stellar_physics/decoding.ts
new file mode 100644
index 000000000..676d03e74
--- /dev/null
+++ b/src/stellar_physics/decoding.ts
@@ -0,0 +1,14 @@
+/** stellar_physics decoding module — tsb analytics library. */
+export interface StellarPhysicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDecodingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDecoding(data: number[], opts: StellarPhysicsDecodingOptions = {}): StellarPhysicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDecoding };
diff --git a/src/stellar_physics/decomposition.ts b/src/stellar_physics/decomposition.ts
new file mode 100644
index 000000000..4372c87b6
--- /dev/null
+++ b/src/stellar_physics/decomposition.ts
@@ -0,0 +1,14 @@
+/** stellar_physics decomposition module — tsb analytics library. */
+export interface StellarPhysicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDecomposition(data: number[], opts: StellarPhysicsDecompositionOptions = {}): StellarPhysicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDecomposition };
diff --git a/src/stellar_physics/detection.ts b/src/stellar_physics/detection.ts
new file mode 100644
index 000000000..3ba7f6c50
--- /dev/null
+++ b/src/stellar_physics/detection.ts
@@ -0,0 +1,14 @@
+/** stellar_physics detection module — tsb analytics library. */
+export interface StellarPhysicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDetectionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDetection(data: number[], opts: StellarPhysicsDetectionOptions = {}): StellarPhysicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDetection };
diff --git a/src/stellar_physics/deterministic.ts b/src/stellar_physics/deterministic.ts
new file mode 100644
index 000000000..b04a65546
--- /dev/null
+++ b/src/stellar_physics/deterministic.ts
@@ -0,0 +1,14 @@
+/** stellar_physics deterministic module — tsb analytics library. */
+export interface StellarPhysicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDeterministic(data: number[], opts: StellarPhysicsDeterministicOptions = {}): StellarPhysicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDeterministic };
diff --git a/src/stellar_physics/diagnostics.ts b/src/stellar_physics/diagnostics.ts
new file mode 100644
index 000000000..be182f04f
--- /dev/null
+++ b/src/stellar_physics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** stellar_physics diagnostics module — tsb analytics library. */
+export interface StellarPhysicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDiagnostics(data: number[], opts: StellarPhysicsDiagnosticsOptions = {}): StellarPhysicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDiagnostics };
diff --git a/src/stellar_physics/differential.ts b/src/stellar_physics/differential.ts
new file mode 100644
index 000000000..718d6c111
--- /dev/null
+++ b/src/stellar_physics/differential.ts
@@ -0,0 +1,14 @@
+/** stellar_physics differential module — tsb analytics library. */
+export interface StellarPhysicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDifferential(data: number[], opts: StellarPhysicsDifferentialOptions = {}): StellarPhysicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDifferential };
diff --git a/src/stellar_physics/discrete.ts b/src/stellar_physics/discrete.ts
new file mode 100644
index 000000000..38b721cfe
--- /dev/null
+++ b/src/stellar_physics/discrete.ts
@@ -0,0 +1,14 @@
+/** stellar_physics discrete module — tsb analytics library. */
+export interface StellarPhysicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDiscrete(data: number[], opts: StellarPhysicsDiscreteOptions = {}): StellarPhysicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDiscrete };
diff --git a/src/stellar_physics/distribution.ts b/src/stellar_physics/distribution.ts
new file mode 100644
index 000000000..d716839df
--- /dev/null
+++ b/src/stellar_physics/distribution.ts
@@ -0,0 +1,14 @@
+/** stellar_physics distribution module — tsb analytics library. */
+export interface StellarPhysicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDistributionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDistribution(data: number[], opts: StellarPhysicsDistributionOptions = {}): StellarPhysicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDistribution };
diff --git a/src/stellar_physics/dynamic.ts b/src/stellar_physics/dynamic.ts
new file mode 100644
index 000000000..b60c9d65e
--- /dev/null
+++ b/src/stellar_physics/dynamic.ts
@@ -0,0 +1,14 @@
+/** stellar_physics dynamic module — tsb analytics library. */
+export interface StellarPhysicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsDynamicResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsDynamic(data: number[], opts: StellarPhysicsDynamicOptions = {}): StellarPhysicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsDynamic };
diff --git a/src/stellar_physics/embedding.ts b/src/stellar_physics/embedding.ts
new file mode 100644
index 000000000..d371c8cb9
--- /dev/null
+++ b/src/stellar_physics/embedding.ts
@@ -0,0 +1,14 @@
+/** stellar_physics embedding module — tsb analytics library. */
+export interface StellarPhysicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsEmbedding(data: number[], opts: StellarPhysicsEmbeddingOptions = {}): StellarPhysicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsEmbedding };
diff --git a/src/stellar_physics/encoding.ts b/src/stellar_physics/encoding.ts
new file mode 100644
index 000000000..e38d45fdc
--- /dev/null
+++ b/src/stellar_physics/encoding.ts
@@ -0,0 +1,14 @@
+/** stellar_physics encoding module — tsb analytics library. */
+export interface StellarPhysicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsEncodingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsEncoding(data: number[], opts: StellarPhysicsEncodingOptions = {}): StellarPhysicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsEncoding };
diff --git a/src/stellar_physics/ensemble.ts b/src/stellar_physics/ensemble.ts
new file mode 100644
index 000000000..b8d941812
--- /dev/null
+++ b/src/stellar_physics/ensemble.ts
@@ -0,0 +1,14 @@
+/** stellar_physics ensemble module — tsb analytics library. */
+export interface StellarPhysicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsEnsemble(data: number[], opts: StellarPhysicsEnsembleOptions = {}): StellarPhysicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsEnsemble };
diff --git a/src/stellar_physics/estimation.ts b/src/stellar_physics/estimation.ts
new file mode 100644
index 000000000..046a732c5
--- /dev/null
+++ b/src/stellar_physics/estimation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics estimation module — tsb analytics library. */
+export interface StellarPhysicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsEstimationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsEstimation(data: number[], opts: StellarPhysicsEstimationOptions = {}): StellarPhysicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsEstimation };
diff --git a/src/stellar_physics/evaluation.ts b/src/stellar_physics/evaluation.ts
new file mode 100644
index 000000000..c735efeac
--- /dev/null
+++ b/src/stellar_physics/evaluation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics evaluation module — tsb analytics library. */
+export interface StellarPhysicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsEvaluation(data: number[], opts: StellarPhysicsEvaluationOptions = {}): StellarPhysicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsEvaluation };
diff --git a/src/stellar_physics/extrapolation.ts b/src/stellar_physics/extrapolation.ts
new file mode 100644
index 000000000..9a0e42aa7
--- /dev/null
+++ b/src/stellar_physics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics extrapolation module — tsb analytics library. */
+export interface StellarPhysicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsExtrapolation(data: number[], opts: StellarPhysicsExtrapolationOptions = {}): StellarPhysicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsExtrapolation };
diff --git a/src/stellar_physics/features.ts b/src/stellar_physics/features.ts
new file mode 100644
index 000000000..41623f2ba
--- /dev/null
+++ b/src/stellar_physics/features.ts
@@ -0,0 +1,14 @@
+/** stellar_physics features module — tsb analytics library. */
+export interface StellarPhysicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsFeatures(data: number[], opts: StellarPhysicsFeaturesOptions = {}): StellarPhysicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsFeatures };
diff --git a/src/stellar_physics/feedback.ts b/src/stellar_physics/feedback.ts
new file mode 100644
index 000000000..d514944e7
--- /dev/null
+++ b/src/stellar_physics/feedback.ts
@@ -0,0 +1,14 @@
+/** stellar_physics feedback module — tsb analytics library. */
+export interface StellarPhysicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsFeedback(data: number[], opts: StellarPhysicsFeedbackOptions = {}): StellarPhysicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsFeedback };
diff --git a/src/stellar_physics/filtering.ts b/src/stellar_physics/filtering.ts
new file mode 100644
index 000000000..c0a6383df
--- /dev/null
+++ b/src/stellar_physics/filtering.ts
@@ -0,0 +1,14 @@
+/** stellar_physics filtering module — tsb analytics library. */
+export interface StellarPhysicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsFilteringResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsFiltering(data: number[], opts: StellarPhysicsFilteringOptions = {}): StellarPhysicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsFiltering };
diff --git a/src/stellar_physics/fourier.ts b/src/stellar_physics/fourier.ts
new file mode 100644
index 000000000..4453f2780
--- /dev/null
+++ b/src/stellar_physics/fourier.ts
@@ -0,0 +1,14 @@
+/** stellar_physics fourier module — tsb analytics library. */
+export interface StellarPhysicsFourierOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsFourierResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsFourier(data: number[], opts: StellarPhysicsFourierOptions = {}): StellarPhysicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsFourier };
diff --git a/src/stellar_physics/fusion.ts b/src/stellar_physics/fusion.ts
new file mode 100644
index 000000000..a611e4d30
--- /dev/null
+++ b/src/stellar_physics/fusion.ts
@@ -0,0 +1,14 @@
+/** stellar_physics fusion module — tsb analytics library. */
+export interface StellarPhysicsFusionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsFusionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsFusion(data: number[], opts: StellarPhysicsFusionOptions = {}): StellarPhysicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsFusion };
diff --git a/src/stellar_physics/generation.ts b/src/stellar_physics/generation.ts
new file mode 100644
index 000000000..8e0eac817
--- /dev/null
+++ b/src/stellar_physics/generation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics generation module — tsb analytics library. */
+export interface StellarPhysicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsGenerationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsGeneration(data: number[], opts: StellarPhysicsGenerationOptions = {}): StellarPhysicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsGeneration };
diff --git a/src/stellar_physics/geometry.ts b/src/stellar_physics/geometry.ts
new file mode 100644
index 000000000..b1acd21a2
--- /dev/null
+++ b/src/stellar_physics/geometry.ts
@@ -0,0 +1,14 @@
+/** stellar_physics geometry module — tsb analytics library. */
+export interface StellarPhysicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsGeometryResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsGeometry(data: number[], opts: StellarPhysicsGeometryOptions = {}): StellarPhysicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsGeometry };
diff --git a/src/stellar_physics/gradient.ts b/src/stellar_physics/gradient.ts
new file mode 100644
index 000000000..a31fdcf3e
--- /dev/null
+++ b/src/stellar_physics/gradient.ts
@@ -0,0 +1,14 @@
+/** stellar_physics gradient module — tsb analytics library. */
+export interface StellarPhysicsGradientOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsGradientResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsGradient(data: number[], opts: StellarPhysicsGradientOptions = {}): StellarPhysicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsGradient };
diff --git a/src/stellar_physics/hessian.ts b/src/stellar_physics/hessian.ts
new file mode 100644
index 000000000..8e801ed62
--- /dev/null
+++ b/src/stellar_physics/hessian.ts
@@ -0,0 +1,14 @@
+/** stellar_physics hessian module — tsb analytics library. */
+export interface StellarPhysicsHessianOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsHessianResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsHessian(data: number[], opts: StellarPhysicsHessianOptions = {}): StellarPhysicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsHessian };
diff --git a/src/stellar_physics/hypothesis.ts b/src/stellar_physics/hypothesis.ts
new file mode 100644
index 000000000..222866af5
--- /dev/null
+++ b/src/stellar_physics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** stellar_physics hypothesis module — tsb analytics library. */
+export interface StellarPhysicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsHypothesis(data: number[], opts: StellarPhysicsHypothesisOptions = {}): StellarPhysicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsHypothesis };
diff --git a/src/stellar_physics/inference.ts b/src/stellar_physics/inference.ts
new file mode 100644
index 000000000..8d12c57ed
--- /dev/null
+++ b/src/stellar_physics/inference.ts
@@ -0,0 +1,14 @@
+/** stellar_physics inference module — tsb analytics library. */
+export interface StellarPhysicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsInferenceResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsInference(data: number[], opts: StellarPhysicsInferenceOptions = {}): StellarPhysicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsInference };
diff --git a/src/stellar_physics/inference2.ts b/src/stellar_physics/inference2.ts
new file mode 100644
index 000000000..9c20b981a
--- /dev/null
+++ b/src/stellar_physics/inference2.ts
@@ -0,0 +1,14 @@
+/** stellar_physics inference2 module — tsb analytics library. */
+export interface StellarPhysicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsInferenceResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsInference(data: number[], opts: StellarPhysicsInferenceOptions = {}): StellarPhysicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsInference };
diff --git a/src/stellar_physics/integral.ts b/src/stellar_physics/integral.ts
new file mode 100644
index 000000000..40382dc91
--- /dev/null
+++ b/src/stellar_physics/integral.ts
@@ -0,0 +1,14 @@
+/** stellar_physics integral module — tsb analytics library. */
+export interface StellarPhysicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsIntegralResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsIntegral(data: number[], opts: StellarPhysicsIntegralOptions = {}): StellarPhysicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsIntegral };
diff --git a/src/stellar_physics/integration.ts b/src/stellar_physics/integration.ts
new file mode 100644
index 000000000..dc3403708
--- /dev/null
+++ b/src/stellar_physics/integration.ts
@@ -0,0 +1,14 @@
+/** stellar_physics integration module — tsb analytics library. */
+export interface StellarPhysicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsIntegration(data: number[], opts: StellarPhysicsIntegrationOptions = {}): StellarPhysicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsIntegration };
diff --git a/src/stellar_physics/interpolation.ts b/src/stellar_physics/interpolation.ts
new file mode 100644
index 000000000..5091bf11c
--- /dev/null
+++ b/src/stellar_physics/interpolation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics interpolation module — tsb analytics library. */
+export interface StellarPhysicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsInterpolation(data: number[], opts: StellarPhysicsInterpolationOptions = {}): StellarPhysicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsInterpolation };
diff --git a/src/stellar_physics/jacobian.ts b/src/stellar_physics/jacobian.ts
new file mode 100644
index 000000000..bdd8fb7d0
--- /dev/null
+++ b/src/stellar_physics/jacobian.ts
@@ -0,0 +1,14 @@
+/** stellar_physics jacobian module — tsb analytics library. */
+export interface StellarPhysicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsJacobianResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsJacobian(data: number[], opts: StellarPhysicsJacobianOptions = {}): StellarPhysicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsJacobian };
diff --git a/src/stellar_physics/kernel.ts b/src/stellar_physics/kernel.ts
new file mode 100644
index 000000000..755033b9a
--- /dev/null
+++ b/src/stellar_physics/kernel.ts
@@ -0,0 +1,14 @@
+/** stellar_physics kernel module — tsb analytics library. */
+export interface StellarPhysicsKernelOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsKernelResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsKernel(data: number[], opts: StellarPhysicsKernelOptions = {}): StellarPhysicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsKernel };
diff --git a/src/stellar_physics/laplacian.ts b/src/stellar_physics/laplacian.ts
new file mode 100644
index 000000000..38577cedd
--- /dev/null
+++ b/src/stellar_physics/laplacian.ts
@@ -0,0 +1,14 @@
+/** stellar_physics laplacian module — tsb analytics library. */
+export interface StellarPhysicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsLaplacian(data: number[], opts: StellarPhysicsLaplacianOptions = {}): StellarPhysicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsLaplacian };
diff --git a/src/stellar_physics/learning.ts b/src/stellar_physics/learning.ts
new file mode 100644
index 000000000..837bff562
--- /dev/null
+++ b/src/stellar_physics/learning.ts
@@ -0,0 +1,14 @@
+/** stellar_physics learning module — tsb analytics library. */
+export interface StellarPhysicsLearningOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsLearningResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsLearning(data: number[], opts: StellarPhysicsLearningOptions = {}): StellarPhysicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsLearning };
diff --git a/src/stellar_physics/linear.ts b/src/stellar_physics/linear.ts
new file mode 100644
index 000000000..ebd043c45
--- /dev/null
+++ b/src/stellar_physics/linear.ts
@@ -0,0 +1,14 @@
+/** stellar_physics linear module — tsb analytics library. */
+export interface StellarPhysicsLinearOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsLinearResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsLinear(data: number[], opts: StellarPhysicsLinearOptions = {}): StellarPhysicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsLinear };
diff --git a/src/stellar_physics/manifold.ts b/src/stellar_physics/manifold.ts
new file mode 100644
index 000000000..d5af1f83f
--- /dev/null
+++ b/src/stellar_physics/manifold.ts
@@ -0,0 +1,14 @@
+/** stellar_physics manifold module — tsb analytics library. */
+export interface StellarPhysicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsManifoldResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsManifold(data: number[], opts: StellarPhysicsManifoldOptions = {}): StellarPhysicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsManifold };
diff --git a/src/stellar_physics/matching.ts b/src/stellar_physics/matching.ts
new file mode 100644
index 000000000..ef6a6dcaa
--- /dev/null
+++ b/src/stellar_physics/matching.ts
@@ -0,0 +1,14 @@
+/** stellar_physics matching module — tsb analytics library. */
+export interface StellarPhysicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsMatchingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsMatching(data: number[], opts: StellarPhysicsMatchingOptions = {}): StellarPhysicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsMatching };
diff --git a/src/stellar_physics/measurement.ts b/src/stellar_physics/measurement.ts
new file mode 100644
index 000000000..fbeaab517
--- /dev/null
+++ b/src/stellar_physics/measurement.ts
@@ -0,0 +1,14 @@
+/** stellar_physics measurement module — tsb analytics library. */
+export interface StellarPhysicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsMeasurement(data: number[], opts: StellarPhysicsMeasurementOptions = {}): StellarPhysicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsMeasurement };
diff --git a/src/stellar_physics/metrics.ts b/src/stellar_physics/metrics.ts
new file mode 100644
index 000000000..b199fbfea
--- /dev/null
+++ b/src/stellar_physics/metrics.ts
@@ -0,0 +1,14 @@
+/** stellar_physics metrics module — tsb analytics library. */
+export interface StellarPhysicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsMetricsResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsMetrics(data: number[], opts: StellarPhysicsMetricsOptions = {}): StellarPhysicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsMetrics };
diff --git a/src/stellar_physics/modeling.ts b/src/stellar_physics/modeling.ts
new file mode 100644
index 000000000..3fd5ab780
--- /dev/null
+++ b/src/stellar_physics/modeling.ts
@@ -0,0 +1,14 @@
+/** stellar_physics modeling module — tsb analytics library. */
+export interface StellarPhysicsModelingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsModelingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsModeling(data: number[], opts: StellarPhysicsModelingOptions = {}): StellarPhysicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsModeling };
diff --git a/src/stellar_physics/monitoring.ts b/src/stellar_physics/monitoring.ts
new file mode 100644
index 000000000..bcf58d5d0
--- /dev/null
+++ b/src/stellar_physics/monitoring.ts
@@ -0,0 +1,14 @@
+/** stellar_physics monitoring module — tsb analytics library. */
+export interface StellarPhysicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsMonitoring(data: number[], opts: StellarPhysicsMonitoringOptions = {}): StellarPhysicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsMonitoring };
diff --git a/src/stellar_physics/nonlinear.ts b/src/stellar_physics/nonlinear.ts
new file mode 100644
index 000000000..70a01c877
--- /dev/null
+++ b/src/stellar_physics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** stellar_physics nonlinear module — tsb analytics library. */
+export interface StellarPhysicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsNonlinear(data: number[], opts: StellarPhysicsNonlinearOptions = {}): StellarPhysicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsNonlinear };
diff --git a/src/stellar_physics/normalization.ts b/src/stellar_physics/normalization.ts
new file mode 100644
index 000000000..f6e9db625
--- /dev/null
+++ b/src/stellar_physics/normalization.ts
@@ -0,0 +1,14 @@
+/** stellar_physics normalization module — tsb analytics library. */
+export interface StellarPhysicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsNormalization(data: number[], opts: StellarPhysicsNormalizationOptions = {}): StellarPhysicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsNormalization };
diff --git a/src/stellar_physics/optimization.ts b/src/stellar_physics/optimization.ts
new file mode 100644
index 000000000..3cc781275
--- /dev/null
+++ b/src/stellar_physics/optimization.ts
@@ -0,0 +1,14 @@
+/** stellar_physics optimization module — tsb analytics library. */
+export interface StellarPhysicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsOptimization(data: number[], opts: StellarPhysicsOptimizationOptions = {}): StellarPhysicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsOptimization };
diff --git a/src/stellar_physics/patterns.ts b/src/stellar_physics/patterns.ts
new file mode 100644
index 000000000..d8b300bb9
--- /dev/null
+++ b/src/stellar_physics/patterns.ts
@@ -0,0 +1,14 @@
+/** stellar_physics patterns module — tsb analytics library. */
+export interface StellarPhysicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsPatternsResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsPatterns(data: number[], opts: StellarPhysicsPatternsOptions = {}): StellarPhysicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsPatterns };
diff --git a/src/stellar_physics/permutation.ts b/src/stellar_physics/permutation.ts
new file mode 100644
index 000000000..8954fa8fb
--- /dev/null
+++ b/src/stellar_physics/permutation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics permutation module — tsb analytics library. */
+export interface StellarPhysicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsPermutationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsPermutation(data: number[], opts: StellarPhysicsPermutationOptions = {}): StellarPhysicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsPermutation };
diff --git a/src/stellar_physics/prediction.ts b/src/stellar_physics/prediction.ts
new file mode 100644
index 000000000..d59cf34bc
--- /dev/null
+++ b/src/stellar_physics/prediction.ts
@@ -0,0 +1,14 @@
+/** stellar_physics prediction module — tsb analytics library. */
+export interface StellarPhysicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsPredictionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsPrediction(data: number[], opts: StellarPhysicsPredictionOptions = {}): StellarPhysicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsPrediction };
diff --git a/src/stellar_physics/processing.ts b/src/stellar_physics/processing.ts
new file mode 100644
index 000000000..5e4a42d35
--- /dev/null
+++ b/src/stellar_physics/processing.ts
@@ -0,0 +1,14 @@
+/** stellar_physics processing module — tsb analytics library. */
+export interface StellarPhysicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsProcessingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsProcessing(data: number[], opts: StellarPhysicsProcessingOptions = {}): StellarPhysicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsProcessing };
diff --git a/src/stellar_physics/profiling.ts b/src/stellar_physics/profiling.ts
new file mode 100644
index 000000000..448922897
--- /dev/null
+++ b/src/stellar_physics/profiling.ts
@@ -0,0 +1,14 @@
+/** stellar_physics profiling module — tsb analytics library. */
+export interface StellarPhysicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsProfilingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsProfiling(data: number[], opts: StellarPhysicsProfilingOptions = {}): StellarPhysicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsProfiling };
diff --git a/src/stellar_physics/projection.ts b/src/stellar_physics/projection.ts
new file mode 100644
index 000000000..efee81ff6
--- /dev/null
+++ b/src/stellar_physics/projection.ts
@@ -0,0 +1,14 @@
+/** stellar_physics projection module — tsb analytics library. */
+export interface StellarPhysicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsProjectionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsProjection(data: number[], opts: StellarPhysicsProjectionOptions = {}): StellarPhysicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsProjection };
diff --git a/src/stellar_physics/ranking.ts b/src/stellar_physics/ranking.ts
new file mode 100644
index 000000000..e26282405
--- /dev/null
+++ b/src/stellar_physics/ranking.ts
@@ -0,0 +1,14 @@
+/** stellar_physics ranking module — tsb analytics library. */
+export interface StellarPhysicsRankingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsRankingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsRanking(data: number[], opts: StellarPhysicsRankingOptions = {}): StellarPhysicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsRanking };
diff --git a/src/stellar_physics/reconstruction.ts b/src/stellar_physics/reconstruction.ts
new file mode 100644
index 000000000..99baed4a4
--- /dev/null
+++ b/src/stellar_physics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** stellar_physics reconstruction module — tsb analytics library. */
+export interface StellarPhysicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsReconstruction(data: number[], opts: StellarPhysicsReconstructionOptions = {}): StellarPhysicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsReconstruction };
diff --git a/src/stellar_physics/registration.ts b/src/stellar_physics/registration.ts
new file mode 100644
index 000000000..4f505f69c
--- /dev/null
+++ b/src/stellar_physics/registration.ts
@@ -0,0 +1,14 @@
+/** stellar_physics registration module — tsb analytics library. */
+export interface StellarPhysicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsRegistration(data: number[], opts: StellarPhysicsRegistrationOptions = {}): StellarPhysicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsRegistration };
diff --git a/src/stellar_physics/regression.ts b/src/stellar_physics/regression.ts
new file mode 100644
index 000000000..f0706a2f4
--- /dev/null
+++ b/src/stellar_physics/regression.ts
@@ -0,0 +1,14 @@
+/** stellar_physics regression module — tsb analytics library. */
+export interface StellarPhysicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsRegressionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsRegression(data: number[], opts: StellarPhysicsRegressionOptions = {}): StellarPhysicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsRegression };
diff --git a/src/stellar_physics/regularization.ts b/src/stellar_physics/regularization.ts
new file mode 100644
index 000000000..904348006
--- /dev/null
+++ b/src/stellar_physics/regularization.ts
@@ -0,0 +1,14 @@
+/** stellar_physics regularization module — tsb analytics library. */
+export interface StellarPhysicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsRegularization(data: number[], opts: StellarPhysicsRegularizationOptions = {}): StellarPhysicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsRegularization };
diff --git a/src/stellar_physics/robustness.ts b/src/stellar_physics/robustness.ts
new file mode 100644
index 000000000..1d6f676db
--- /dev/null
+++ b/src/stellar_physics/robustness.ts
@@ -0,0 +1,14 @@
+/** stellar_physics robustness module — tsb analytics library. */
+export interface StellarPhysicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsRobustness(data: number[], opts: StellarPhysicsRobustnessOptions = {}): StellarPhysicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsRobustness };
diff --git a/src/stellar_physics/sampling.ts b/src/stellar_physics/sampling.ts
new file mode 100644
index 000000000..db7e2bb11
--- /dev/null
+++ b/src/stellar_physics/sampling.ts
@@ -0,0 +1,14 @@
+/** stellar_physics sampling module — tsb analytics library. */
+export interface StellarPhysicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsSamplingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsSampling(data: number[], opts: StellarPhysicsSamplingOptions = {}): StellarPhysicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsSampling };
diff --git a/src/stellar_physics/sampling2.ts b/src/stellar_physics/sampling2.ts
new file mode 100644
index 000000000..0828b427e
--- /dev/null
+++ b/src/stellar_physics/sampling2.ts
@@ -0,0 +1,14 @@
+/** stellar_physics sampling2 module — tsb analytics library. */
+export interface StellarPhysicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsSamplingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsSampling(data: number[], opts: StellarPhysicsSamplingOptions = {}): StellarPhysicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsSampling };
diff --git a/src/stellar_physics/scaling.ts b/src/stellar_physics/scaling.ts
new file mode 100644
index 000000000..34b95b801
--- /dev/null
+++ b/src/stellar_physics/scaling.ts
@@ -0,0 +1,14 @@
+/** stellar_physics scaling module — tsb analytics library. */
+export interface StellarPhysicsScalingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsScalingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsScaling(data: number[], opts: StellarPhysicsScalingOptions = {}): StellarPhysicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsScaling };
diff --git a/src/stellar_physics/scoring.ts b/src/stellar_physics/scoring.ts
new file mode 100644
index 000000000..4a7297b1d
--- /dev/null
+++ b/src/stellar_physics/scoring.ts
@@ -0,0 +1,14 @@
+/** stellar_physics scoring module — tsb analytics library. */
+export interface StellarPhysicsScoringOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsScoringResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsScoring(data: number[], opts: StellarPhysicsScoringOptions = {}): StellarPhysicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsScoring };
diff --git a/src/stellar_physics/segmentation.ts b/src/stellar_physics/segmentation.ts
new file mode 100644
index 000000000..560dabf23
--- /dev/null
+++ b/src/stellar_physics/segmentation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics segmentation module — tsb analytics library. */
+export interface StellarPhysicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsSegmentation(data: number[], opts: StellarPhysicsSegmentationOptions = {}): StellarPhysicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsSegmentation };
diff --git a/src/stellar_physics/selection.ts b/src/stellar_physics/selection.ts
new file mode 100644
index 000000000..54e41a83b
--- /dev/null
+++ b/src/stellar_physics/selection.ts
@@ -0,0 +1,14 @@
+/** stellar_physics selection module — tsb analytics library. */
+export interface StellarPhysicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsSelectionResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsSelection(data: number[], opts: StellarPhysicsSelectionOptions = {}): StellarPhysicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsSelection };
diff --git a/src/stellar_physics/sensitivity.ts b/src/stellar_physics/sensitivity.ts
new file mode 100644
index 000000000..1fc6507e6
--- /dev/null
+++ b/src/stellar_physics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** stellar_physics sensitivity module — tsb analytics library. */
+export interface StellarPhysicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsSensitivity(data: number[], opts: StellarPhysicsSensitivityOptions = {}): StellarPhysicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsSensitivity };
diff --git a/src/stellar_physics/simulation.ts b/src/stellar_physics/simulation.ts
new file mode 100644
index 000000000..f4fc61d7e
--- /dev/null
+++ b/src/stellar_physics/simulation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics simulation module — tsb analytics library. */
+export interface StellarPhysicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsSimulationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsSimulation(data: number[], opts: StellarPhysicsSimulationOptions = {}): StellarPhysicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsSimulation };
diff --git a/src/stellar_physics/smoothing.ts b/src/stellar_physics/smoothing.ts
new file mode 100644
index 000000000..337e4f109
--- /dev/null
+++ b/src/stellar_physics/smoothing.ts
@@ -0,0 +1,14 @@
+/** stellar_physics smoothing module — tsb analytics library. */
+export interface StellarPhysicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsSmoothing(data: number[], opts: StellarPhysicsSmoothingOptions = {}): StellarPhysicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsSmoothing };
diff --git a/src/stellar_physics/stability.ts b/src/stellar_physics/stability.ts
new file mode 100644
index 000000000..65ac06929
--- /dev/null
+++ b/src/stellar_physics/stability.ts
@@ -0,0 +1,14 @@
+/** stellar_physics stability module — tsb analytics library. */
+export interface StellarPhysicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsStabilityResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsStability(data: number[], opts: StellarPhysicsStabilityOptions = {}): StellarPhysicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsStability };
diff --git a/src/stellar_physics/stacking.ts b/src/stellar_physics/stacking.ts
new file mode 100644
index 000000000..1d94f1975
--- /dev/null
+++ b/src/stellar_physics/stacking.ts
@@ -0,0 +1,14 @@
+/** stellar_physics stacking module — tsb analytics library. */
+export interface StellarPhysicsStackingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsStackingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsStacking(data: number[], opts: StellarPhysicsStackingOptions = {}): StellarPhysicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsStacking };
diff --git a/src/stellar_physics/standardization.ts b/src/stellar_physics/standardization.ts
new file mode 100644
index 000000000..aa317332d
--- /dev/null
+++ b/src/stellar_physics/standardization.ts
@@ -0,0 +1,14 @@
+/** stellar_physics standardization module — tsb analytics library. */
+export interface StellarPhysicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsStandardization(data: number[], opts: StellarPhysicsStandardizationOptions = {}): StellarPhysicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsStandardization };
diff --git a/src/stellar_physics/static.ts b/src/stellar_physics/static.ts
new file mode 100644
index 000000000..bedf517a8
--- /dev/null
+++ b/src/stellar_physics/static.ts
@@ -0,0 +1,14 @@
+/** stellar_physics static module — tsb analytics library. */
+export interface StellarPhysicsStaticOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsStaticResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsStatic(data: number[], opts: StellarPhysicsStaticOptions = {}): StellarPhysicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsStatic };
diff --git a/src/stellar_physics/stochastic.ts b/src/stellar_physics/stochastic.ts
new file mode 100644
index 000000000..2da28b1e2
--- /dev/null
+++ b/src/stellar_physics/stochastic.ts
@@ -0,0 +1,14 @@
+/** stellar_physics stochastic module — tsb analytics library. */
+export interface StellarPhysicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsStochasticResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsStochastic(data: number[], opts: StellarPhysicsStochasticOptions = {}): StellarPhysicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsStochastic };
diff --git a/src/stellar_physics/synthesis.ts b/src/stellar_physics/synthesis.ts
new file mode 100644
index 000000000..6ce43a1f7
--- /dev/null
+++ b/src/stellar_physics/synthesis.ts
@@ -0,0 +1,14 @@
+/** stellar_physics synthesis module — tsb analytics library. */
+export interface StellarPhysicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsSynthesis(data: number[], opts: StellarPhysicsSynthesisOptions = {}): StellarPhysicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsSynthesis };
diff --git a/src/stellar_physics/topology.ts b/src/stellar_physics/topology.ts
new file mode 100644
index 000000000..d25ebffb1
--- /dev/null
+++ b/src/stellar_physics/topology.ts
@@ -0,0 +1,14 @@
+/** stellar_physics topology module — tsb analytics library. */
+export interface StellarPhysicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsTopologyResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsTopology(data: number[], opts: StellarPhysicsTopologyOptions = {}): StellarPhysicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsTopology };
diff --git a/src/stellar_physics/tracking.ts b/src/stellar_physics/tracking.ts
new file mode 100644
index 000000000..1a94775d1
--- /dev/null
+++ b/src/stellar_physics/tracking.ts
@@ -0,0 +1,14 @@
+/** stellar_physics tracking module — tsb analytics library. */
+export interface StellarPhysicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsTrackingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsTracking(data: number[], opts: StellarPhysicsTrackingOptions = {}): StellarPhysicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsTracking };
diff --git a/src/stellar_physics/transform.ts b/src/stellar_physics/transform.ts
new file mode 100644
index 000000000..d1b213476
--- /dev/null
+++ b/src/stellar_physics/transform.ts
@@ -0,0 +1,14 @@
+/** stellar_physics transform module — tsb analytics library. */
+export interface StellarPhysicsTransformOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsTransformResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsTransform(data: number[], opts: StellarPhysicsTransformOptions = {}): StellarPhysicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsTransform };
diff --git a/src/stellar_physics/uncertainty.ts b/src/stellar_physics/uncertainty.ts
new file mode 100644
index 000000000..e5117dc76
--- /dev/null
+++ b/src/stellar_physics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** stellar_physics uncertainty module — tsb analytics library. */
+export interface StellarPhysicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsUncertainty(data: number[], opts: StellarPhysicsUncertaintyOptions = {}): StellarPhysicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsUncertainty };
diff --git a/src/stellar_physics/validation.ts b/src/stellar_physics/validation.ts
new file mode 100644
index 000000000..9edfdc83f
--- /dev/null
+++ b/src/stellar_physics/validation.ts
@@ -0,0 +1,14 @@
+/** stellar_physics validation module — tsb analytics library. */
+export interface StellarPhysicsValidationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsValidationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsValidation(data: number[], opts: StellarPhysicsValidationOptions = {}): StellarPhysicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsValidation };
diff --git a/src/stellar_physics/verification.ts b/src/stellar_physics/verification.ts
new file mode 100644
index 000000000..35aa298d2
--- /dev/null
+++ b/src/stellar_physics/verification.ts
@@ -0,0 +1,14 @@
+/** stellar_physics verification module — tsb analytics library. */
+export interface StellarPhysicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsVerificationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsVerification(data: number[], opts: StellarPhysicsVerificationOptions = {}): StellarPhysicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsVerification };
diff --git a/src/stellar_physics/visualization.ts b/src/stellar_physics/visualization.ts
new file mode 100644
index 000000000..d7bfd7a15
--- /dev/null
+++ b/src/stellar_physics/visualization.ts
@@ -0,0 +1,14 @@
+/** stellar_physics visualization module — tsb analytics library. */
+export interface StellarPhysicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsVisualization(data: number[], opts: StellarPhysicsVisualizationOptions = {}): StellarPhysicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsVisualization };
diff --git a/src/stellar_physics/voting.ts b/src/stellar_physics/voting.ts
new file mode 100644
index 000000000..82d82feb2
--- /dev/null
+++ b/src/stellar_physics/voting.ts
@@ -0,0 +1,14 @@
+/** stellar_physics voting module — tsb analytics library. */
+export interface StellarPhysicsVotingOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsVotingResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsVoting(data: number[], opts: StellarPhysicsVotingOptions = {}): StellarPhysicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsVoting };
diff --git a/src/stellar_physics/wavelet.ts b/src/stellar_physics/wavelet.ts
new file mode 100644
index 000000000..a3e2c1fc4
--- /dev/null
+++ b/src/stellar_physics/wavelet.ts
@@ -0,0 +1,14 @@
+/** stellar_physics wavelet module — tsb analytics library. */
+export interface StellarPhysicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface StellarPhysicsWaveletResult { values: number[]; converged: boolean; }
+export function computeStellarPhysicsWavelet(data: number[], opts: StellarPhysicsWaveletOptions = {}): StellarPhysicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStellarPhysicsWavelet };
diff --git a/src/stratigraphy/adaptation.ts b/src/stratigraphy/adaptation.ts
new file mode 100644
index 000000000..ec75dcef2
--- /dev/null
+++ b/src/stratigraphy/adaptation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy adaptation module — tsb analytics library. */
+export interface StratigraphyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyAdaptationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyAdaptation(data: number[], opts: StratigraphyAdaptationOptions = {}): StratigraphyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyAdaptation };
diff --git a/src/stratigraphy/aggregation.ts b/src/stratigraphy/aggregation.ts
new file mode 100644
index 000000000..93f5f1299
--- /dev/null
+++ b/src/stratigraphy/aggregation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy aggregation module — tsb analytics library. */
+export interface StratigraphyAggregationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyAggregationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyAggregation(data: number[], opts: StratigraphyAggregationOptions = {}): StratigraphyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyAggregation };
diff --git a/src/stratigraphy/algebra.ts b/src/stratigraphy/algebra.ts
new file mode 100644
index 000000000..904e0485b
--- /dev/null
+++ b/src/stratigraphy/algebra.ts
@@ -0,0 +1,14 @@
+/** stratigraphy algebra module — tsb analytics library. */
+export interface StratigraphyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyAlgebraResult { values: number[]; converged: boolean; }
+export function computeStratigraphyAlgebra(data: number[], opts: StratigraphyAlgebraOptions = {}): StratigraphyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyAlgebra };
diff --git a/src/stratigraphy/alignment.ts b/src/stratigraphy/alignment.ts
new file mode 100644
index 000000000..dddcc3bc4
--- /dev/null
+++ b/src/stratigraphy/alignment.ts
@@ -0,0 +1,14 @@
+/** stratigraphy alignment module — tsb analytics library. */
+export interface StratigraphyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyAlignmentResult { values: number[]; converged: boolean; }
+export function computeStratigraphyAlignment(data: number[], opts: StratigraphyAlignmentOptions = {}): StratigraphyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyAlignment };
diff --git a/src/stratigraphy/analysis.ts b/src/stratigraphy/analysis.ts
new file mode 100644
index 000000000..b6b345fd0
--- /dev/null
+++ b/src/stratigraphy/analysis.ts
@@ -0,0 +1,14 @@
+/** stratigraphy analysis module — tsb analytics library. */
+export interface StratigraphyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyAnalysisResult { values: number[]; converged: boolean; }
+export function computeStratigraphyAnalysis(data: number[], opts: StratigraphyAnalysisOptions = {}): StratigraphyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyAnalysis };
diff --git a/src/stratigraphy/augmentation.ts b/src/stratigraphy/augmentation.ts
new file mode 100644
index 000000000..f3627ee35
--- /dev/null
+++ b/src/stratigraphy/augmentation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy augmentation module — tsb analytics library. */
+export interface StratigraphyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyAugmentationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyAugmentation(data: number[], opts: StratigraphyAugmentationOptions = {}): StratigraphyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyAugmentation };
diff --git a/src/stratigraphy/bagging.ts b/src/stratigraphy/bagging.ts
new file mode 100644
index 000000000..0bc808aed
--- /dev/null
+++ b/src/stratigraphy/bagging.ts
@@ -0,0 +1,14 @@
+/** stratigraphy bagging module — tsb analytics library. */
+export interface StratigraphyBaggingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyBaggingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyBagging(data: number[], opts: StratigraphyBaggingOptions = {}): StratigraphyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyBagging };
diff --git a/src/stratigraphy/basis.ts b/src/stratigraphy/basis.ts
new file mode 100644
index 000000000..49e82a3b9
--- /dev/null
+++ b/src/stratigraphy/basis.ts
@@ -0,0 +1,14 @@
+/** stratigraphy basis module — tsb analytics library. */
+export interface StratigraphyBasisOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyBasisResult { values: number[]; converged: boolean; }
+export function computeStratigraphyBasis(data: number[], opts: StratigraphyBasisOptions = {}): StratigraphyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyBasis };
diff --git a/src/stratigraphy/benchmarking.ts b/src/stratigraphy/benchmarking.ts
new file mode 100644
index 000000000..6c8d8d7b1
--- /dev/null
+++ b/src/stratigraphy/benchmarking.ts
@@ -0,0 +1,14 @@
+/** stratigraphy benchmarking module — tsb analytics library. */
+export interface StratigraphyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyBenchmarking(data: number[], opts: StratigraphyBenchmarkingOptions = {}): StratigraphyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyBenchmarking };
diff --git a/src/stratigraphy/blending.ts b/src/stratigraphy/blending.ts
new file mode 100644
index 000000000..8fc3f860f
--- /dev/null
+++ b/src/stratigraphy/blending.ts
@@ -0,0 +1,14 @@
+/** stratigraphy blending module — tsb analytics library. */
+export interface StratigraphyBlendingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyBlendingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyBlending(data: number[], opts: StratigraphyBlendingOptions = {}): StratigraphyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyBlending };
diff --git a/src/stratigraphy/boosting.ts b/src/stratigraphy/boosting.ts
new file mode 100644
index 000000000..0fcc86ce1
--- /dev/null
+++ b/src/stratigraphy/boosting.ts
@@ -0,0 +1,14 @@
+/** stratigraphy boosting module — tsb analytics library. */
+export interface StratigraphyBoostingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyBoostingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyBoosting(data: number[], opts: StratigraphyBoostingOptions = {}): StratigraphyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyBoosting };
diff --git a/src/stratigraphy/bootstrap.ts b/src/stratigraphy/bootstrap.ts
new file mode 100644
index 000000000..2fd50e819
--- /dev/null
+++ b/src/stratigraphy/bootstrap.ts
@@ -0,0 +1,14 @@
+/** stratigraphy bootstrap module — tsb analytics library. */
+export interface StratigraphyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyBootstrapResult { values: number[]; converged: boolean; }
+export function computeStratigraphyBootstrap(data: number[], opts: StratigraphyBootstrapOptions = {}): StratigraphyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyBootstrap };
diff --git a/src/stratigraphy/calculus.ts b/src/stratigraphy/calculus.ts
new file mode 100644
index 000000000..05ed9ae33
--- /dev/null
+++ b/src/stratigraphy/calculus.ts
@@ -0,0 +1,14 @@
+/** stratigraphy calculus module — tsb analytics library. */
+export interface StratigraphyCalculusOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyCalculusResult { values: number[]; converged: boolean; }
+export function computeStratigraphyCalculus(data: number[], opts: StratigraphyCalculusOptions = {}): StratigraphyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyCalculus };
diff --git a/src/stratigraphy/calibration.ts b/src/stratigraphy/calibration.ts
new file mode 100644
index 000000000..b3118cbad
--- /dev/null
+++ b/src/stratigraphy/calibration.ts
@@ -0,0 +1,14 @@
+/** stratigraphy calibration module — tsb analytics library. */
+export interface StratigraphyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyCalibrationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyCalibration(data: number[], opts: StratigraphyCalibrationOptions = {}): StratigraphyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyCalibration };
diff --git a/src/stratigraphy/characterization.ts b/src/stratigraphy/characterization.ts
new file mode 100644
index 000000000..d9fc27fab
--- /dev/null
+++ b/src/stratigraphy/characterization.ts
@@ -0,0 +1,14 @@
+/** stratigraphy characterization module — tsb analytics library. */
+export interface StratigraphyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyCharacterization(data: number[], opts: StratigraphyCharacterizationOptions = {}): StratigraphyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyCharacterization };
diff --git a/src/stratigraphy/classification.ts b/src/stratigraphy/classification.ts
new file mode 100644
index 000000000..26f723ec6
--- /dev/null
+++ b/src/stratigraphy/classification.ts
@@ -0,0 +1,14 @@
+/** stratigraphy classification module — tsb analytics library. */
+export interface StratigraphyClassificationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyClassificationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyClassification(data: number[], opts: StratigraphyClassificationOptions = {}): StratigraphyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyClassification };
diff --git a/src/stratigraphy/clustering.ts b/src/stratigraphy/clustering.ts
new file mode 100644
index 000000000..c1c623253
--- /dev/null
+++ b/src/stratigraphy/clustering.ts
@@ -0,0 +1,14 @@
+/** stratigraphy clustering module — tsb analytics library. */
+export interface StratigraphyClusteringOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyClusteringResult { values: number[]; converged: boolean; }
+export function computeStratigraphyClustering(data: number[], opts: StratigraphyClusteringOptions = {}): StratigraphyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyClustering };
diff --git a/src/stratigraphy/compression.ts b/src/stratigraphy/compression.ts
new file mode 100644
index 000000000..e32925b1a
--- /dev/null
+++ b/src/stratigraphy/compression.ts
@@ -0,0 +1,14 @@
+/** stratigraphy compression module — tsb analytics library. */
+export interface StratigraphyCompressionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyCompressionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyCompression(data: number[], opts: StratigraphyCompressionOptions = {}): StratigraphyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyCompression };
diff --git a/src/stratigraphy/continuous.ts b/src/stratigraphy/continuous.ts
new file mode 100644
index 000000000..4d92f0019
--- /dev/null
+++ b/src/stratigraphy/continuous.ts
@@ -0,0 +1,14 @@
+/** stratigraphy continuous module — tsb analytics library. */
+export interface StratigraphyContinuousOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyContinuousResult { values: number[]; converged: boolean; }
+export function computeStratigraphyContinuous(data: number[], opts: StratigraphyContinuousOptions = {}): StratigraphyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyContinuous };
diff --git a/src/stratigraphy/control.ts b/src/stratigraphy/control.ts
new file mode 100644
index 000000000..d1c2d1e4f
--- /dev/null
+++ b/src/stratigraphy/control.ts
@@ -0,0 +1,14 @@
+/** stratigraphy control module — tsb analytics library. */
+export interface StratigraphyControlOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyControlResult { values: number[]; converged: boolean; }
+export function computeStratigraphyControl(data: number[], opts: StratigraphyControlOptions = {}): StratigraphyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyControl };
diff --git a/src/stratigraphy/convergence.ts b/src/stratigraphy/convergence.ts
new file mode 100644
index 000000000..aca31f5b6
--- /dev/null
+++ b/src/stratigraphy/convergence.ts
@@ -0,0 +1,14 @@
+/** stratigraphy convergence module — tsb analytics library. */
+export interface StratigraphyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyConvergenceResult { values: number[]; converged: boolean; }
+export function computeStratigraphyConvergence(data: number[], opts: StratigraphyConvergenceOptions = {}): StratigraphyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyConvergence };
diff --git a/src/stratigraphy/convex.ts b/src/stratigraphy/convex.ts
new file mode 100644
index 000000000..9b825c78d
--- /dev/null
+++ b/src/stratigraphy/convex.ts
@@ -0,0 +1,14 @@
+/** stratigraphy convex module — tsb analytics library. */
+export interface StratigraphyConvexOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyConvexResult { values: number[]; converged: boolean; }
+export function computeStratigraphyConvex(data: number[], opts: StratigraphyConvexOptions = {}): StratigraphyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyConvex };
diff --git a/src/stratigraphy/correlation.ts b/src/stratigraphy/correlation.ts
new file mode 100644
index 000000000..7586da9ae
--- /dev/null
+++ b/src/stratigraphy/correlation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy correlation module — tsb analytics library. */
+export interface StratigraphyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyCorrelationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyCorrelation(data: number[], opts: StratigraphyCorrelationOptions = {}): StratigraphyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyCorrelation };
diff --git a/src/stratigraphy/covariance.ts b/src/stratigraphy/covariance.ts
new file mode 100644
index 000000000..363ab7d89
--- /dev/null
+++ b/src/stratigraphy/covariance.ts
@@ -0,0 +1,14 @@
+/** stratigraphy covariance module — tsb analytics library. */
+export interface StratigraphyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyCovarianceResult { values: number[]; converged: boolean; }
+export function computeStratigraphyCovariance(data: number[], opts: StratigraphyCovarianceOptions = {}): StratigraphyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyCovariance };
diff --git a/src/stratigraphy/cross_validation.ts b/src/stratigraphy/cross_validation.ts
new file mode 100644
index 000000000..ae5cfbd7e
--- /dev/null
+++ b/src/stratigraphy/cross_validation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy cross_validation module — tsb analytics library. */
+export interface StratigraphyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyCrossValidation(data: number[], opts: StratigraphyCrossValidationOptions = {}): StratigraphyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyCrossValidation };
diff --git a/src/stratigraphy/decoding.ts b/src/stratigraphy/decoding.ts
new file mode 100644
index 000000000..596d47441
--- /dev/null
+++ b/src/stratigraphy/decoding.ts
@@ -0,0 +1,14 @@
+/** stratigraphy decoding module — tsb analytics library. */
+export interface StratigraphyDecodingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDecodingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDecoding(data: number[], opts: StratigraphyDecodingOptions = {}): StratigraphyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDecoding };
diff --git a/src/stratigraphy/decomposition.ts b/src/stratigraphy/decomposition.ts
new file mode 100644
index 000000000..95d457285
--- /dev/null
+++ b/src/stratigraphy/decomposition.ts
@@ -0,0 +1,14 @@
+/** stratigraphy decomposition module — tsb analytics library. */
+export interface StratigraphyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDecompositionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDecomposition(data: number[], opts: StratigraphyDecompositionOptions = {}): StratigraphyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDecomposition };
diff --git a/src/stratigraphy/detection.ts b/src/stratigraphy/detection.ts
new file mode 100644
index 000000000..8b4aa1846
--- /dev/null
+++ b/src/stratigraphy/detection.ts
@@ -0,0 +1,14 @@
+/** stratigraphy detection module — tsb analytics library. */
+export interface StratigraphyDetectionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDetectionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDetection(data: number[], opts: StratigraphyDetectionOptions = {}): StratigraphyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDetection };
diff --git a/src/stratigraphy/deterministic.ts b/src/stratigraphy/deterministic.ts
new file mode 100644
index 000000000..86163eea0
--- /dev/null
+++ b/src/stratigraphy/deterministic.ts
@@ -0,0 +1,14 @@
+/** stratigraphy deterministic module — tsb analytics library. */
+export interface StratigraphyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDeterministicResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDeterministic(data: number[], opts: StratigraphyDeterministicOptions = {}): StratigraphyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDeterministic };
diff --git a/src/stratigraphy/diagnostics.ts b/src/stratigraphy/diagnostics.ts
new file mode 100644
index 000000000..443f2cfd3
--- /dev/null
+++ b/src/stratigraphy/diagnostics.ts
@@ -0,0 +1,14 @@
+/** stratigraphy diagnostics module — tsb analytics library. */
+export interface StratigraphyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDiagnostics(data: number[], opts: StratigraphyDiagnosticsOptions = {}): StratigraphyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDiagnostics };
diff --git a/src/stratigraphy/differential.ts b/src/stratigraphy/differential.ts
new file mode 100644
index 000000000..67b42b688
--- /dev/null
+++ b/src/stratigraphy/differential.ts
@@ -0,0 +1,14 @@
+/** stratigraphy differential module — tsb analytics library. */
+export interface StratigraphyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDifferentialResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDifferential(data: number[], opts: StratigraphyDifferentialOptions = {}): StratigraphyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDifferential };
diff --git a/src/stratigraphy/discrete.ts b/src/stratigraphy/discrete.ts
new file mode 100644
index 000000000..22c561496
--- /dev/null
+++ b/src/stratigraphy/discrete.ts
@@ -0,0 +1,14 @@
+/** stratigraphy discrete module — tsb analytics library. */
+export interface StratigraphyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDiscreteResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDiscrete(data: number[], opts: StratigraphyDiscreteOptions = {}): StratigraphyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDiscrete };
diff --git a/src/stratigraphy/distribution.ts b/src/stratigraphy/distribution.ts
new file mode 100644
index 000000000..291263b04
--- /dev/null
+++ b/src/stratigraphy/distribution.ts
@@ -0,0 +1,14 @@
+/** stratigraphy distribution module — tsb analytics library. */
+export interface StratigraphyDistributionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDistributionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDistribution(data: number[], opts: StratigraphyDistributionOptions = {}): StratigraphyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDistribution };
diff --git a/src/stratigraphy/dynamic.ts b/src/stratigraphy/dynamic.ts
new file mode 100644
index 000000000..a972207ee
--- /dev/null
+++ b/src/stratigraphy/dynamic.ts
@@ -0,0 +1,14 @@
+/** stratigraphy dynamic module — tsb analytics library. */
+export interface StratigraphyDynamicOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyDynamicResult { values: number[]; converged: boolean; }
+export function computeStratigraphyDynamic(data: number[], opts: StratigraphyDynamicOptions = {}): StratigraphyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyDynamic };
diff --git a/src/stratigraphy/embedding.ts b/src/stratigraphy/embedding.ts
new file mode 100644
index 000000000..1b36632b0
--- /dev/null
+++ b/src/stratigraphy/embedding.ts
@@ -0,0 +1,14 @@
+/** stratigraphy embedding module — tsb analytics library. */
+export interface StratigraphyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyEmbedding(data: number[], opts: StratigraphyEmbeddingOptions = {}): StratigraphyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyEmbedding };
diff --git a/src/stratigraphy/encoding.ts b/src/stratigraphy/encoding.ts
new file mode 100644
index 000000000..93510d115
--- /dev/null
+++ b/src/stratigraphy/encoding.ts
@@ -0,0 +1,14 @@
+/** stratigraphy encoding module — tsb analytics library. */
+export interface StratigraphyEncodingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyEncodingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyEncoding(data: number[], opts: StratigraphyEncodingOptions = {}): StratigraphyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyEncoding };
diff --git a/src/stratigraphy/ensemble.ts b/src/stratigraphy/ensemble.ts
new file mode 100644
index 000000000..c8f419fb4
--- /dev/null
+++ b/src/stratigraphy/ensemble.ts
@@ -0,0 +1,14 @@
+/** stratigraphy ensemble module — tsb analytics library. */
+export interface StratigraphyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyEnsembleResult { values: number[]; converged: boolean; }
+export function computeStratigraphyEnsemble(data: number[], opts: StratigraphyEnsembleOptions = {}): StratigraphyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyEnsemble };
diff --git a/src/stratigraphy/estimation.ts b/src/stratigraphy/estimation.ts
new file mode 100644
index 000000000..ed62b6fb0
--- /dev/null
+++ b/src/stratigraphy/estimation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy estimation module — tsb analytics library. */
+export interface StratigraphyEstimationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyEstimationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyEstimation(data: number[], opts: StratigraphyEstimationOptions = {}): StratigraphyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyEstimation };
diff --git a/src/stratigraphy/evaluation.ts b/src/stratigraphy/evaluation.ts
new file mode 100644
index 000000000..0e09fc93c
--- /dev/null
+++ b/src/stratigraphy/evaluation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy evaluation module — tsb analytics library. */
+export interface StratigraphyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyEvaluationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyEvaluation(data: number[], opts: StratigraphyEvaluationOptions = {}): StratigraphyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyEvaluation };
diff --git a/src/stratigraphy/extrapolation.ts b/src/stratigraphy/extrapolation.ts
new file mode 100644
index 000000000..216766e57
--- /dev/null
+++ b/src/stratigraphy/extrapolation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy extrapolation module — tsb analytics library. */
+export interface StratigraphyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyExtrapolation(data: number[], opts: StratigraphyExtrapolationOptions = {}): StratigraphyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyExtrapolation };
diff --git a/src/stratigraphy/features.ts b/src/stratigraphy/features.ts
new file mode 100644
index 000000000..a0300dda4
--- /dev/null
+++ b/src/stratigraphy/features.ts
@@ -0,0 +1,14 @@
+/** stratigraphy features module — tsb analytics library. */
+export interface StratigraphyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyFeaturesResult { values: number[]; converged: boolean; }
+export function computeStratigraphyFeatures(data: number[], opts: StratigraphyFeaturesOptions = {}): StratigraphyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyFeatures };
diff --git a/src/stratigraphy/feedback.ts b/src/stratigraphy/feedback.ts
new file mode 100644
index 000000000..245c5f66c
--- /dev/null
+++ b/src/stratigraphy/feedback.ts
@@ -0,0 +1,14 @@
+/** stratigraphy feedback module — tsb analytics library. */
+export interface StratigraphyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyFeedbackResult { values: number[]; converged: boolean; }
+export function computeStratigraphyFeedback(data: number[], opts: StratigraphyFeedbackOptions = {}): StratigraphyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyFeedback };
diff --git a/src/stratigraphy/filtering.ts b/src/stratigraphy/filtering.ts
new file mode 100644
index 000000000..dcad34949
--- /dev/null
+++ b/src/stratigraphy/filtering.ts
@@ -0,0 +1,14 @@
+/** stratigraphy filtering module — tsb analytics library. */
+export interface StratigraphyFilteringOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyFilteringResult { values: number[]; converged: boolean; }
+export function computeStratigraphyFiltering(data: number[], opts: StratigraphyFilteringOptions = {}): StratigraphyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyFiltering };
diff --git a/src/stratigraphy/fourier.ts b/src/stratigraphy/fourier.ts
new file mode 100644
index 000000000..161520b26
--- /dev/null
+++ b/src/stratigraphy/fourier.ts
@@ -0,0 +1,14 @@
+/** stratigraphy fourier module — tsb analytics library. */
+export interface StratigraphyFourierOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyFourierResult { values: number[]; converged: boolean; }
+export function computeStratigraphyFourier(data: number[], opts: StratigraphyFourierOptions = {}): StratigraphyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyFourier };
diff --git a/src/stratigraphy/fusion.ts b/src/stratigraphy/fusion.ts
new file mode 100644
index 000000000..7d0bb26e4
--- /dev/null
+++ b/src/stratigraphy/fusion.ts
@@ -0,0 +1,14 @@
+/** stratigraphy fusion module — tsb analytics library. */
+export interface StratigraphyFusionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyFusionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyFusion(data: number[], opts: StratigraphyFusionOptions = {}): StratigraphyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyFusion };
diff --git a/src/stratigraphy/generation.ts b/src/stratigraphy/generation.ts
new file mode 100644
index 000000000..4e79f0be5
--- /dev/null
+++ b/src/stratigraphy/generation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy generation module — tsb analytics library. */
+export interface StratigraphyGenerationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyGenerationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyGeneration(data: number[], opts: StratigraphyGenerationOptions = {}): StratigraphyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyGeneration };
diff --git a/src/stratigraphy/geometry.ts b/src/stratigraphy/geometry.ts
new file mode 100644
index 000000000..3ec2cfb65
--- /dev/null
+++ b/src/stratigraphy/geometry.ts
@@ -0,0 +1,14 @@
+/** stratigraphy geometry module — tsb analytics library. */
+export interface StratigraphyGeometryOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyGeometryResult { values: number[]; converged: boolean; }
+export function computeStratigraphyGeometry(data: number[], opts: StratigraphyGeometryOptions = {}): StratigraphyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyGeometry };
diff --git a/src/stratigraphy/gradient.ts b/src/stratigraphy/gradient.ts
new file mode 100644
index 000000000..d5309a726
--- /dev/null
+++ b/src/stratigraphy/gradient.ts
@@ -0,0 +1,14 @@
+/** stratigraphy gradient module — tsb analytics library. */
+export interface StratigraphyGradientOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyGradientResult { values: number[]; converged: boolean; }
+export function computeStratigraphyGradient(data: number[], opts: StratigraphyGradientOptions = {}): StratigraphyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyGradient };
diff --git a/src/stratigraphy/hessian.ts b/src/stratigraphy/hessian.ts
new file mode 100644
index 000000000..eea741448
--- /dev/null
+++ b/src/stratigraphy/hessian.ts
@@ -0,0 +1,14 @@
+/** stratigraphy hessian module — tsb analytics library. */
+export interface StratigraphyHessianOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyHessianResult { values: number[]; converged: boolean; }
+export function computeStratigraphyHessian(data: number[], opts: StratigraphyHessianOptions = {}): StratigraphyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyHessian };
diff --git a/src/stratigraphy/hypothesis.ts b/src/stratigraphy/hypothesis.ts
new file mode 100644
index 000000000..3eb18da21
--- /dev/null
+++ b/src/stratigraphy/hypothesis.ts
@@ -0,0 +1,14 @@
+/** stratigraphy hypothesis module — tsb analytics library. */
+export interface StratigraphyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyHypothesisResult { values: number[]; converged: boolean; }
+export function computeStratigraphyHypothesis(data: number[], opts: StratigraphyHypothesisOptions = {}): StratigraphyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyHypothesis };
diff --git a/src/stratigraphy/inference.ts b/src/stratigraphy/inference.ts
new file mode 100644
index 000000000..91a1305d2
--- /dev/null
+++ b/src/stratigraphy/inference.ts
@@ -0,0 +1,14 @@
+/** stratigraphy inference module — tsb analytics library. */
+export interface StratigraphyInferenceOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyInferenceResult { values: number[]; converged: boolean; }
+export function computeStratigraphyInference(data: number[], opts: StratigraphyInferenceOptions = {}): StratigraphyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyInference };
diff --git a/src/stratigraphy/inference2.ts b/src/stratigraphy/inference2.ts
new file mode 100644
index 000000000..63a52543e
--- /dev/null
+++ b/src/stratigraphy/inference2.ts
@@ -0,0 +1,14 @@
+/** stratigraphy inference2 module — tsb analytics library. */
+export interface StratigraphyInferenceOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyInferenceResult { values: number[]; converged: boolean; }
+export function computeStratigraphyInference(data: number[], opts: StratigraphyInferenceOptions = {}): StratigraphyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyInference };
diff --git a/src/stratigraphy/integral.ts b/src/stratigraphy/integral.ts
new file mode 100644
index 000000000..e1bdece2b
--- /dev/null
+++ b/src/stratigraphy/integral.ts
@@ -0,0 +1,14 @@
+/** stratigraphy integral module — tsb analytics library. */
+export interface StratigraphyIntegralOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyIntegralResult { values: number[]; converged: boolean; }
+export function computeStratigraphyIntegral(data: number[], opts: StratigraphyIntegralOptions = {}): StratigraphyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyIntegral };
diff --git a/src/stratigraphy/integration.ts b/src/stratigraphy/integration.ts
new file mode 100644
index 000000000..9798263a4
--- /dev/null
+++ b/src/stratigraphy/integration.ts
@@ -0,0 +1,14 @@
+/** stratigraphy integration module — tsb analytics library. */
+export interface StratigraphyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyIntegrationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyIntegration(data: number[], opts: StratigraphyIntegrationOptions = {}): StratigraphyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyIntegration };
diff --git a/src/stratigraphy/interpolation.ts b/src/stratigraphy/interpolation.ts
new file mode 100644
index 000000000..d2515392e
--- /dev/null
+++ b/src/stratigraphy/interpolation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy interpolation module — tsb analytics library. */
+export interface StratigraphyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyInterpolationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyInterpolation(data: number[], opts: StratigraphyInterpolationOptions = {}): StratigraphyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyInterpolation };
diff --git a/src/stratigraphy/jacobian.ts b/src/stratigraphy/jacobian.ts
new file mode 100644
index 000000000..1907c7c40
--- /dev/null
+++ b/src/stratigraphy/jacobian.ts
@@ -0,0 +1,14 @@
+/** stratigraphy jacobian module — tsb analytics library. */
+export interface StratigraphyJacobianOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyJacobianResult { values: number[]; converged: boolean; }
+export function computeStratigraphyJacobian(data: number[], opts: StratigraphyJacobianOptions = {}): StratigraphyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyJacobian };
diff --git a/src/stratigraphy/kernel.ts b/src/stratigraphy/kernel.ts
new file mode 100644
index 000000000..0245c38ea
--- /dev/null
+++ b/src/stratigraphy/kernel.ts
@@ -0,0 +1,14 @@
+/** stratigraphy kernel module — tsb analytics library. */
+export interface StratigraphyKernelOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyKernelResult { values: number[]; converged: boolean; }
+export function computeStratigraphyKernel(data: number[], opts: StratigraphyKernelOptions = {}): StratigraphyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyKernel };
diff --git a/src/stratigraphy/laplacian.ts b/src/stratigraphy/laplacian.ts
new file mode 100644
index 000000000..aa1c01b3c
--- /dev/null
+++ b/src/stratigraphy/laplacian.ts
@@ -0,0 +1,14 @@
+/** stratigraphy laplacian module — tsb analytics library. */
+export interface StratigraphyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyLaplacianResult { values: number[]; converged: boolean; }
+export function computeStratigraphyLaplacian(data: number[], opts: StratigraphyLaplacianOptions = {}): StratigraphyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyLaplacian };
diff --git a/src/stratigraphy/learning.ts b/src/stratigraphy/learning.ts
new file mode 100644
index 000000000..460fc2572
--- /dev/null
+++ b/src/stratigraphy/learning.ts
@@ -0,0 +1,14 @@
+/** stratigraphy learning module — tsb analytics library. */
+export interface StratigraphyLearningOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyLearningResult { values: number[]; converged: boolean; }
+export function computeStratigraphyLearning(data: number[], opts: StratigraphyLearningOptions = {}): StratigraphyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyLearning };
diff --git a/src/stratigraphy/linear.ts b/src/stratigraphy/linear.ts
new file mode 100644
index 000000000..39e8e8837
--- /dev/null
+++ b/src/stratigraphy/linear.ts
@@ -0,0 +1,14 @@
+/** stratigraphy linear module — tsb analytics library. */
+export interface StratigraphyLinearOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyLinearResult { values: number[]; converged: boolean; }
+export function computeStratigraphyLinear(data: number[], opts: StratigraphyLinearOptions = {}): StratigraphyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyLinear };
diff --git a/src/stratigraphy/manifold.ts b/src/stratigraphy/manifold.ts
new file mode 100644
index 000000000..3d6ff4f12
--- /dev/null
+++ b/src/stratigraphy/manifold.ts
@@ -0,0 +1,14 @@
+/** stratigraphy manifold module — tsb analytics library. */
+export interface StratigraphyManifoldOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyManifoldResult { values: number[]; converged: boolean; }
+export function computeStratigraphyManifold(data: number[], opts: StratigraphyManifoldOptions = {}): StratigraphyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyManifold };
diff --git a/src/stratigraphy/matching.ts b/src/stratigraphy/matching.ts
new file mode 100644
index 000000000..c9713c500
--- /dev/null
+++ b/src/stratigraphy/matching.ts
@@ -0,0 +1,14 @@
+/** stratigraphy matching module — tsb analytics library. */
+export interface StratigraphyMatchingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyMatchingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyMatching(data: number[], opts: StratigraphyMatchingOptions = {}): StratigraphyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyMatching };
diff --git a/src/stratigraphy/measurement.ts b/src/stratigraphy/measurement.ts
new file mode 100644
index 000000000..0e5935485
--- /dev/null
+++ b/src/stratigraphy/measurement.ts
@@ -0,0 +1,14 @@
+/** stratigraphy measurement module — tsb analytics library. */
+export interface StratigraphyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyMeasurementResult { values: number[]; converged: boolean; }
+export function computeStratigraphyMeasurement(data: number[], opts: StratigraphyMeasurementOptions = {}): StratigraphyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyMeasurement };
diff --git a/src/stratigraphy/metrics.ts b/src/stratigraphy/metrics.ts
new file mode 100644
index 000000000..82ceab52f
--- /dev/null
+++ b/src/stratigraphy/metrics.ts
@@ -0,0 +1,14 @@
+/** stratigraphy metrics module — tsb analytics library. */
+export interface StratigraphyMetricsOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyMetricsResult { values: number[]; converged: boolean; }
+export function computeStratigraphyMetrics(data: number[], opts: StratigraphyMetricsOptions = {}): StratigraphyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyMetrics };
diff --git a/src/stratigraphy/modeling.ts b/src/stratigraphy/modeling.ts
new file mode 100644
index 000000000..111896e79
--- /dev/null
+++ b/src/stratigraphy/modeling.ts
@@ -0,0 +1,14 @@
+/** stratigraphy modeling module — tsb analytics library. */
+export interface StratigraphyModelingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyModelingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyModeling(data: number[], opts: StratigraphyModelingOptions = {}): StratigraphyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyModeling };
diff --git a/src/stratigraphy/monitoring.ts b/src/stratigraphy/monitoring.ts
new file mode 100644
index 000000000..a9413f048
--- /dev/null
+++ b/src/stratigraphy/monitoring.ts
@@ -0,0 +1,14 @@
+/** stratigraphy monitoring module — tsb analytics library. */
+export interface StratigraphyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyMonitoringResult { values: number[]; converged: boolean; }
+export function computeStratigraphyMonitoring(data: number[], opts: StratigraphyMonitoringOptions = {}): StratigraphyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyMonitoring };
diff --git a/src/stratigraphy/nonlinear.ts b/src/stratigraphy/nonlinear.ts
new file mode 100644
index 000000000..ccf4341f6
--- /dev/null
+++ b/src/stratigraphy/nonlinear.ts
@@ -0,0 +1,14 @@
+/** stratigraphy nonlinear module — tsb analytics library. */
+export interface StratigraphyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyNonlinearResult { values: number[]; converged: boolean; }
+export function computeStratigraphyNonlinear(data: number[], opts: StratigraphyNonlinearOptions = {}): StratigraphyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyNonlinear };
diff --git a/src/stratigraphy/normalization.ts b/src/stratigraphy/normalization.ts
new file mode 100644
index 000000000..92c01c80a
--- /dev/null
+++ b/src/stratigraphy/normalization.ts
@@ -0,0 +1,14 @@
+/** stratigraphy normalization module — tsb analytics library. */
+export interface StratigraphyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyNormalizationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyNormalization(data: number[], opts: StratigraphyNormalizationOptions = {}): StratigraphyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyNormalization };
diff --git a/src/stratigraphy/optimization.ts b/src/stratigraphy/optimization.ts
new file mode 100644
index 000000000..3a177a423
--- /dev/null
+++ b/src/stratigraphy/optimization.ts
@@ -0,0 +1,14 @@
+/** stratigraphy optimization module — tsb analytics library. */
+export interface StratigraphyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyOptimizationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyOptimization(data: number[], opts: StratigraphyOptimizationOptions = {}): StratigraphyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyOptimization };
diff --git a/src/stratigraphy/patterns.ts b/src/stratigraphy/patterns.ts
new file mode 100644
index 000000000..6fb323a92
--- /dev/null
+++ b/src/stratigraphy/patterns.ts
@@ -0,0 +1,14 @@
+/** stratigraphy patterns module — tsb analytics library. */
+export interface StratigraphyPatternsOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyPatternsResult { values: number[]; converged: boolean; }
+export function computeStratigraphyPatterns(data: number[], opts: StratigraphyPatternsOptions = {}): StratigraphyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyPatterns };
diff --git a/src/stratigraphy/permutation.ts b/src/stratigraphy/permutation.ts
new file mode 100644
index 000000000..cacdbe1ef
--- /dev/null
+++ b/src/stratigraphy/permutation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy permutation module — tsb analytics library. */
+export interface StratigraphyPermutationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyPermutationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyPermutation(data: number[], opts: StratigraphyPermutationOptions = {}): StratigraphyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyPermutation };
diff --git a/src/stratigraphy/prediction.ts b/src/stratigraphy/prediction.ts
new file mode 100644
index 000000000..36004d6b4
--- /dev/null
+++ b/src/stratigraphy/prediction.ts
@@ -0,0 +1,14 @@
+/** stratigraphy prediction module — tsb analytics library. */
+export interface StratigraphyPredictionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyPredictionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyPrediction(data: number[], opts: StratigraphyPredictionOptions = {}): StratigraphyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyPrediction };
diff --git a/src/stratigraphy/processing.ts b/src/stratigraphy/processing.ts
new file mode 100644
index 000000000..2e4f8b86b
--- /dev/null
+++ b/src/stratigraphy/processing.ts
@@ -0,0 +1,14 @@
+/** stratigraphy processing module — tsb analytics library. */
+export interface StratigraphyProcessingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyProcessingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyProcessing(data: number[], opts: StratigraphyProcessingOptions = {}): StratigraphyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyProcessing };
diff --git a/src/stratigraphy/profiling.ts b/src/stratigraphy/profiling.ts
new file mode 100644
index 000000000..c72d74c4f
--- /dev/null
+++ b/src/stratigraphy/profiling.ts
@@ -0,0 +1,14 @@
+/** stratigraphy profiling module — tsb analytics library. */
+export interface StratigraphyProfilingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyProfilingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyProfiling(data: number[], opts: StratigraphyProfilingOptions = {}): StratigraphyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyProfiling };
diff --git a/src/stratigraphy/projection.ts b/src/stratigraphy/projection.ts
new file mode 100644
index 000000000..0db92358a
--- /dev/null
+++ b/src/stratigraphy/projection.ts
@@ -0,0 +1,14 @@
+/** stratigraphy projection module — tsb analytics library. */
+export interface StratigraphyProjectionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyProjectionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyProjection(data: number[], opts: StratigraphyProjectionOptions = {}): StratigraphyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyProjection };
diff --git a/src/stratigraphy/ranking.ts b/src/stratigraphy/ranking.ts
new file mode 100644
index 000000000..c42719e38
--- /dev/null
+++ b/src/stratigraphy/ranking.ts
@@ -0,0 +1,14 @@
+/** stratigraphy ranking module — tsb analytics library. */
+export interface StratigraphyRankingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyRankingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyRanking(data: number[], opts: StratigraphyRankingOptions = {}): StratigraphyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyRanking };
diff --git a/src/stratigraphy/reconstruction.ts b/src/stratigraphy/reconstruction.ts
new file mode 100644
index 000000000..f56aea813
--- /dev/null
+++ b/src/stratigraphy/reconstruction.ts
@@ -0,0 +1,14 @@
+/** stratigraphy reconstruction module — tsb analytics library. */
+export interface StratigraphyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyReconstructionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyReconstruction(data: number[], opts: StratigraphyReconstructionOptions = {}): StratigraphyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyReconstruction };
diff --git a/src/stratigraphy/registration.ts b/src/stratigraphy/registration.ts
new file mode 100644
index 000000000..4a5e5a14d
--- /dev/null
+++ b/src/stratigraphy/registration.ts
@@ -0,0 +1,14 @@
+/** stratigraphy registration module — tsb analytics library. */
+export interface StratigraphyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyRegistrationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyRegistration(data: number[], opts: StratigraphyRegistrationOptions = {}): StratigraphyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyRegistration };
diff --git a/src/stratigraphy/regression.ts b/src/stratigraphy/regression.ts
new file mode 100644
index 000000000..d2534d305
--- /dev/null
+++ b/src/stratigraphy/regression.ts
@@ -0,0 +1,14 @@
+/** stratigraphy regression module — tsb analytics library. */
+export interface StratigraphyRegressionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyRegressionResult { values: number[]; converged: boolean; }
+export function computeStratigraphyRegression(data: number[], opts: StratigraphyRegressionOptions = {}): StratigraphyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyRegression };
diff --git a/src/stratigraphy/regularization.ts b/src/stratigraphy/regularization.ts
new file mode 100644
index 000000000..2ca591359
--- /dev/null
+++ b/src/stratigraphy/regularization.ts
@@ -0,0 +1,14 @@
+/** stratigraphy regularization module — tsb analytics library. */
+export interface StratigraphyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyRegularizationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyRegularization(data: number[], opts: StratigraphyRegularizationOptions = {}): StratigraphyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyRegularization };
diff --git a/src/stratigraphy/robustness.ts b/src/stratigraphy/robustness.ts
new file mode 100644
index 000000000..9d0a616d2
--- /dev/null
+++ b/src/stratigraphy/robustness.ts
@@ -0,0 +1,14 @@
+/** stratigraphy robustness module — tsb analytics library. */
+export interface StratigraphyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyRobustnessResult { values: number[]; converged: boolean; }
+export function computeStratigraphyRobustness(data: number[], opts: StratigraphyRobustnessOptions = {}): StratigraphyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyRobustness };
diff --git a/src/stratigraphy/sampling.ts b/src/stratigraphy/sampling.ts
new file mode 100644
index 000000000..d6c72b737
--- /dev/null
+++ b/src/stratigraphy/sampling.ts
@@ -0,0 +1,14 @@
+/** stratigraphy sampling module — tsb analytics library. */
+export interface StratigraphySamplingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphySamplingResult { values: number[]; converged: boolean; }
+export function computeStratigraphySampling(data: number[], opts: StratigraphySamplingOptions = {}): StratigraphySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphySampling };
diff --git a/src/stratigraphy/sampling2.ts b/src/stratigraphy/sampling2.ts
new file mode 100644
index 000000000..2244d37cc
--- /dev/null
+++ b/src/stratigraphy/sampling2.ts
@@ -0,0 +1,14 @@
+/** stratigraphy sampling2 module — tsb analytics library. */
+export interface StratigraphySamplingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphySamplingResult { values: number[]; converged: boolean; }
+export function computeStratigraphySampling(data: number[], opts: StratigraphySamplingOptions = {}): StratigraphySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphySampling };
diff --git a/src/stratigraphy/scaling.ts b/src/stratigraphy/scaling.ts
new file mode 100644
index 000000000..1cd607089
--- /dev/null
+++ b/src/stratigraphy/scaling.ts
@@ -0,0 +1,14 @@
+/** stratigraphy scaling module — tsb analytics library. */
+export interface StratigraphyScalingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyScalingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyScaling(data: number[], opts: StratigraphyScalingOptions = {}): StratigraphyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyScaling };
diff --git a/src/stratigraphy/scoring.ts b/src/stratigraphy/scoring.ts
new file mode 100644
index 000000000..ace3f2784
--- /dev/null
+++ b/src/stratigraphy/scoring.ts
@@ -0,0 +1,14 @@
+/** stratigraphy scoring module — tsb analytics library. */
+export interface StratigraphyScoringOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyScoringResult { values: number[]; converged: boolean; }
+export function computeStratigraphyScoring(data: number[], opts: StratigraphyScoringOptions = {}): StratigraphyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyScoring };
diff --git a/src/stratigraphy/segmentation.ts b/src/stratigraphy/segmentation.ts
new file mode 100644
index 000000000..147348706
--- /dev/null
+++ b/src/stratigraphy/segmentation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy segmentation module — tsb analytics library. */
+export interface StratigraphySegmentationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphySegmentationResult { values: number[]; converged: boolean; }
+export function computeStratigraphySegmentation(data: number[], opts: StratigraphySegmentationOptions = {}): StratigraphySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphySegmentation };
diff --git a/src/stratigraphy/selection.ts b/src/stratigraphy/selection.ts
new file mode 100644
index 000000000..fdff873c8
--- /dev/null
+++ b/src/stratigraphy/selection.ts
@@ -0,0 +1,14 @@
+/** stratigraphy selection module — tsb analytics library. */
+export interface StratigraphySelectionOptions { tol?: number; maxIter?: number; }
+export interface StratigraphySelectionResult { values: number[]; converged: boolean; }
+export function computeStratigraphySelection(data: number[], opts: StratigraphySelectionOptions = {}): StratigraphySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphySelection };
diff --git a/src/stratigraphy/sensitivity.ts b/src/stratigraphy/sensitivity.ts
new file mode 100644
index 000000000..132749cc6
--- /dev/null
+++ b/src/stratigraphy/sensitivity.ts
@@ -0,0 +1,14 @@
+/** stratigraphy sensitivity module — tsb analytics library. */
+export interface StratigraphySensitivityOptions { tol?: number; maxIter?: number; }
+export interface StratigraphySensitivityResult { values: number[]; converged: boolean; }
+export function computeStratigraphySensitivity(data: number[], opts: StratigraphySensitivityOptions = {}): StratigraphySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphySensitivity };
diff --git a/src/stratigraphy/simulation.ts b/src/stratigraphy/simulation.ts
new file mode 100644
index 000000000..03fbb4bca
--- /dev/null
+++ b/src/stratigraphy/simulation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy simulation module — tsb analytics library. */
+export interface StratigraphySimulationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphySimulationResult { values: number[]; converged: boolean; }
+export function computeStratigraphySimulation(data: number[], opts: StratigraphySimulationOptions = {}): StratigraphySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphySimulation };
diff --git a/src/stratigraphy/smoothing.ts b/src/stratigraphy/smoothing.ts
new file mode 100644
index 000000000..fa6777de0
--- /dev/null
+++ b/src/stratigraphy/smoothing.ts
@@ -0,0 +1,14 @@
+/** stratigraphy smoothing module — tsb analytics library. */
+export interface StratigraphySmoothingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphySmoothingResult { values: number[]; converged: boolean; }
+export function computeStratigraphySmoothing(data: number[], opts: StratigraphySmoothingOptions = {}): StratigraphySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphySmoothing };
diff --git a/src/stratigraphy/stability.ts b/src/stratigraphy/stability.ts
new file mode 100644
index 000000000..26e97db0d
--- /dev/null
+++ b/src/stratigraphy/stability.ts
@@ -0,0 +1,14 @@
+/** stratigraphy stability module — tsb analytics library. */
+export interface StratigraphyStabilityOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyStabilityResult { values: number[]; converged: boolean; }
+export function computeStratigraphyStability(data: number[], opts: StratigraphyStabilityOptions = {}): StratigraphyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyStability };
diff --git a/src/stratigraphy/stacking.ts b/src/stratigraphy/stacking.ts
new file mode 100644
index 000000000..439eb0a75
--- /dev/null
+++ b/src/stratigraphy/stacking.ts
@@ -0,0 +1,14 @@
+/** stratigraphy stacking module — tsb analytics library. */
+export interface StratigraphyStackingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyStackingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyStacking(data: number[], opts: StratigraphyStackingOptions = {}): StratigraphyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyStacking };
diff --git a/src/stratigraphy/standardization.ts b/src/stratigraphy/standardization.ts
new file mode 100644
index 000000000..6e254b42d
--- /dev/null
+++ b/src/stratigraphy/standardization.ts
@@ -0,0 +1,14 @@
+/** stratigraphy standardization module — tsb analytics library. */
+export interface StratigraphyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyStandardizationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyStandardization(data: number[], opts: StratigraphyStandardizationOptions = {}): StratigraphyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyStandardization };
diff --git a/src/stratigraphy/static.ts b/src/stratigraphy/static.ts
new file mode 100644
index 000000000..5331dd462
--- /dev/null
+++ b/src/stratigraphy/static.ts
@@ -0,0 +1,14 @@
+/** stratigraphy static module — tsb analytics library. */
+export interface StratigraphyStaticOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyStaticResult { values: number[]; converged: boolean; }
+export function computeStratigraphyStatic(data: number[], opts: StratigraphyStaticOptions = {}): StratigraphyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyStatic };
diff --git a/src/stratigraphy/stochastic.ts b/src/stratigraphy/stochastic.ts
new file mode 100644
index 000000000..c0c2132a7
--- /dev/null
+++ b/src/stratigraphy/stochastic.ts
@@ -0,0 +1,14 @@
+/** stratigraphy stochastic module — tsb analytics library. */
+export interface StratigraphyStochasticOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyStochasticResult { values: number[]; converged: boolean; }
+export function computeStratigraphyStochastic(data: number[], opts: StratigraphyStochasticOptions = {}): StratigraphyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyStochastic };
diff --git a/src/stratigraphy/synthesis.ts b/src/stratigraphy/synthesis.ts
new file mode 100644
index 000000000..c59e91135
--- /dev/null
+++ b/src/stratigraphy/synthesis.ts
@@ -0,0 +1,14 @@
+/** stratigraphy synthesis module — tsb analytics library. */
+export interface StratigraphySynthesisOptions { tol?: number; maxIter?: number; }
+export interface StratigraphySynthesisResult { values: number[]; converged: boolean; }
+export function computeStratigraphySynthesis(data: number[], opts: StratigraphySynthesisOptions = {}): StratigraphySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphySynthesis };
diff --git a/src/stratigraphy/topology.ts b/src/stratigraphy/topology.ts
new file mode 100644
index 000000000..488a6caf0
--- /dev/null
+++ b/src/stratigraphy/topology.ts
@@ -0,0 +1,14 @@
+/** stratigraphy topology module — tsb analytics library. */
+export interface StratigraphyTopologyOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyTopologyResult { values: number[]; converged: boolean; }
+export function computeStratigraphyTopology(data: number[], opts: StratigraphyTopologyOptions = {}): StratigraphyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyTopology };
diff --git a/src/stratigraphy/tracking.ts b/src/stratigraphy/tracking.ts
new file mode 100644
index 000000000..fd8691fa9
--- /dev/null
+++ b/src/stratigraphy/tracking.ts
@@ -0,0 +1,14 @@
+/** stratigraphy tracking module — tsb analytics library. */
+export interface StratigraphyTrackingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyTrackingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyTracking(data: number[], opts: StratigraphyTrackingOptions = {}): StratigraphyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyTracking };
diff --git a/src/stratigraphy/transform.ts b/src/stratigraphy/transform.ts
new file mode 100644
index 000000000..0a3aaccdb
--- /dev/null
+++ b/src/stratigraphy/transform.ts
@@ -0,0 +1,14 @@
+/** stratigraphy transform module — tsb analytics library. */
+export interface StratigraphyTransformOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyTransformResult { values: number[]; converged: boolean; }
+export function computeStratigraphyTransform(data: number[], opts: StratigraphyTransformOptions = {}): StratigraphyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyTransform };
diff --git a/src/stratigraphy/uncertainty.ts b/src/stratigraphy/uncertainty.ts
new file mode 100644
index 000000000..b3bc1cf91
--- /dev/null
+++ b/src/stratigraphy/uncertainty.ts
@@ -0,0 +1,14 @@
+/** stratigraphy uncertainty module — tsb analytics library. */
+export interface StratigraphyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeStratigraphyUncertainty(data: number[], opts: StratigraphyUncertaintyOptions = {}): StratigraphyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyUncertainty };
diff --git a/src/stratigraphy/validation.ts b/src/stratigraphy/validation.ts
new file mode 100644
index 000000000..5b2d6f5de
--- /dev/null
+++ b/src/stratigraphy/validation.ts
@@ -0,0 +1,14 @@
+/** stratigraphy validation module — tsb analytics library. */
+export interface StratigraphyValidationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyValidationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyValidation(data: number[], opts: StratigraphyValidationOptions = {}): StratigraphyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyValidation };
diff --git a/src/stratigraphy/verification.ts b/src/stratigraphy/verification.ts
new file mode 100644
index 000000000..55e737bb8
--- /dev/null
+++ b/src/stratigraphy/verification.ts
@@ -0,0 +1,14 @@
+/** stratigraphy verification module — tsb analytics library. */
+export interface StratigraphyVerificationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyVerificationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyVerification(data: number[], opts: StratigraphyVerificationOptions = {}): StratigraphyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyVerification };
diff --git a/src/stratigraphy/visualization.ts b/src/stratigraphy/visualization.ts
new file mode 100644
index 000000000..a89db39a8
--- /dev/null
+++ b/src/stratigraphy/visualization.ts
@@ -0,0 +1,14 @@
+/** stratigraphy visualization module — tsb analytics library. */
+export interface StratigraphyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyVisualizationResult { values: number[]; converged: boolean; }
+export function computeStratigraphyVisualization(data: number[], opts: StratigraphyVisualizationOptions = {}): StratigraphyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyVisualization };
diff --git a/src/stratigraphy/voting.ts b/src/stratigraphy/voting.ts
new file mode 100644
index 000000000..b2371ea7c
--- /dev/null
+++ b/src/stratigraphy/voting.ts
@@ -0,0 +1,14 @@
+/** stratigraphy voting module — tsb analytics library. */
+export interface StratigraphyVotingOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyVotingResult { values: number[]; converged: boolean; }
+export function computeStratigraphyVoting(data: number[], opts: StratigraphyVotingOptions = {}): StratigraphyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyVoting };
diff --git a/src/stratigraphy/wavelet.ts b/src/stratigraphy/wavelet.ts
new file mode 100644
index 000000000..23d6a1e87
--- /dev/null
+++ b/src/stratigraphy/wavelet.ts
@@ -0,0 +1,14 @@
+/** stratigraphy wavelet module — tsb analytics library. */
+export interface StratigraphyWaveletOptions { tol?: number; maxIter?: number; }
+export interface StratigraphyWaveletResult { values: number[]; converged: boolean; }
+export function computeStratigraphyWavelet(data: number[], opts: StratigraphyWaveletOptions = {}): StratigraphyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStratigraphyWavelet };
diff --git a/src/structural_bio/adaptation.ts b/src/structural_bio/adaptation.ts
new file mode 100644
index 000000000..4c112eb22
--- /dev/null
+++ b/src/structural_bio/adaptation.ts
@@ -0,0 +1,14 @@
+/** structural_bio adaptation module — tsb analytics library. */
+export interface StructuralBioAdaptationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioAdaptationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioAdaptation(data: number[], opts: StructuralBioAdaptationOptions = {}): StructuralBioAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioAdaptation };
diff --git a/src/structural_bio/aggregation.ts b/src/structural_bio/aggregation.ts
new file mode 100644
index 000000000..c2f10a90b
--- /dev/null
+++ b/src/structural_bio/aggregation.ts
@@ -0,0 +1,14 @@
+/** structural_bio aggregation module — tsb analytics library. */
+export interface StructuralBioAggregationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioAggregationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioAggregation(data: number[], opts: StructuralBioAggregationOptions = {}): StructuralBioAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioAggregation };
diff --git a/src/structural_bio/algebra.ts b/src/structural_bio/algebra.ts
new file mode 100644
index 000000000..fe694de24
--- /dev/null
+++ b/src/structural_bio/algebra.ts
@@ -0,0 +1,14 @@
+/** structural_bio algebra module — tsb analytics library. */
+export interface StructuralBioAlgebraOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioAlgebraResult { values: number[]; converged: boolean; }
+export function computeStructuralBioAlgebra(data: number[], opts: StructuralBioAlgebraOptions = {}): StructuralBioAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioAlgebra };
diff --git a/src/structural_bio/alignment.ts b/src/structural_bio/alignment.ts
new file mode 100644
index 000000000..9467470ed
--- /dev/null
+++ b/src/structural_bio/alignment.ts
@@ -0,0 +1,14 @@
+/** structural_bio alignment module — tsb analytics library. */
+export interface StructuralBioAlignmentOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioAlignmentResult { values: number[]; converged: boolean; }
+export function computeStructuralBioAlignment(data: number[], opts: StructuralBioAlignmentOptions = {}): StructuralBioAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioAlignment };
diff --git a/src/structural_bio/analysis.ts b/src/structural_bio/analysis.ts
new file mode 100644
index 000000000..2d5087f38
--- /dev/null
+++ b/src/structural_bio/analysis.ts
@@ -0,0 +1,14 @@
+/** structural_bio analysis module — tsb analytics library. */
+export interface StructuralBioAnalysisOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioAnalysisResult { values: number[]; converged: boolean; }
+export function computeStructuralBioAnalysis(data: number[], opts: StructuralBioAnalysisOptions = {}): StructuralBioAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioAnalysis };
diff --git a/src/structural_bio/augmentation.ts b/src/structural_bio/augmentation.ts
new file mode 100644
index 000000000..65d7f13cb
--- /dev/null
+++ b/src/structural_bio/augmentation.ts
@@ -0,0 +1,14 @@
+/** structural_bio augmentation module — tsb analytics library. */
+export interface StructuralBioAugmentationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioAugmentationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioAugmentation(data: number[], opts: StructuralBioAugmentationOptions = {}): StructuralBioAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioAugmentation };
diff --git a/src/structural_bio/bagging.ts b/src/structural_bio/bagging.ts
new file mode 100644
index 000000000..8bcaaa5c5
--- /dev/null
+++ b/src/structural_bio/bagging.ts
@@ -0,0 +1,14 @@
+/** structural_bio bagging module — tsb analytics library. */
+export interface StructuralBioBaggingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioBaggingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioBagging(data: number[], opts: StructuralBioBaggingOptions = {}): StructuralBioBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioBagging };
diff --git a/src/structural_bio/basis.ts b/src/structural_bio/basis.ts
new file mode 100644
index 000000000..6bd9c8edb
--- /dev/null
+++ b/src/structural_bio/basis.ts
@@ -0,0 +1,14 @@
+/** structural_bio basis module — tsb analytics library. */
+export interface StructuralBioBasisOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioBasisResult { values: number[]; converged: boolean; }
+export function computeStructuralBioBasis(data: number[], opts: StructuralBioBasisOptions = {}): StructuralBioBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioBasis };
diff --git a/src/structural_bio/benchmarking.ts b/src/structural_bio/benchmarking.ts
new file mode 100644
index 000000000..573bf277b
--- /dev/null
+++ b/src/structural_bio/benchmarking.ts
@@ -0,0 +1,14 @@
+/** structural_bio benchmarking module — tsb analytics library. */
+export interface StructuralBioBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioBenchmarking(data: number[], opts: StructuralBioBenchmarkingOptions = {}): StructuralBioBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioBenchmarking };
diff --git a/src/structural_bio/blending.ts b/src/structural_bio/blending.ts
new file mode 100644
index 000000000..5776bb0a6
--- /dev/null
+++ b/src/structural_bio/blending.ts
@@ -0,0 +1,14 @@
+/** structural_bio blending module — tsb analytics library. */
+export interface StructuralBioBlendingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioBlendingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioBlending(data: number[], opts: StructuralBioBlendingOptions = {}): StructuralBioBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioBlending };
diff --git a/src/structural_bio/boosting.ts b/src/structural_bio/boosting.ts
new file mode 100644
index 000000000..76ee0b04d
--- /dev/null
+++ b/src/structural_bio/boosting.ts
@@ -0,0 +1,14 @@
+/** structural_bio boosting module — tsb analytics library. */
+export interface StructuralBioBoostingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioBoostingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioBoosting(data: number[], opts: StructuralBioBoostingOptions = {}): StructuralBioBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioBoosting };
diff --git a/src/structural_bio/bootstrap.ts b/src/structural_bio/bootstrap.ts
new file mode 100644
index 000000000..df01e4a8f
--- /dev/null
+++ b/src/structural_bio/bootstrap.ts
@@ -0,0 +1,14 @@
+/** structural_bio bootstrap module — tsb analytics library. */
+export interface StructuralBioBootstrapOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioBootstrapResult { values: number[]; converged: boolean; }
+export function computeStructuralBioBootstrap(data: number[], opts: StructuralBioBootstrapOptions = {}): StructuralBioBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioBootstrap };
diff --git a/src/structural_bio/calculus.ts b/src/structural_bio/calculus.ts
new file mode 100644
index 000000000..b4ee6d51f
--- /dev/null
+++ b/src/structural_bio/calculus.ts
@@ -0,0 +1,14 @@
+/** structural_bio calculus module — tsb analytics library. */
+export interface StructuralBioCalculusOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioCalculusResult { values: number[]; converged: boolean; }
+export function computeStructuralBioCalculus(data: number[], opts: StructuralBioCalculusOptions = {}): StructuralBioCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioCalculus };
diff --git a/src/structural_bio/calibration.ts b/src/structural_bio/calibration.ts
new file mode 100644
index 000000000..11d62d562
--- /dev/null
+++ b/src/structural_bio/calibration.ts
@@ -0,0 +1,14 @@
+/** structural_bio calibration module — tsb analytics library. */
+export interface StructuralBioCalibrationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioCalibrationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioCalibration(data: number[], opts: StructuralBioCalibrationOptions = {}): StructuralBioCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioCalibration };
diff --git a/src/structural_bio/characterization.ts b/src/structural_bio/characterization.ts
new file mode 100644
index 000000000..cfd08af60
--- /dev/null
+++ b/src/structural_bio/characterization.ts
@@ -0,0 +1,14 @@
+/** structural_bio characterization module — tsb analytics library. */
+export interface StructuralBioCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioCharacterizationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioCharacterization(data: number[], opts: StructuralBioCharacterizationOptions = {}): StructuralBioCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioCharacterization };
diff --git a/src/structural_bio/classification.ts b/src/structural_bio/classification.ts
new file mode 100644
index 000000000..e1180dec4
--- /dev/null
+++ b/src/structural_bio/classification.ts
@@ -0,0 +1,14 @@
+/** structural_bio classification module — tsb analytics library. */
+export interface StructuralBioClassificationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioClassificationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioClassification(data: number[], opts: StructuralBioClassificationOptions = {}): StructuralBioClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioClassification };
diff --git a/src/structural_bio/clustering.ts b/src/structural_bio/clustering.ts
new file mode 100644
index 000000000..a0408dc64
--- /dev/null
+++ b/src/structural_bio/clustering.ts
@@ -0,0 +1,14 @@
+/** structural_bio clustering module — tsb analytics library. */
+export interface StructuralBioClusteringOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioClusteringResult { values: number[]; converged: boolean; }
+export function computeStructuralBioClustering(data: number[], opts: StructuralBioClusteringOptions = {}): StructuralBioClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioClustering };
diff --git a/src/structural_bio/compression.ts b/src/structural_bio/compression.ts
new file mode 100644
index 000000000..62f588ad9
--- /dev/null
+++ b/src/structural_bio/compression.ts
@@ -0,0 +1,14 @@
+/** structural_bio compression module — tsb analytics library. */
+export interface StructuralBioCompressionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioCompressionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioCompression(data: number[], opts: StructuralBioCompressionOptions = {}): StructuralBioCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioCompression };
diff --git a/src/structural_bio/continuous.ts b/src/structural_bio/continuous.ts
new file mode 100644
index 000000000..9f6bf9b08
--- /dev/null
+++ b/src/structural_bio/continuous.ts
@@ -0,0 +1,14 @@
+/** structural_bio continuous module — tsb analytics library. */
+export interface StructuralBioContinuousOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioContinuousResult { values: number[]; converged: boolean; }
+export function computeStructuralBioContinuous(data: number[], opts: StructuralBioContinuousOptions = {}): StructuralBioContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioContinuous };
diff --git a/src/structural_bio/control.ts b/src/structural_bio/control.ts
new file mode 100644
index 000000000..cdd91e416
--- /dev/null
+++ b/src/structural_bio/control.ts
@@ -0,0 +1,14 @@
+/** structural_bio control module — tsb analytics library. */
+export interface StructuralBioControlOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioControlResult { values: number[]; converged: boolean; }
+export function computeStructuralBioControl(data: number[], opts: StructuralBioControlOptions = {}): StructuralBioControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioControl };
diff --git a/src/structural_bio/convergence.ts b/src/structural_bio/convergence.ts
new file mode 100644
index 000000000..8f924fd46
--- /dev/null
+++ b/src/structural_bio/convergence.ts
@@ -0,0 +1,14 @@
+/** structural_bio convergence module — tsb analytics library. */
+export interface StructuralBioConvergenceOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioConvergenceResult { values: number[]; converged: boolean; }
+export function computeStructuralBioConvergence(data: number[], opts: StructuralBioConvergenceOptions = {}): StructuralBioConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioConvergence };
diff --git a/src/structural_bio/convex.ts b/src/structural_bio/convex.ts
new file mode 100644
index 000000000..2c0b4e793
--- /dev/null
+++ b/src/structural_bio/convex.ts
@@ -0,0 +1,14 @@
+/** structural_bio convex module — tsb analytics library. */
+export interface StructuralBioConvexOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioConvexResult { values: number[]; converged: boolean; }
+export function computeStructuralBioConvex(data: number[], opts: StructuralBioConvexOptions = {}): StructuralBioConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioConvex };
diff --git a/src/structural_bio/correlation.ts b/src/structural_bio/correlation.ts
new file mode 100644
index 000000000..558690b7a
--- /dev/null
+++ b/src/structural_bio/correlation.ts
@@ -0,0 +1,14 @@
+/** structural_bio correlation module — tsb analytics library. */
+export interface StructuralBioCorrelationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioCorrelationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioCorrelation(data: number[], opts: StructuralBioCorrelationOptions = {}): StructuralBioCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioCorrelation };
diff --git a/src/structural_bio/covariance.ts b/src/structural_bio/covariance.ts
new file mode 100644
index 000000000..5be557319
--- /dev/null
+++ b/src/structural_bio/covariance.ts
@@ -0,0 +1,14 @@
+/** structural_bio covariance module — tsb analytics library. */
+export interface StructuralBioCovarianceOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioCovarianceResult { values: number[]; converged: boolean; }
+export function computeStructuralBioCovariance(data: number[], opts: StructuralBioCovarianceOptions = {}): StructuralBioCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioCovariance };
diff --git a/src/structural_bio/cross_validation.ts b/src/structural_bio/cross_validation.ts
new file mode 100644
index 000000000..e83715901
--- /dev/null
+++ b/src/structural_bio/cross_validation.ts
@@ -0,0 +1,14 @@
+/** structural_bio cross_validation module — tsb analytics library. */
+export interface StructuralBioCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioCrossValidationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioCrossValidation(data: number[], opts: StructuralBioCrossValidationOptions = {}): StructuralBioCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioCrossValidation };
diff --git a/src/structural_bio/decoding.ts b/src/structural_bio/decoding.ts
new file mode 100644
index 000000000..b908bbef6
--- /dev/null
+++ b/src/structural_bio/decoding.ts
@@ -0,0 +1,14 @@
+/** structural_bio decoding module — tsb analytics library. */
+export interface StructuralBioDecodingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDecodingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDecoding(data: number[], opts: StructuralBioDecodingOptions = {}): StructuralBioDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDecoding };
diff --git a/src/structural_bio/decomposition.ts b/src/structural_bio/decomposition.ts
new file mode 100644
index 000000000..445465dec
--- /dev/null
+++ b/src/structural_bio/decomposition.ts
@@ -0,0 +1,14 @@
+/** structural_bio decomposition module — tsb analytics library. */
+export interface StructuralBioDecompositionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDecompositionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDecomposition(data: number[], opts: StructuralBioDecompositionOptions = {}): StructuralBioDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDecomposition };
diff --git a/src/structural_bio/detection.ts b/src/structural_bio/detection.ts
new file mode 100644
index 000000000..1f21fb700
--- /dev/null
+++ b/src/structural_bio/detection.ts
@@ -0,0 +1,14 @@
+/** structural_bio detection module — tsb analytics library. */
+export interface StructuralBioDetectionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDetectionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDetection(data: number[], opts: StructuralBioDetectionOptions = {}): StructuralBioDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDetection };
diff --git a/src/structural_bio/deterministic.ts b/src/structural_bio/deterministic.ts
new file mode 100644
index 000000000..42370c690
--- /dev/null
+++ b/src/structural_bio/deterministic.ts
@@ -0,0 +1,14 @@
+/** structural_bio deterministic module — tsb analytics library. */
+export interface StructuralBioDeterministicOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDeterministicResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDeterministic(data: number[], opts: StructuralBioDeterministicOptions = {}): StructuralBioDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDeterministic };
diff --git a/src/structural_bio/diagnostics.ts b/src/structural_bio/diagnostics.ts
new file mode 100644
index 000000000..5dc9c84a1
--- /dev/null
+++ b/src/structural_bio/diagnostics.ts
@@ -0,0 +1,14 @@
+/** structural_bio diagnostics module — tsb analytics library. */
+export interface StructuralBioDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDiagnostics(data: number[], opts: StructuralBioDiagnosticsOptions = {}): StructuralBioDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDiagnostics };
diff --git a/src/structural_bio/differential.ts b/src/structural_bio/differential.ts
new file mode 100644
index 000000000..413c9c87a
--- /dev/null
+++ b/src/structural_bio/differential.ts
@@ -0,0 +1,14 @@
+/** structural_bio differential module — tsb analytics library. */
+export interface StructuralBioDifferentialOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDifferentialResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDifferential(data: number[], opts: StructuralBioDifferentialOptions = {}): StructuralBioDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDifferential };
diff --git a/src/structural_bio/discrete.ts b/src/structural_bio/discrete.ts
new file mode 100644
index 000000000..301d78471
--- /dev/null
+++ b/src/structural_bio/discrete.ts
@@ -0,0 +1,14 @@
+/** structural_bio discrete module — tsb analytics library. */
+export interface StructuralBioDiscreteOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDiscreteResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDiscrete(data: number[], opts: StructuralBioDiscreteOptions = {}): StructuralBioDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDiscrete };
diff --git a/src/structural_bio/distribution.ts b/src/structural_bio/distribution.ts
new file mode 100644
index 000000000..bacf743e2
--- /dev/null
+++ b/src/structural_bio/distribution.ts
@@ -0,0 +1,14 @@
+/** structural_bio distribution module — tsb analytics library. */
+export interface StructuralBioDistributionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDistributionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDistribution(data: number[], opts: StructuralBioDistributionOptions = {}): StructuralBioDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDistribution };
diff --git a/src/structural_bio/dynamic.ts b/src/structural_bio/dynamic.ts
new file mode 100644
index 000000000..153ded916
--- /dev/null
+++ b/src/structural_bio/dynamic.ts
@@ -0,0 +1,14 @@
+/** structural_bio dynamic module — tsb analytics library. */
+export interface StructuralBioDynamicOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioDynamicResult { values: number[]; converged: boolean; }
+export function computeStructuralBioDynamic(data: number[], opts: StructuralBioDynamicOptions = {}): StructuralBioDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioDynamic };
diff --git a/src/structural_bio/embedding.ts b/src/structural_bio/embedding.ts
new file mode 100644
index 000000000..7bb6fc9f0
--- /dev/null
+++ b/src/structural_bio/embedding.ts
@@ -0,0 +1,14 @@
+/** structural_bio embedding module — tsb analytics library. */
+export interface StructuralBioEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioEmbeddingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioEmbedding(data: number[], opts: StructuralBioEmbeddingOptions = {}): StructuralBioEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioEmbedding };
diff --git a/src/structural_bio/encoding.ts b/src/structural_bio/encoding.ts
new file mode 100644
index 000000000..c0add7cbe
--- /dev/null
+++ b/src/structural_bio/encoding.ts
@@ -0,0 +1,14 @@
+/** structural_bio encoding module — tsb analytics library. */
+export interface StructuralBioEncodingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioEncodingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioEncoding(data: number[], opts: StructuralBioEncodingOptions = {}): StructuralBioEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioEncoding };
diff --git a/src/structural_bio/ensemble.ts b/src/structural_bio/ensemble.ts
new file mode 100644
index 000000000..983845ea8
--- /dev/null
+++ b/src/structural_bio/ensemble.ts
@@ -0,0 +1,14 @@
+/** structural_bio ensemble module — tsb analytics library. */
+export interface StructuralBioEnsembleOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioEnsembleResult { values: number[]; converged: boolean; }
+export function computeStructuralBioEnsemble(data: number[], opts: StructuralBioEnsembleOptions = {}): StructuralBioEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioEnsemble };
diff --git a/src/structural_bio/estimation.ts b/src/structural_bio/estimation.ts
new file mode 100644
index 000000000..b63d5020d
--- /dev/null
+++ b/src/structural_bio/estimation.ts
@@ -0,0 +1,14 @@
+/** structural_bio estimation module — tsb analytics library. */
+export interface StructuralBioEstimationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioEstimationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioEstimation(data: number[], opts: StructuralBioEstimationOptions = {}): StructuralBioEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioEstimation };
diff --git a/src/structural_bio/evaluation.ts b/src/structural_bio/evaluation.ts
new file mode 100644
index 000000000..542d33e58
--- /dev/null
+++ b/src/structural_bio/evaluation.ts
@@ -0,0 +1,14 @@
+/** structural_bio evaluation module — tsb analytics library. */
+export interface StructuralBioEvaluationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioEvaluationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioEvaluation(data: number[], opts: StructuralBioEvaluationOptions = {}): StructuralBioEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioEvaluation };
diff --git a/src/structural_bio/extrapolation.ts b/src/structural_bio/extrapolation.ts
new file mode 100644
index 000000000..333525510
--- /dev/null
+++ b/src/structural_bio/extrapolation.ts
@@ -0,0 +1,14 @@
+/** structural_bio extrapolation module — tsb analytics library. */
+export interface StructuralBioExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioExtrapolationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioExtrapolation(data: number[], opts: StructuralBioExtrapolationOptions = {}): StructuralBioExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioExtrapolation };
diff --git a/src/structural_bio/features.ts b/src/structural_bio/features.ts
new file mode 100644
index 000000000..28db2e5d3
--- /dev/null
+++ b/src/structural_bio/features.ts
@@ -0,0 +1,14 @@
+/** structural_bio features module — tsb analytics library. */
+export interface StructuralBioFeaturesOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioFeaturesResult { values: number[]; converged: boolean; }
+export function computeStructuralBioFeatures(data: number[], opts: StructuralBioFeaturesOptions = {}): StructuralBioFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioFeatures };
diff --git a/src/structural_bio/feedback.ts b/src/structural_bio/feedback.ts
new file mode 100644
index 000000000..7b3960b8e
--- /dev/null
+++ b/src/structural_bio/feedback.ts
@@ -0,0 +1,14 @@
+/** structural_bio feedback module — tsb analytics library. */
+export interface StructuralBioFeedbackOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioFeedbackResult { values: number[]; converged: boolean; }
+export function computeStructuralBioFeedback(data: number[], opts: StructuralBioFeedbackOptions = {}): StructuralBioFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioFeedback };
diff --git a/src/structural_bio/filtering.ts b/src/structural_bio/filtering.ts
new file mode 100644
index 000000000..6b6cb382d
--- /dev/null
+++ b/src/structural_bio/filtering.ts
@@ -0,0 +1,14 @@
+/** structural_bio filtering module — tsb analytics library. */
+export interface StructuralBioFilteringOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioFilteringResult { values: number[]; converged: boolean; }
+export function computeStructuralBioFiltering(data: number[], opts: StructuralBioFilteringOptions = {}): StructuralBioFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioFiltering };
diff --git a/src/structural_bio/fourier.ts b/src/structural_bio/fourier.ts
new file mode 100644
index 000000000..610dc3957
--- /dev/null
+++ b/src/structural_bio/fourier.ts
@@ -0,0 +1,14 @@
+/** structural_bio fourier module — tsb analytics library. */
+export interface StructuralBioFourierOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioFourierResult { values: number[]; converged: boolean; }
+export function computeStructuralBioFourier(data: number[], opts: StructuralBioFourierOptions = {}): StructuralBioFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioFourier };
diff --git a/src/structural_bio/fusion.ts b/src/structural_bio/fusion.ts
new file mode 100644
index 000000000..61c880c2a
--- /dev/null
+++ b/src/structural_bio/fusion.ts
@@ -0,0 +1,14 @@
+/** structural_bio fusion module — tsb analytics library. */
+export interface StructuralBioFusionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioFusionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioFusion(data: number[], opts: StructuralBioFusionOptions = {}): StructuralBioFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioFusion };
diff --git a/src/structural_bio/generation.ts b/src/structural_bio/generation.ts
new file mode 100644
index 000000000..9b8445236
--- /dev/null
+++ b/src/structural_bio/generation.ts
@@ -0,0 +1,14 @@
+/** structural_bio generation module — tsb analytics library. */
+export interface StructuralBioGenerationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioGenerationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioGeneration(data: number[], opts: StructuralBioGenerationOptions = {}): StructuralBioGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioGeneration };
diff --git a/src/structural_bio/geometry.ts b/src/structural_bio/geometry.ts
new file mode 100644
index 000000000..26a7738cf
--- /dev/null
+++ b/src/structural_bio/geometry.ts
@@ -0,0 +1,14 @@
+/** structural_bio geometry module — tsb analytics library. */
+export interface StructuralBioGeometryOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioGeometryResult { values: number[]; converged: boolean; }
+export function computeStructuralBioGeometry(data: number[], opts: StructuralBioGeometryOptions = {}): StructuralBioGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioGeometry };
diff --git a/src/structural_bio/gradient.ts b/src/structural_bio/gradient.ts
new file mode 100644
index 000000000..d02db8d80
--- /dev/null
+++ b/src/structural_bio/gradient.ts
@@ -0,0 +1,14 @@
+/** structural_bio gradient module — tsb analytics library. */
+export interface StructuralBioGradientOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioGradientResult { values: number[]; converged: boolean; }
+export function computeStructuralBioGradient(data: number[], opts: StructuralBioGradientOptions = {}): StructuralBioGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioGradient };
diff --git a/src/structural_bio/hessian.ts b/src/structural_bio/hessian.ts
new file mode 100644
index 000000000..3d8c1b693
--- /dev/null
+++ b/src/structural_bio/hessian.ts
@@ -0,0 +1,14 @@
+/** structural_bio hessian module — tsb analytics library. */
+export interface StructuralBioHessianOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioHessianResult { values: number[]; converged: boolean; }
+export function computeStructuralBioHessian(data: number[], opts: StructuralBioHessianOptions = {}): StructuralBioHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioHessian };
diff --git a/src/structural_bio/hypothesis.ts b/src/structural_bio/hypothesis.ts
new file mode 100644
index 000000000..9ef93f766
--- /dev/null
+++ b/src/structural_bio/hypothesis.ts
@@ -0,0 +1,14 @@
+/** structural_bio hypothesis module — tsb analytics library. */
+export interface StructuralBioHypothesisOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioHypothesisResult { values: number[]; converged: boolean; }
+export function computeStructuralBioHypothesis(data: number[], opts: StructuralBioHypothesisOptions = {}): StructuralBioHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioHypothesis };
diff --git a/src/structural_bio/inference.ts b/src/structural_bio/inference.ts
new file mode 100644
index 000000000..c1163d794
--- /dev/null
+++ b/src/structural_bio/inference.ts
@@ -0,0 +1,14 @@
+/** structural_bio inference module — tsb analytics library. */
+export interface StructuralBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioInferenceResult { values: number[]; converged: boolean; }
+export function computeStructuralBioInference(data: number[], opts: StructuralBioInferenceOptions = {}): StructuralBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioInference };
diff --git a/src/structural_bio/inference2.ts b/src/structural_bio/inference2.ts
new file mode 100644
index 000000000..7ad994a31
--- /dev/null
+++ b/src/structural_bio/inference2.ts
@@ -0,0 +1,14 @@
+/** structural_bio inference2 module — tsb analytics library. */
+export interface StructuralBioInferenceOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioInferenceResult { values: number[]; converged: boolean; }
+export function computeStructuralBioInference(data: number[], opts: StructuralBioInferenceOptions = {}): StructuralBioInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioInference };
diff --git a/src/structural_bio/integral.ts b/src/structural_bio/integral.ts
new file mode 100644
index 000000000..a52dda755
--- /dev/null
+++ b/src/structural_bio/integral.ts
@@ -0,0 +1,14 @@
+/** structural_bio integral module — tsb analytics library. */
+export interface StructuralBioIntegralOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioIntegralResult { values: number[]; converged: boolean; }
+export function computeStructuralBioIntegral(data: number[], opts: StructuralBioIntegralOptions = {}): StructuralBioIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioIntegral };
diff --git a/src/structural_bio/integration.ts b/src/structural_bio/integration.ts
new file mode 100644
index 000000000..0f02b4252
--- /dev/null
+++ b/src/structural_bio/integration.ts
@@ -0,0 +1,14 @@
+/** structural_bio integration module — tsb analytics library. */
+export interface StructuralBioIntegrationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioIntegrationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioIntegration(data: number[], opts: StructuralBioIntegrationOptions = {}): StructuralBioIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioIntegration };
diff --git a/src/structural_bio/interpolation.ts b/src/structural_bio/interpolation.ts
new file mode 100644
index 000000000..0b6af054c
--- /dev/null
+++ b/src/structural_bio/interpolation.ts
@@ -0,0 +1,14 @@
+/** structural_bio interpolation module — tsb analytics library. */
+export interface StructuralBioInterpolationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioInterpolationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioInterpolation(data: number[], opts: StructuralBioInterpolationOptions = {}): StructuralBioInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioInterpolation };
diff --git a/src/structural_bio/jacobian.ts b/src/structural_bio/jacobian.ts
new file mode 100644
index 000000000..0d1b9b764
--- /dev/null
+++ b/src/structural_bio/jacobian.ts
@@ -0,0 +1,14 @@
+/** structural_bio jacobian module — tsb analytics library. */
+export interface StructuralBioJacobianOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioJacobianResult { values: number[]; converged: boolean; }
+export function computeStructuralBioJacobian(data: number[], opts: StructuralBioJacobianOptions = {}): StructuralBioJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioJacobian };
diff --git a/src/structural_bio/kernel.ts b/src/structural_bio/kernel.ts
new file mode 100644
index 000000000..52757e970
--- /dev/null
+++ b/src/structural_bio/kernel.ts
@@ -0,0 +1,14 @@
+/** structural_bio kernel module — tsb analytics library. */
+export interface StructuralBioKernelOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioKernelResult { values: number[]; converged: boolean; }
+export function computeStructuralBioKernel(data: number[], opts: StructuralBioKernelOptions = {}): StructuralBioKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioKernel };
diff --git a/src/structural_bio/laplacian.ts b/src/structural_bio/laplacian.ts
new file mode 100644
index 000000000..dacb51606
--- /dev/null
+++ b/src/structural_bio/laplacian.ts
@@ -0,0 +1,14 @@
+/** structural_bio laplacian module — tsb analytics library. */
+export interface StructuralBioLaplacianOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioLaplacianResult { values: number[]; converged: boolean; }
+export function computeStructuralBioLaplacian(data: number[], opts: StructuralBioLaplacianOptions = {}): StructuralBioLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioLaplacian };
diff --git a/src/structural_bio/learning.ts b/src/structural_bio/learning.ts
new file mode 100644
index 000000000..b35d7a5ad
--- /dev/null
+++ b/src/structural_bio/learning.ts
@@ -0,0 +1,14 @@
+/** structural_bio learning module — tsb analytics library. */
+export interface StructuralBioLearningOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioLearningResult { values: number[]; converged: boolean; }
+export function computeStructuralBioLearning(data: number[], opts: StructuralBioLearningOptions = {}): StructuralBioLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioLearning };
diff --git a/src/structural_bio/linear.ts b/src/structural_bio/linear.ts
new file mode 100644
index 000000000..6688a8bdf
--- /dev/null
+++ b/src/structural_bio/linear.ts
@@ -0,0 +1,14 @@
+/** structural_bio linear module — tsb analytics library. */
+export interface StructuralBioLinearOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioLinearResult { values: number[]; converged: boolean; }
+export function computeStructuralBioLinear(data: number[], opts: StructuralBioLinearOptions = {}): StructuralBioLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioLinear };
diff --git a/src/structural_bio/manifold.ts b/src/structural_bio/manifold.ts
new file mode 100644
index 000000000..424e57873
--- /dev/null
+++ b/src/structural_bio/manifold.ts
@@ -0,0 +1,14 @@
+/** structural_bio manifold module — tsb analytics library. */
+export interface StructuralBioManifoldOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioManifoldResult { values: number[]; converged: boolean; }
+export function computeStructuralBioManifold(data: number[], opts: StructuralBioManifoldOptions = {}): StructuralBioManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioManifold };
diff --git a/src/structural_bio/matching.ts b/src/structural_bio/matching.ts
new file mode 100644
index 000000000..61427b076
--- /dev/null
+++ b/src/structural_bio/matching.ts
@@ -0,0 +1,14 @@
+/** structural_bio matching module — tsb analytics library. */
+export interface StructuralBioMatchingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioMatchingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioMatching(data: number[], opts: StructuralBioMatchingOptions = {}): StructuralBioMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioMatching };
diff --git a/src/structural_bio/measurement.ts b/src/structural_bio/measurement.ts
new file mode 100644
index 000000000..7d785be1c
--- /dev/null
+++ b/src/structural_bio/measurement.ts
@@ -0,0 +1,14 @@
+/** structural_bio measurement module — tsb analytics library. */
+export interface StructuralBioMeasurementOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioMeasurementResult { values: number[]; converged: boolean; }
+export function computeStructuralBioMeasurement(data: number[], opts: StructuralBioMeasurementOptions = {}): StructuralBioMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioMeasurement };
diff --git a/src/structural_bio/metrics.ts b/src/structural_bio/metrics.ts
new file mode 100644
index 000000000..74bc59dba
--- /dev/null
+++ b/src/structural_bio/metrics.ts
@@ -0,0 +1,14 @@
+/** structural_bio metrics module — tsb analytics library. */
+export interface StructuralBioMetricsOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioMetricsResult { values: number[]; converged: boolean; }
+export function computeStructuralBioMetrics(data: number[], opts: StructuralBioMetricsOptions = {}): StructuralBioMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioMetrics };
diff --git a/src/structural_bio/modeling.ts b/src/structural_bio/modeling.ts
new file mode 100644
index 000000000..f928cb6ae
--- /dev/null
+++ b/src/structural_bio/modeling.ts
@@ -0,0 +1,14 @@
+/** structural_bio modeling module — tsb analytics library. */
+export interface StructuralBioModelingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioModelingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioModeling(data: number[], opts: StructuralBioModelingOptions = {}): StructuralBioModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioModeling };
diff --git a/src/structural_bio/monitoring.ts b/src/structural_bio/monitoring.ts
new file mode 100644
index 000000000..209e4076f
--- /dev/null
+++ b/src/structural_bio/monitoring.ts
@@ -0,0 +1,14 @@
+/** structural_bio monitoring module — tsb analytics library. */
+export interface StructuralBioMonitoringOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioMonitoringResult { values: number[]; converged: boolean; }
+export function computeStructuralBioMonitoring(data: number[], opts: StructuralBioMonitoringOptions = {}): StructuralBioMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioMonitoring };
diff --git a/src/structural_bio/nonlinear.ts b/src/structural_bio/nonlinear.ts
new file mode 100644
index 000000000..f3a88300d
--- /dev/null
+++ b/src/structural_bio/nonlinear.ts
@@ -0,0 +1,14 @@
+/** structural_bio nonlinear module — tsb analytics library. */
+export interface StructuralBioNonlinearOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioNonlinearResult { values: number[]; converged: boolean; }
+export function computeStructuralBioNonlinear(data: number[], opts: StructuralBioNonlinearOptions = {}): StructuralBioNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioNonlinear };
diff --git a/src/structural_bio/normalization.ts b/src/structural_bio/normalization.ts
new file mode 100644
index 000000000..1531a22c7
--- /dev/null
+++ b/src/structural_bio/normalization.ts
@@ -0,0 +1,14 @@
+/** structural_bio normalization module — tsb analytics library. */
+export interface StructuralBioNormalizationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioNormalizationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioNormalization(data: number[], opts: StructuralBioNormalizationOptions = {}): StructuralBioNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioNormalization };
diff --git a/src/structural_bio/optimization.ts b/src/structural_bio/optimization.ts
new file mode 100644
index 000000000..558cd7e91
--- /dev/null
+++ b/src/structural_bio/optimization.ts
@@ -0,0 +1,14 @@
+/** structural_bio optimization module — tsb analytics library. */
+export interface StructuralBioOptimizationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioOptimizationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioOptimization(data: number[], opts: StructuralBioOptimizationOptions = {}): StructuralBioOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioOptimization };
diff --git a/src/structural_bio/patterns.ts b/src/structural_bio/patterns.ts
new file mode 100644
index 000000000..09964f4e2
--- /dev/null
+++ b/src/structural_bio/patterns.ts
@@ -0,0 +1,14 @@
+/** structural_bio patterns module — tsb analytics library. */
+export interface StructuralBioPatternsOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioPatternsResult { values: number[]; converged: boolean; }
+export function computeStructuralBioPatterns(data: number[], opts: StructuralBioPatternsOptions = {}): StructuralBioPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioPatterns };
diff --git a/src/structural_bio/permutation.ts b/src/structural_bio/permutation.ts
new file mode 100644
index 000000000..e15fdd71b
--- /dev/null
+++ b/src/structural_bio/permutation.ts
@@ -0,0 +1,14 @@
+/** structural_bio permutation module — tsb analytics library. */
+export interface StructuralBioPermutationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioPermutationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioPermutation(data: number[], opts: StructuralBioPermutationOptions = {}): StructuralBioPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioPermutation };
diff --git a/src/structural_bio/prediction.ts b/src/structural_bio/prediction.ts
new file mode 100644
index 000000000..5d9686c34
--- /dev/null
+++ b/src/structural_bio/prediction.ts
@@ -0,0 +1,14 @@
+/** structural_bio prediction module — tsb analytics library. */
+export interface StructuralBioPredictionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioPredictionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioPrediction(data: number[], opts: StructuralBioPredictionOptions = {}): StructuralBioPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioPrediction };
diff --git a/src/structural_bio/processing.ts b/src/structural_bio/processing.ts
new file mode 100644
index 000000000..0c367ff60
--- /dev/null
+++ b/src/structural_bio/processing.ts
@@ -0,0 +1,14 @@
+/** structural_bio processing module — tsb analytics library. */
+export interface StructuralBioProcessingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioProcessingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioProcessing(data: number[], opts: StructuralBioProcessingOptions = {}): StructuralBioProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioProcessing };
diff --git a/src/structural_bio/profiling.ts b/src/structural_bio/profiling.ts
new file mode 100644
index 000000000..4d690bbb0
--- /dev/null
+++ b/src/structural_bio/profiling.ts
@@ -0,0 +1,14 @@
+/** structural_bio profiling module — tsb analytics library. */
+export interface StructuralBioProfilingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioProfilingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioProfiling(data: number[], opts: StructuralBioProfilingOptions = {}): StructuralBioProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioProfiling };
diff --git a/src/structural_bio/projection.ts b/src/structural_bio/projection.ts
new file mode 100644
index 000000000..adf61391b
--- /dev/null
+++ b/src/structural_bio/projection.ts
@@ -0,0 +1,14 @@
+/** structural_bio projection module — tsb analytics library. */
+export interface StructuralBioProjectionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioProjectionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioProjection(data: number[], opts: StructuralBioProjectionOptions = {}): StructuralBioProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioProjection };
diff --git a/src/structural_bio/ranking.ts b/src/structural_bio/ranking.ts
new file mode 100644
index 000000000..f66c5aa48
--- /dev/null
+++ b/src/structural_bio/ranking.ts
@@ -0,0 +1,14 @@
+/** structural_bio ranking module — tsb analytics library. */
+export interface StructuralBioRankingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioRankingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioRanking(data: number[], opts: StructuralBioRankingOptions = {}): StructuralBioRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioRanking };
diff --git a/src/structural_bio/reconstruction.ts b/src/structural_bio/reconstruction.ts
new file mode 100644
index 000000000..3e9d3c0e1
--- /dev/null
+++ b/src/structural_bio/reconstruction.ts
@@ -0,0 +1,14 @@
+/** structural_bio reconstruction module — tsb analytics library. */
+export interface StructuralBioReconstructionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioReconstructionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioReconstruction(data: number[], opts: StructuralBioReconstructionOptions = {}): StructuralBioReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioReconstruction };
diff --git a/src/structural_bio/registration.ts b/src/structural_bio/registration.ts
new file mode 100644
index 000000000..3d0bb1def
--- /dev/null
+++ b/src/structural_bio/registration.ts
@@ -0,0 +1,14 @@
+/** structural_bio registration module — tsb analytics library. */
+export interface StructuralBioRegistrationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioRegistrationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioRegistration(data: number[], opts: StructuralBioRegistrationOptions = {}): StructuralBioRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioRegistration };
diff --git a/src/structural_bio/regression.ts b/src/structural_bio/regression.ts
new file mode 100644
index 000000000..69337dccd
--- /dev/null
+++ b/src/structural_bio/regression.ts
@@ -0,0 +1,14 @@
+/** structural_bio regression module — tsb analytics library. */
+export interface StructuralBioRegressionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioRegressionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioRegression(data: number[], opts: StructuralBioRegressionOptions = {}): StructuralBioRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioRegression };
diff --git a/src/structural_bio/regularization.ts b/src/structural_bio/regularization.ts
new file mode 100644
index 000000000..e2187ff30
--- /dev/null
+++ b/src/structural_bio/regularization.ts
@@ -0,0 +1,14 @@
+/** structural_bio regularization module — tsb analytics library. */
+export interface StructuralBioRegularizationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioRegularizationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioRegularization(data: number[], opts: StructuralBioRegularizationOptions = {}): StructuralBioRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioRegularization };
diff --git a/src/structural_bio/robustness.ts b/src/structural_bio/robustness.ts
new file mode 100644
index 000000000..5ff884657
--- /dev/null
+++ b/src/structural_bio/robustness.ts
@@ -0,0 +1,14 @@
+/** structural_bio robustness module — tsb analytics library. */
+export interface StructuralBioRobustnessOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioRobustnessResult { values: number[]; converged: boolean; }
+export function computeStructuralBioRobustness(data: number[], opts: StructuralBioRobustnessOptions = {}): StructuralBioRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioRobustness };
diff --git a/src/structural_bio/sampling.ts b/src/structural_bio/sampling.ts
new file mode 100644
index 000000000..556193190
--- /dev/null
+++ b/src/structural_bio/sampling.ts
@@ -0,0 +1,14 @@
+/** structural_bio sampling module — tsb analytics library. */
+export interface StructuralBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioSamplingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioSampling(data: number[], opts: StructuralBioSamplingOptions = {}): StructuralBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioSampling };
diff --git a/src/structural_bio/sampling2.ts b/src/structural_bio/sampling2.ts
new file mode 100644
index 000000000..c41a87e38
--- /dev/null
+++ b/src/structural_bio/sampling2.ts
@@ -0,0 +1,14 @@
+/** structural_bio sampling2 module — tsb analytics library. */
+export interface StructuralBioSamplingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioSamplingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioSampling(data: number[], opts: StructuralBioSamplingOptions = {}): StructuralBioSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioSampling };
diff --git a/src/structural_bio/scaling.ts b/src/structural_bio/scaling.ts
new file mode 100644
index 000000000..ae434fdef
--- /dev/null
+++ b/src/structural_bio/scaling.ts
@@ -0,0 +1,14 @@
+/** structural_bio scaling module — tsb analytics library. */
+export interface StructuralBioScalingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioScalingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioScaling(data: number[], opts: StructuralBioScalingOptions = {}): StructuralBioScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioScaling };
diff --git a/src/structural_bio/scoring.ts b/src/structural_bio/scoring.ts
new file mode 100644
index 000000000..aa4a51249
--- /dev/null
+++ b/src/structural_bio/scoring.ts
@@ -0,0 +1,14 @@
+/** structural_bio scoring module — tsb analytics library. */
+export interface StructuralBioScoringOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioScoringResult { values: number[]; converged: boolean; }
+export function computeStructuralBioScoring(data: number[], opts: StructuralBioScoringOptions = {}): StructuralBioScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioScoring };
diff --git a/src/structural_bio/segmentation.ts b/src/structural_bio/segmentation.ts
new file mode 100644
index 000000000..86dab10de
--- /dev/null
+++ b/src/structural_bio/segmentation.ts
@@ -0,0 +1,14 @@
+/** structural_bio segmentation module — tsb analytics library. */
+export interface StructuralBioSegmentationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioSegmentationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioSegmentation(data: number[], opts: StructuralBioSegmentationOptions = {}): StructuralBioSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioSegmentation };
diff --git a/src/structural_bio/selection.ts b/src/structural_bio/selection.ts
new file mode 100644
index 000000000..bc533fa20
--- /dev/null
+++ b/src/structural_bio/selection.ts
@@ -0,0 +1,14 @@
+/** structural_bio selection module — tsb analytics library. */
+export interface StructuralBioSelectionOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioSelectionResult { values: number[]; converged: boolean; }
+export function computeStructuralBioSelection(data: number[], opts: StructuralBioSelectionOptions = {}): StructuralBioSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioSelection };
diff --git a/src/structural_bio/sensitivity.ts b/src/structural_bio/sensitivity.ts
new file mode 100644
index 000000000..f2a3ee57a
--- /dev/null
+++ b/src/structural_bio/sensitivity.ts
@@ -0,0 +1,14 @@
+/** structural_bio sensitivity module — tsb analytics library. */
+export interface StructuralBioSensitivityOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioSensitivityResult { values: number[]; converged: boolean; }
+export function computeStructuralBioSensitivity(data: number[], opts: StructuralBioSensitivityOptions = {}): StructuralBioSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioSensitivity };
diff --git a/src/structural_bio/simulation.ts b/src/structural_bio/simulation.ts
new file mode 100644
index 000000000..339294247
--- /dev/null
+++ b/src/structural_bio/simulation.ts
@@ -0,0 +1,14 @@
+/** structural_bio simulation module — tsb analytics library. */
+export interface StructuralBioSimulationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioSimulationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioSimulation(data: number[], opts: StructuralBioSimulationOptions = {}): StructuralBioSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioSimulation };
diff --git a/src/structural_bio/smoothing.ts b/src/structural_bio/smoothing.ts
new file mode 100644
index 000000000..f1992098b
--- /dev/null
+++ b/src/structural_bio/smoothing.ts
@@ -0,0 +1,14 @@
+/** structural_bio smoothing module — tsb analytics library. */
+export interface StructuralBioSmoothingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioSmoothingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioSmoothing(data: number[], opts: StructuralBioSmoothingOptions = {}): StructuralBioSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioSmoothing };
diff --git a/src/structural_bio/stability.ts b/src/structural_bio/stability.ts
new file mode 100644
index 000000000..f4b043c30
--- /dev/null
+++ b/src/structural_bio/stability.ts
@@ -0,0 +1,14 @@
+/** structural_bio stability module — tsb analytics library. */
+export interface StructuralBioStabilityOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioStabilityResult { values: number[]; converged: boolean; }
+export function computeStructuralBioStability(data: number[], opts: StructuralBioStabilityOptions = {}): StructuralBioStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioStability };
diff --git a/src/structural_bio/stacking.ts b/src/structural_bio/stacking.ts
new file mode 100644
index 000000000..9210f55ad
--- /dev/null
+++ b/src/structural_bio/stacking.ts
@@ -0,0 +1,14 @@
+/** structural_bio stacking module — tsb analytics library. */
+export interface StructuralBioStackingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioStackingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioStacking(data: number[], opts: StructuralBioStackingOptions = {}): StructuralBioStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioStacking };
diff --git a/src/structural_bio/standardization.ts b/src/structural_bio/standardization.ts
new file mode 100644
index 000000000..fd8d77848
--- /dev/null
+++ b/src/structural_bio/standardization.ts
@@ -0,0 +1,14 @@
+/** structural_bio standardization module — tsb analytics library. */
+export interface StructuralBioStandardizationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioStandardizationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioStandardization(data: number[], opts: StructuralBioStandardizationOptions = {}): StructuralBioStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioStandardization };
diff --git a/src/structural_bio/static.ts b/src/structural_bio/static.ts
new file mode 100644
index 000000000..c02253790
--- /dev/null
+++ b/src/structural_bio/static.ts
@@ -0,0 +1,14 @@
+/** structural_bio static module — tsb analytics library. */
+export interface StructuralBioStaticOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioStaticResult { values: number[]; converged: boolean; }
+export function computeStructuralBioStatic(data: number[], opts: StructuralBioStaticOptions = {}): StructuralBioStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioStatic };
diff --git a/src/structural_bio/stochastic.ts b/src/structural_bio/stochastic.ts
new file mode 100644
index 000000000..dad64411c
--- /dev/null
+++ b/src/structural_bio/stochastic.ts
@@ -0,0 +1,14 @@
+/** structural_bio stochastic module — tsb analytics library. */
+export interface StructuralBioStochasticOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioStochasticResult { values: number[]; converged: boolean; }
+export function computeStructuralBioStochastic(data: number[], opts: StructuralBioStochasticOptions = {}): StructuralBioStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioStochastic };
diff --git a/src/structural_bio/synthesis.ts b/src/structural_bio/synthesis.ts
new file mode 100644
index 000000000..85494e114
--- /dev/null
+++ b/src/structural_bio/synthesis.ts
@@ -0,0 +1,14 @@
+/** structural_bio synthesis module — tsb analytics library. */
+export interface StructuralBioSynthesisOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioSynthesisResult { values: number[]; converged: boolean; }
+export function computeStructuralBioSynthesis(data: number[], opts: StructuralBioSynthesisOptions = {}): StructuralBioSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioSynthesis };
diff --git a/src/structural_bio/topology.ts b/src/structural_bio/topology.ts
new file mode 100644
index 000000000..eee86fdc0
--- /dev/null
+++ b/src/structural_bio/topology.ts
@@ -0,0 +1,14 @@
+/** structural_bio topology module — tsb analytics library. */
+export interface StructuralBioTopologyOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioTopologyResult { values: number[]; converged: boolean; }
+export function computeStructuralBioTopology(data: number[], opts: StructuralBioTopologyOptions = {}): StructuralBioTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioTopology };
diff --git a/src/structural_bio/tracking.ts b/src/structural_bio/tracking.ts
new file mode 100644
index 000000000..090abf1c8
--- /dev/null
+++ b/src/structural_bio/tracking.ts
@@ -0,0 +1,14 @@
+/** structural_bio tracking module — tsb analytics library. */
+export interface StructuralBioTrackingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioTrackingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioTracking(data: number[], opts: StructuralBioTrackingOptions = {}): StructuralBioTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioTracking };
diff --git a/src/structural_bio/transform.ts b/src/structural_bio/transform.ts
new file mode 100644
index 000000000..69b778c9e
--- /dev/null
+++ b/src/structural_bio/transform.ts
@@ -0,0 +1,14 @@
+/** structural_bio transform module — tsb analytics library. */
+export interface StructuralBioTransformOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioTransformResult { values: number[]; converged: boolean; }
+export function computeStructuralBioTransform(data: number[], opts: StructuralBioTransformOptions = {}): StructuralBioTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioTransform };
diff --git a/src/structural_bio/uncertainty.ts b/src/structural_bio/uncertainty.ts
new file mode 100644
index 000000000..bb13f8db0
--- /dev/null
+++ b/src/structural_bio/uncertainty.ts
@@ -0,0 +1,14 @@
+/** structural_bio uncertainty module — tsb analytics library. */
+export interface StructuralBioUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioUncertaintyResult { values: number[]; converged: boolean; }
+export function computeStructuralBioUncertainty(data: number[], opts: StructuralBioUncertaintyOptions = {}): StructuralBioUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioUncertainty };
diff --git a/src/structural_bio/validation.ts b/src/structural_bio/validation.ts
new file mode 100644
index 000000000..30c1010cf
--- /dev/null
+++ b/src/structural_bio/validation.ts
@@ -0,0 +1,14 @@
+/** structural_bio validation module — tsb analytics library. */
+export interface StructuralBioValidationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioValidationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioValidation(data: number[], opts: StructuralBioValidationOptions = {}): StructuralBioValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioValidation };
diff --git a/src/structural_bio/verification.ts b/src/structural_bio/verification.ts
new file mode 100644
index 000000000..0d2be08dd
--- /dev/null
+++ b/src/structural_bio/verification.ts
@@ -0,0 +1,14 @@
+/** structural_bio verification module — tsb analytics library. */
+export interface StructuralBioVerificationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioVerificationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioVerification(data: number[], opts: StructuralBioVerificationOptions = {}): StructuralBioVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioVerification };
diff --git a/src/structural_bio/visualization.ts b/src/structural_bio/visualization.ts
new file mode 100644
index 000000000..5f6d5aa55
--- /dev/null
+++ b/src/structural_bio/visualization.ts
@@ -0,0 +1,14 @@
+/** structural_bio visualization module — tsb analytics library. */
+export interface StructuralBioVisualizationOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioVisualizationResult { values: number[]; converged: boolean; }
+export function computeStructuralBioVisualization(data: number[], opts: StructuralBioVisualizationOptions = {}): StructuralBioVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioVisualization };
diff --git a/src/structural_bio/voting.ts b/src/structural_bio/voting.ts
new file mode 100644
index 000000000..a4acc10de
--- /dev/null
+++ b/src/structural_bio/voting.ts
@@ -0,0 +1,14 @@
+/** structural_bio voting module — tsb analytics library. */
+export interface StructuralBioVotingOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioVotingResult { values: number[]; converged: boolean; }
+export function computeStructuralBioVoting(data: number[], opts: StructuralBioVotingOptions = {}): StructuralBioVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioVoting };
diff --git a/src/structural_bio/wavelet.ts b/src/structural_bio/wavelet.ts
new file mode 100644
index 000000000..acd5225be
--- /dev/null
+++ b/src/structural_bio/wavelet.ts
@@ -0,0 +1,14 @@
+/** structural_bio wavelet module — tsb analytics library. */
+export interface StructuralBioWaveletOptions { tol?: number; maxIter?: number; }
+export interface StructuralBioWaveletResult { values: number[]; converged: boolean; }
+export function computeStructuralBioWavelet(data: number[], opts: StructuralBioWaveletOptions = {}): StructuralBioWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeStructuralBioWavelet };
diff --git a/src/supply_chain/advanced.ts b/src/supply_chain/advanced.ts
new file mode 100644
index 000000000..7898c1b3c
--- /dev/null
+++ b/src/supply_chain/advanced.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Advanced module — tsb analytics library. */
+export interface SupplyChain advancedOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain advancedResult { values: number[]; converged: boolean; }
+export function computeSupplyChain advanced(data: number[], opts: SupplyChain advancedOptions = {}): SupplyChain advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain advanced };
diff --git a/src/supply_chain/base2.ts b/src/supply_chain/base2.ts
new file mode 100644
index 000000000..863f208fb
--- /dev/null
+++ b/src/supply_chain/base2.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Base2 module — tsb analytics library. */
+export interface SupplyChain base2Options { tol?: number; maxIter?: number; }
+export interface SupplyChain base2Result { values: number[]; converged: boolean; }
+export function computeSupplyChain base2(data: number[], opts: SupplyChain base2Options = {}): SupplyChain base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain base2 };
diff --git a/src/supply_chain/batch.ts b/src/supply_chain/batch.ts
new file mode 100644
index 000000000..a5e546c69
--- /dev/null
+++ b/src/supply_chain/batch.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Batch module — tsb analytics library. */
+export interface SupplyChain batchOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain batchResult { values: number[]; converged: boolean; }
+export function computeSupplyChain batch(data: number[], opts: SupplyChain batchOptions = {}): SupplyChain batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain batch };
diff --git a/src/supply_chain/beta.ts b/src/supply_chain/beta.ts
new file mode 100644
index 000000000..e805c42e2
--- /dev/null
+++ b/src/supply_chain/beta.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Beta module — tsb analytics library. */
+export interface SupplyChain betaOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain betaResult { values: number[]; converged: boolean; }
+export function computeSupplyChain beta(data: number[], opts: SupplyChain betaOptions = {}): SupplyChain betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain beta };
diff --git a/src/supply_chain/blockchain_sc.ts b/src/supply_chain/blockchain_sc.ts
new file mode 100644
index 000000000..fb78a9c33
--- /dev/null
+++ b/src/supply_chain/blockchain_sc.ts
@@ -0,0 +1,22 @@
+/** Blockchain Sc module — tsb analytics library. */
+
+/** Options for Blockchain Sc. */
+export interface BlockchainScOptions { tol?: number; maxIter?: number; }
+
+/** Result from Blockchain Sc. */
+export interface BlockchainScResult { values: number[]; converged: boolean; }
+
+/** Compute Blockchain Sc. */
+export function computeBlockchainSc(data: number[], opts: BlockchainScOptions = {}): BlockchainScResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeBlockchainSc };
diff --git a/src/supply_chain/capacity.ts b/src/supply_chain/capacity.ts
new file mode 100644
index 000000000..a7ce821ff
--- /dev/null
+++ b/src/supply_chain/capacity.ts
@@ -0,0 +1,22 @@
+/** Capacity module — tsb analytics library. */
+
+/** Options for Capacity. */
+export interface CapacityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Capacity. */
+export interface CapacityResult { values: number[]; converged: boolean; }
+
+/** Compute Capacity. */
+export function computeCapacity(data: number[], opts: CapacityOptions = {}): CapacityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCapacity };
diff --git a/src/supply_chain/circular_economy.ts b/src/supply_chain/circular_economy.ts
new file mode 100644
index 000000000..80f4d5b8b
--- /dev/null
+++ b/src/supply_chain/circular_economy.ts
@@ -0,0 +1,22 @@
+/** Circular Economy module — tsb analytics library. */
+
+/** Options for Circular Economy. */
+export interface CircularEconomyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Circular Economy. */
+export interface CircularEconomyResult { values: number[]; converged: boolean; }
+
+/** Compute Circular Economy. */
+export function computeCircularEconomy(data: number[], opts: CircularEconomyOptions = {}): CircularEconomyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCircularEconomy };
diff --git a/src/supply_chain/collaboration.ts b/src/supply_chain/collaboration.ts
new file mode 100644
index 000000000..6bc78de01
--- /dev/null
+++ b/src/supply_chain/collaboration.ts
@@ -0,0 +1,22 @@
+/** Collaboration module — tsb analytics library. */
+
+/** Options for Collaboration. */
+export interface CollaborationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Collaboration. */
+export interface CollaborationResult { values: number[]; converged: boolean; }
+
+/** Compute Collaboration. */
+export function computeCollaboration(data: number[], opts: CollaborationOptions = {}): CollaborationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCollaboration };
diff --git a/src/supply_chain/constraint.ts b/src/supply_chain/constraint.ts
new file mode 100644
index 000000000..8e833edaf
--- /dev/null
+++ b/src/supply_chain/constraint.ts
@@ -0,0 +1,22 @@
+/** Constraint module — tsb analytics library. */
+
+/** Options for Constraint. */
+export interface ConstraintOptions { tol?: number; maxIter?: number; }
+
+/** Result from Constraint. */
+export interface ConstraintResult { values: number[]; converged: boolean; }
+
+/** Compute Constraint. */
+export function computeConstraint(data: number[], opts: ConstraintOptions = {}): ConstraintResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeConstraint };
diff --git a/src/supply_chain/cpu.ts b/src/supply_chain/cpu.ts
new file mode 100644
index 000000000..a87f513a3
--- /dev/null
+++ b/src/supply_chain/cpu.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Cpu module — tsb analytics library. */
+export interface SupplyChain cpuOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain cpuResult { values: number[]; converged: boolean; }
+export function computeSupplyChain cpu(data: number[], opts: SupplyChain cpuOptions = {}): SupplyChain cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain cpu };
diff --git a/src/supply_chain/demand_forecasting.ts b/src/supply_chain/demand_forecasting.ts
new file mode 100644
index 000000000..0be8ce49b
--- /dev/null
+++ b/src/supply_chain/demand_forecasting.ts
@@ -0,0 +1,22 @@
+/** Demand Forecasting module — tsb analytics library. */
+
+/** Options for Demand Forecasting. */
+export interface DemandForecastingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Demand Forecasting. */
+export interface DemandForecastingResult { values: number[]; converged: boolean; }
+
+/** Compute Demand Forecasting. */
+export function computeDemandForecasting(data: number[], opts: DemandForecastingOptions = {}): DemandForecastingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDemandForecasting };
diff --git a/src/supply_chain/dense.ts b/src/supply_chain/dense.ts
new file mode 100644
index 000000000..b604d74e3
--- /dev/null
+++ b/src/supply_chain/dense.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Dense module — tsb analytics library. */
+export interface SupplyChain denseOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain denseResult { values: number[]; converged: boolean; }
+export function computeSupplyChain dense(data: number[], opts: SupplyChain denseOptions = {}): SupplyChain denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain dense };
diff --git a/src/supply_chain/digital_twin.ts b/src/supply_chain/digital_twin.ts
new file mode 100644
index 000000000..41e739cbb
--- /dev/null
+++ b/src/supply_chain/digital_twin.ts
@@ -0,0 +1,22 @@
+/** Digital Twin module — tsb analytics library. */
+
+/** Options for Digital Twin. */
+export interface DigitalTwinOptions { tol?: number; maxIter?: number; }
+
+/** Result from Digital Twin. */
+export interface DigitalTwinResult { values: number[]; converged: boolean; }
+
+/** Compute Digital Twin. */
+export function computeDigitalTwin(data: number[], opts: DigitalTwinOptions = {}): DigitalTwinResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDigitalTwin };
diff --git a/src/supply_chain/distributed.ts b/src/supply_chain/distributed.ts
new file mode 100644
index 000000000..5f5eee56e
--- /dev/null
+++ b/src/supply_chain/distributed.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Distributed module — tsb analytics library. */
+export interface SupplyChain distributedOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain distributedResult { values: number[]; converged: boolean; }
+export function computeSupplyChain distributed(data: number[], opts: SupplyChain distributedOptions = {}): SupplyChain distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain distributed };
diff --git a/src/supply_chain/distribution.ts b/src/supply_chain/distribution.ts
new file mode 100644
index 000000000..0d6b21d5e
--- /dev/null
+++ b/src/supply_chain/distribution.ts
@@ -0,0 +1,22 @@
+/** Distribution module — tsb analytics library. */
+
+/** Options for Distribution. */
+export interface DistributionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Distribution. */
+export interface DistributionResult { values: number[]; converged: boolean; }
+
+/** Compute Distribution. */
+export function computeDistribution(data: number[], opts: DistributionOptions = {}): DistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDistribution };
diff --git a/src/supply_chain/experimental.ts b/src/supply_chain/experimental.ts
new file mode 100644
index 000000000..1fd689200
--- /dev/null
+++ b/src/supply_chain/experimental.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Experimental module — tsb analytics library. */
+export interface SupplyChain experimentalOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain experimentalResult { values: number[]; converged: boolean; }
+export function computeSupplyChain experimental(data: number[], opts: SupplyChain experimentalOptions = {}): SupplyChain experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain experimental };
diff --git a/src/supply_chain/facility_location.ts b/src/supply_chain/facility_location.ts
new file mode 100644
index 000000000..1072ab26a
--- /dev/null
+++ b/src/supply_chain/facility_location.ts
@@ -0,0 +1,22 @@
+/** Facility Location module — tsb analytics library. */
+
+/** Options for Facility Location. */
+export interface FacilityLocationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Facility Location. */
+export interface FacilityLocationResult { values: number[]; converged: boolean; }
+
+/** Compute Facility Location. */
+export function computeFacilityLocation(data: number[], opts: FacilityLocationOptions = {}): FacilityLocationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFacilityLocation };
diff --git a/src/supply_chain/fast.ts b/src/supply_chain/fast.ts
new file mode 100644
index 000000000..0571f4c0e
--- /dev/null
+++ b/src/supply_chain/fast.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Fast module — tsb analytics library. */
+export interface SupplyChain fastOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain fastResult { values: number[]; converged: boolean; }
+export function computeSupplyChain fast(data: number[], opts: SupplyChain fastOptions = {}): SupplyChain fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain fast };
diff --git a/src/supply_chain/future.ts b/src/supply_chain/future.ts
new file mode 100644
index 000000000..100e35a49
--- /dev/null
+++ b/src/supply_chain/future.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Future module — tsb analytics library. */
+export interface SupplyChain futureOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain futureResult { values: number[]; converged: boolean; }
+export function computeSupplyChain future(data: number[], opts: SupplyChain futureOptions = {}): SupplyChain futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain future };
diff --git a/src/supply_chain/gpu.ts b/src/supply_chain/gpu.ts
new file mode 100644
index 000000000..19ab30b94
--- /dev/null
+++ b/src/supply_chain/gpu.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Gpu module — tsb analytics library. */
+export interface SupplyChain gpuOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain gpuResult { values: number[]; converged: boolean; }
+export function computeSupplyChain gpu(data: number[], opts: SupplyChain gpuOptions = {}): SupplyChain gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain gpu };
diff --git a/src/supply_chain/inventory.ts b/src/supply_chain/inventory.ts
new file mode 100644
index 000000000..4c3e7d7e8
--- /dev/null
+++ b/src/supply_chain/inventory.ts
@@ -0,0 +1,22 @@
+/** Inventory module — tsb analytics library. */
+
+/** Options for Inventory. */
+export interface InventoryOptions { tol?: number; maxIter?: number; }
+
+/** Result from Inventory. */
+export interface InventoryResult { values: number[]; converged: boolean; }
+
+/** Compute Inventory. */
+export function computeInventory(data: number[], opts: InventoryOptions = {}): InventoryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInventory };
diff --git a/src/supply_chain/iot_sc.ts b/src/supply_chain/iot_sc.ts
new file mode 100644
index 000000000..0d5161e65
--- /dev/null
+++ b/src/supply_chain/iot_sc.ts
@@ -0,0 +1,22 @@
+/** Iot Sc module — tsb analytics library. */
+
+/** Options for Iot Sc. */
+export interface IotScOptions { tol?: number; maxIter?: number; }
+
+/** Result from Iot Sc. */
+export interface IotScResult { values: number[]; converged: boolean; }
+
+/** Compute Iot Sc. */
+export function computeIotSc(data: number[], opts: IotScOptions = {}): IotScResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIotSc };
diff --git a/src/supply_chain/large.ts b/src/supply_chain/large.ts
new file mode 100644
index 000000000..a21f86c39
--- /dev/null
+++ b/src/supply_chain/large.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Large module — tsb analytics library. */
+export interface SupplyChain largeOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain largeResult { values: number[]; converged: boolean; }
+export function computeSupplyChain large(data: number[], opts: SupplyChain largeOptions = {}): SupplyChain largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain large };
diff --git a/src/supply_chain/last_mile.ts b/src/supply_chain/last_mile.ts
new file mode 100644
index 000000000..f2b009ca1
--- /dev/null
+++ b/src/supply_chain/last_mile.ts
@@ -0,0 +1,22 @@
+/** Last Mile module — tsb analytics library. */
+
+/** Options for Last Mile. */
+export interface LastMileOptions { tol?: number; maxIter?: number; }
+
+/** Result from Last Mile. */
+export interface LastMileResult { values: number[]; converged: boolean; }
+
+/** Compute Last Mile. */
+export function computeLastMile(data: number[], opts: LastMileOptions = {}): LastMileResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLastMile };
diff --git a/src/supply_chain/legacy.ts b/src/supply_chain/legacy.ts
new file mode 100644
index 000000000..4eb806782
--- /dev/null
+++ b/src/supply_chain/legacy.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Legacy module — tsb analytics library. */
+export interface SupplyChain legacyOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain legacyResult { values: number[]; converged: boolean; }
+export function computeSupplyChain legacy(data: number[], opts: SupplyChain legacyOptions = {}): SupplyChain legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain legacy };
diff --git a/src/supply_chain/lite.ts b/src/supply_chain/lite.ts
new file mode 100644
index 000000000..601f006c7
--- /dev/null
+++ b/src/supply_chain/lite.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Lite module — tsb analytics library. */
+export interface SupplyChain liteOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain liteResult { values: number[]; converged: boolean; }
+export function computeSupplyChain lite(data: number[], opts: SupplyChain liteOptions = {}): SupplyChain liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain lite };
diff --git a/src/supply_chain/mini.ts b/src/supply_chain/mini.ts
new file mode 100644
index 000000000..4f7b2eb93
--- /dev/null
+++ b/src/supply_chain/mini.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Mini module — tsb analytics library. */
+export interface SupplyChain miniOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain miniResult { values: number[]; converged: boolean; }
+export function computeSupplyChain mini(data: number[], opts: SupplyChain miniOptions = {}): SupplyChain miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain mini };
diff --git a/src/supply_chain/next.ts b/src/supply_chain/next.ts
new file mode 100644
index 000000000..41edb0b92
--- /dev/null
+++ b/src/supply_chain/next.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Next module — tsb analytics library. */
+export interface SupplyChain nextOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain nextResult { values: number[]; converged: boolean; }
+export function computeSupplyChain next(data: number[], opts: SupplyChain nextOptions = {}): SupplyChain nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain next };
diff --git a/src/supply_chain/online.ts b/src/supply_chain/online.ts
new file mode 100644
index 000000000..9761b7c74
--- /dev/null
+++ b/src/supply_chain/online.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Online module — tsb analytics library. */
+export interface SupplyChain onlineOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain onlineResult { values: number[]; converged: boolean; }
+export function computeSupplyChain online(data: number[], opts: SupplyChain onlineOptions = {}): SupplyChain onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain online };
diff --git a/src/supply_chain/optimization_sc.ts b/src/supply_chain/optimization_sc.ts
new file mode 100644
index 000000000..646cfbb36
--- /dev/null
+++ b/src/supply_chain/optimization_sc.ts
@@ -0,0 +1,22 @@
+/** Optimization Sc module — tsb analytics library. */
+
+/** Options for Optimization Sc. */
+export interface OptimizationScOptions { tol?: number; maxIter?: number; }
+
+/** Result from Optimization Sc. */
+export interface OptimizationScResult { values: number[]; converged: boolean; }
+
+/** Compute Optimization Sc. */
+export function computeOptimizationSc(data: number[], opts: OptimizationScOptions = {}): OptimizationScResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeOptimizationSc };
diff --git a/src/supply_chain/parallel.ts b/src/supply_chain/parallel.ts
new file mode 100644
index 000000000..fe7d31c11
--- /dev/null
+++ b/src/supply_chain/parallel.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Parallel module — tsb analytics library. */
+export interface SupplyChain parallelOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain parallelResult { values: number[]; converged: boolean; }
+export function computeSupplyChain parallel(data: number[], opts: SupplyChain parallelOptions = {}): SupplyChain parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain parallel };
diff --git a/src/supply_chain/plus.ts b/src/supply_chain/plus.ts
new file mode 100644
index 000000000..e188dad2e
--- /dev/null
+++ b/src/supply_chain/plus.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Plus module — tsb analytics library. */
+export interface SupplyChain plusOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain plusResult { values: number[]; converged: boolean; }
+export function computeSupplyChain plus(data: number[], opts: SupplyChain plusOptions = {}): SupplyChain plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain plus };
diff --git a/src/supply_chain/pro.ts b/src/supply_chain/pro.ts
new file mode 100644
index 000000000..aa3861464
--- /dev/null
+++ b/src/supply_chain/pro.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Pro module — tsb analytics library. */
+export interface SupplyChain proOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain proResult { values: number[]; converged: boolean; }
+export function computeSupplyChain pro(data: number[], opts: SupplyChain proOptions = {}): SupplyChain proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain pro };
diff --git a/src/supply_chain/procurement.ts b/src/supply_chain/procurement.ts
new file mode 100644
index 000000000..7c0e53ff7
--- /dev/null
+++ b/src/supply_chain/procurement.ts
@@ -0,0 +1,22 @@
+/** Procurement module — tsb analytics library. */
+
+/** Options for Procurement. */
+export interface ProcurementOptions { tol?: number; maxIter?: number; }
+
+/** Result from Procurement. */
+export interface ProcurementResult { values: number[]; converged: boolean; }
+
+/** Compute Procurement. */
+export function computeProcurement(data: number[], opts: ProcurementOptions = {}): ProcurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProcurement };
diff --git a/src/supply_chain/production_planning.ts b/src/supply_chain/production_planning.ts
new file mode 100644
index 000000000..e545f8b53
--- /dev/null
+++ b/src/supply_chain/production_planning.ts
@@ -0,0 +1,22 @@
+/** Production Planning module — tsb analytics library. */
+
+/** Options for Production Planning. */
+export interface ProductionPlanningOptions { tol?: number; maxIter?: number; }
+
+/** Result from Production Planning. */
+export interface ProductionPlanningResult { values: number[]; converged: boolean; }
+
+/** Compute Production Planning. */
+export function computeProductionPlanning(data: number[], opts: ProductionPlanningOptions = {}): ProductionPlanningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProductionPlanning };
diff --git a/src/supply_chain/quality.ts b/src/supply_chain/quality.ts
new file mode 100644
index 000000000..bf7f8c234
--- /dev/null
+++ b/src/supply_chain/quality.ts
@@ -0,0 +1,22 @@
+/** Quality module — tsb analytics library. */
+
+/** Options for Quality. */
+export interface QualityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Quality. */
+export interface QualityResult { values: number[]; converged: boolean; }
+
+/** Compute Quality. */
+export function computeQuality(data: number[], opts: QualityOptions = {}): QualityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeQuality };
diff --git a/src/supply_chain/resilience.ts b/src/supply_chain/resilience.ts
new file mode 100644
index 000000000..e5021990a
--- /dev/null
+++ b/src/supply_chain/resilience.ts
@@ -0,0 +1,22 @@
+/** Resilience module — tsb analytics library. */
+
+/** Options for Resilience. */
+export interface ResilienceOptions { tol?: number; maxIter?: number; }
+
+/** Result from Resilience. */
+export interface ResilienceResult { values: number[]; converged: boolean; }
+
+/** Compute Resilience. */
+export function computeResilience(data: number[], opts: ResilienceOptions = {}): ResilienceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeResilience };
diff --git a/src/supply_chain/reverse_logistics.ts b/src/supply_chain/reverse_logistics.ts
new file mode 100644
index 000000000..82e2415b0
--- /dev/null
+++ b/src/supply_chain/reverse_logistics.ts
@@ -0,0 +1,22 @@
+/** Reverse Logistics module — tsb analytics library. */
+
+/** Options for Reverse Logistics. */
+export interface ReverseLogisticsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reverse Logistics. */
+export interface ReverseLogisticsResult { values: number[]; converged: boolean; }
+
+/** Compute Reverse Logistics. */
+export function computeReverseLogistics(data: number[], opts: ReverseLogisticsOptions = {}): ReverseLogisticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReverseLogistics };
diff --git a/src/supply_chain/risk_supply.ts b/src/supply_chain/risk_supply.ts
new file mode 100644
index 000000000..f34fd783d
--- /dev/null
+++ b/src/supply_chain/risk_supply.ts
@@ -0,0 +1,22 @@
+/** Risk Supply module — tsb analytics library. */
+
+/** Options for Risk Supply. */
+export interface RiskSupplyOptions { tol?: number; maxIter?: number; }
+
+/** Result from Risk Supply. */
+export interface RiskSupplyResult { values: number[]; converged: boolean; }
+
+/** Compute Risk Supply. */
+export function computeRiskSupply(data: number[], opts: RiskSupplyOptions = {}): RiskSupplyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRiskSupply };
diff --git a/src/supply_chain/robust.ts b/src/supply_chain/robust.ts
new file mode 100644
index 000000000..5fcc43218
--- /dev/null
+++ b/src/supply_chain/robust.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Robust module — tsb analytics library. */
+export interface SupplyChain robustOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain robustResult { values: number[]; converged: boolean; }
+export function computeSupplyChain robust(data: number[], opts: SupplyChain robustOptions = {}): SupplyChain robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain robust };
diff --git a/src/supply_chain/routing.ts b/src/supply_chain/routing.ts
new file mode 100644
index 000000000..3de2357ea
--- /dev/null
+++ b/src/supply_chain/routing.ts
@@ -0,0 +1,22 @@
+/** Routing module — tsb analytics library. */
+
+/** Options for Routing. */
+export interface RoutingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Routing. */
+export interface RoutingResult { values: number[]; converged: boolean; }
+
+/** Compute Routing. */
+export function computeRouting(data: number[], opts: RoutingOptions = {}): RoutingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRouting };
diff --git a/src/supply_chain/scheduling.ts b/src/supply_chain/scheduling.ts
new file mode 100644
index 000000000..abf9ca6e2
--- /dev/null
+++ b/src/supply_chain/scheduling.ts
@@ -0,0 +1,22 @@
+/** Scheduling module — tsb analytics library. */
+
+/** Options for Scheduling. */
+export interface SchedulingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Scheduling. */
+export interface SchedulingResult { values: number[]; converged: boolean; }
+
+/** Compute Scheduling. */
+export function computeScheduling(data: number[], opts: SchedulingOptions = {}): SchedulingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeScheduling };
diff --git a/src/supply_chain/simulation_sc.ts b/src/supply_chain/simulation_sc.ts
new file mode 100644
index 000000000..13b01419e
--- /dev/null
+++ b/src/supply_chain/simulation_sc.ts
@@ -0,0 +1,22 @@
+/** Simulation Sc module — tsb analytics library. */
+
+/** Options for Simulation Sc. */
+export interface SimulationScOptions { tol?: number; maxIter?: number; }
+
+/** Result from Simulation Sc. */
+export interface SimulationScResult { values: number[]; converged: boolean; }
+
+/** Compute Simulation Sc. */
+export function computeSimulationSc(data: number[], opts: SimulationScOptions = {}): SimulationScResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSimulationSc };
diff --git a/src/supply_chain/small.ts b/src/supply_chain/small.ts
new file mode 100644
index 000000000..c617f0901
--- /dev/null
+++ b/src/supply_chain/small.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Small module — tsb analytics library. */
+export interface SupplyChain smallOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain smallResult { values: number[]; converged: boolean; }
+export function computeSupplyChain small(data: number[], opts: SupplyChain smallOptions = {}): SupplyChain smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain small };
diff --git a/src/supply_chain/sourcing.ts b/src/supply_chain/sourcing.ts
new file mode 100644
index 000000000..935b59c31
--- /dev/null
+++ b/src/supply_chain/sourcing.ts
@@ -0,0 +1,22 @@
+/** Sourcing module — tsb analytics library. */
+
+/** Options for Sourcing. */
+export interface SourcingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sourcing. */
+export interface SourcingResult { values: number[]; converged: boolean; }
+
+/** Compute Sourcing. */
+export function computeSourcing(data: number[], opts: SourcingOptions = {}): SourcingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSourcing };
diff --git a/src/supply_chain/sparse.ts b/src/supply_chain/sparse.ts
new file mode 100644
index 000000000..31c257721
--- /dev/null
+++ b/src/supply_chain/sparse.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Sparse module — tsb analytics library. */
+export interface SupplyChain sparseOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain sparseResult { values: number[]; converged: boolean; }
+export function computeSupplyChain sparse(data: number[], opts: SupplyChain sparseOptions = {}): SupplyChain sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain sparse };
diff --git a/src/supply_chain/stable.ts b/src/supply_chain/stable.ts
new file mode 100644
index 000000000..90ef92312
--- /dev/null
+++ b/src/supply_chain/stable.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Stable module — tsb analytics library. */
+export interface SupplyChain stableOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain stableResult { values: number[]; converged: boolean; }
+export function computeSupplyChain stable(data: number[], opts: SupplyChain stableOptions = {}): SupplyChain stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain stable };
diff --git a/src/supply_chain/streaming.ts b/src/supply_chain/streaming.ts
new file mode 100644
index 000000000..498740e7b
--- /dev/null
+++ b/src/supply_chain/streaming.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Streaming module — tsb analytics library. */
+export interface SupplyChain streamingOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain streamingResult { values: number[]; converged: boolean; }
+export function computeSupplyChain streaming(data: number[], opts: SupplyChain streamingOptions = {}): SupplyChain streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain streaming };
diff --git a/src/supply_chain/supplier.ts b/src/supply_chain/supplier.ts
new file mode 100644
index 000000000..41da11007
--- /dev/null
+++ b/src/supply_chain/supplier.ts
@@ -0,0 +1,22 @@
+/** Supplier module — tsb analytics library. */
+
+/** Options for Supplier. */
+export interface SupplierOptions { tol?: number; maxIter?: number; }
+
+/** Result from Supplier. */
+export interface SupplierResult { values: number[]; converged: boolean; }
+
+/** Compute Supplier. */
+export function computeSupplier(data: number[], opts: SupplierOptions = {}): SupplierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSupplier };
diff --git a/src/supply_chain/sustainability.ts b/src/supply_chain/sustainability.ts
new file mode 100644
index 000000000..77749fa82
--- /dev/null
+++ b/src/supply_chain/sustainability.ts
@@ -0,0 +1,22 @@
+/** Sustainability module — tsb analytics library. */
+
+/** Options for Sustainability. */
+export interface SustainabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sustainability. */
+export interface SustainabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Sustainability. */
+export function computeSustainability(data: number[], opts: SustainabilityOptions = {}): SustainabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSustainability };
diff --git a/src/supply_chain/traceability.ts b/src/supply_chain/traceability.ts
new file mode 100644
index 000000000..87d655ba9
--- /dev/null
+++ b/src/supply_chain/traceability.ts
@@ -0,0 +1,22 @@
+/** Traceability module — tsb analytics library. */
+
+/** Options for Traceability. */
+export interface TraceabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Traceability. */
+export interface TraceabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Traceability. */
+export function computeTraceability(data: number[], opts: TraceabilityOptions = {}): TraceabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTraceability };
diff --git a/src/supply_chain/v2.ts b/src/supply_chain/v2.ts
new file mode 100644
index 000000000..c83b58539
--- /dev/null
+++ b/src/supply_chain/v2.ts
@@ -0,0 +1,15 @@
+/** Supply Chain V2 module — tsb analytics library. */
+export interface SupplyChain v2Options { tol?: number; maxIter?: number; }
+export interface SupplyChain v2Result { values: number[]; converged: boolean; }
+export function computeSupplyChain v2(data: number[], opts: SupplyChain v2Options = {}): SupplyChain v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain v2 };
diff --git a/src/supply_chain/v3.ts b/src/supply_chain/v3.ts
new file mode 100644
index 000000000..3c8df8447
--- /dev/null
+++ b/src/supply_chain/v3.ts
@@ -0,0 +1,15 @@
+/** Supply Chain V3 module — tsb analytics library. */
+export interface SupplyChain v3Options { tol?: number; maxIter?: number; }
+export interface SupplyChain v3Result { values: number[]; converged: boolean; }
+export function computeSupplyChain v3(data: number[], opts: SupplyChain v3Options = {}): SupplyChain v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain v3 };
diff --git a/src/supply_chain/vehicle_routing.ts b/src/supply_chain/vehicle_routing.ts
new file mode 100644
index 000000000..5714bd55f
--- /dev/null
+++ b/src/supply_chain/vehicle_routing.ts
@@ -0,0 +1,22 @@
+/** Vehicle Routing module — tsb analytics library. */
+
+/** Options for Vehicle Routing. */
+export interface VehicleRoutingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vehicle Routing. */
+export interface VehicleRoutingResult { values: number[]; converged: boolean; }
+
+/** Compute Vehicle Routing. */
+export function computeVehicleRouting(data: number[], opts: VehicleRoutingOptions = {}): VehicleRoutingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVehicleRouting };
diff --git a/src/supply_chain/visibility.ts b/src/supply_chain/visibility.ts
new file mode 100644
index 000000000..45f7c93f6
--- /dev/null
+++ b/src/supply_chain/visibility.ts
@@ -0,0 +1,22 @@
+/** Visibility module — tsb analytics library. */
+
+/** Options for Visibility. */
+export interface VisibilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Visibility. */
+export interface VisibilityResult { values: number[]; converged: boolean; }
+
+/** Compute Visibility. */
+export function computeVisibility(data: number[], opts: VisibilityOptions = {}): VisibilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVisibility };
diff --git a/src/supply_chain/warehouse.ts b/src/supply_chain/warehouse.ts
new file mode 100644
index 000000000..0a6691932
--- /dev/null
+++ b/src/supply_chain/warehouse.ts
@@ -0,0 +1,22 @@
+/** Warehouse module — tsb analytics library. */
+
+/** Options for Warehouse. */
+export interface WarehouseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Warehouse. */
+export interface WarehouseResult { values: number[]; converged: boolean; }
+
+/** Compute Warehouse. */
+export function computeWarehouse(data: number[], opts: WarehouseOptions = {}): WarehouseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWarehouse };
diff --git a/src/supply_chain/wasm.ts b/src/supply_chain/wasm.ts
new file mode 100644
index 000000000..8d5674248
--- /dev/null
+++ b/src/supply_chain/wasm.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Wasm module — tsb analytics library. */
+export interface SupplyChain wasmOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain wasmResult { values: number[]; converged: boolean; }
+export function computeSupplyChain wasm(data: number[], opts: SupplyChain wasmOptions = {}): SupplyChain wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain wasm };
diff --git a/src/supply_chain/xlarge.ts b/src/supply_chain/xlarge.ts
new file mode 100644
index 000000000..21d32b2a9
--- /dev/null
+++ b/src/supply_chain/xlarge.ts
@@ -0,0 +1,15 @@
+/** Supply Chain Xlarge module — tsb analytics library. */
+export interface SupplyChain xlargeOptions { tol?: number; maxIter?: number; }
+export interface SupplyChain xlargeResult { values: number[]; converged: boolean; }
+export function computeSupplyChain xlarge(data: number[], opts: SupplyChain xlargeOptions = {}): SupplyChain xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSupplyChain xlarge };
diff --git a/src/supply_chain/yield.ts b/src/supply_chain/yield.ts
new file mode 100644
index 000000000..d1e9b2278
--- /dev/null
+++ b/src/supply_chain/yield.ts
@@ -0,0 +1,22 @@
+/** Yield module — tsb analytics library. */
+
+/** Options for Yield. */
+export interface YieldOptions { tol?: number; maxIter?: number; }
+
+/** Result from Yield. */
+export interface YieldResult { values: number[]; converged: boolean; }
+
+/** Compute Yield. */
+export function computeYield(data: number[], opts: YieldOptions = {}): YieldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeYield };
diff --git a/src/surface_sci/adaptation.ts b/src/surface_sci/adaptation.ts
new file mode 100644
index 000000000..9cc65573b
--- /dev/null
+++ b/src/surface_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** surface_sci adaptation module — tsb analytics library. */
+export interface SurfaceSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciAdaptation(data: number[], opts: SurfaceSciAdaptationOptions = {}): SurfaceSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciAdaptation };
diff --git a/src/surface_sci/aggregation.ts b/src/surface_sci/aggregation.ts
new file mode 100644
index 000000000..c9ae2e3ed
--- /dev/null
+++ b/src/surface_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** surface_sci aggregation module — tsb analytics library. */
+export interface SurfaceSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciAggregationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciAggregation(data: number[], opts: SurfaceSciAggregationOptions = {}): SurfaceSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciAggregation };
diff --git a/src/surface_sci/algebra.ts b/src/surface_sci/algebra.ts
new file mode 100644
index 000000000..88001426d
--- /dev/null
+++ b/src/surface_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** surface_sci algebra module — tsb analytics library. */
+export interface SurfaceSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciAlgebra(data: number[], opts: SurfaceSciAlgebraOptions = {}): SurfaceSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciAlgebra };
diff --git a/src/surface_sci/alignment.ts b/src/surface_sci/alignment.ts
new file mode 100644
index 000000000..af549143e
--- /dev/null
+++ b/src/surface_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** surface_sci alignment module — tsb analytics library. */
+export interface SurfaceSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciAlignment(data: number[], opts: SurfaceSciAlignmentOptions = {}): SurfaceSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciAlignment };
diff --git a/src/surface_sci/analysis.ts b/src/surface_sci/analysis.ts
new file mode 100644
index 000000000..f42968354
--- /dev/null
+++ b/src/surface_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** surface_sci analysis module — tsb analytics library. */
+export interface SurfaceSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciAnalysis(data: number[], opts: SurfaceSciAnalysisOptions = {}): SurfaceSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciAnalysis };
diff --git a/src/surface_sci/augmentation.ts b/src/surface_sci/augmentation.ts
new file mode 100644
index 000000000..d7ae6f1b3
--- /dev/null
+++ b/src/surface_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** surface_sci augmentation module — tsb analytics library. */
+export interface SurfaceSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciAugmentation(data: number[], opts: SurfaceSciAugmentationOptions = {}): SurfaceSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciAugmentation };
diff --git a/src/surface_sci/bagging.ts b/src/surface_sci/bagging.ts
new file mode 100644
index 000000000..b54ef329a
--- /dev/null
+++ b/src/surface_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** surface_sci bagging module — tsb analytics library. */
+export interface SurfaceSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciBaggingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciBagging(data: number[], opts: SurfaceSciBaggingOptions = {}): SurfaceSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciBagging };
diff --git a/src/surface_sci/basis.ts b/src/surface_sci/basis.ts
new file mode 100644
index 000000000..74266c8f0
--- /dev/null
+++ b/src/surface_sci/basis.ts
@@ -0,0 +1,14 @@
+/** surface_sci basis module — tsb analytics library. */
+export interface SurfaceSciBasisOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciBasisResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciBasis(data: number[], opts: SurfaceSciBasisOptions = {}): SurfaceSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciBasis };
diff --git a/src/surface_sci/benchmarking.ts b/src/surface_sci/benchmarking.ts
new file mode 100644
index 000000000..bb3267e38
--- /dev/null
+++ b/src/surface_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** surface_sci benchmarking module — tsb analytics library. */
+export interface SurfaceSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciBenchmarking(data: number[], opts: SurfaceSciBenchmarkingOptions = {}): SurfaceSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciBenchmarking };
diff --git a/src/surface_sci/blending.ts b/src/surface_sci/blending.ts
new file mode 100644
index 000000000..e4a339d04
--- /dev/null
+++ b/src/surface_sci/blending.ts
@@ -0,0 +1,14 @@
+/** surface_sci blending module — tsb analytics library. */
+export interface SurfaceSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciBlendingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciBlending(data: number[], opts: SurfaceSciBlendingOptions = {}): SurfaceSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciBlending };
diff --git a/src/surface_sci/boosting.ts b/src/surface_sci/boosting.ts
new file mode 100644
index 000000000..06b4c03a2
--- /dev/null
+++ b/src/surface_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** surface_sci boosting module — tsb analytics library. */
+export interface SurfaceSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciBoostingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciBoosting(data: number[], opts: SurfaceSciBoostingOptions = {}): SurfaceSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciBoosting };
diff --git a/src/surface_sci/bootstrap.ts b/src/surface_sci/bootstrap.ts
new file mode 100644
index 000000000..3f754b08a
--- /dev/null
+++ b/src/surface_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** surface_sci bootstrap module — tsb analytics library. */
+export interface SurfaceSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciBootstrap(data: number[], opts: SurfaceSciBootstrapOptions = {}): SurfaceSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciBootstrap };
diff --git a/src/surface_sci/calculus.ts b/src/surface_sci/calculus.ts
new file mode 100644
index 000000000..1c05544a9
--- /dev/null
+++ b/src/surface_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** surface_sci calculus module — tsb analytics library. */
+export interface SurfaceSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciCalculusResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciCalculus(data: number[], opts: SurfaceSciCalculusOptions = {}): SurfaceSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciCalculus };
diff --git a/src/surface_sci/calibration.ts b/src/surface_sci/calibration.ts
new file mode 100644
index 000000000..3179856ac
--- /dev/null
+++ b/src/surface_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** surface_sci calibration module — tsb analytics library. */
+export interface SurfaceSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciCalibration(data: number[], opts: SurfaceSciCalibrationOptions = {}): SurfaceSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciCalibration };
diff --git a/src/surface_sci/characterization.ts b/src/surface_sci/characterization.ts
new file mode 100644
index 000000000..c50b91dff
--- /dev/null
+++ b/src/surface_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** surface_sci characterization module — tsb analytics library. */
+export interface SurfaceSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciCharacterization(data: number[], opts: SurfaceSciCharacterizationOptions = {}): SurfaceSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciCharacterization };
diff --git a/src/surface_sci/classification.ts b/src/surface_sci/classification.ts
new file mode 100644
index 000000000..55703216a
--- /dev/null
+++ b/src/surface_sci/classification.ts
@@ -0,0 +1,14 @@
+/** surface_sci classification module — tsb analytics library. */
+export interface SurfaceSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciClassificationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciClassification(data: number[], opts: SurfaceSciClassificationOptions = {}): SurfaceSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciClassification };
diff --git a/src/surface_sci/clustering.ts b/src/surface_sci/clustering.ts
new file mode 100644
index 000000000..1bed58a75
--- /dev/null
+++ b/src/surface_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** surface_sci clustering module — tsb analytics library. */
+export interface SurfaceSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciClusteringResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciClustering(data: number[], opts: SurfaceSciClusteringOptions = {}): SurfaceSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciClustering };
diff --git a/src/surface_sci/compression.ts b/src/surface_sci/compression.ts
new file mode 100644
index 000000000..cd88eb925
--- /dev/null
+++ b/src/surface_sci/compression.ts
@@ -0,0 +1,14 @@
+/** surface_sci compression module — tsb analytics library. */
+export interface SurfaceSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciCompressionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciCompression(data: number[], opts: SurfaceSciCompressionOptions = {}): SurfaceSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciCompression };
diff --git a/src/surface_sci/continuous.ts b/src/surface_sci/continuous.ts
new file mode 100644
index 000000000..11c2e77ec
--- /dev/null
+++ b/src/surface_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** surface_sci continuous module — tsb analytics library. */
+export interface SurfaceSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciContinuousResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciContinuous(data: number[], opts: SurfaceSciContinuousOptions = {}): SurfaceSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciContinuous };
diff --git a/src/surface_sci/control.ts b/src/surface_sci/control.ts
new file mode 100644
index 000000000..83089f5ca
--- /dev/null
+++ b/src/surface_sci/control.ts
@@ -0,0 +1,14 @@
+/** surface_sci control module — tsb analytics library. */
+export interface SurfaceSciControlOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciControlResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciControl(data: number[], opts: SurfaceSciControlOptions = {}): SurfaceSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciControl };
diff --git a/src/surface_sci/convergence.ts b/src/surface_sci/convergence.ts
new file mode 100644
index 000000000..a41186b15
--- /dev/null
+++ b/src/surface_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** surface_sci convergence module — tsb analytics library. */
+export interface SurfaceSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciConvergence(data: number[], opts: SurfaceSciConvergenceOptions = {}): SurfaceSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciConvergence };
diff --git a/src/surface_sci/convex.ts b/src/surface_sci/convex.ts
new file mode 100644
index 000000000..fd2f81a7c
--- /dev/null
+++ b/src/surface_sci/convex.ts
@@ -0,0 +1,14 @@
+/** surface_sci convex module — tsb analytics library. */
+export interface SurfaceSciConvexOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciConvexResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciConvex(data: number[], opts: SurfaceSciConvexOptions = {}): SurfaceSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciConvex };
diff --git a/src/surface_sci/correlation.ts b/src/surface_sci/correlation.ts
new file mode 100644
index 000000000..1836e7b22
--- /dev/null
+++ b/src/surface_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** surface_sci correlation module — tsb analytics library. */
+export interface SurfaceSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciCorrelation(data: number[], opts: SurfaceSciCorrelationOptions = {}): SurfaceSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciCorrelation };
diff --git a/src/surface_sci/covariance.ts b/src/surface_sci/covariance.ts
new file mode 100644
index 000000000..dba0083f5
--- /dev/null
+++ b/src/surface_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** surface_sci covariance module — tsb analytics library. */
+export interface SurfaceSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciCovariance(data: number[], opts: SurfaceSciCovarianceOptions = {}): SurfaceSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciCovariance };
diff --git a/src/surface_sci/cross_validation.ts b/src/surface_sci/cross_validation.ts
new file mode 100644
index 000000000..9c80228c5
--- /dev/null
+++ b/src/surface_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** surface_sci cross_validation module — tsb analytics library. */
+export interface SurfaceSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciCrossValidation(data: number[], opts: SurfaceSciCrossValidationOptions = {}): SurfaceSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciCrossValidation };
diff --git a/src/surface_sci/decoding.ts b/src/surface_sci/decoding.ts
new file mode 100644
index 000000000..04cf21f02
--- /dev/null
+++ b/src/surface_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** surface_sci decoding module — tsb analytics library. */
+export interface SurfaceSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDecodingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDecoding(data: number[], opts: SurfaceSciDecodingOptions = {}): SurfaceSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDecoding };
diff --git a/src/surface_sci/decomposition.ts b/src/surface_sci/decomposition.ts
new file mode 100644
index 000000000..d0335a1a8
--- /dev/null
+++ b/src/surface_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** surface_sci decomposition module — tsb analytics library. */
+export interface SurfaceSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDecomposition(data: number[], opts: SurfaceSciDecompositionOptions = {}): SurfaceSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDecomposition };
diff --git a/src/surface_sci/detection.ts b/src/surface_sci/detection.ts
new file mode 100644
index 000000000..2d1c7e6fc
--- /dev/null
+++ b/src/surface_sci/detection.ts
@@ -0,0 +1,14 @@
+/** surface_sci detection module — tsb analytics library. */
+export interface SurfaceSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDetectionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDetection(data: number[], opts: SurfaceSciDetectionOptions = {}): SurfaceSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDetection };
diff --git a/src/surface_sci/deterministic.ts b/src/surface_sci/deterministic.ts
new file mode 100644
index 000000000..89a68a4a7
--- /dev/null
+++ b/src/surface_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** surface_sci deterministic module — tsb analytics library. */
+export interface SurfaceSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDeterministic(data: number[], opts: SurfaceSciDeterministicOptions = {}): SurfaceSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDeterministic };
diff --git a/src/surface_sci/diagnostics.ts b/src/surface_sci/diagnostics.ts
new file mode 100644
index 000000000..fc4b406be
--- /dev/null
+++ b/src/surface_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** surface_sci diagnostics module — tsb analytics library. */
+export interface SurfaceSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDiagnostics(data: number[], opts: SurfaceSciDiagnosticsOptions = {}): SurfaceSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDiagnostics };
diff --git a/src/surface_sci/differential.ts b/src/surface_sci/differential.ts
new file mode 100644
index 000000000..e298fa94b
--- /dev/null
+++ b/src/surface_sci/differential.ts
@@ -0,0 +1,14 @@
+/** surface_sci differential module — tsb analytics library. */
+export interface SurfaceSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDifferential(data: number[], opts: SurfaceSciDifferentialOptions = {}): SurfaceSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDifferential };
diff --git a/src/surface_sci/discrete.ts b/src/surface_sci/discrete.ts
new file mode 100644
index 000000000..2654806cd
--- /dev/null
+++ b/src/surface_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** surface_sci discrete module — tsb analytics library. */
+export interface SurfaceSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDiscrete(data: number[], opts: SurfaceSciDiscreteOptions = {}): SurfaceSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDiscrete };
diff --git a/src/surface_sci/distribution.ts b/src/surface_sci/distribution.ts
new file mode 100644
index 000000000..5a566950a
--- /dev/null
+++ b/src/surface_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** surface_sci distribution module — tsb analytics library. */
+export interface SurfaceSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDistributionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDistribution(data: number[], opts: SurfaceSciDistributionOptions = {}): SurfaceSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDistribution };
diff --git a/src/surface_sci/dynamic.ts b/src/surface_sci/dynamic.ts
new file mode 100644
index 000000000..8bf9b54bd
--- /dev/null
+++ b/src/surface_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** surface_sci dynamic module — tsb analytics library. */
+export interface SurfaceSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciDynamicResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciDynamic(data: number[], opts: SurfaceSciDynamicOptions = {}): SurfaceSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciDynamic };
diff --git a/src/surface_sci/embedding.ts b/src/surface_sci/embedding.ts
new file mode 100644
index 000000000..e36a8fee6
--- /dev/null
+++ b/src/surface_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** surface_sci embedding module — tsb analytics library. */
+export interface SurfaceSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciEmbedding(data: number[], opts: SurfaceSciEmbeddingOptions = {}): SurfaceSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciEmbedding };
diff --git a/src/surface_sci/encoding.ts b/src/surface_sci/encoding.ts
new file mode 100644
index 000000000..d229e7373
--- /dev/null
+++ b/src/surface_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** surface_sci encoding module — tsb analytics library. */
+export interface SurfaceSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciEncodingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciEncoding(data: number[], opts: SurfaceSciEncodingOptions = {}): SurfaceSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciEncoding };
diff --git a/src/surface_sci/ensemble.ts b/src/surface_sci/ensemble.ts
new file mode 100644
index 000000000..c6b21b076
--- /dev/null
+++ b/src/surface_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** surface_sci ensemble module — tsb analytics library. */
+export interface SurfaceSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciEnsemble(data: number[], opts: SurfaceSciEnsembleOptions = {}): SurfaceSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciEnsemble };
diff --git a/src/surface_sci/estimation.ts b/src/surface_sci/estimation.ts
new file mode 100644
index 000000000..581258dad
--- /dev/null
+++ b/src/surface_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** surface_sci estimation module — tsb analytics library. */
+export interface SurfaceSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciEstimationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciEstimation(data: number[], opts: SurfaceSciEstimationOptions = {}): SurfaceSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciEstimation };
diff --git a/src/surface_sci/evaluation.ts b/src/surface_sci/evaluation.ts
new file mode 100644
index 000000000..0ea12dcee
--- /dev/null
+++ b/src/surface_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** surface_sci evaluation module — tsb analytics library. */
+export interface SurfaceSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciEvaluation(data: number[], opts: SurfaceSciEvaluationOptions = {}): SurfaceSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciEvaluation };
diff --git a/src/surface_sci/extrapolation.ts b/src/surface_sci/extrapolation.ts
new file mode 100644
index 000000000..4a5b3e151
--- /dev/null
+++ b/src/surface_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** surface_sci extrapolation module — tsb analytics library. */
+export interface SurfaceSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciExtrapolation(data: number[], opts: SurfaceSciExtrapolationOptions = {}): SurfaceSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciExtrapolation };
diff --git a/src/surface_sci/features.ts b/src/surface_sci/features.ts
new file mode 100644
index 000000000..c387492ec
--- /dev/null
+++ b/src/surface_sci/features.ts
@@ -0,0 +1,14 @@
+/** surface_sci features module — tsb analytics library. */
+export interface SurfaceSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciFeatures(data: number[], opts: SurfaceSciFeaturesOptions = {}): SurfaceSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciFeatures };
diff --git a/src/surface_sci/feedback.ts b/src/surface_sci/feedback.ts
new file mode 100644
index 000000000..fb53c6ea0
--- /dev/null
+++ b/src/surface_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** surface_sci feedback module — tsb analytics library. */
+export interface SurfaceSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciFeedback(data: number[], opts: SurfaceSciFeedbackOptions = {}): SurfaceSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciFeedback };
diff --git a/src/surface_sci/filtering.ts b/src/surface_sci/filtering.ts
new file mode 100644
index 000000000..ea8d2e4b0
--- /dev/null
+++ b/src/surface_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** surface_sci filtering module — tsb analytics library. */
+export interface SurfaceSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciFilteringResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciFiltering(data: number[], opts: SurfaceSciFilteringOptions = {}): SurfaceSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciFiltering };
diff --git a/src/surface_sci/fourier.ts b/src/surface_sci/fourier.ts
new file mode 100644
index 000000000..120a10e04
--- /dev/null
+++ b/src/surface_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** surface_sci fourier module — tsb analytics library. */
+export interface SurfaceSciFourierOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciFourierResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciFourier(data: number[], opts: SurfaceSciFourierOptions = {}): SurfaceSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciFourier };
diff --git a/src/surface_sci/fusion.ts b/src/surface_sci/fusion.ts
new file mode 100644
index 000000000..30a6219bd
--- /dev/null
+++ b/src/surface_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** surface_sci fusion module — tsb analytics library. */
+export interface SurfaceSciFusionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciFusionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciFusion(data: number[], opts: SurfaceSciFusionOptions = {}): SurfaceSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciFusion };
diff --git a/src/surface_sci/generation.ts b/src/surface_sci/generation.ts
new file mode 100644
index 000000000..11f66417e
--- /dev/null
+++ b/src/surface_sci/generation.ts
@@ -0,0 +1,14 @@
+/** surface_sci generation module — tsb analytics library. */
+export interface SurfaceSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciGenerationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciGeneration(data: number[], opts: SurfaceSciGenerationOptions = {}): SurfaceSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciGeneration };
diff --git a/src/surface_sci/geometry.ts b/src/surface_sci/geometry.ts
new file mode 100644
index 000000000..d43e59e72
--- /dev/null
+++ b/src/surface_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** surface_sci geometry module — tsb analytics library. */
+export interface SurfaceSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciGeometryResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciGeometry(data: number[], opts: SurfaceSciGeometryOptions = {}): SurfaceSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciGeometry };
diff --git a/src/surface_sci/gradient.ts b/src/surface_sci/gradient.ts
new file mode 100644
index 000000000..bdb02663a
--- /dev/null
+++ b/src/surface_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** surface_sci gradient module — tsb analytics library. */
+export interface SurfaceSciGradientOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciGradientResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciGradient(data: number[], opts: SurfaceSciGradientOptions = {}): SurfaceSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciGradient };
diff --git a/src/surface_sci/hessian.ts b/src/surface_sci/hessian.ts
new file mode 100644
index 000000000..09f0822a8
--- /dev/null
+++ b/src/surface_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** surface_sci hessian module — tsb analytics library. */
+export interface SurfaceSciHessianOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciHessianResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciHessian(data: number[], opts: SurfaceSciHessianOptions = {}): SurfaceSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciHessian };
diff --git a/src/surface_sci/hypothesis.ts b/src/surface_sci/hypothesis.ts
new file mode 100644
index 000000000..df3992058
--- /dev/null
+++ b/src/surface_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** surface_sci hypothesis module — tsb analytics library. */
+export interface SurfaceSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciHypothesis(data: number[], opts: SurfaceSciHypothesisOptions = {}): SurfaceSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciHypothesis };
diff --git a/src/surface_sci/inference.ts b/src/surface_sci/inference.ts
new file mode 100644
index 000000000..3ab72f6ce
--- /dev/null
+++ b/src/surface_sci/inference.ts
@@ -0,0 +1,14 @@
+/** surface_sci inference module — tsb analytics library. */
+export interface SurfaceSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciInferenceResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciInference(data: number[], opts: SurfaceSciInferenceOptions = {}): SurfaceSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciInference };
diff --git a/src/surface_sci/inference2.ts b/src/surface_sci/inference2.ts
new file mode 100644
index 000000000..ed1a73d02
--- /dev/null
+++ b/src/surface_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** surface_sci inference2 module — tsb analytics library. */
+export interface SurfaceSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciInferenceResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciInference(data: number[], opts: SurfaceSciInferenceOptions = {}): SurfaceSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciInference };
diff --git a/src/surface_sci/integral.ts b/src/surface_sci/integral.ts
new file mode 100644
index 000000000..6f5491abd
--- /dev/null
+++ b/src/surface_sci/integral.ts
@@ -0,0 +1,14 @@
+/** surface_sci integral module — tsb analytics library. */
+export interface SurfaceSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciIntegralResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciIntegral(data: number[], opts: SurfaceSciIntegralOptions = {}): SurfaceSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciIntegral };
diff --git a/src/surface_sci/integration.ts b/src/surface_sci/integration.ts
new file mode 100644
index 000000000..4c4044a73
--- /dev/null
+++ b/src/surface_sci/integration.ts
@@ -0,0 +1,14 @@
+/** surface_sci integration module — tsb analytics library. */
+export interface SurfaceSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciIntegration(data: number[], opts: SurfaceSciIntegrationOptions = {}): SurfaceSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciIntegration };
diff --git a/src/surface_sci/interpolation.ts b/src/surface_sci/interpolation.ts
new file mode 100644
index 000000000..f5a925b3d
--- /dev/null
+++ b/src/surface_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** surface_sci interpolation module — tsb analytics library. */
+export interface SurfaceSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciInterpolation(data: number[], opts: SurfaceSciInterpolationOptions = {}): SurfaceSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciInterpolation };
diff --git a/src/surface_sci/jacobian.ts b/src/surface_sci/jacobian.ts
new file mode 100644
index 000000000..a44b5a077
--- /dev/null
+++ b/src/surface_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** surface_sci jacobian module — tsb analytics library. */
+export interface SurfaceSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciJacobianResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciJacobian(data: number[], opts: SurfaceSciJacobianOptions = {}): SurfaceSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciJacobian };
diff --git a/src/surface_sci/kernel.ts b/src/surface_sci/kernel.ts
new file mode 100644
index 000000000..6f14d26a1
--- /dev/null
+++ b/src/surface_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** surface_sci kernel module — tsb analytics library. */
+export interface SurfaceSciKernelOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciKernelResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciKernel(data: number[], opts: SurfaceSciKernelOptions = {}): SurfaceSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciKernel };
diff --git a/src/surface_sci/laplacian.ts b/src/surface_sci/laplacian.ts
new file mode 100644
index 000000000..db5c97725
--- /dev/null
+++ b/src/surface_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** surface_sci laplacian module — tsb analytics library. */
+export interface SurfaceSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciLaplacian(data: number[], opts: SurfaceSciLaplacianOptions = {}): SurfaceSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciLaplacian };
diff --git a/src/surface_sci/learning.ts b/src/surface_sci/learning.ts
new file mode 100644
index 000000000..3551a25b8
--- /dev/null
+++ b/src/surface_sci/learning.ts
@@ -0,0 +1,14 @@
+/** surface_sci learning module — tsb analytics library. */
+export interface SurfaceSciLearningOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciLearningResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciLearning(data: number[], opts: SurfaceSciLearningOptions = {}): SurfaceSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciLearning };
diff --git a/src/surface_sci/linear.ts b/src/surface_sci/linear.ts
new file mode 100644
index 000000000..4a7c0e99e
--- /dev/null
+++ b/src/surface_sci/linear.ts
@@ -0,0 +1,14 @@
+/** surface_sci linear module — tsb analytics library. */
+export interface SurfaceSciLinearOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciLinearResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciLinear(data: number[], opts: SurfaceSciLinearOptions = {}): SurfaceSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciLinear };
diff --git a/src/surface_sci/manifold.ts b/src/surface_sci/manifold.ts
new file mode 100644
index 000000000..88cfb68a6
--- /dev/null
+++ b/src/surface_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** surface_sci manifold module — tsb analytics library. */
+export interface SurfaceSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciManifoldResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciManifold(data: number[], opts: SurfaceSciManifoldOptions = {}): SurfaceSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciManifold };
diff --git a/src/surface_sci/matching.ts b/src/surface_sci/matching.ts
new file mode 100644
index 000000000..404957ee5
--- /dev/null
+++ b/src/surface_sci/matching.ts
@@ -0,0 +1,14 @@
+/** surface_sci matching module — tsb analytics library. */
+export interface SurfaceSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciMatchingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciMatching(data: number[], opts: SurfaceSciMatchingOptions = {}): SurfaceSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciMatching };
diff --git a/src/surface_sci/measurement.ts b/src/surface_sci/measurement.ts
new file mode 100644
index 000000000..eb6d13a00
--- /dev/null
+++ b/src/surface_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** surface_sci measurement module — tsb analytics library. */
+export interface SurfaceSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciMeasurement(data: number[], opts: SurfaceSciMeasurementOptions = {}): SurfaceSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciMeasurement };
diff --git a/src/surface_sci/metrics.ts b/src/surface_sci/metrics.ts
new file mode 100644
index 000000000..b1c9be227
--- /dev/null
+++ b/src/surface_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** surface_sci metrics module — tsb analytics library. */
+export interface SurfaceSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciMetricsResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciMetrics(data: number[], opts: SurfaceSciMetricsOptions = {}): SurfaceSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciMetrics };
diff --git a/src/surface_sci/modeling.ts b/src/surface_sci/modeling.ts
new file mode 100644
index 000000000..573c4e056
--- /dev/null
+++ b/src/surface_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** surface_sci modeling module — tsb analytics library. */
+export interface SurfaceSciModelingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciModelingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciModeling(data: number[], opts: SurfaceSciModelingOptions = {}): SurfaceSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciModeling };
diff --git a/src/surface_sci/monitoring.ts b/src/surface_sci/monitoring.ts
new file mode 100644
index 000000000..334b80f28
--- /dev/null
+++ b/src/surface_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** surface_sci monitoring module — tsb analytics library. */
+export interface SurfaceSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciMonitoring(data: number[], opts: SurfaceSciMonitoringOptions = {}): SurfaceSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciMonitoring };
diff --git a/src/surface_sci/nonlinear.ts b/src/surface_sci/nonlinear.ts
new file mode 100644
index 000000000..3f29b3e78
--- /dev/null
+++ b/src/surface_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** surface_sci nonlinear module — tsb analytics library. */
+export interface SurfaceSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciNonlinear(data: number[], opts: SurfaceSciNonlinearOptions = {}): SurfaceSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciNonlinear };
diff --git a/src/surface_sci/normalization.ts b/src/surface_sci/normalization.ts
new file mode 100644
index 000000000..309997ca4
--- /dev/null
+++ b/src/surface_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** surface_sci normalization module — tsb analytics library. */
+export interface SurfaceSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciNormalization(data: number[], opts: SurfaceSciNormalizationOptions = {}): SurfaceSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciNormalization };
diff --git a/src/surface_sci/optimization.ts b/src/surface_sci/optimization.ts
new file mode 100644
index 000000000..b32e52782
--- /dev/null
+++ b/src/surface_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** surface_sci optimization module — tsb analytics library. */
+export interface SurfaceSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciOptimization(data: number[], opts: SurfaceSciOptimizationOptions = {}): SurfaceSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciOptimization };
diff --git a/src/surface_sci/patterns.ts b/src/surface_sci/patterns.ts
new file mode 100644
index 000000000..61db52d8f
--- /dev/null
+++ b/src/surface_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** surface_sci patterns module — tsb analytics library. */
+export interface SurfaceSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciPatternsResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciPatterns(data: number[], opts: SurfaceSciPatternsOptions = {}): SurfaceSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciPatterns };
diff --git a/src/surface_sci/permutation.ts b/src/surface_sci/permutation.ts
new file mode 100644
index 000000000..34803a390
--- /dev/null
+++ b/src/surface_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** surface_sci permutation module — tsb analytics library. */
+export interface SurfaceSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciPermutationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciPermutation(data: number[], opts: SurfaceSciPermutationOptions = {}): SurfaceSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciPermutation };
diff --git a/src/surface_sci/prediction.ts b/src/surface_sci/prediction.ts
new file mode 100644
index 000000000..b0b248b76
--- /dev/null
+++ b/src/surface_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** surface_sci prediction module — tsb analytics library. */
+export interface SurfaceSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciPredictionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciPrediction(data: number[], opts: SurfaceSciPredictionOptions = {}): SurfaceSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciPrediction };
diff --git a/src/surface_sci/processing.ts b/src/surface_sci/processing.ts
new file mode 100644
index 000000000..ac9d6c062
--- /dev/null
+++ b/src/surface_sci/processing.ts
@@ -0,0 +1,14 @@
+/** surface_sci processing module — tsb analytics library. */
+export interface SurfaceSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciProcessingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciProcessing(data: number[], opts: SurfaceSciProcessingOptions = {}): SurfaceSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciProcessing };
diff --git a/src/surface_sci/profiling.ts b/src/surface_sci/profiling.ts
new file mode 100644
index 000000000..f6f942338
--- /dev/null
+++ b/src/surface_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** surface_sci profiling module — tsb analytics library. */
+export interface SurfaceSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciProfilingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciProfiling(data: number[], opts: SurfaceSciProfilingOptions = {}): SurfaceSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciProfiling };
diff --git a/src/surface_sci/projection.ts b/src/surface_sci/projection.ts
new file mode 100644
index 000000000..fba5d5394
--- /dev/null
+++ b/src/surface_sci/projection.ts
@@ -0,0 +1,14 @@
+/** surface_sci projection module — tsb analytics library. */
+export interface SurfaceSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciProjectionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciProjection(data: number[], opts: SurfaceSciProjectionOptions = {}): SurfaceSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciProjection };
diff --git a/src/surface_sci/ranking.ts b/src/surface_sci/ranking.ts
new file mode 100644
index 000000000..458ce4771
--- /dev/null
+++ b/src/surface_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** surface_sci ranking module — tsb analytics library. */
+export interface SurfaceSciRankingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciRankingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciRanking(data: number[], opts: SurfaceSciRankingOptions = {}): SurfaceSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciRanking };
diff --git a/src/surface_sci/reconstruction.ts b/src/surface_sci/reconstruction.ts
new file mode 100644
index 000000000..eeb876188
--- /dev/null
+++ b/src/surface_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** surface_sci reconstruction module — tsb analytics library. */
+export interface SurfaceSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciReconstruction(data: number[], opts: SurfaceSciReconstructionOptions = {}): SurfaceSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciReconstruction };
diff --git a/src/surface_sci/registration.ts b/src/surface_sci/registration.ts
new file mode 100644
index 000000000..2ab31191e
--- /dev/null
+++ b/src/surface_sci/registration.ts
@@ -0,0 +1,14 @@
+/** surface_sci registration module — tsb analytics library. */
+export interface SurfaceSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciRegistration(data: number[], opts: SurfaceSciRegistrationOptions = {}): SurfaceSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciRegistration };
diff --git a/src/surface_sci/regression.ts b/src/surface_sci/regression.ts
new file mode 100644
index 000000000..5ce176958
--- /dev/null
+++ b/src/surface_sci/regression.ts
@@ -0,0 +1,14 @@
+/** surface_sci regression module — tsb analytics library. */
+export interface SurfaceSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciRegressionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciRegression(data: number[], opts: SurfaceSciRegressionOptions = {}): SurfaceSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciRegression };
diff --git a/src/surface_sci/regularization.ts b/src/surface_sci/regularization.ts
new file mode 100644
index 000000000..1c90c0c5b
--- /dev/null
+++ b/src/surface_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** surface_sci regularization module — tsb analytics library. */
+export interface SurfaceSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciRegularization(data: number[], opts: SurfaceSciRegularizationOptions = {}): SurfaceSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciRegularization };
diff --git a/src/surface_sci/robustness.ts b/src/surface_sci/robustness.ts
new file mode 100644
index 000000000..129dcec2a
--- /dev/null
+++ b/src/surface_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** surface_sci robustness module — tsb analytics library. */
+export interface SurfaceSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciRobustness(data: number[], opts: SurfaceSciRobustnessOptions = {}): SurfaceSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciRobustness };
diff --git a/src/surface_sci/sampling.ts b/src/surface_sci/sampling.ts
new file mode 100644
index 000000000..fd839a9c5
--- /dev/null
+++ b/src/surface_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** surface_sci sampling module — tsb analytics library. */
+export interface SurfaceSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciSamplingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciSampling(data: number[], opts: SurfaceSciSamplingOptions = {}): SurfaceSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciSampling };
diff --git a/src/surface_sci/sampling2.ts b/src/surface_sci/sampling2.ts
new file mode 100644
index 000000000..8322cc10c
--- /dev/null
+++ b/src/surface_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** surface_sci sampling2 module — tsb analytics library. */
+export interface SurfaceSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciSamplingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciSampling(data: number[], opts: SurfaceSciSamplingOptions = {}): SurfaceSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciSampling };
diff --git a/src/surface_sci/scaling.ts b/src/surface_sci/scaling.ts
new file mode 100644
index 000000000..02fe9f30e
--- /dev/null
+++ b/src/surface_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** surface_sci scaling module — tsb analytics library. */
+export interface SurfaceSciScalingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciScalingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciScaling(data: number[], opts: SurfaceSciScalingOptions = {}): SurfaceSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciScaling };
diff --git a/src/surface_sci/scoring.ts b/src/surface_sci/scoring.ts
new file mode 100644
index 000000000..2496b3790
--- /dev/null
+++ b/src/surface_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** surface_sci scoring module — tsb analytics library. */
+export interface SurfaceSciScoringOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciScoringResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciScoring(data: number[], opts: SurfaceSciScoringOptions = {}): SurfaceSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciScoring };
diff --git a/src/surface_sci/segmentation.ts b/src/surface_sci/segmentation.ts
new file mode 100644
index 000000000..c749b9581
--- /dev/null
+++ b/src/surface_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** surface_sci segmentation module — tsb analytics library. */
+export interface SurfaceSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciSegmentation(data: number[], opts: SurfaceSciSegmentationOptions = {}): SurfaceSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciSegmentation };
diff --git a/src/surface_sci/selection.ts b/src/surface_sci/selection.ts
new file mode 100644
index 000000000..51604b707
--- /dev/null
+++ b/src/surface_sci/selection.ts
@@ -0,0 +1,14 @@
+/** surface_sci selection module — tsb analytics library. */
+export interface SurfaceSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciSelectionResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciSelection(data: number[], opts: SurfaceSciSelectionOptions = {}): SurfaceSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciSelection };
diff --git a/src/surface_sci/sensitivity.ts b/src/surface_sci/sensitivity.ts
new file mode 100644
index 000000000..d6f9dea4c
--- /dev/null
+++ b/src/surface_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** surface_sci sensitivity module — tsb analytics library. */
+export interface SurfaceSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciSensitivity(data: number[], opts: SurfaceSciSensitivityOptions = {}): SurfaceSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciSensitivity };
diff --git a/src/surface_sci/simulation.ts b/src/surface_sci/simulation.ts
new file mode 100644
index 000000000..ef63b13fa
--- /dev/null
+++ b/src/surface_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** surface_sci simulation module — tsb analytics library. */
+export interface SurfaceSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciSimulationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciSimulation(data: number[], opts: SurfaceSciSimulationOptions = {}): SurfaceSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciSimulation };
diff --git a/src/surface_sci/smoothing.ts b/src/surface_sci/smoothing.ts
new file mode 100644
index 000000000..2e0d18360
--- /dev/null
+++ b/src/surface_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** surface_sci smoothing module — tsb analytics library. */
+export interface SurfaceSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciSmoothing(data: number[], opts: SurfaceSciSmoothingOptions = {}): SurfaceSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciSmoothing };
diff --git a/src/surface_sci/stability.ts b/src/surface_sci/stability.ts
new file mode 100644
index 000000000..799c211ef
--- /dev/null
+++ b/src/surface_sci/stability.ts
@@ -0,0 +1,14 @@
+/** surface_sci stability module — tsb analytics library. */
+export interface SurfaceSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciStabilityResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciStability(data: number[], opts: SurfaceSciStabilityOptions = {}): SurfaceSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciStability };
diff --git a/src/surface_sci/stacking.ts b/src/surface_sci/stacking.ts
new file mode 100644
index 000000000..0c25e4ffc
--- /dev/null
+++ b/src/surface_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** surface_sci stacking module — tsb analytics library. */
+export interface SurfaceSciStackingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciStackingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciStacking(data: number[], opts: SurfaceSciStackingOptions = {}): SurfaceSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciStacking };
diff --git a/src/surface_sci/standardization.ts b/src/surface_sci/standardization.ts
new file mode 100644
index 000000000..e21dbca91
--- /dev/null
+++ b/src/surface_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** surface_sci standardization module — tsb analytics library. */
+export interface SurfaceSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciStandardization(data: number[], opts: SurfaceSciStandardizationOptions = {}): SurfaceSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciStandardization };
diff --git a/src/surface_sci/static.ts b/src/surface_sci/static.ts
new file mode 100644
index 000000000..81d15dfbe
--- /dev/null
+++ b/src/surface_sci/static.ts
@@ -0,0 +1,14 @@
+/** surface_sci static module — tsb analytics library. */
+export interface SurfaceSciStaticOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciStaticResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciStatic(data: number[], opts: SurfaceSciStaticOptions = {}): SurfaceSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciStatic };
diff --git a/src/surface_sci/stochastic.ts b/src/surface_sci/stochastic.ts
new file mode 100644
index 000000000..dc59f40b2
--- /dev/null
+++ b/src/surface_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** surface_sci stochastic module — tsb analytics library. */
+export interface SurfaceSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciStochasticResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciStochastic(data: number[], opts: SurfaceSciStochasticOptions = {}): SurfaceSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciStochastic };
diff --git a/src/surface_sci/synthesis.ts b/src/surface_sci/synthesis.ts
new file mode 100644
index 000000000..9270429d2
--- /dev/null
+++ b/src/surface_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** surface_sci synthesis module — tsb analytics library. */
+export interface SurfaceSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciSynthesis(data: number[], opts: SurfaceSciSynthesisOptions = {}): SurfaceSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciSynthesis };
diff --git a/src/surface_sci/topology.ts b/src/surface_sci/topology.ts
new file mode 100644
index 000000000..01660fcaa
--- /dev/null
+++ b/src/surface_sci/topology.ts
@@ -0,0 +1,14 @@
+/** surface_sci topology module — tsb analytics library. */
+export interface SurfaceSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciTopologyResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciTopology(data: number[], opts: SurfaceSciTopologyOptions = {}): SurfaceSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciTopology };
diff --git a/src/surface_sci/tracking.ts b/src/surface_sci/tracking.ts
new file mode 100644
index 000000000..26aac19d7
--- /dev/null
+++ b/src/surface_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** surface_sci tracking module — tsb analytics library. */
+export interface SurfaceSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciTrackingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciTracking(data: number[], opts: SurfaceSciTrackingOptions = {}): SurfaceSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciTracking };
diff --git a/src/surface_sci/transform.ts b/src/surface_sci/transform.ts
new file mode 100644
index 000000000..971a64c4a
--- /dev/null
+++ b/src/surface_sci/transform.ts
@@ -0,0 +1,14 @@
+/** surface_sci transform module — tsb analytics library. */
+export interface SurfaceSciTransformOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciTransformResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciTransform(data: number[], opts: SurfaceSciTransformOptions = {}): SurfaceSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciTransform };
diff --git a/src/surface_sci/uncertainty.ts b/src/surface_sci/uncertainty.ts
new file mode 100644
index 000000000..96912d7b8
--- /dev/null
+++ b/src/surface_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** surface_sci uncertainty module — tsb analytics library. */
+export interface SurfaceSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciUncertainty(data: number[], opts: SurfaceSciUncertaintyOptions = {}): SurfaceSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciUncertainty };
diff --git a/src/surface_sci/validation.ts b/src/surface_sci/validation.ts
new file mode 100644
index 000000000..03b81ee0b
--- /dev/null
+++ b/src/surface_sci/validation.ts
@@ -0,0 +1,14 @@
+/** surface_sci validation module — tsb analytics library. */
+export interface SurfaceSciValidationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciValidationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciValidation(data: number[], opts: SurfaceSciValidationOptions = {}): SurfaceSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciValidation };
diff --git a/src/surface_sci/verification.ts b/src/surface_sci/verification.ts
new file mode 100644
index 000000000..9aed2e92b
--- /dev/null
+++ b/src/surface_sci/verification.ts
@@ -0,0 +1,14 @@
+/** surface_sci verification module — tsb analytics library. */
+export interface SurfaceSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciVerificationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciVerification(data: number[], opts: SurfaceSciVerificationOptions = {}): SurfaceSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciVerification };
diff --git a/src/surface_sci/visualization.ts b/src/surface_sci/visualization.ts
new file mode 100644
index 000000000..dfa9c8e9e
--- /dev/null
+++ b/src/surface_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** surface_sci visualization module — tsb analytics library. */
+export interface SurfaceSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciVisualization(data: number[], opts: SurfaceSciVisualizationOptions = {}): SurfaceSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciVisualization };
diff --git a/src/surface_sci/voting.ts b/src/surface_sci/voting.ts
new file mode 100644
index 000000000..c32abd685
--- /dev/null
+++ b/src/surface_sci/voting.ts
@@ -0,0 +1,14 @@
+/** surface_sci voting module — tsb analytics library. */
+export interface SurfaceSciVotingOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciVotingResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciVoting(data: number[], opts: SurfaceSciVotingOptions = {}): SurfaceSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciVoting };
diff --git a/src/surface_sci/wavelet.ts b/src/surface_sci/wavelet.ts
new file mode 100644
index 000000000..58e0555dc
--- /dev/null
+++ b/src/surface_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** surface_sci wavelet module — tsb analytics library. */
+export interface SurfaceSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface SurfaceSciWaveletResult { values: number[]; converged: boolean; }
+export function computeSurfaceSciWavelet(data: number[], opts: SurfaceSciWaveletOptions = {}): SurfaceSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurfaceSciWavelet };
diff --git a/src/survey/adaptive_testing.ts b/src/survey/adaptive_testing.ts
new file mode 100644
index 000000000..756d88521
--- /dev/null
+++ b/src/survey/adaptive_testing.ts
@@ -0,0 +1,22 @@
+/** Adaptive Testing module — tsb analytics library. */
+
+/** Options for Adaptive Testing. */
+export interface AdaptiveTestingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Adaptive Testing. */
+export interface AdaptiveTestingResult { values: number[]; converged: boolean; }
+
+/** Compute Adaptive Testing. */
+export function computeAdaptiveTesting(data: number[], opts: AdaptiveTestingOptions = {}): AdaptiveTestingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAdaptiveTesting };
diff --git a/src/survey/advanced.ts b/src/survey/advanced.ts
new file mode 100644
index 000000000..75cca3c2b
--- /dev/null
+++ b/src/survey/advanced.ts
@@ -0,0 +1,15 @@
+/** Survey Advanced module — tsb analytics library. */
+export interface Survey advancedOptions { tol?: number; maxIter?: number; }
+export interface Survey advancedResult { values: number[]; converged: boolean; }
+export function computeSurvey advanced(data: number[], opts: Survey advancedOptions = {}): Survey advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey advanced };
diff --git a/src/survey/anchoring.ts b/src/survey/anchoring.ts
new file mode 100644
index 000000000..278fc28cc
--- /dev/null
+++ b/src/survey/anchoring.ts
@@ -0,0 +1,22 @@
+/** Anchoring module — tsb analytics library. */
+
+/** Options for Anchoring. */
+export interface AnchoringOptions { tol?: number; maxIter?: number; }
+
+/** Result from Anchoring. */
+export interface AnchoringResult { values: number[]; converged: boolean; }
+
+/** Compute Anchoring. */
+export function computeAnchoring(data: number[], opts: AnchoringOptions = {}): AnchoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAnchoring };
diff --git a/src/survey/attrition.ts b/src/survey/attrition.ts
new file mode 100644
index 000000000..e4ee6228b
--- /dev/null
+++ b/src/survey/attrition.ts
@@ -0,0 +1,22 @@
+/** Attrition module — tsb analytics library. */
+
+/** Options for Attrition. */
+export interface AttritionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Attrition. */
+export interface AttritionResult { values: number[]; converged: boolean; }
+
+/** Compute Attrition. */
+export function computeAttrition(data: number[], opts: AttritionOptions = {}): AttritionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAttrition };
diff --git a/src/survey/base2.ts b/src/survey/base2.ts
new file mode 100644
index 000000000..1664b17bf
--- /dev/null
+++ b/src/survey/base2.ts
@@ -0,0 +1,15 @@
+/** Survey Base2 module — tsb analytics library. */
+export interface Survey base2Options { tol?: number; maxIter?: number; }
+export interface Survey base2Result { values: number[]; converged: boolean; }
+export function computeSurvey base2(data: number[], opts: Survey base2Options = {}): Survey base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey base2 };
diff --git a/src/survey/batch.ts b/src/survey/batch.ts
new file mode 100644
index 000000000..8f6352983
--- /dev/null
+++ b/src/survey/batch.ts
@@ -0,0 +1,15 @@
+/** Survey Batch module — tsb analytics library. */
+export interface Survey batchOptions { tol?: number; maxIter?: number; }
+export interface Survey batchResult { values: number[]; converged: boolean; }
+export function computeSurvey batch(data: number[], opts: Survey batchOptions = {}): Survey batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey batch };
diff --git a/src/survey/beta.ts b/src/survey/beta.ts
new file mode 100644
index 000000000..6db5ebc5f
--- /dev/null
+++ b/src/survey/beta.ts
@@ -0,0 +1,15 @@
+/** Survey Beta module — tsb analytics library. */
+export interface Survey betaOptions { tol?: number; maxIter?: number; }
+export interface Survey betaResult { values: number[]; converged: boolean; }
+export function computeSurvey beta(data: number[], opts: Survey betaOptions = {}): Survey betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey beta };
diff --git a/src/survey/calibration.ts b/src/survey/calibration.ts
new file mode 100644
index 000000000..1fb4ff42e
--- /dev/null
+++ b/src/survey/calibration.ts
@@ -0,0 +1,22 @@
+/** Calibration module — tsb analytics library. */
+
+/** Options for Calibration. */
+export interface CalibrationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Calibration. */
+export interface CalibrationResult { values: number[]; converged: boolean; }
+
+/** Compute Calibration. */
+export function computeCalibration(data: number[], opts: CalibrationOptions = {}): CalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCalibration };
diff --git a/src/survey/complex_design.ts b/src/survey/complex_design.ts
new file mode 100644
index 000000000..baa1e86a9
--- /dev/null
+++ b/src/survey/complex_design.ts
@@ -0,0 +1,22 @@
+/** Complex Design module — tsb analytics library. */
+
+/** Options for Complex Design. */
+export interface ComplexDesignOptions { tol?: number; maxIter?: number; }
+
+/** Result from Complex Design. */
+export interface ComplexDesignResult { values: number[]; converged: boolean; }
+
+/** Compute Complex Design. */
+export function computeComplexDesign(data: number[], opts: ComplexDesignOptions = {}): ComplexDesignResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeComplexDesign };
diff --git a/src/survey/cpu.ts b/src/survey/cpu.ts
new file mode 100644
index 000000000..452be4c87
--- /dev/null
+++ b/src/survey/cpu.ts
@@ -0,0 +1,15 @@
+/** Survey Cpu module — tsb analytics library. */
+export interface Survey cpuOptions { tol?: number; maxIter?: number; }
+export interface Survey cpuResult { values: number[]; converged: boolean; }
+export function computeSurvey cpu(data: number[], opts: Survey cpuOptions = {}): Survey cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey cpu };
diff --git a/src/survey/dense.ts b/src/survey/dense.ts
new file mode 100644
index 000000000..6086576a8
--- /dev/null
+++ b/src/survey/dense.ts
@@ -0,0 +1,15 @@
+/** Survey Dense module — tsb analytics library. */
+export interface Survey denseOptions { tol?: number; maxIter?: number; }
+export interface Survey denseResult { values: number[]; converged: boolean; }
+export function computeSurvey dense(data: number[], opts: Survey denseOptions = {}): Survey denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey dense };
diff --git a/src/survey/distributed.ts b/src/survey/distributed.ts
new file mode 100644
index 000000000..934effabd
--- /dev/null
+++ b/src/survey/distributed.ts
@@ -0,0 +1,15 @@
+/** Survey Distributed module — tsb analytics library. */
+export interface Survey distributedOptions { tol?: number; maxIter?: number; }
+export interface Survey distributedResult { values: number[]; converged: boolean; }
+export function computeSurvey distributed(data: number[], opts: Survey distributedOptions = {}): Survey distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey distributed };
diff --git a/src/survey/experimental.ts b/src/survey/experimental.ts
new file mode 100644
index 000000000..14667370b
--- /dev/null
+++ b/src/survey/experimental.ts
@@ -0,0 +1,15 @@
+/** Survey Experimental module — tsb analytics library. */
+export interface Survey experimentalOptions { tol?: number; maxIter?: number; }
+export interface Survey experimentalResult { values: number[]; converged: boolean; }
+export function computeSurvey experimental(data: number[], opts: Survey experimentalOptions = {}): Survey experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey experimental };
diff --git a/src/survey/factor.ts b/src/survey/factor.ts
new file mode 100644
index 000000000..fc4bc52bd
--- /dev/null
+++ b/src/survey/factor.ts
@@ -0,0 +1,22 @@
+/** Factor module — tsb analytics library. */
+
+/** Options for Factor. */
+export interface FactorOptions { tol?: number; maxIter?: number; }
+
+/** Result from Factor. */
+export interface FactorResult { values: number[]; converged: boolean; }
+
+/** Compute Factor. */
+export function computeFactor(data: number[], opts: FactorOptions = {}): FactorResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFactor };
diff --git a/src/survey/fast.ts b/src/survey/fast.ts
new file mode 100644
index 000000000..3461bc5fa
--- /dev/null
+++ b/src/survey/fast.ts
@@ -0,0 +1,15 @@
+/** Survey Fast module — tsb analytics library. */
+export interface Survey fastOptions { tol?: number; maxIter?: number; }
+export interface Survey fastResult { values: number[]; converged: boolean; }
+export function computeSurvey fast(data: number[], opts: Survey fastOptions = {}): Survey fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey fast };
diff --git a/src/survey/framing.ts b/src/survey/framing.ts
new file mode 100644
index 000000000..c09014632
--- /dev/null
+++ b/src/survey/framing.ts
@@ -0,0 +1,22 @@
+/** Framing module — tsb analytics library. */
+
+/** Options for Framing. */
+export interface FramingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Framing. */
+export interface FramingResult { values: number[]; converged: boolean; }
+
+/** Compute Framing. */
+export function computeFraming(data: number[], opts: FramingOptions = {}): FramingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFraming };
diff --git a/src/survey/future.ts b/src/survey/future.ts
new file mode 100644
index 000000000..87c0c2058
--- /dev/null
+++ b/src/survey/future.ts
@@ -0,0 +1,15 @@
+/** Survey Future module — tsb analytics library. */
+export interface Survey futureOptions { tol?: number; maxIter?: number; }
+export interface Survey futureResult { values: number[]; converged: boolean; }
+export function computeSurvey future(data: number[], opts: Survey futureOptions = {}): Survey futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey future };
diff --git a/src/survey/gpu.ts b/src/survey/gpu.ts
new file mode 100644
index 000000000..15947bc63
--- /dev/null
+++ b/src/survey/gpu.ts
@@ -0,0 +1,15 @@
+/** Survey Gpu module — tsb analytics library. */
+export interface Survey gpuOptions { tol?: number; maxIter?: number; }
+export interface Survey gpuResult { values: number[]; converged: boolean; }
+export function computeSurvey gpu(data: number[], opts: Survey gpuOptions = {}): Survey gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey gpu };
diff --git a/src/survey/imputation.ts b/src/survey/imputation.ts
new file mode 100644
index 000000000..41014255e
--- /dev/null
+++ b/src/survey/imputation.ts
@@ -0,0 +1,22 @@
+/** Imputation module — tsb analytics library. */
+
+/** Options for Imputation. */
+export interface ImputationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Imputation. */
+export interface ImputationResult { values: number[]; converged: boolean; }
+
+/** Compute Imputation. */
+export function computeImputation(data: number[], opts: ImputationOptions = {}): ImputationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeImputation };
diff --git a/src/survey/interviewer.ts b/src/survey/interviewer.ts
new file mode 100644
index 000000000..054dde92c
--- /dev/null
+++ b/src/survey/interviewer.ts
@@ -0,0 +1,22 @@
+/** Interviewer module — tsb analytics library. */
+
+/** Options for Interviewer. */
+export interface InterviewerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Interviewer. */
+export interface InterviewerResult { values: number[]; converged: boolean; }
+
+/** Compute Interviewer. */
+export function computeInterviewer(data: number[], opts: InterviewerOptions = {}): InterviewerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInterviewer };
diff --git a/src/survey/irt.ts b/src/survey/irt.ts
new file mode 100644
index 000000000..c402cf12f
--- /dev/null
+++ b/src/survey/irt.ts
@@ -0,0 +1,22 @@
+/** Irt module — tsb analytics library. */
+
+/** Options for Irt. */
+export interface IrtOptions { tol?: number; maxIter?: number; }
+
+/** Result from Irt. */
+export interface IrtResult { values: number[]; converged: boolean; }
+
+/** Compute Irt. */
+export function computeIrt(data: number[], opts: IrtOptions = {}): IrtResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeIrt };
diff --git a/src/survey/item_analysis.ts b/src/survey/item_analysis.ts
new file mode 100644
index 000000000..0a9605c2d
--- /dev/null
+++ b/src/survey/item_analysis.ts
@@ -0,0 +1,22 @@
+/** Item Analysis module — tsb analytics library. */
+
+/** Options for Item Analysis. */
+export interface ItemAnalysisOptions { tol?: number; maxIter?: number; }
+
+/** Result from Item Analysis. */
+export interface ItemAnalysisResult { values: number[]; converged: boolean; }
+
+/** Compute Item Analysis. */
+export function computeItemAnalysis(data: number[], opts: ItemAnalysisOptions = {}): ItemAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeItemAnalysis };
diff --git a/src/survey/large.ts b/src/survey/large.ts
new file mode 100644
index 000000000..d87c4bb16
--- /dev/null
+++ b/src/survey/large.ts
@@ -0,0 +1,15 @@
+/** Survey Large module — tsb analytics library. */
+export interface Survey largeOptions { tol?: number; maxIter?: number; }
+export interface Survey largeResult { values: number[]; converged: boolean; }
+export function computeSurvey large(data: number[], opts: Survey largeOptions = {}): Survey largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey large };
diff --git a/src/survey/legacy.ts b/src/survey/legacy.ts
new file mode 100644
index 000000000..e17136dcc
--- /dev/null
+++ b/src/survey/legacy.ts
@@ -0,0 +1,15 @@
+/** Survey Legacy module — tsb analytics library. */
+export interface Survey legacyOptions { tol?: number; maxIter?: number; }
+export interface Survey legacyResult { values: number[]; converged: boolean; }
+export function computeSurvey legacy(data: number[], opts: Survey legacyOptions = {}): Survey legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey legacy };
diff --git a/src/survey/lite.ts b/src/survey/lite.ts
new file mode 100644
index 000000000..e0d01c8ce
--- /dev/null
+++ b/src/survey/lite.ts
@@ -0,0 +1,15 @@
+/** Survey Lite module — tsb analytics library. */
+export interface Survey liteOptions { tol?: number; maxIter?: number; }
+export interface Survey liteResult { values: number[]; converged: boolean; }
+export function computeSurvey lite(data: number[], opts: Survey liteOptions = {}): Survey liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey lite };
diff --git a/src/survey/longitudinal.ts b/src/survey/longitudinal.ts
new file mode 100644
index 000000000..3530933e7
--- /dev/null
+++ b/src/survey/longitudinal.ts
@@ -0,0 +1,22 @@
+/** Longitudinal module — tsb analytics library. */
+
+/** Options for Longitudinal. */
+export interface LongitudinalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Longitudinal. */
+export interface LongitudinalResult { values: number[]; converged: boolean; }
+
+/** Compute Longitudinal. */
+export function computeLongitudinal(data: number[], opts: LongitudinalOptions = {}): LongitudinalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeLongitudinal };
diff --git a/src/survey/measurement.ts b/src/survey/measurement.ts
new file mode 100644
index 000000000..4eabb944b
--- /dev/null
+++ b/src/survey/measurement.ts
@@ -0,0 +1,22 @@
+/** Measurement module — tsb analytics library. */
+
+/** Options for Measurement. */
+export interface MeasurementOptions { tol?: number; maxIter?: number; }
+
+/** Result from Measurement. */
+export interface MeasurementResult { values: number[]; converged: boolean; }
+
+/** Compute Measurement. */
+export function computeMeasurement(data: number[], opts: MeasurementOptions = {}): MeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMeasurement };
diff --git a/src/survey/mini.ts b/src/survey/mini.ts
new file mode 100644
index 000000000..4ef1232c9
--- /dev/null
+++ b/src/survey/mini.ts
@@ -0,0 +1,15 @@
+/** Survey Mini module — tsb analytics library. */
+export interface Survey miniOptions { tol?: number; maxIter?: number; }
+export interface Survey miniResult { values: number[]; converged: boolean; }
+export function computeSurvey mini(data: number[], opts: Survey miniOptions = {}): Survey miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey mini };
diff --git a/src/survey/mode.ts b/src/survey/mode.ts
new file mode 100644
index 000000000..1fb2b4d74
--- /dev/null
+++ b/src/survey/mode.ts
@@ -0,0 +1,22 @@
+/** Mode module — tsb analytics library. */
+
+/** Options for Mode. */
+export interface ModeOptions { tol?: number; maxIter?: number; }
+
+/** Result from Mode. */
+export interface ModeResult { values: number[]; converged: boolean; }
+
+/** Compute Mode. */
+export function computeMode(data: number[], opts: ModeOptions = {}): ModeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMode };
diff --git a/src/survey/multistage.ts b/src/survey/multistage.ts
new file mode 100644
index 000000000..7b2d4db8e
--- /dev/null
+++ b/src/survey/multistage.ts
@@ -0,0 +1,22 @@
+/** Multistage module — tsb analytics library. */
+
+/** Options for Multistage. */
+export interface MultistageOptions { tol?: number; maxIter?: number; }
+
+/** Result from Multistage. */
+export interface MultistageResult { values: number[]; converged: boolean; }
+
+/** Compute Multistage. */
+export function computeMultistage(data: number[], opts: MultistageOptions = {}): MultistageResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeMultistage };
diff --git a/src/survey/next.ts b/src/survey/next.ts
new file mode 100644
index 000000000..7d844a64a
--- /dev/null
+++ b/src/survey/next.ts
@@ -0,0 +1,15 @@
+/** Survey Next module — tsb analytics library. */
+export interface Survey nextOptions { tol?: number; maxIter?: number; }
+export interface Survey nextResult { values: number[]; converged: boolean; }
+export function computeSurvey next(data: number[], opts: Survey nextOptions = {}): Survey nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey next };
diff --git a/src/survey/nonresponse.ts b/src/survey/nonresponse.ts
new file mode 100644
index 000000000..7f6b0acae
--- /dev/null
+++ b/src/survey/nonresponse.ts
@@ -0,0 +1,22 @@
+/** Nonresponse module — tsb analytics library. */
+
+/** Options for Nonresponse. */
+export interface NonresponseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nonresponse. */
+export interface NonresponseResult { values: number[]; converged: boolean; }
+
+/** Compute Nonresponse. */
+export function computeNonresponse(data: number[], opts: NonresponseOptions = {}): NonresponseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNonresponse };
diff --git a/src/survey/online.ts b/src/survey/online.ts
new file mode 100644
index 000000000..331b12da5
--- /dev/null
+++ b/src/survey/online.ts
@@ -0,0 +1,15 @@
+/** Survey Online module — tsb analytics library. */
+export interface Survey onlineOptions { tol?: number; maxIter?: number; }
+export interface Survey onlineResult { values: number[]; converged: boolean; }
+export function computeSurvey online(data: number[], opts: Survey onlineOptions = {}): Survey onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey online };
diff --git a/src/survey/panel.ts b/src/survey/panel.ts
new file mode 100644
index 000000000..f6e6a9005
--- /dev/null
+++ b/src/survey/panel.ts
@@ -0,0 +1,22 @@
+/** Panel module — tsb analytics library. */
+
+/** Options for Panel. */
+export interface PanelOptions { tol?: number; maxIter?: number; }
+
+/** Result from Panel. */
+export interface PanelResult { values: number[]; converged: boolean; }
+
+/** Compute Panel. */
+export function computePanel(data: number[], opts: PanelOptions = {}): PanelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePanel };
diff --git a/src/survey/parallel.ts b/src/survey/parallel.ts
new file mode 100644
index 000000000..efbc5ee3d
--- /dev/null
+++ b/src/survey/parallel.ts
@@ -0,0 +1,15 @@
+/** Survey Parallel module — tsb analytics library. */
+export interface Survey parallelOptions { tol?: number; maxIter?: number; }
+export interface Survey parallelResult { values: number[]; converged: boolean; }
+export function computeSurvey parallel(data: number[], opts: Survey parallelOptions = {}): Survey parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey parallel };
diff --git a/src/survey/plus.ts b/src/survey/plus.ts
new file mode 100644
index 000000000..41254ed8a
--- /dev/null
+++ b/src/survey/plus.ts
@@ -0,0 +1,15 @@
+/** Survey Plus module — tsb analytics library. */
+export interface Survey plusOptions { tol?: number; maxIter?: number; }
+export interface Survey plusResult { values: number[]; converged: boolean; }
+export function computeSurvey plus(data: number[], opts: Survey plusOptions = {}): Survey plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey plus };
diff --git a/src/survey/pooling.ts b/src/survey/pooling.ts
new file mode 100644
index 000000000..99a42360c
--- /dev/null
+++ b/src/survey/pooling.ts
@@ -0,0 +1,22 @@
+/** Pooling module — tsb analytics library. */
+
+/** Options for Pooling. */
+export interface PoolingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Pooling. */
+export interface PoolingResult { values: number[]; converged: boolean; }
+
+/** Compute Pooling. */
+export function computePooling(data: number[], opts: PoolingOptions = {}): PoolingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePooling };
diff --git a/src/survey/pro.ts b/src/survey/pro.ts
new file mode 100644
index 000000000..ed9671faa
--- /dev/null
+++ b/src/survey/pro.ts
@@ -0,0 +1,15 @@
+/** Survey Pro module — tsb analytics library. */
+export interface Survey proOptions { tol?: number; maxIter?: number; }
+export interface Survey proResult { values: number[]; converged: boolean; }
+export function computeSurvey pro(data: number[], opts: Survey proOptions = {}): Survey proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey pro };
diff --git a/src/survey/recall.ts b/src/survey/recall.ts
new file mode 100644
index 000000000..7a9251cd5
--- /dev/null
+++ b/src/survey/recall.ts
@@ -0,0 +1,22 @@
+/** Recall module — tsb analytics library. */
+
+/** Options for Recall. */
+export interface RecallOptions { tol?: number; maxIter?: number; }
+
+/** Result from Recall. */
+export interface RecallResult { values: number[]; converged: boolean; }
+
+/** Compute Recall. */
+export function computeRecall(data: number[], opts: RecallOptions = {}): RecallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeRecall };
diff --git a/src/survey/reliability.ts b/src/survey/reliability.ts
new file mode 100644
index 000000000..1f53c73ea
--- /dev/null
+++ b/src/survey/reliability.ts
@@ -0,0 +1,22 @@
+/** Reliability module — tsb analytics library. */
+
+/** Options for Reliability. */
+export interface ReliabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Reliability. */
+export interface ReliabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Reliability. */
+export function computeReliability(data: number[], opts: ReliabilityOptions = {}): ReliabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeReliability };
diff --git a/src/survey/robust.ts b/src/survey/robust.ts
new file mode 100644
index 000000000..9b3b999b2
--- /dev/null
+++ b/src/survey/robust.ts
@@ -0,0 +1,15 @@
+/** Survey Robust module — tsb analytics library. */
+export interface Survey robustOptions { tol?: number; maxIter?: number; }
+export interface Survey robustResult { values: number[]; converged: boolean; }
+export function computeSurvey robust(data: number[], opts: Survey robustOptions = {}): Survey robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey robust };
diff --git a/src/survey/sampling.ts b/src/survey/sampling.ts
new file mode 100644
index 000000000..656bc191b
--- /dev/null
+++ b/src/survey/sampling.ts
@@ -0,0 +1,22 @@
+/** Sampling module — tsb analytics library. */
+
+/** Options for Sampling. */
+export interface SamplingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sampling. */
+export interface SamplingResult { values: number[]; converged: boolean; }
+
+/** Compute Sampling. */
+export function computeSampling(data: number[], opts: SamplingOptions = {}): SamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSampling };
diff --git a/src/survey/sem.ts b/src/survey/sem.ts
new file mode 100644
index 000000000..2fd6b2a76
--- /dev/null
+++ b/src/survey/sem.ts
@@ -0,0 +1,22 @@
+/** Sem module — tsb analytics library. */
+
+/** Options for Sem. */
+export interface SemOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sem. */
+export interface SemResult { values: number[]; converged: boolean; }
+
+/** Compute Sem. */
+export function computeSem(data: number[], opts: SemOptions = {}): SemResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSem };
diff --git a/src/survey/small.ts b/src/survey/small.ts
new file mode 100644
index 000000000..f6178d35c
--- /dev/null
+++ b/src/survey/small.ts
@@ -0,0 +1,15 @@
+/** Survey Small module — tsb analytics library. */
+export interface Survey smallOptions { tol?: number; maxIter?: number; }
+export interface Survey smallResult { values: number[]; converged: boolean; }
+export function computeSurvey small(data: number[], opts: Survey smallOptions = {}): Survey smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey small };
diff --git a/src/survey/small_area.ts b/src/survey/small_area.ts
new file mode 100644
index 000000000..a40919c3d
--- /dev/null
+++ b/src/survey/small_area.ts
@@ -0,0 +1,22 @@
+/** Small Area module — tsb analytics library. */
+
+/** Options for Small Area. */
+export interface SmallAreaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Small Area. */
+export interface SmallAreaResult { values: number[]; converged: boolean; }
+
+/** Compute Small Area. */
+export function computeSmallArea(data: number[], opts: SmallAreaOptions = {}): SmallAreaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSmallArea };
diff --git a/src/survey/social_desirability.ts b/src/survey/social_desirability.ts
new file mode 100644
index 000000000..98ff23eb6
--- /dev/null
+++ b/src/survey/social_desirability.ts
@@ -0,0 +1,22 @@
+/** Social Desirability module — tsb analytics library. */
+
+/** Options for Social Desirability. */
+export interface SocialDesirabilityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Social Desirability. */
+export interface SocialDesirabilityResult { values: number[]; converged: boolean; }
+
+/** Compute Social Desirability. */
+export function computeSocialDesirability(data: number[], opts: SocialDesirabilityOptions = {}): SocialDesirabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSocialDesirability };
diff --git a/src/survey/sparse.ts b/src/survey/sparse.ts
new file mode 100644
index 000000000..75a7d06a8
--- /dev/null
+++ b/src/survey/sparse.ts
@@ -0,0 +1,15 @@
+/** Survey Sparse module — tsb analytics library. */
+export interface Survey sparseOptions { tol?: number; maxIter?: number; }
+export interface Survey sparseResult { values: number[]; converged: boolean; }
+export function computeSurvey sparse(data: number[], opts: Survey sparseOptions = {}): Survey sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey sparse };
diff --git a/src/survey/stable.ts b/src/survey/stable.ts
new file mode 100644
index 000000000..01705eab1
--- /dev/null
+++ b/src/survey/stable.ts
@@ -0,0 +1,15 @@
+/** Survey Stable module — tsb analytics library. */
+export interface Survey stableOptions { tol?: number; maxIter?: number; }
+export interface Survey stableResult { values: number[]; converged: boolean; }
+export function computeSurvey stable(data: number[], opts: Survey stableOptions = {}): Survey stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey stable };
diff --git a/src/survey/stratification.ts b/src/survey/stratification.ts
new file mode 100644
index 000000000..2d2e88af5
--- /dev/null
+++ b/src/survey/stratification.ts
@@ -0,0 +1,22 @@
+/** Stratification module — tsb analytics library. */
+
+/** Options for Stratification. */
+export interface StratificationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stratification. */
+export interface StratificationResult { values: number[]; converged: boolean; }
+
+/** Compute Stratification. */
+export function computeStratification(data: number[], opts: StratificationOptions = {}): StratificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStratification };
diff --git a/src/survey/streaming.ts b/src/survey/streaming.ts
new file mode 100644
index 000000000..ac98649a4
--- /dev/null
+++ b/src/survey/streaming.ts
@@ -0,0 +1,15 @@
+/** Survey Streaming module — tsb analytics library. */
+export interface Survey streamingOptions { tol?: number; maxIter?: number; }
+export interface Survey streamingResult { values: number[]; converged: boolean; }
+export function computeSurvey streaming(data: number[], opts: Survey streamingOptions = {}): Survey streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey streaming };
diff --git a/src/survey/test_equating.ts b/src/survey/test_equating.ts
new file mode 100644
index 000000000..67c2eb8a4
--- /dev/null
+++ b/src/survey/test_equating.ts
@@ -0,0 +1,22 @@
+/** Test Equating module — tsb analytics library. */
+
+/** Options for Test Equating. */
+export interface TestEquatingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Test Equating. */
+export interface TestEquatingResult { values: number[]; converged: boolean; }
+
+/** Compute Test Equating. */
+export function computeTestEquating(data: number[], opts: TestEquatingOptions = {}): TestEquatingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTestEquating };
diff --git a/src/survey/translation.ts b/src/survey/translation.ts
new file mode 100644
index 000000000..95026cb1e
--- /dev/null
+++ b/src/survey/translation.ts
@@ -0,0 +1,22 @@
+/** Translation module — tsb analytics library. */
+
+/** Options for Translation. */
+export interface TranslationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Translation. */
+export interface TranslationResult { values: number[]; converged: boolean; }
+
+/** Compute Translation. */
+export function computeTranslation(data: number[], opts: TranslationOptions = {}): TranslationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeTranslation };
diff --git a/src/survey/v2.ts b/src/survey/v2.ts
new file mode 100644
index 000000000..f64bd9138
--- /dev/null
+++ b/src/survey/v2.ts
@@ -0,0 +1,15 @@
+/** Survey V2 module — tsb analytics library. */
+export interface Survey v2Options { tol?: number; maxIter?: number; }
+export interface Survey v2Result { values: number[]; converged: boolean; }
+export function computeSurvey v2(data: number[], opts: Survey v2Options = {}): Survey v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey v2 };
diff --git a/src/survey/v3.ts b/src/survey/v3.ts
new file mode 100644
index 000000000..d5e5f9693
--- /dev/null
+++ b/src/survey/v3.ts
@@ -0,0 +1,15 @@
+/** Survey V3 module — tsb analytics library. */
+export interface Survey v3Options { tol?: number; maxIter?: number; }
+export interface Survey v3Result { values: number[]; converged: boolean; }
+export function computeSurvey v3(data: number[], opts: Survey v3Options = {}): Survey v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey v3 };
diff --git a/src/survey/validity.ts b/src/survey/validity.ts
new file mode 100644
index 000000000..8ce7c2714
--- /dev/null
+++ b/src/survey/validity.ts
@@ -0,0 +1,22 @@
+/** Validity module — tsb analytics library. */
+
+/** Options for Validity. */
+export interface ValidityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Validity. */
+export interface ValidityResult { values: number[]; converged: boolean; }
+
+/** Compute Validity. */
+export function computeValidity(data: number[], opts: ValidityOptions = {}): ValidityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeValidity };
diff --git a/src/survey/vignette.ts b/src/survey/vignette.ts
new file mode 100644
index 000000000..3e8cc0292
--- /dev/null
+++ b/src/survey/vignette.ts
@@ -0,0 +1,22 @@
+/** Vignette module — tsb analytics library. */
+
+/** Options for Vignette. */
+export interface VignetteOptions { tol?: number; maxIter?: number; }
+
+/** Result from Vignette. */
+export interface VignetteResult { values: number[]; converged: boolean; }
+
+/** Compute Vignette. */
+export function computeVignette(data: number[], opts: VignetteOptions = {}): VignetteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVignette };
diff --git a/src/survey/wasm.ts b/src/survey/wasm.ts
new file mode 100644
index 000000000..bf918ac3b
--- /dev/null
+++ b/src/survey/wasm.ts
@@ -0,0 +1,15 @@
+/** Survey Wasm module — tsb analytics library. */
+export interface Survey wasmOptions { tol?: number; maxIter?: number; }
+export interface Survey wasmResult { values: number[]; converged: boolean; }
+export function computeSurvey wasm(data: number[], opts: Survey wasmOptions = {}): Survey wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey wasm };
diff --git a/src/survey/weighting.ts b/src/survey/weighting.ts
new file mode 100644
index 000000000..da5551067
--- /dev/null
+++ b/src/survey/weighting.ts
@@ -0,0 +1,22 @@
+/** Weighting module — tsb analytics library. */
+
+/** Options for Weighting. */
+export interface WeightingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Weighting. */
+export interface WeightingResult { values: number[]; converged: boolean; }
+
+/** Compute Weighting. */
+export function computeWeighting(data: number[], opts: WeightingOptions = {}): WeightingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWeighting };
diff --git a/src/survey/xlarge.ts b/src/survey/xlarge.ts
new file mode 100644
index 000000000..4910998b7
--- /dev/null
+++ b/src/survey/xlarge.ts
@@ -0,0 +1,15 @@
+/** Survey Xlarge module — tsb analytics library. */
+export interface Survey xlargeOptions { tol?: number; maxIter?: number; }
+export interface Survey xlargeResult { values: number[]; converged: boolean; }
+export function computeSurvey xlarge(data: number[], opts: Survey xlargeOptions = {}): Survey xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeSurvey xlarge };
diff --git a/src/tectonics/adaptation.ts b/src/tectonics/adaptation.ts
new file mode 100644
index 000000000..9fbd8058a
--- /dev/null
+++ b/src/tectonics/adaptation.ts
@@ -0,0 +1,14 @@
+/** tectonics adaptation module — tsb analytics library. */
+export interface TectonicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeTectonicsAdaptation(data: number[], opts: TectonicsAdaptationOptions = {}): TectonicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsAdaptation };
diff --git a/src/tectonics/aggregation.ts b/src/tectonics/aggregation.ts
new file mode 100644
index 000000000..25fd6d810
--- /dev/null
+++ b/src/tectonics/aggregation.ts
@@ -0,0 +1,14 @@
+/** tectonics aggregation module — tsb analytics library. */
+export interface TectonicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsAggregationResult { values: number[]; converged: boolean; }
+export function computeTectonicsAggregation(data: number[], opts: TectonicsAggregationOptions = {}): TectonicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsAggregation };
diff --git a/src/tectonics/algebra.ts b/src/tectonics/algebra.ts
new file mode 100644
index 000000000..91611adc1
--- /dev/null
+++ b/src/tectonics/algebra.ts
@@ -0,0 +1,14 @@
+/** tectonics algebra module — tsb analytics library. */
+export interface TectonicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface TectonicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeTectonicsAlgebra(data: number[], opts: TectonicsAlgebraOptions = {}): TectonicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsAlgebra };
diff --git a/src/tectonics/alignment.ts b/src/tectonics/alignment.ts
new file mode 100644
index 000000000..f66187470
--- /dev/null
+++ b/src/tectonics/alignment.ts
@@ -0,0 +1,14 @@
+/** tectonics alignment module — tsb analytics library. */
+export interface TectonicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface TectonicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeTectonicsAlignment(data: number[], opts: TectonicsAlignmentOptions = {}): TectonicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsAlignment };
diff --git a/src/tectonics/analysis.ts b/src/tectonics/analysis.ts
new file mode 100644
index 000000000..102feaae4
--- /dev/null
+++ b/src/tectonics/analysis.ts
@@ -0,0 +1,14 @@
+/** tectonics analysis module — tsb analytics library. */
+export interface TectonicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface TectonicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeTectonicsAnalysis(data: number[], opts: TectonicsAnalysisOptions = {}): TectonicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsAnalysis };
diff --git a/src/tectonics/augmentation.ts b/src/tectonics/augmentation.ts
new file mode 100644
index 000000000..66d6817aa
--- /dev/null
+++ b/src/tectonics/augmentation.ts
@@ -0,0 +1,14 @@
+/** tectonics augmentation module — tsb analytics library. */
+export interface TectonicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeTectonicsAugmentation(data: number[], opts: TectonicsAugmentationOptions = {}): TectonicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsAugmentation };
diff --git a/src/tectonics/bagging.ts b/src/tectonics/bagging.ts
new file mode 100644
index 000000000..f94d63b56
--- /dev/null
+++ b/src/tectonics/bagging.ts
@@ -0,0 +1,14 @@
+/** tectonics bagging module — tsb analytics library. */
+export interface TectonicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsBaggingResult { values: number[]; converged: boolean; }
+export function computeTectonicsBagging(data: number[], opts: TectonicsBaggingOptions = {}): TectonicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsBagging };
diff --git a/src/tectonics/basis.ts b/src/tectonics/basis.ts
new file mode 100644
index 000000000..ff1380894
--- /dev/null
+++ b/src/tectonics/basis.ts
@@ -0,0 +1,14 @@
+/** tectonics basis module — tsb analytics library. */
+export interface TectonicsBasisOptions { tol?: number; maxIter?: number; }
+export interface TectonicsBasisResult { values: number[]; converged: boolean; }
+export function computeTectonicsBasis(data: number[], opts: TectonicsBasisOptions = {}): TectonicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsBasis };
diff --git a/src/tectonics/benchmarking.ts b/src/tectonics/benchmarking.ts
new file mode 100644
index 000000000..3595a5ccb
--- /dev/null
+++ b/src/tectonics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** tectonics benchmarking module — tsb analytics library. */
+export interface TectonicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeTectonicsBenchmarking(data: number[], opts: TectonicsBenchmarkingOptions = {}): TectonicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsBenchmarking };
diff --git a/src/tectonics/blending.ts b/src/tectonics/blending.ts
new file mode 100644
index 000000000..f59b45a48
--- /dev/null
+++ b/src/tectonics/blending.ts
@@ -0,0 +1,14 @@
+/** tectonics blending module — tsb analytics library. */
+export interface TectonicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsBlendingResult { values: number[]; converged: boolean; }
+export function computeTectonicsBlending(data: number[], opts: TectonicsBlendingOptions = {}): TectonicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsBlending };
diff --git a/src/tectonics/boosting.ts b/src/tectonics/boosting.ts
new file mode 100644
index 000000000..f300a49db
--- /dev/null
+++ b/src/tectonics/boosting.ts
@@ -0,0 +1,14 @@
+/** tectonics boosting module — tsb analytics library. */
+export interface TectonicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsBoostingResult { values: number[]; converged: boolean; }
+export function computeTectonicsBoosting(data: number[], opts: TectonicsBoostingOptions = {}): TectonicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsBoosting };
diff --git a/src/tectonics/bootstrap.ts b/src/tectonics/bootstrap.ts
new file mode 100644
index 000000000..a3a074c4f
--- /dev/null
+++ b/src/tectonics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** tectonics bootstrap module — tsb analytics library. */
+export interface TectonicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface TectonicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeTectonicsBootstrap(data: number[], opts: TectonicsBootstrapOptions = {}): TectonicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsBootstrap };
diff --git a/src/tectonics/calculus.ts b/src/tectonics/calculus.ts
new file mode 100644
index 000000000..c281ded73
--- /dev/null
+++ b/src/tectonics/calculus.ts
@@ -0,0 +1,14 @@
+/** tectonics calculus module — tsb analytics library. */
+export interface TectonicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface TectonicsCalculusResult { values: number[]; converged: boolean; }
+export function computeTectonicsCalculus(data: number[], opts: TectonicsCalculusOptions = {}): TectonicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsCalculus };
diff --git a/src/tectonics/calibration.ts b/src/tectonics/calibration.ts
new file mode 100644
index 000000000..54dd0d22c
--- /dev/null
+++ b/src/tectonics/calibration.ts
@@ -0,0 +1,14 @@
+/** tectonics calibration module — tsb analytics library. */
+export interface TectonicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeTectonicsCalibration(data: number[], opts: TectonicsCalibrationOptions = {}): TectonicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsCalibration };
diff --git a/src/tectonics/characterization.ts b/src/tectonics/characterization.ts
new file mode 100644
index 000000000..9da44f7b5
--- /dev/null
+++ b/src/tectonics/characterization.ts
@@ -0,0 +1,14 @@
+/** tectonics characterization module — tsb analytics library. */
+export interface TectonicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeTectonicsCharacterization(data: number[], opts: TectonicsCharacterizationOptions = {}): TectonicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsCharacterization };
diff --git a/src/tectonics/classification.ts b/src/tectonics/classification.ts
new file mode 100644
index 000000000..ff93d6188
--- /dev/null
+++ b/src/tectonics/classification.ts
@@ -0,0 +1,14 @@
+/** tectonics classification module — tsb analytics library. */
+export interface TectonicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsClassificationResult { values: number[]; converged: boolean; }
+export function computeTectonicsClassification(data: number[], opts: TectonicsClassificationOptions = {}): TectonicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsClassification };
diff --git a/src/tectonics/clustering.ts b/src/tectonics/clustering.ts
new file mode 100644
index 000000000..6f8f00589
--- /dev/null
+++ b/src/tectonics/clustering.ts
@@ -0,0 +1,14 @@
+/** tectonics clustering module — tsb analytics library. */
+export interface TectonicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface TectonicsClusteringResult { values: number[]; converged: boolean; }
+export function computeTectonicsClustering(data: number[], opts: TectonicsClusteringOptions = {}): TectonicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsClustering };
diff --git a/src/tectonics/compression.ts b/src/tectonics/compression.ts
new file mode 100644
index 000000000..c7ed5dbfd
--- /dev/null
+++ b/src/tectonics/compression.ts
@@ -0,0 +1,14 @@
+/** tectonics compression module — tsb analytics library. */
+export interface TectonicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsCompressionResult { values: number[]; converged: boolean; }
+export function computeTectonicsCompression(data: number[], opts: TectonicsCompressionOptions = {}): TectonicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsCompression };
diff --git a/src/tectonics/continuous.ts b/src/tectonics/continuous.ts
new file mode 100644
index 000000000..971890ad7
--- /dev/null
+++ b/src/tectonics/continuous.ts
@@ -0,0 +1,14 @@
+/** tectonics continuous module — tsb analytics library. */
+export interface TectonicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface TectonicsContinuousResult { values: number[]; converged: boolean; }
+export function computeTectonicsContinuous(data: number[], opts: TectonicsContinuousOptions = {}): TectonicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsContinuous };
diff --git a/src/tectonics/control.ts b/src/tectonics/control.ts
new file mode 100644
index 000000000..97f413f45
--- /dev/null
+++ b/src/tectonics/control.ts
@@ -0,0 +1,14 @@
+/** tectonics control module — tsb analytics library. */
+export interface TectonicsControlOptions { tol?: number; maxIter?: number; }
+export interface TectonicsControlResult { values: number[]; converged: boolean; }
+export function computeTectonicsControl(data: number[], opts: TectonicsControlOptions = {}): TectonicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsControl };
diff --git a/src/tectonics/convergence.ts b/src/tectonics/convergence.ts
new file mode 100644
index 000000000..140b2c1ce
--- /dev/null
+++ b/src/tectonics/convergence.ts
@@ -0,0 +1,14 @@
+/** tectonics convergence module — tsb analytics library. */
+export interface TectonicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface TectonicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeTectonicsConvergence(data: number[], opts: TectonicsConvergenceOptions = {}): TectonicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsConvergence };
diff --git a/src/tectonics/convex.ts b/src/tectonics/convex.ts
new file mode 100644
index 000000000..53b92dc75
--- /dev/null
+++ b/src/tectonics/convex.ts
@@ -0,0 +1,14 @@
+/** tectonics convex module — tsb analytics library. */
+export interface TectonicsConvexOptions { tol?: number; maxIter?: number; }
+export interface TectonicsConvexResult { values: number[]; converged: boolean; }
+export function computeTectonicsConvex(data: number[], opts: TectonicsConvexOptions = {}): TectonicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsConvex };
diff --git a/src/tectonics/correlation.ts b/src/tectonics/correlation.ts
new file mode 100644
index 000000000..a0450c74c
--- /dev/null
+++ b/src/tectonics/correlation.ts
@@ -0,0 +1,14 @@
+/** tectonics correlation module — tsb analytics library. */
+export interface TectonicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeTectonicsCorrelation(data: number[], opts: TectonicsCorrelationOptions = {}): TectonicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsCorrelation };
diff --git a/src/tectonics/covariance.ts b/src/tectonics/covariance.ts
new file mode 100644
index 000000000..2ba2ab7e8
--- /dev/null
+++ b/src/tectonics/covariance.ts
@@ -0,0 +1,14 @@
+/** tectonics covariance module — tsb analytics library. */
+export interface TectonicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface TectonicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeTectonicsCovariance(data: number[], opts: TectonicsCovarianceOptions = {}): TectonicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsCovariance };
diff --git a/src/tectonics/cross_validation.ts b/src/tectonics/cross_validation.ts
new file mode 100644
index 000000000..ac2dcbcf4
--- /dev/null
+++ b/src/tectonics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** tectonics cross_validation module — tsb analytics library. */
+export interface TectonicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeTectonicsCrossValidation(data: number[], opts: TectonicsCrossValidationOptions = {}): TectonicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsCrossValidation };
diff --git a/src/tectonics/decoding.ts b/src/tectonics/decoding.ts
new file mode 100644
index 000000000..884f24fe7
--- /dev/null
+++ b/src/tectonics/decoding.ts
@@ -0,0 +1,14 @@
+/** tectonics decoding module — tsb analytics library. */
+export interface TectonicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDecodingResult { values: number[]; converged: boolean; }
+export function computeTectonicsDecoding(data: number[], opts: TectonicsDecodingOptions = {}): TectonicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDecoding };
diff --git a/src/tectonics/decomposition.ts b/src/tectonics/decomposition.ts
new file mode 100644
index 000000000..2a480c0e5
--- /dev/null
+++ b/src/tectonics/decomposition.ts
@@ -0,0 +1,14 @@
+/** tectonics decomposition module — tsb analytics library. */
+export interface TectonicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeTectonicsDecomposition(data: number[], opts: TectonicsDecompositionOptions = {}): TectonicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDecomposition };
diff --git a/src/tectonics/detection.ts b/src/tectonics/detection.ts
new file mode 100644
index 000000000..69c867b41
--- /dev/null
+++ b/src/tectonics/detection.ts
@@ -0,0 +1,14 @@
+/** tectonics detection module — tsb analytics library. */
+export interface TectonicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDetectionResult { values: number[]; converged: boolean; }
+export function computeTectonicsDetection(data: number[], opts: TectonicsDetectionOptions = {}): TectonicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDetection };
diff --git a/src/tectonics/deterministic.ts b/src/tectonics/deterministic.ts
new file mode 100644
index 000000000..90cb14651
--- /dev/null
+++ b/src/tectonics/deterministic.ts
@@ -0,0 +1,14 @@
+/** tectonics deterministic module — tsb analytics library. */
+export interface TectonicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeTectonicsDeterministic(data: number[], opts: TectonicsDeterministicOptions = {}): TectonicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDeterministic };
diff --git a/src/tectonics/diagnostics.ts b/src/tectonics/diagnostics.ts
new file mode 100644
index 000000000..a381c2513
--- /dev/null
+++ b/src/tectonics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** tectonics diagnostics module — tsb analytics library. */
+export interface TectonicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeTectonicsDiagnostics(data: number[], opts: TectonicsDiagnosticsOptions = {}): TectonicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDiagnostics };
diff --git a/src/tectonics/differential.ts b/src/tectonics/differential.ts
new file mode 100644
index 000000000..73637794d
--- /dev/null
+++ b/src/tectonics/differential.ts
@@ -0,0 +1,14 @@
+/** tectonics differential module — tsb analytics library. */
+export interface TectonicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeTectonicsDifferential(data: number[], opts: TectonicsDifferentialOptions = {}): TectonicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDifferential };
diff --git a/src/tectonics/discrete.ts b/src/tectonics/discrete.ts
new file mode 100644
index 000000000..2335403df
--- /dev/null
+++ b/src/tectonics/discrete.ts
@@ -0,0 +1,14 @@
+/** tectonics discrete module — tsb analytics library. */
+export interface TectonicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeTectonicsDiscrete(data: number[], opts: TectonicsDiscreteOptions = {}): TectonicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDiscrete };
diff --git a/src/tectonics/distribution.ts b/src/tectonics/distribution.ts
new file mode 100644
index 000000000..1e4bfd388
--- /dev/null
+++ b/src/tectonics/distribution.ts
@@ -0,0 +1,14 @@
+/** tectonics distribution module — tsb analytics library. */
+export interface TectonicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDistributionResult { values: number[]; converged: boolean; }
+export function computeTectonicsDistribution(data: number[], opts: TectonicsDistributionOptions = {}): TectonicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDistribution };
diff --git a/src/tectonics/dynamic.ts b/src/tectonics/dynamic.ts
new file mode 100644
index 000000000..ff4abf0bd
--- /dev/null
+++ b/src/tectonics/dynamic.ts
@@ -0,0 +1,14 @@
+/** tectonics dynamic module — tsb analytics library. */
+export interface TectonicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface TectonicsDynamicResult { values: number[]; converged: boolean; }
+export function computeTectonicsDynamic(data: number[], opts: TectonicsDynamicOptions = {}): TectonicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsDynamic };
diff --git a/src/tectonics/embedding.ts b/src/tectonics/embedding.ts
new file mode 100644
index 000000000..a5557f3cc
--- /dev/null
+++ b/src/tectonics/embedding.ts
@@ -0,0 +1,14 @@
+/** tectonics embedding module — tsb analytics library. */
+export interface TectonicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeTectonicsEmbedding(data: number[], opts: TectonicsEmbeddingOptions = {}): TectonicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsEmbedding };
diff --git a/src/tectonics/encoding.ts b/src/tectonics/encoding.ts
new file mode 100644
index 000000000..73d2e7d80
--- /dev/null
+++ b/src/tectonics/encoding.ts
@@ -0,0 +1,14 @@
+/** tectonics encoding module — tsb analytics library. */
+export interface TectonicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsEncodingResult { values: number[]; converged: boolean; }
+export function computeTectonicsEncoding(data: number[], opts: TectonicsEncodingOptions = {}): TectonicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsEncoding };
diff --git a/src/tectonics/ensemble.ts b/src/tectonics/ensemble.ts
new file mode 100644
index 000000000..0fed0964f
--- /dev/null
+++ b/src/tectonics/ensemble.ts
@@ -0,0 +1,14 @@
+/** tectonics ensemble module — tsb analytics library. */
+export interface TectonicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface TectonicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeTectonicsEnsemble(data: number[], opts: TectonicsEnsembleOptions = {}): TectonicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsEnsemble };
diff --git a/src/tectonics/estimation.ts b/src/tectonics/estimation.ts
new file mode 100644
index 000000000..eb558d146
--- /dev/null
+++ b/src/tectonics/estimation.ts
@@ -0,0 +1,14 @@
+/** tectonics estimation module — tsb analytics library. */
+export interface TectonicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsEstimationResult { values: number[]; converged: boolean; }
+export function computeTectonicsEstimation(data: number[], opts: TectonicsEstimationOptions = {}): TectonicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsEstimation };
diff --git a/src/tectonics/evaluation.ts b/src/tectonics/evaluation.ts
new file mode 100644
index 000000000..48e2bd76f
--- /dev/null
+++ b/src/tectonics/evaluation.ts
@@ -0,0 +1,14 @@
+/** tectonics evaluation module — tsb analytics library. */
+export interface TectonicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeTectonicsEvaluation(data: number[], opts: TectonicsEvaluationOptions = {}): TectonicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsEvaluation };
diff --git a/src/tectonics/extrapolation.ts b/src/tectonics/extrapolation.ts
new file mode 100644
index 000000000..a94e82ce7
--- /dev/null
+++ b/src/tectonics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** tectonics extrapolation module — tsb analytics library. */
+export interface TectonicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeTectonicsExtrapolation(data: number[], opts: TectonicsExtrapolationOptions = {}): TectonicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsExtrapolation };
diff --git a/src/tectonics/features.ts b/src/tectonics/features.ts
new file mode 100644
index 000000000..6ce4aef08
--- /dev/null
+++ b/src/tectonics/features.ts
@@ -0,0 +1,14 @@
+/** tectonics features module — tsb analytics library. */
+export interface TectonicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface TectonicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeTectonicsFeatures(data: number[], opts: TectonicsFeaturesOptions = {}): TectonicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsFeatures };
diff --git a/src/tectonics/feedback.ts b/src/tectonics/feedback.ts
new file mode 100644
index 000000000..180bccba8
--- /dev/null
+++ b/src/tectonics/feedback.ts
@@ -0,0 +1,14 @@
+/** tectonics feedback module — tsb analytics library. */
+export interface TectonicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface TectonicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeTectonicsFeedback(data: number[], opts: TectonicsFeedbackOptions = {}): TectonicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsFeedback };
diff --git a/src/tectonics/filtering.ts b/src/tectonics/filtering.ts
new file mode 100644
index 000000000..ef1596881
--- /dev/null
+++ b/src/tectonics/filtering.ts
@@ -0,0 +1,14 @@
+/** tectonics filtering module — tsb analytics library. */
+export interface TectonicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface TectonicsFilteringResult { values: number[]; converged: boolean; }
+export function computeTectonicsFiltering(data: number[], opts: TectonicsFilteringOptions = {}): TectonicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsFiltering };
diff --git a/src/tectonics/fourier.ts b/src/tectonics/fourier.ts
new file mode 100644
index 000000000..61a9670bf
--- /dev/null
+++ b/src/tectonics/fourier.ts
@@ -0,0 +1,14 @@
+/** tectonics fourier module — tsb analytics library. */
+export interface TectonicsFourierOptions { tol?: number; maxIter?: number; }
+export interface TectonicsFourierResult { values: number[]; converged: boolean; }
+export function computeTectonicsFourier(data: number[], opts: TectonicsFourierOptions = {}): TectonicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsFourier };
diff --git a/src/tectonics/fusion.ts b/src/tectonics/fusion.ts
new file mode 100644
index 000000000..93c4881f3
--- /dev/null
+++ b/src/tectonics/fusion.ts
@@ -0,0 +1,14 @@
+/** tectonics fusion module — tsb analytics library. */
+export interface TectonicsFusionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsFusionResult { values: number[]; converged: boolean; }
+export function computeTectonicsFusion(data: number[], opts: TectonicsFusionOptions = {}): TectonicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsFusion };
diff --git a/src/tectonics/generation.ts b/src/tectonics/generation.ts
new file mode 100644
index 000000000..edfd047f7
--- /dev/null
+++ b/src/tectonics/generation.ts
@@ -0,0 +1,14 @@
+/** tectonics generation module — tsb analytics library. */
+export interface TectonicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsGenerationResult { values: number[]; converged: boolean; }
+export function computeTectonicsGeneration(data: number[], opts: TectonicsGenerationOptions = {}): TectonicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsGeneration };
diff --git a/src/tectonics/geometry.ts b/src/tectonics/geometry.ts
new file mode 100644
index 000000000..3249efecc
--- /dev/null
+++ b/src/tectonics/geometry.ts
@@ -0,0 +1,14 @@
+/** tectonics geometry module — tsb analytics library. */
+export interface TectonicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface TectonicsGeometryResult { values: number[]; converged: boolean; }
+export function computeTectonicsGeometry(data: number[], opts: TectonicsGeometryOptions = {}): TectonicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsGeometry };
diff --git a/src/tectonics/gradient.ts b/src/tectonics/gradient.ts
new file mode 100644
index 000000000..4a6aba0ea
--- /dev/null
+++ b/src/tectonics/gradient.ts
@@ -0,0 +1,14 @@
+/** tectonics gradient module — tsb analytics library. */
+export interface TectonicsGradientOptions { tol?: number; maxIter?: number; }
+export interface TectonicsGradientResult { values: number[]; converged: boolean; }
+export function computeTectonicsGradient(data: number[], opts: TectonicsGradientOptions = {}): TectonicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsGradient };
diff --git a/src/tectonics/hessian.ts b/src/tectonics/hessian.ts
new file mode 100644
index 000000000..3d8e78b3b
--- /dev/null
+++ b/src/tectonics/hessian.ts
@@ -0,0 +1,14 @@
+/** tectonics hessian module — tsb analytics library. */
+export interface TectonicsHessianOptions { tol?: number; maxIter?: number; }
+export interface TectonicsHessianResult { values: number[]; converged: boolean; }
+export function computeTectonicsHessian(data: number[], opts: TectonicsHessianOptions = {}): TectonicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsHessian };
diff --git a/src/tectonics/hypothesis.ts b/src/tectonics/hypothesis.ts
new file mode 100644
index 000000000..cd908c526
--- /dev/null
+++ b/src/tectonics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** tectonics hypothesis module — tsb analytics library. */
+export interface TectonicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface TectonicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeTectonicsHypothesis(data: number[], opts: TectonicsHypothesisOptions = {}): TectonicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsHypothesis };
diff --git a/src/tectonics/inference.ts b/src/tectonics/inference.ts
new file mode 100644
index 000000000..4e430daf3
--- /dev/null
+++ b/src/tectonics/inference.ts
@@ -0,0 +1,14 @@
+/** tectonics inference module — tsb analytics library. */
+export interface TectonicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface TectonicsInferenceResult { values: number[]; converged: boolean; }
+export function computeTectonicsInference(data: number[], opts: TectonicsInferenceOptions = {}): TectonicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsInference };
diff --git a/src/tectonics/inference2.ts b/src/tectonics/inference2.ts
new file mode 100644
index 000000000..7996a2e34
--- /dev/null
+++ b/src/tectonics/inference2.ts
@@ -0,0 +1,14 @@
+/** tectonics inference2 module — tsb analytics library. */
+export interface TectonicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface TectonicsInferenceResult { values: number[]; converged: boolean; }
+export function computeTectonicsInference(data: number[], opts: TectonicsInferenceOptions = {}): TectonicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsInference };
diff --git a/src/tectonics/integral.ts b/src/tectonics/integral.ts
new file mode 100644
index 000000000..a9f21ebb0
--- /dev/null
+++ b/src/tectonics/integral.ts
@@ -0,0 +1,14 @@
+/** tectonics integral module — tsb analytics library. */
+export interface TectonicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface TectonicsIntegralResult { values: number[]; converged: boolean; }
+export function computeTectonicsIntegral(data: number[], opts: TectonicsIntegralOptions = {}): TectonicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsIntegral };
diff --git a/src/tectonics/integration.ts b/src/tectonics/integration.ts
new file mode 100644
index 000000000..d6541b976
--- /dev/null
+++ b/src/tectonics/integration.ts
@@ -0,0 +1,14 @@
+/** tectonics integration module — tsb analytics library. */
+export interface TectonicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeTectonicsIntegration(data: number[], opts: TectonicsIntegrationOptions = {}): TectonicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsIntegration };
diff --git a/src/tectonics/interpolation.ts b/src/tectonics/interpolation.ts
new file mode 100644
index 000000000..8d6df6d4a
--- /dev/null
+++ b/src/tectonics/interpolation.ts
@@ -0,0 +1,14 @@
+/** tectonics interpolation module — tsb analytics library. */
+export interface TectonicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeTectonicsInterpolation(data: number[], opts: TectonicsInterpolationOptions = {}): TectonicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsInterpolation };
diff --git a/src/tectonics/jacobian.ts b/src/tectonics/jacobian.ts
new file mode 100644
index 000000000..43a06ecd0
--- /dev/null
+++ b/src/tectonics/jacobian.ts
@@ -0,0 +1,14 @@
+/** tectonics jacobian module — tsb analytics library. */
+export interface TectonicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface TectonicsJacobianResult { values: number[]; converged: boolean; }
+export function computeTectonicsJacobian(data: number[], opts: TectonicsJacobianOptions = {}): TectonicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsJacobian };
diff --git a/src/tectonics/kernel.ts b/src/tectonics/kernel.ts
new file mode 100644
index 000000000..bd456322f
--- /dev/null
+++ b/src/tectonics/kernel.ts
@@ -0,0 +1,14 @@
+/** tectonics kernel module — tsb analytics library. */
+export interface TectonicsKernelOptions { tol?: number; maxIter?: number; }
+export interface TectonicsKernelResult { values: number[]; converged: boolean; }
+export function computeTectonicsKernel(data: number[], opts: TectonicsKernelOptions = {}): TectonicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsKernel };
diff --git a/src/tectonics/laplacian.ts b/src/tectonics/laplacian.ts
new file mode 100644
index 000000000..31a1c0e11
--- /dev/null
+++ b/src/tectonics/laplacian.ts
@@ -0,0 +1,14 @@
+/** tectonics laplacian module — tsb analytics library. */
+export interface TectonicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface TectonicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeTectonicsLaplacian(data: number[], opts: TectonicsLaplacianOptions = {}): TectonicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsLaplacian };
diff --git a/src/tectonics/learning.ts b/src/tectonics/learning.ts
new file mode 100644
index 000000000..18ad32f99
--- /dev/null
+++ b/src/tectonics/learning.ts
@@ -0,0 +1,14 @@
+/** tectonics learning module — tsb analytics library. */
+export interface TectonicsLearningOptions { tol?: number; maxIter?: number; }
+export interface TectonicsLearningResult { values: number[]; converged: boolean; }
+export function computeTectonicsLearning(data: number[], opts: TectonicsLearningOptions = {}): TectonicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsLearning };
diff --git a/src/tectonics/linear.ts b/src/tectonics/linear.ts
new file mode 100644
index 000000000..ed7eb1a52
--- /dev/null
+++ b/src/tectonics/linear.ts
@@ -0,0 +1,14 @@
+/** tectonics linear module — tsb analytics library. */
+export interface TectonicsLinearOptions { tol?: number; maxIter?: number; }
+export interface TectonicsLinearResult { values: number[]; converged: boolean; }
+export function computeTectonicsLinear(data: number[], opts: TectonicsLinearOptions = {}): TectonicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsLinear };
diff --git a/src/tectonics/manifold.ts b/src/tectonics/manifold.ts
new file mode 100644
index 000000000..96d8d8235
--- /dev/null
+++ b/src/tectonics/manifold.ts
@@ -0,0 +1,14 @@
+/** tectonics manifold module — tsb analytics library. */
+export interface TectonicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface TectonicsManifoldResult { values: number[]; converged: boolean; }
+export function computeTectonicsManifold(data: number[], opts: TectonicsManifoldOptions = {}): TectonicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsManifold };
diff --git a/src/tectonics/matching.ts b/src/tectonics/matching.ts
new file mode 100644
index 000000000..b074455ab
--- /dev/null
+++ b/src/tectonics/matching.ts
@@ -0,0 +1,14 @@
+/** tectonics matching module — tsb analytics library. */
+export interface TectonicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsMatchingResult { values: number[]; converged: boolean; }
+export function computeTectonicsMatching(data: number[], opts: TectonicsMatchingOptions = {}): TectonicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsMatching };
diff --git a/src/tectonics/measurement.ts b/src/tectonics/measurement.ts
new file mode 100644
index 000000000..b3a536c38
--- /dev/null
+++ b/src/tectonics/measurement.ts
@@ -0,0 +1,14 @@
+/** tectonics measurement module — tsb analytics library. */
+export interface TectonicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface TectonicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeTectonicsMeasurement(data: number[], opts: TectonicsMeasurementOptions = {}): TectonicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsMeasurement };
diff --git a/src/tectonics/metrics.ts b/src/tectonics/metrics.ts
new file mode 100644
index 000000000..7b086089b
--- /dev/null
+++ b/src/tectonics/metrics.ts
@@ -0,0 +1,14 @@
+/** tectonics metrics module — tsb analytics library. */
+export interface TectonicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface TectonicsMetricsResult { values: number[]; converged: boolean; }
+export function computeTectonicsMetrics(data: number[], opts: TectonicsMetricsOptions = {}): TectonicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsMetrics };
diff --git a/src/tectonics/modeling.ts b/src/tectonics/modeling.ts
new file mode 100644
index 000000000..92824256d
--- /dev/null
+++ b/src/tectonics/modeling.ts
@@ -0,0 +1,14 @@
+/** tectonics modeling module — tsb analytics library. */
+export interface TectonicsModelingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsModelingResult { values: number[]; converged: boolean; }
+export function computeTectonicsModeling(data: number[], opts: TectonicsModelingOptions = {}): TectonicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsModeling };
diff --git a/src/tectonics/monitoring.ts b/src/tectonics/monitoring.ts
new file mode 100644
index 000000000..7692f924d
--- /dev/null
+++ b/src/tectonics/monitoring.ts
@@ -0,0 +1,14 @@
+/** tectonics monitoring module — tsb analytics library. */
+export interface TectonicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface TectonicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeTectonicsMonitoring(data: number[], opts: TectonicsMonitoringOptions = {}): TectonicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsMonitoring };
diff --git a/src/tectonics/nonlinear.ts b/src/tectonics/nonlinear.ts
new file mode 100644
index 000000000..8c421a9fd
--- /dev/null
+++ b/src/tectonics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** tectonics nonlinear module — tsb analytics library. */
+export interface TectonicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface TectonicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeTectonicsNonlinear(data: number[], opts: TectonicsNonlinearOptions = {}): TectonicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsNonlinear };
diff --git a/src/tectonics/normalization.ts b/src/tectonics/normalization.ts
new file mode 100644
index 000000000..d1b6521a1
--- /dev/null
+++ b/src/tectonics/normalization.ts
@@ -0,0 +1,14 @@
+/** tectonics normalization module — tsb analytics library. */
+export interface TectonicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeTectonicsNormalization(data: number[], opts: TectonicsNormalizationOptions = {}): TectonicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsNormalization };
diff --git a/src/tectonics/optimization.ts b/src/tectonics/optimization.ts
new file mode 100644
index 000000000..de2fdd566
--- /dev/null
+++ b/src/tectonics/optimization.ts
@@ -0,0 +1,14 @@
+/** tectonics optimization module — tsb analytics library. */
+export interface TectonicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeTectonicsOptimization(data: number[], opts: TectonicsOptimizationOptions = {}): TectonicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsOptimization };
diff --git a/src/tectonics/patterns.ts b/src/tectonics/patterns.ts
new file mode 100644
index 000000000..0d14690e2
--- /dev/null
+++ b/src/tectonics/patterns.ts
@@ -0,0 +1,14 @@
+/** tectonics patterns module — tsb analytics library. */
+export interface TectonicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface TectonicsPatternsResult { values: number[]; converged: boolean; }
+export function computeTectonicsPatterns(data: number[], opts: TectonicsPatternsOptions = {}): TectonicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsPatterns };
diff --git a/src/tectonics/permutation.ts b/src/tectonics/permutation.ts
new file mode 100644
index 000000000..3fd4488d7
--- /dev/null
+++ b/src/tectonics/permutation.ts
@@ -0,0 +1,14 @@
+/** tectonics permutation module — tsb analytics library. */
+export interface TectonicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsPermutationResult { values: number[]; converged: boolean; }
+export function computeTectonicsPermutation(data: number[], opts: TectonicsPermutationOptions = {}): TectonicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsPermutation };
diff --git a/src/tectonics/prediction.ts b/src/tectonics/prediction.ts
new file mode 100644
index 000000000..3363069d2
--- /dev/null
+++ b/src/tectonics/prediction.ts
@@ -0,0 +1,14 @@
+/** tectonics prediction module — tsb analytics library. */
+export interface TectonicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsPredictionResult { values: number[]; converged: boolean; }
+export function computeTectonicsPrediction(data: number[], opts: TectonicsPredictionOptions = {}): TectonicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsPrediction };
diff --git a/src/tectonics/processing.ts b/src/tectonics/processing.ts
new file mode 100644
index 000000000..34a4ec59e
--- /dev/null
+++ b/src/tectonics/processing.ts
@@ -0,0 +1,14 @@
+/** tectonics processing module — tsb analytics library. */
+export interface TectonicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsProcessingResult { values: number[]; converged: boolean; }
+export function computeTectonicsProcessing(data: number[], opts: TectonicsProcessingOptions = {}): TectonicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsProcessing };
diff --git a/src/tectonics/profiling.ts b/src/tectonics/profiling.ts
new file mode 100644
index 000000000..6c5aac9b6
--- /dev/null
+++ b/src/tectonics/profiling.ts
@@ -0,0 +1,14 @@
+/** tectonics profiling module — tsb analytics library. */
+export interface TectonicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsProfilingResult { values: number[]; converged: boolean; }
+export function computeTectonicsProfiling(data: number[], opts: TectonicsProfilingOptions = {}): TectonicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsProfiling };
diff --git a/src/tectonics/projection.ts b/src/tectonics/projection.ts
new file mode 100644
index 000000000..d23aa959b
--- /dev/null
+++ b/src/tectonics/projection.ts
@@ -0,0 +1,14 @@
+/** tectonics projection module — tsb analytics library. */
+export interface TectonicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsProjectionResult { values: number[]; converged: boolean; }
+export function computeTectonicsProjection(data: number[], opts: TectonicsProjectionOptions = {}): TectonicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsProjection };
diff --git a/src/tectonics/ranking.ts b/src/tectonics/ranking.ts
new file mode 100644
index 000000000..5594c49a8
--- /dev/null
+++ b/src/tectonics/ranking.ts
@@ -0,0 +1,14 @@
+/** tectonics ranking module — tsb analytics library. */
+export interface TectonicsRankingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsRankingResult { values: number[]; converged: boolean; }
+export function computeTectonicsRanking(data: number[], opts: TectonicsRankingOptions = {}): TectonicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsRanking };
diff --git a/src/tectonics/reconstruction.ts b/src/tectonics/reconstruction.ts
new file mode 100644
index 000000000..271c564bb
--- /dev/null
+++ b/src/tectonics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** tectonics reconstruction module — tsb analytics library. */
+export interface TectonicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeTectonicsReconstruction(data: number[], opts: TectonicsReconstructionOptions = {}): TectonicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsReconstruction };
diff --git a/src/tectonics/registration.ts b/src/tectonics/registration.ts
new file mode 100644
index 000000000..8a7b2ef1f
--- /dev/null
+++ b/src/tectonics/registration.ts
@@ -0,0 +1,14 @@
+/** tectonics registration module — tsb analytics library. */
+export interface TectonicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeTectonicsRegistration(data: number[], opts: TectonicsRegistrationOptions = {}): TectonicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsRegistration };
diff --git a/src/tectonics/regression.ts b/src/tectonics/regression.ts
new file mode 100644
index 000000000..f5c2692f0
--- /dev/null
+++ b/src/tectonics/regression.ts
@@ -0,0 +1,14 @@
+/** tectonics regression module — tsb analytics library. */
+export interface TectonicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsRegressionResult { values: number[]; converged: boolean; }
+export function computeTectonicsRegression(data: number[], opts: TectonicsRegressionOptions = {}): TectonicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsRegression };
diff --git a/src/tectonics/regularization.ts b/src/tectonics/regularization.ts
new file mode 100644
index 000000000..d26aadfaa
--- /dev/null
+++ b/src/tectonics/regularization.ts
@@ -0,0 +1,14 @@
+/** tectonics regularization module — tsb analytics library. */
+export interface TectonicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeTectonicsRegularization(data: number[], opts: TectonicsRegularizationOptions = {}): TectonicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsRegularization };
diff --git a/src/tectonics/robustness.ts b/src/tectonics/robustness.ts
new file mode 100644
index 000000000..763d2def8
--- /dev/null
+++ b/src/tectonics/robustness.ts
@@ -0,0 +1,14 @@
+/** tectonics robustness module — tsb analytics library. */
+export interface TectonicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface TectonicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeTectonicsRobustness(data: number[], opts: TectonicsRobustnessOptions = {}): TectonicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsRobustness };
diff --git a/src/tectonics/sampling.ts b/src/tectonics/sampling.ts
new file mode 100644
index 000000000..b8812e570
--- /dev/null
+++ b/src/tectonics/sampling.ts
@@ -0,0 +1,14 @@
+/** tectonics sampling module — tsb analytics library. */
+export interface TectonicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsSamplingResult { values: number[]; converged: boolean; }
+export function computeTectonicsSampling(data: number[], opts: TectonicsSamplingOptions = {}): TectonicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsSampling };
diff --git a/src/tectonics/sampling2.ts b/src/tectonics/sampling2.ts
new file mode 100644
index 000000000..44fd49938
--- /dev/null
+++ b/src/tectonics/sampling2.ts
@@ -0,0 +1,14 @@
+/** tectonics sampling2 module — tsb analytics library. */
+export interface TectonicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsSamplingResult { values: number[]; converged: boolean; }
+export function computeTectonicsSampling(data: number[], opts: TectonicsSamplingOptions = {}): TectonicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsSampling };
diff --git a/src/tectonics/scaling.ts b/src/tectonics/scaling.ts
new file mode 100644
index 000000000..2531c82b5
--- /dev/null
+++ b/src/tectonics/scaling.ts
@@ -0,0 +1,14 @@
+/** tectonics scaling module — tsb analytics library. */
+export interface TectonicsScalingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsScalingResult { values: number[]; converged: boolean; }
+export function computeTectonicsScaling(data: number[], opts: TectonicsScalingOptions = {}): TectonicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsScaling };
diff --git a/src/tectonics/scoring.ts b/src/tectonics/scoring.ts
new file mode 100644
index 000000000..317037f1d
--- /dev/null
+++ b/src/tectonics/scoring.ts
@@ -0,0 +1,14 @@
+/** tectonics scoring module — tsb analytics library. */
+export interface TectonicsScoringOptions { tol?: number; maxIter?: number; }
+export interface TectonicsScoringResult { values: number[]; converged: boolean; }
+export function computeTectonicsScoring(data: number[], opts: TectonicsScoringOptions = {}): TectonicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsScoring };
diff --git a/src/tectonics/segmentation.ts b/src/tectonics/segmentation.ts
new file mode 100644
index 000000000..72e0e92c5
--- /dev/null
+++ b/src/tectonics/segmentation.ts
@@ -0,0 +1,14 @@
+/** tectonics segmentation module — tsb analytics library. */
+export interface TectonicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeTectonicsSegmentation(data: number[], opts: TectonicsSegmentationOptions = {}): TectonicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsSegmentation };
diff --git a/src/tectonics/selection.ts b/src/tectonics/selection.ts
new file mode 100644
index 000000000..b1488b552
--- /dev/null
+++ b/src/tectonics/selection.ts
@@ -0,0 +1,14 @@
+/** tectonics selection module — tsb analytics library. */
+export interface TectonicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface TectonicsSelectionResult { values: number[]; converged: boolean; }
+export function computeTectonicsSelection(data: number[], opts: TectonicsSelectionOptions = {}): TectonicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsSelection };
diff --git a/src/tectonics/sensitivity.ts b/src/tectonics/sensitivity.ts
new file mode 100644
index 000000000..87b43e3c5
--- /dev/null
+++ b/src/tectonics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** tectonics sensitivity module — tsb analytics library. */
+export interface TectonicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface TectonicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeTectonicsSensitivity(data: number[], opts: TectonicsSensitivityOptions = {}): TectonicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsSensitivity };
diff --git a/src/tectonics/simulation.ts b/src/tectonics/simulation.ts
new file mode 100644
index 000000000..edb0160e0
--- /dev/null
+++ b/src/tectonics/simulation.ts
@@ -0,0 +1,14 @@
+/** tectonics simulation module — tsb analytics library. */
+export interface TectonicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsSimulationResult { values: number[]; converged: boolean; }
+export function computeTectonicsSimulation(data: number[], opts: TectonicsSimulationOptions = {}): TectonicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsSimulation };
diff --git a/src/tectonics/smoothing.ts b/src/tectonics/smoothing.ts
new file mode 100644
index 000000000..f65ff5eee
--- /dev/null
+++ b/src/tectonics/smoothing.ts
@@ -0,0 +1,14 @@
+/** tectonics smoothing module — tsb analytics library. */
+export interface TectonicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeTectonicsSmoothing(data: number[], opts: TectonicsSmoothingOptions = {}): TectonicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsSmoothing };
diff --git a/src/tectonics/stability.ts b/src/tectonics/stability.ts
new file mode 100644
index 000000000..3af140876
--- /dev/null
+++ b/src/tectonics/stability.ts
@@ -0,0 +1,14 @@
+/** tectonics stability module — tsb analytics library. */
+export interface TectonicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface TectonicsStabilityResult { values: number[]; converged: boolean; }
+export function computeTectonicsStability(data: number[], opts: TectonicsStabilityOptions = {}): TectonicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsStability };
diff --git a/src/tectonics/stacking.ts b/src/tectonics/stacking.ts
new file mode 100644
index 000000000..bdd5dad82
--- /dev/null
+++ b/src/tectonics/stacking.ts
@@ -0,0 +1,14 @@
+/** tectonics stacking module — tsb analytics library. */
+export interface TectonicsStackingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsStackingResult { values: number[]; converged: boolean; }
+export function computeTectonicsStacking(data: number[], opts: TectonicsStackingOptions = {}): TectonicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsStacking };
diff --git a/src/tectonics/standardization.ts b/src/tectonics/standardization.ts
new file mode 100644
index 000000000..f11279566
--- /dev/null
+++ b/src/tectonics/standardization.ts
@@ -0,0 +1,14 @@
+/** tectonics standardization module — tsb analytics library. */
+export interface TectonicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeTectonicsStandardization(data: number[], opts: TectonicsStandardizationOptions = {}): TectonicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsStandardization };
diff --git a/src/tectonics/static.ts b/src/tectonics/static.ts
new file mode 100644
index 000000000..a38137ea6
--- /dev/null
+++ b/src/tectonics/static.ts
@@ -0,0 +1,14 @@
+/** tectonics static module — tsb analytics library. */
+export interface TectonicsStaticOptions { tol?: number; maxIter?: number; }
+export interface TectonicsStaticResult { values: number[]; converged: boolean; }
+export function computeTectonicsStatic(data: number[], opts: TectonicsStaticOptions = {}): TectonicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsStatic };
diff --git a/src/tectonics/stochastic.ts b/src/tectonics/stochastic.ts
new file mode 100644
index 000000000..3d1378110
--- /dev/null
+++ b/src/tectonics/stochastic.ts
@@ -0,0 +1,14 @@
+/** tectonics stochastic module — tsb analytics library. */
+export interface TectonicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface TectonicsStochasticResult { values: number[]; converged: boolean; }
+export function computeTectonicsStochastic(data: number[], opts: TectonicsStochasticOptions = {}): TectonicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsStochastic };
diff --git a/src/tectonics/synthesis.ts b/src/tectonics/synthesis.ts
new file mode 100644
index 000000000..a85486c80
--- /dev/null
+++ b/src/tectonics/synthesis.ts
@@ -0,0 +1,14 @@
+/** tectonics synthesis module — tsb analytics library. */
+export interface TectonicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface TectonicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeTectonicsSynthesis(data: number[], opts: TectonicsSynthesisOptions = {}): TectonicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsSynthesis };
diff --git a/src/tectonics/topology.ts b/src/tectonics/topology.ts
new file mode 100644
index 000000000..cf02b3bd2
--- /dev/null
+++ b/src/tectonics/topology.ts
@@ -0,0 +1,14 @@
+/** tectonics topology module — tsb analytics library. */
+export interface TectonicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface TectonicsTopologyResult { values: number[]; converged: boolean; }
+export function computeTectonicsTopology(data: number[], opts: TectonicsTopologyOptions = {}): TectonicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsTopology };
diff --git a/src/tectonics/tracking.ts b/src/tectonics/tracking.ts
new file mode 100644
index 000000000..6bf13be5f
--- /dev/null
+++ b/src/tectonics/tracking.ts
@@ -0,0 +1,14 @@
+/** tectonics tracking module — tsb analytics library. */
+export interface TectonicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsTrackingResult { values: number[]; converged: boolean; }
+export function computeTectonicsTracking(data: number[], opts: TectonicsTrackingOptions = {}): TectonicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsTracking };
diff --git a/src/tectonics/transform.ts b/src/tectonics/transform.ts
new file mode 100644
index 000000000..017d2642b
--- /dev/null
+++ b/src/tectonics/transform.ts
@@ -0,0 +1,14 @@
+/** tectonics transform module — tsb analytics library. */
+export interface TectonicsTransformOptions { tol?: number; maxIter?: number; }
+export interface TectonicsTransformResult { values: number[]; converged: boolean; }
+export function computeTectonicsTransform(data: number[], opts: TectonicsTransformOptions = {}): TectonicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsTransform };
diff --git a/src/tectonics/uncertainty.ts b/src/tectonics/uncertainty.ts
new file mode 100644
index 000000000..5ef4fbda9
--- /dev/null
+++ b/src/tectonics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** tectonics uncertainty module — tsb analytics library. */
+export interface TectonicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface TectonicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeTectonicsUncertainty(data: number[], opts: TectonicsUncertaintyOptions = {}): TectonicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsUncertainty };
diff --git a/src/tectonics/validation.ts b/src/tectonics/validation.ts
new file mode 100644
index 000000000..eb3c45227
--- /dev/null
+++ b/src/tectonics/validation.ts
@@ -0,0 +1,14 @@
+/** tectonics validation module — tsb analytics library. */
+export interface TectonicsValidationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsValidationResult { values: number[]; converged: boolean; }
+export function computeTectonicsValidation(data: number[], opts: TectonicsValidationOptions = {}): TectonicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsValidation };
diff --git a/src/tectonics/verification.ts b/src/tectonics/verification.ts
new file mode 100644
index 000000000..1ac95dcbd
--- /dev/null
+++ b/src/tectonics/verification.ts
@@ -0,0 +1,14 @@
+/** tectonics verification module — tsb analytics library. */
+export interface TectonicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsVerificationResult { values: number[]; converged: boolean; }
+export function computeTectonicsVerification(data: number[], opts: TectonicsVerificationOptions = {}): TectonicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsVerification };
diff --git a/src/tectonics/visualization.ts b/src/tectonics/visualization.ts
new file mode 100644
index 000000000..a35d22788
--- /dev/null
+++ b/src/tectonics/visualization.ts
@@ -0,0 +1,14 @@
+/** tectonics visualization module — tsb analytics library. */
+export interface TectonicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface TectonicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeTectonicsVisualization(data: number[], opts: TectonicsVisualizationOptions = {}): TectonicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsVisualization };
diff --git a/src/tectonics/voting.ts b/src/tectonics/voting.ts
new file mode 100644
index 000000000..341047087
--- /dev/null
+++ b/src/tectonics/voting.ts
@@ -0,0 +1,14 @@
+/** tectonics voting module — tsb analytics library. */
+export interface TectonicsVotingOptions { tol?: number; maxIter?: number; }
+export interface TectonicsVotingResult { values: number[]; converged: boolean; }
+export function computeTectonicsVoting(data: number[], opts: TectonicsVotingOptions = {}): TectonicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsVoting };
diff --git a/src/tectonics/wavelet.ts b/src/tectonics/wavelet.ts
new file mode 100644
index 000000000..15adbf711
--- /dev/null
+++ b/src/tectonics/wavelet.ts
@@ -0,0 +1,14 @@
+/** tectonics wavelet module — tsb analytics library. */
+export interface TectonicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface TectonicsWaveletResult { values: number[]; converged: boolean; }
+export function computeTectonicsWavelet(data: number[], opts: TectonicsWaveletOptions = {}): TectonicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTectonicsWavelet };
diff --git a/src/thermodynamics_sci/adaptation.ts b/src/thermodynamics_sci/adaptation.ts
new file mode 100644
index 000000000..94ff19545
--- /dev/null
+++ b/src/thermodynamics_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci adaptation module — tsb analytics library. */
+export interface ThermodynamicsSciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciAdaptationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciAdaptation(data: number[], opts: ThermodynamicsSciAdaptationOptions = {}): ThermodynamicsSciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciAdaptation };
diff --git a/src/thermodynamics_sci/aggregation.ts b/src/thermodynamics_sci/aggregation.ts
new file mode 100644
index 000000000..8027a5cb6
--- /dev/null
+++ b/src/thermodynamics_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci aggregation module — tsb analytics library. */
+export interface ThermodynamicsSciAggregationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciAggregationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciAggregation(data: number[], opts: ThermodynamicsSciAggregationOptions = {}): ThermodynamicsSciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciAggregation };
diff --git a/src/thermodynamics_sci/algebra.ts b/src/thermodynamics_sci/algebra.ts
new file mode 100644
index 000000000..a638a6a9f
--- /dev/null
+++ b/src/thermodynamics_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci algebra module — tsb analytics library. */
+export interface ThermodynamicsSciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciAlgebraResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciAlgebra(data: number[], opts: ThermodynamicsSciAlgebraOptions = {}): ThermodynamicsSciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciAlgebra };
diff --git a/src/thermodynamics_sci/alignment.ts b/src/thermodynamics_sci/alignment.ts
new file mode 100644
index 000000000..2b4f04dce
--- /dev/null
+++ b/src/thermodynamics_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci alignment module — tsb analytics library. */
+export interface ThermodynamicsSciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciAlignmentResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciAlignment(data: number[], opts: ThermodynamicsSciAlignmentOptions = {}): ThermodynamicsSciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciAlignment };
diff --git a/src/thermodynamics_sci/analysis.ts b/src/thermodynamics_sci/analysis.ts
new file mode 100644
index 000000000..9669e20b8
--- /dev/null
+++ b/src/thermodynamics_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci analysis module — tsb analytics library. */
+export interface ThermodynamicsSciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciAnalysisResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciAnalysis(data: number[], opts: ThermodynamicsSciAnalysisOptions = {}): ThermodynamicsSciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciAnalysis };
diff --git a/src/thermodynamics_sci/augmentation.ts b/src/thermodynamics_sci/augmentation.ts
new file mode 100644
index 000000000..779b9862b
--- /dev/null
+++ b/src/thermodynamics_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci augmentation module — tsb analytics library. */
+export interface ThermodynamicsSciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciAugmentationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciAugmentation(data: number[], opts: ThermodynamicsSciAugmentationOptions = {}): ThermodynamicsSciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciAugmentation };
diff --git a/src/thermodynamics_sci/bagging.ts b/src/thermodynamics_sci/bagging.ts
new file mode 100644
index 000000000..d01ab7287
--- /dev/null
+++ b/src/thermodynamics_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci bagging module — tsb analytics library. */
+export interface ThermodynamicsSciBaggingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciBaggingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciBagging(data: number[], opts: ThermodynamicsSciBaggingOptions = {}): ThermodynamicsSciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciBagging };
diff --git a/src/thermodynamics_sci/basis.ts b/src/thermodynamics_sci/basis.ts
new file mode 100644
index 000000000..7865d8195
--- /dev/null
+++ b/src/thermodynamics_sci/basis.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci basis module — tsb analytics library. */
+export interface ThermodynamicsSciBasisOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciBasisResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciBasis(data: number[], opts: ThermodynamicsSciBasisOptions = {}): ThermodynamicsSciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciBasis };
diff --git a/src/thermodynamics_sci/benchmarking.ts b/src/thermodynamics_sci/benchmarking.ts
new file mode 100644
index 000000000..5d69e9c1a
--- /dev/null
+++ b/src/thermodynamics_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci benchmarking module — tsb analytics library. */
+export interface ThermodynamicsSciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciBenchmarking(data: number[], opts: ThermodynamicsSciBenchmarkingOptions = {}): ThermodynamicsSciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciBenchmarking };
diff --git a/src/thermodynamics_sci/blending.ts b/src/thermodynamics_sci/blending.ts
new file mode 100644
index 000000000..11c606ac2
--- /dev/null
+++ b/src/thermodynamics_sci/blending.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci blending module — tsb analytics library. */
+export interface ThermodynamicsSciBlendingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciBlendingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciBlending(data: number[], opts: ThermodynamicsSciBlendingOptions = {}): ThermodynamicsSciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciBlending };
diff --git a/src/thermodynamics_sci/boosting.ts b/src/thermodynamics_sci/boosting.ts
new file mode 100644
index 000000000..c891e6a3f
--- /dev/null
+++ b/src/thermodynamics_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci boosting module — tsb analytics library. */
+export interface ThermodynamicsSciBoostingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciBoostingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciBoosting(data: number[], opts: ThermodynamicsSciBoostingOptions = {}): ThermodynamicsSciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciBoosting };
diff --git a/src/thermodynamics_sci/bootstrap.ts b/src/thermodynamics_sci/bootstrap.ts
new file mode 100644
index 000000000..f7949396a
--- /dev/null
+++ b/src/thermodynamics_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci bootstrap module — tsb analytics library. */
+export interface ThermodynamicsSciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciBootstrapResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciBootstrap(data: number[], opts: ThermodynamicsSciBootstrapOptions = {}): ThermodynamicsSciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciBootstrap };
diff --git a/src/thermodynamics_sci/calculus.ts b/src/thermodynamics_sci/calculus.ts
new file mode 100644
index 000000000..00fa7fe82
--- /dev/null
+++ b/src/thermodynamics_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci calculus module — tsb analytics library. */
+export interface ThermodynamicsSciCalculusOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciCalculusResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciCalculus(data: number[], opts: ThermodynamicsSciCalculusOptions = {}): ThermodynamicsSciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciCalculus };
diff --git a/src/thermodynamics_sci/calibration.ts b/src/thermodynamics_sci/calibration.ts
new file mode 100644
index 000000000..ca8093252
--- /dev/null
+++ b/src/thermodynamics_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci calibration module — tsb analytics library. */
+export interface ThermodynamicsSciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciCalibrationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciCalibration(data: number[], opts: ThermodynamicsSciCalibrationOptions = {}): ThermodynamicsSciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciCalibration };
diff --git a/src/thermodynamics_sci/characterization.ts b/src/thermodynamics_sci/characterization.ts
new file mode 100644
index 000000000..f2120e0b5
--- /dev/null
+++ b/src/thermodynamics_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci characterization module — tsb analytics library. */
+export interface ThermodynamicsSciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciCharacterization(data: number[], opts: ThermodynamicsSciCharacterizationOptions = {}): ThermodynamicsSciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciCharacterization };
diff --git a/src/thermodynamics_sci/classification.ts b/src/thermodynamics_sci/classification.ts
new file mode 100644
index 000000000..47ad3bdfd
--- /dev/null
+++ b/src/thermodynamics_sci/classification.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci classification module — tsb analytics library. */
+export interface ThermodynamicsSciClassificationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciClassificationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciClassification(data: number[], opts: ThermodynamicsSciClassificationOptions = {}): ThermodynamicsSciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciClassification };
diff --git a/src/thermodynamics_sci/clustering.ts b/src/thermodynamics_sci/clustering.ts
new file mode 100644
index 000000000..c42ff61c8
--- /dev/null
+++ b/src/thermodynamics_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci clustering module — tsb analytics library. */
+export interface ThermodynamicsSciClusteringOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciClusteringResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciClustering(data: number[], opts: ThermodynamicsSciClusteringOptions = {}): ThermodynamicsSciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciClustering };
diff --git a/src/thermodynamics_sci/compression.ts b/src/thermodynamics_sci/compression.ts
new file mode 100644
index 000000000..626bdc82e
--- /dev/null
+++ b/src/thermodynamics_sci/compression.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci compression module — tsb analytics library. */
+export interface ThermodynamicsSciCompressionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciCompressionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciCompression(data: number[], opts: ThermodynamicsSciCompressionOptions = {}): ThermodynamicsSciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciCompression };
diff --git a/src/thermodynamics_sci/continuous.ts b/src/thermodynamics_sci/continuous.ts
new file mode 100644
index 000000000..b9c907955
--- /dev/null
+++ b/src/thermodynamics_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci continuous module — tsb analytics library. */
+export interface ThermodynamicsSciContinuousOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciContinuousResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciContinuous(data: number[], opts: ThermodynamicsSciContinuousOptions = {}): ThermodynamicsSciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciContinuous };
diff --git a/src/thermodynamics_sci/control.ts b/src/thermodynamics_sci/control.ts
new file mode 100644
index 000000000..2e3b9a141
--- /dev/null
+++ b/src/thermodynamics_sci/control.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci control module — tsb analytics library. */
+export interface ThermodynamicsSciControlOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciControlResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciControl(data: number[], opts: ThermodynamicsSciControlOptions = {}): ThermodynamicsSciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciControl };
diff --git a/src/thermodynamics_sci/convergence.ts b/src/thermodynamics_sci/convergence.ts
new file mode 100644
index 000000000..00d5bba95
--- /dev/null
+++ b/src/thermodynamics_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci convergence module — tsb analytics library. */
+export interface ThermodynamicsSciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciConvergenceResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciConvergence(data: number[], opts: ThermodynamicsSciConvergenceOptions = {}): ThermodynamicsSciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciConvergence };
diff --git a/src/thermodynamics_sci/convex.ts b/src/thermodynamics_sci/convex.ts
new file mode 100644
index 000000000..a924ff0a8
--- /dev/null
+++ b/src/thermodynamics_sci/convex.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci convex module — tsb analytics library. */
+export interface ThermodynamicsSciConvexOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciConvexResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciConvex(data: number[], opts: ThermodynamicsSciConvexOptions = {}): ThermodynamicsSciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciConvex };
diff --git a/src/thermodynamics_sci/correlation.ts b/src/thermodynamics_sci/correlation.ts
new file mode 100644
index 000000000..b60144877
--- /dev/null
+++ b/src/thermodynamics_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci correlation module — tsb analytics library. */
+export interface ThermodynamicsSciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciCorrelationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciCorrelation(data: number[], opts: ThermodynamicsSciCorrelationOptions = {}): ThermodynamicsSciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciCorrelation };
diff --git a/src/thermodynamics_sci/covariance.ts b/src/thermodynamics_sci/covariance.ts
new file mode 100644
index 000000000..ef25f79d1
--- /dev/null
+++ b/src/thermodynamics_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci covariance module — tsb analytics library. */
+export interface ThermodynamicsSciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciCovarianceResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciCovariance(data: number[], opts: ThermodynamicsSciCovarianceOptions = {}): ThermodynamicsSciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciCovariance };
diff --git a/src/thermodynamics_sci/cross_validation.ts b/src/thermodynamics_sci/cross_validation.ts
new file mode 100644
index 000000000..24646e53a
--- /dev/null
+++ b/src/thermodynamics_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci cross_validation module — tsb analytics library. */
+export interface ThermodynamicsSciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciCrossValidation(data: number[], opts: ThermodynamicsSciCrossValidationOptions = {}): ThermodynamicsSciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciCrossValidation };
diff --git a/src/thermodynamics_sci/decoding.ts b/src/thermodynamics_sci/decoding.ts
new file mode 100644
index 000000000..c64b35760
--- /dev/null
+++ b/src/thermodynamics_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci decoding module — tsb analytics library. */
+export interface ThermodynamicsSciDecodingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDecodingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDecoding(data: number[], opts: ThermodynamicsSciDecodingOptions = {}): ThermodynamicsSciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDecoding };
diff --git a/src/thermodynamics_sci/decomposition.ts b/src/thermodynamics_sci/decomposition.ts
new file mode 100644
index 000000000..51027be42
--- /dev/null
+++ b/src/thermodynamics_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci decomposition module — tsb analytics library. */
+export interface ThermodynamicsSciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDecompositionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDecomposition(data: number[], opts: ThermodynamicsSciDecompositionOptions = {}): ThermodynamicsSciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDecomposition };
diff --git a/src/thermodynamics_sci/detection.ts b/src/thermodynamics_sci/detection.ts
new file mode 100644
index 000000000..658efb4b6
--- /dev/null
+++ b/src/thermodynamics_sci/detection.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci detection module — tsb analytics library. */
+export interface ThermodynamicsSciDetectionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDetectionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDetection(data: number[], opts: ThermodynamicsSciDetectionOptions = {}): ThermodynamicsSciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDetection };
diff --git a/src/thermodynamics_sci/deterministic.ts b/src/thermodynamics_sci/deterministic.ts
new file mode 100644
index 000000000..ec125ce4d
--- /dev/null
+++ b/src/thermodynamics_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci deterministic module — tsb analytics library. */
+export interface ThermodynamicsSciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDeterministicResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDeterministic(data: number[], opts: ThermodynamicsSciDeterministicOptions = {}): ThermodynamicsSciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDeterministic };
diff --git a/src/thermodynamics_sci/diagnostics.ts b/src/thermodynamics_sci/diagnostics.ts
new file mode 100644
index 000000000..e5a5da03e
--- /dev/null
+++ b/src/thermodynamics_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci diagnostics module — tsb analytics library. */
+export interface ThermodynamicsSciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDiagnostics(data: number[], opts: ThermodynamicsSciDiagnosticsOptions = {}): ThermodynamicsSciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDiagnostics };
diff --git a/src/thermodynamics_sci/differential.ts b/src/thermodynamics_sci/differential.ts
new file mode 100644
index 000000000..eb7c15402
--- /dev/null
+++ b/src/thermodynamics_sci/differential.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci differential module — tsb analytics library. */
+export interface ThermodynamicsSciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDifferentialResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDifferential(data: number[], opts: ThermodynamicsSciDifferentialOptions = {}): ThermodynamicsSciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDifferential };
diff --git a/src/thermodynamics_sci/discrete.ts b/src/thermodynamics_sci/discrete.ts
new file mode 100644
index 000000000..6b40f7e89
--- /dev/null
+++ b/src/thermodynamics_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci discrete module — tsb analytics library. */
+export interface ThermodynamicsSciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDiscreteResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDiscrete(data: number[], opts: ThermodynamicsSciDiscreteOptions = {}): ThermodynamicsSciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDiscrete };
diff --git a/src/thermodynamics_sci/distribution.ts b/src/thermodynamics_sci/distribution.ts
new file mode 100644
index 000000000..e64f5e15a
--- /dev/null
+++ b/src/thermodynamics_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci distribution module — tsb analytics library. */
+export interface ThermodynamicsSciDistributionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDistributionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDistribution(data: number[], opts: ThermodynamicsSciDistributionOptions = {}): ThermodynamicsSciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDistribution };
diff --git a/src/thermodynamics_sci/dynamic.ts b/src/thermodynamics_sci/dynamic.ts
new file mode 100644
index 000000000..69bd09e1a
--- /dev/null
+++ b/src/thermodynamics_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci dynamic module — tsb analytics library. */
+export interface ThermodynamicsSciDynamicOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciDynamicResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciDynamic(data: number[], opts: ThermodynamicsSciDynamicOptions = {}): ThermodynamicsSciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciDynamic };
diff --git a/src/thermodynamics_sci/embedding.ts b/src/thermodynamics_sci/embedding.ts
new file mode 100644
index 000000000..75d076566
--- /dev/null
+++ b/src/thermodynamics_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci embedding module — tsb analytics library. */
+export interface ThermodynamicsSciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciEmbedding(data: number[], opts: ThermodynamicsSciEmbeddingOptions = {}): ThermodynamicsSciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciEmbedding };
diff --git a/src/thermodynamics_sci/encoding.ts b/src/thermodynamics_sci/encoding.ts
new file mode 100644
index 000000000..2a33f2379
--- /dev/null
+++ b/src/thermodynamics_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci encoding module — tsb analytics library. */
+export interface ThermodynamicsSciEncodingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciEncodingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciEncoding(data: number[], opts: ThermodynamicsSciEncodingOptions = {}): ThermodynamicsSciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciEncoding };
diff --git a/src/thermodynamics_sci/ensemble.ts b/src/thermodynamics_sci/ensemble.ts
new file mode 100644
index 000000000..c66d2eb0c
--- /dev/null
+++ b/src/thermodynamics_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci ensemble module — tsb analytics library. */
+export interface ThermodynamicsSciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciEnsembleResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciEnsemble(data: number[], opts: ThermodynamicsSciEnsembleOptions = {}): ThermodynamicsSciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciEnsemble };
diff --git a/src/thermodynamics_sci/estimation.ts b/src/thermodynamics_sci/estimation.ts
new file mode 100644
index 000000000..46e129a1f
--- /dev/null
+++ b/src/thermodynamics_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci estimation module — tsb analytics library. */
+export interface ThermodynamicsSciEstimationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciEstimationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciEstimation(data: number[], opts: ThermodynamicsSciEstimationOptions = {}): ThermodynamicsSciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciEstimation };
diff --git a/src/thermodynamics_sci/evaluation.ts b/src/thermodynamics_sci/evaluation.ts
new file mode 100644
index 000000000..e1e42ca24
--- /dev/null
+++ b/src/thermodynamics_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci evaluation module — tsb analytics library. */
+export interface ThermodynamicsSciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciEvaluationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciEvaluation(data: number[], opts: ThermodynamicsSciEvaluationOptions = {}): ThermodynamicsSciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciEvaluation };
diff --git a/src/thermodynamics_sci/extrapolation.ts b/src/thermodynamics_sci/extrapolation.ts
new file mode 100644
index 000000000..16753dff0
--- /dev/null
+++ b/src/thermodynamics_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci extrapolation module — tsb analytics library. */
+export interface ThermodynamicsSciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciExtrapolation(data: number[], opts: ThermodynamicsSciExtrapolationOptions = {}): ThermodynamicsSciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciExtrapolation };
diff --git a/src/thermodynamics_sci/features.ts b/src/thermodynamics_sci/features.ts
new file mode 100644
index 000000000..a64c366b5
--- /dev/null
+++ b/src/thermodynamics_sci/features.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci features module — tsb analytics library. */
+export interface ThermodynamicsSciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciFeaturesResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciFeatures(data: number[], opts: ThermodynamicsSciFeaturesOptions = {}): ThermodynamicsSciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciFeatures };
diff --git a/src/thermodynamics_sci/feedback.ts b/src/thermodynamics_sci/feedback.ts
new file mode 100644
index 000000000..5f7cef5a4
--- /dev/null
+++ b/src/thermodynamics_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci feedback module — tsb analytics library. */
+export interface ThermodynamicsSciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciFeedbackResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciFeedback(data: number[], opts: ThermodynamicsSciFeedbackOptions = {}): ThermodynamicsSciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciFeedback };
diff --git a/src/thermodynamics_sci/filtering.ts b/src/thermodynamics_sci/filtering.ts
new file mode 100644
index 000000000..2ea2a85aa
--- /dev/null
+++ b/src/thermodynamics_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci filtering module — tsb analytics library. */
+export interface ThermodynamicsSciFilteringOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciFilteringResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciFiltering(data: number[], opts: ThermodynamicsSciFilteringOptions = {}): ThermodynamicsSciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciFiltering };
diff --git a/src/thermodynamics_sci/fourier.ts b/src/thermodynamics_sci/fourier.ts
new file mode 100644
index 000000000..ea556ff28
--- /dev/null
+++ b/src/thermodynamics_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci fourier module — tsb analytics library. */
+export interface ThermodynamicsSciFourierOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciFourierResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciFourier(data: number[], opts: ThermodynamicsSciFourierOptions = {}): ThermodynamicsSciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciFourier };
diff --git a/src/thermodynamics_sci/fusion.ts b/src/thermodynamics_sci/fusion.ts
new file mode 100644
index 000000000..3d2c96378
--- /dev/null
+++ b/src/thermodynamics_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci fusion module — tsb analytics library. */
+export interface ThermodynamicsSciFusionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciFusionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciFusion(data: number[], opts: ThermodynamicsSciFusionOptions = {}): ThermodynamicsSciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciFusion };
diff --git a/src/thermodynamics_sci/generation.ts b/src/thermodynamics_sci/generation.ts
new file mode 100644
index 000000000..fccd13d2f
--- /dev/null
+++ b/src/thermodynamics_sci/generation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci generation module — tsb analytics library. */
+export interface ThermodynamicsSciGenerationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciGenerationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciGeneration(data: number[], opts: ThermodynamicsSciGenerationOptions = {}): ThermodynamicsSciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciGeneration };
diff --git a/src/thermodynamics_sci/geometry.ts b/src/thermodynamics_sci/geometry.ts
new file mode 100644
index 000000000..381db9bbf
--- /dev/null
+++ b/src/thermodynamics_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci geometry module — tsb analytics library. */
+export interface ThermodynamicsSciGeometryOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciGeometryResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciGeometry(data: number[], opts: ThermodynamicsSciGeometryOptions = {}): ThermodynamicsSciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciGeometry };
diff --git a/src/thermodynamics_sci/gradient.ts b/src/thermodynamics_sci/gradient.ts
new file mode 100644
index 000000000..adb65c739
--- /dev/null
+++ b/src/thermodynamics_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci gradient module — tsb analytics library. */
+export interface ThermodynamicsSciGradientOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciGradientResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciGradient(data: number[], opts: ThermodynamicsSciGradientOptions = {}): ThermodynamicsSciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciGradient };
diff --git a/src/thermodynamics_sci/hessian.ts b/src/thermodynamics_sci/hessian.ts
new file mode 100644
index 000000000..0a32d32a6
--- /dev/null
+++ b/src/thermodynamics_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci hessian module — tsb analytics library. */
+export interface ThermodynamicsSciHessianOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciHessianResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciHessian(data: number[], opts: ThermodynamicsSciHessianOptions = {}): ThermodynamicsSciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciHessian };
diff --git a/src/thermodynamics_sci/hypothesis.ts b/src/thermodynamics_sci/hypothesis.ts
new file mode 100644
index 000000000..7e2c7ef4c
--- /dev/null
+++ b/src/thermodynamics_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci hypothesis module — tsb analytics library. */
+export interface ThermodynamicsSciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciHypothesisResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciHypothesis(data: number[], opts: ThermodynamicsSciHypothesisOptions = {}): ThermodynamicsSciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciHypothesis };
diff --git a/src/thermodynamics_sci/inference.ts b/src/thermodynamics_sci/inference.ts
new file mode 100644
index 000000000..82e7cef14
--- /dev/null
+++ b/src/thermodynamics_sci/inference.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci inference module — tsb analytics library. */
+export interface ThermodynamicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciInference(data: number[], opts: ThermodynamicsSciInferenceOptions = {}): ThermodynamicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciInference };
diff --git a/src/thermodynamics_sci/inference2.ts b/src/thermodynamics_sci/inference2.ts
new file mode 100644
index 000000000..b68ae8d6e
--- /dev/null
+++ b/src/thermodynamics_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci inference2 module — tsb analytics library. */
+export interface ThermodynamicsSciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciInferenceResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciInference(data: number[], opts: ThermodynamicsSciInferenceOptions = {}): ThermodynamicsSciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciInference };
diff --git a/src/thermodynamics_sci/integral.ts b/src/thermodynamics_sci/integral.ts
new file mode 100644
index 000000000..fb4aaad48
--- /dev/null
+++ b/src/thermodynamics_sci/integral.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci integral module — tsb analytics library. */
+export interface ThermodynamicsSciIntegralOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciIntegralResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciIntegral(data: number[], opts: ThermodynamicsSciIntegralOptions = {}): ThermodynamicsSciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciIntegral };
diff --git a/src/thermodynamics_sci/integration.ts b/src/thermodynamics_sci/integration.ts
new file mode 100644
index 000000000..a5d70121c
--- /dev/null
+++ b/src/thermodynamics_sci/integration.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci integration module — tsb analytics library. */
+export interface ThermodynamicsSciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciIntegrationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciIntegration(data: number[], opts: ThermodynamicsSciIntegrationOptions = {}): ThermodynamicsSciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciIntegration };
diff --git a/src/thermodynamics_sci/interpolation.ts b/src/thermodynamics_sci/interpolation.ts
new file mode 100644
index 000000000..da41ffac3
--- /dev/null
+++ b/src/thermodynamics_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci interpolation module — tsb analytics library. */
+export interface ThermodynamicsSciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciInterpolationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciInterpolation(data: number[], opts: ThermodynamicsSciInterpolationOptions = {}): ThermodynamicsSciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciInterpolation };
diff --git a/src/thermodynamics_sci/jacobian.ts b/src/thermodynamics_sci/jacobian.ts
new file mode 100644
index 000000000..0f1efc2c3
--- /dev/null
+++ b/src/thermodynamics_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci jacobian module — tsb analytics library. */
+export interface ThermodynamicsSciJacobianOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciJacobianResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciJacobian(data: number[], opts: ThermodynamicsSciJacobianOptions = {}): ThermodynamicsSciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciJacobian };
diff --git a/src/thermodynamics_sci/kernel.ts b/src/thermodynamics_sci/kernel.ts
new file mode 100644
index 000000000..faf892a1a
--- /dev/null
+++ b/src/thermodynamics_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci kernel module — tsb analytics library. */
+export interface ThermodynamicsSciKernelOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciKernelResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciKernel(data: number[], opts: ThermodynamicsSciKernelOptions = {}): ThermodynamicsSciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciKernel };
diff --git a/src/thermodynamics_sci/laplacian.ts b/src/thermodynamics_sci/laplacian.ts
new file mode 100644
index 000000000..1d26206bf
--- /dev/null
+++ b/src/thermodynamics_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci laplacian module — tsb analytics library. */
+export interface ThermodynamicsSciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciLaplacianResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciLaplacian(data: number[], opts: ThermodynamicsSciLaplacianOptions = {}): ThermodynamicsSciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciLaplacian };
diff --git a/src/thermodynamics_sci/learning.ts b/src/thermodynamics_sci/learning.ts
new file mode 100644
index 000000000..79c64c117
--- /dev/null
+++ b/src/thermodynamics_sci/learning.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci learning module — tsb analytics library. */
+export interface ThermodynamicsSciLearningOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciLearningResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciLearning(data: number[], opts: ThermodynamicsSciLearningOptions = {}): ThermodynamicsSciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciLearning };
diff --git a/src/thermodynamics_sci/linear.ts b/src/thermodynamics_sci/linear.ts
new file mode 100644
index 000000000..20c62ab16
--- /dev/null
+++ b/src/thermodynamics_sci/linear.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci linear module — tsb analytics library. */
+export interface ThermodynamicsSciLinearOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciLinearResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciLinear(data: number[], opts: ThermodynamicsSciLinearOptions = {}): ThermodynamicsSciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciLinear };
diff --git a/src/thermodynamics_sci/manifold.ts b/src/thermodynamics_sci/manifold.ts
new file mode 100644
index 000000000..475e79851
--- /dev/null
+++ b/src/thermodynamics_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci manifold module — tsb analytics library. */
+export interface ThermodynamicsSciManifoldOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciManifoldResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciManifold(data: number[], opts: ThermodynamicsSciManifoldOptions = {}): ThermodynamicsSciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciManifold };
diff --git a/src/thermodynamics_sci/matching.ts b/src/thermodynamics_sci/matching.ts
new file mode 100644
index 000000000..166a2a227
--- /dev/null
+++ b/src/thermodynamics_sci/matching.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci matching module — tsb analytics library. */
+export interface ThermodynamicsSciMatchingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciMatchingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciMatching(data: number[], opts: ThermodynamicsSciMatchingOptions = {}): ThermodynamicsSciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciMatching };
diff --git a/src/thermodynamics_sci/measurement.ts b/src/thermodynamics_sci/measurement.ts
new file mode 100644
index 000000000..633e2f8d0
--- /dev/null
+++ b/src/thermodynamics_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci measurement module — tsb analytics library. */
+export interface ThermodynamicsSciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciMeasurementResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciMeasurement(data: number[], opts: ThermodynamicsSciMeasurementOptions = {}): ThermodynamicsSciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciMeasurement };
diff --git a/src/thermodynamics_sci/metrics.ts b/src/thermodynamics_sci/metrics.ts
new file mode 100644
index 000000000..2d19d1358
--- /dev/null
+++ b/src/thermodynamics_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci metrics module — tsb analytics library. */
+export interface ThermodynamicsSciMetricsOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciMetricsResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciMetrics(data: number[], opts: ThermodynamicsSciMetricsOptions = {}): ThermodynamicsSciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciMetrics };
diff --git a/src/thermodynamics_sci/modeling.ts b/src/thermodynamics_sci/modeling.ts
new file mode 100644
index 000000000..b93b15145
--- /dev/null
+++ b/src/thermodynamics_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci modeling module — tsb analytics library. */
+export interface ThermodynamicsSciModelingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciModelingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciModeling(data: number[], opts: ThermodynamicsSciModelingOptions = {}): ThermodynamicsSciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciModeling };
diff --git a/src/thermodynamics_sci/monitoring.ts b/src/thermodynamics_sci/monitoring.ts
new file mode 100644
index 000000000..13edc7d37
--- /dev/null
+++ b/src/thermodynamics_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci monitoring module — tsb analytics library. */
+export interface ThermodynamicsSciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciMonitoringResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciMonitoring(data: number[], opts: ThermodynamicsSciMonitoringOptions = {}): ThermodynamicsSciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciMonitoring };
diff --git a/src/thermodynamics_sci/nonlinear.ts b/src/thermodynamics_sci/nonlinear.ts
new file mode 100644
index 000000000..808d1903b
--- /dev/null
+++ b/src/thermodynamics_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci nonlinear module — tsb analytics library. */
+export interface ThermodynamicsSciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciNonlinearResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciNonlinear(data: number[], opts: ThermodynamicsSciNonlinearOptions = {}): ThermodynamicsSciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciNonlinear };
diff --git a/src/thermodynamics_sci/normalization.ts b/src/thermodynamics_sci/normalization.ts
new file mode 100644
index 000000000..dbae01f36
--- /dev/null
+++ b/src/thermodynamics_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci normalization module — tsb analytics library. */
+export interface ThermodynamicsSciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciNormalizationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciNormalization(data: number[], opts: ThermodynamicsSciNormalizationOptions = {}): ThermodynamicsSciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciNormalization };
diff --git a/src/thermodynamics_sci/optimization.ts b/src/thermodynamics_sci/optimization.ts
new file mode 100644
index 000000000..ffe3c73ba
--- /dev/null
+++ b/src/thermodynamics_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci optimization module — tsb analytics library. */
+export interface ThermodynamicsSciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciOptimizationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciOptimization(data: number[], opts: ThermodynamicsSciOptimizationOptions = {}): ThermodynamicsSciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciOptimization };
diff --git a/src/thermodynamics_sci/patterns.ts b/src/thermodynamics_sci/patterns.ts
new file mode 100644
index 000000000..c58ceaf35
--- /dev/null
+++ b/src/thermodynamics_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci patterns module — tsb analytics library. */
+export interface ThermodynamicsSciPatternsOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciPatternsResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciPatterns(data: number[], opts: ThermodynamicsSciPatternsOptions = {}): ThermodynamicsSciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciPatterns };
diff --git a/src/thermodynamics_sci/permutation.ts b/src/thermodynamics_sci/permutation.ts
new file mode 100644
index 000000000..51cb90bfa
--- /dev/null
+++ b/src/thermodynamics_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci permutation module — tsb analytics library. */
+export interface ThermodynamicsSciPermutationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciPermutationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciPermutation(data: number[], opts: ThermodynamicsSciPermutationOptions = {}): ThermodynamicsSciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciPermutation };
diff --git a/src/thermodynamics_sci/prediction.ts b/src/thermodynamics_sci/prediction.ts
new file mode 100644
index 000000000..cdbf2f282
--- /dev/null
+++ b/src/thermodynamics_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci prediction module — tsb analytics library. */
+export interface ThermodynamicsSciPredictionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciPredictionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciPrediction(data: number[], opts: ThermodynamicsSciPredictionOptions = {}): ThermodynamicsSciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciPrediction };
diff --git a/src/thermodynamics_sci/processing.ts b/src/thermodynamics_sci/processing.ts
new file mode 100644
index 000000000..5a4e70b95
--- /dev/null
+++ b/src/thermodynamics_sci/processing.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci processing module — tsb analytics library. */
+export interface ThermodynamicsSciProcessingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciProcessingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciProcessing(data: number[], opts: ThermodynamicsSciProcessingOptions = {}): ThermodynamicsSciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciProcessing };
diff --git a/src/thermodynamics_sci/profiling.ts b/src/thermodynamics_sci/profiling.ts
new file mode 100644
index 000000000..ece7ec4ec
--- /dev/null
+++ b/src/thermodynamics_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci profiling module — tsb analytics library. */
+export interface ThermodynamicsSciProfilingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciProfilingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciProfiling(data: number[], opts: ThermodynamicsSciProfilingOptions = {}): ThermodynamicsSciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciProfiling };
diff --git a/src/thermodynamics_sci/projection.ts b/src/thermodynamics_sci/projection.ts
new file mode 100644
index 000000000..e3d05d6d2
--- /dev/null
+++ b/src/thermodynamics_sci/projection.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci projection module — tsb analytics library. */
+export interface ThermodynamicsSciProjectionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciProjectionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciProjection(data: number[], opts: ThermodynamicsSciProjectionOptions = {}): ThermodynamicsSciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciProjection };
diff --git a/src/thermodynamics_sci/ranking.ts b/src/thermodynamics_sci/ranking.ts
new file mode 100644
index 000000000..92dd9075a
--- /dev/null
+++ b/src/thermodynamics_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci ranking module — tsb analytics library. */
+export interface ThermodynamicsSciRankingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciRankingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciRanking(data: number[], opts: ThermodynamicsSciRankingOptions = {}): ThermodynamicsSciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciRanking };
diff --git a/src/thermodynamics_sci/reconstruction.ts b/src/thermodynamics_sci/reconstruction.ts
new file mode 100644
index 000000000..fc944792f
--- /dev/null
+++ b/src/thermodynamics_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci reconstruction module — tsb analytics library. */
+export interface ThermodynamicsSciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciReconstructionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciReconstruction(data: number[], opts: ThermodynamicsSciReconstructionOptions = {}): ThermodynamicsSciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciReconstruction };
diff --git a/src/thermodynamics_sci/registration.ts b/src/thermodynamics_sci/registration.ts
new file mode 100644
index 000000000..71683311c
--- /dev/null
+++ b/src/thermodynamics_sci/registration.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci registration module — tsb analytics library. */
+export interface ThermodynamicsSciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciRegistrationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciRegistration(data: number[], opts: ThermodynamicsSciRegistrationOptions = {}): ThermodynamicsSciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciRegistration };
diff --git a/src/thermodynamics_sci/regression.ts b/src/thermodynamics_sci/regression.ts
new file mode 100644
index 000000000..c1386b75c
--- /dev/null
+++ b/src/thermodynamics_sci/regression.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci regression module — tsb analytics library. */
+export interface ThermodynamicsSciRegressionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciRegressionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciRegression(data: number[], opts: ThermodynamicsSciRegressionOptions = {}): ThermodynamicsSciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciRegression };
diff --git a/src/thermodynamics_sci/regularization.ts b/src/thermodynamics_sci/regularization.ts
new file mode 100644
index 000000000..528f352cf
--- /dev/null
+++ b/src/thermodynamics_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci regularization module — tsb analytics library. */
+export interface ThermodynamicsSciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciRegularizationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciRegularization(data: number[], opts: ThermodynamicsSciRegularizationOptions = {}): ThermodynamicsSciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciRegularization };
diff --git a/src/thermodynamics_sci/robustness.ts b/src/thermodynamics_sci/robustness.ts
new file mode 100644
index 000000000..91db5ab6a
--- /dev/null
+++ b/src/thermodynamics_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci robustness module — tsb analytics library. */
+export interface ThermodynamicsSciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciRobustnessResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciRobustness(data: number[], opts: ThermodynamicsSciRobustnessOptions = {}): ThermodynamicsSciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciRobustness };
diff --git a/src/thermodynamics_sci/sampling.ts b/src/thermodynamics_sci/sampling.ts
new file mode 100644
index 000000000..7adba37be
--- /dev/null
+++ b/src/thermodynamics_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci sampling module — tsb analytics library. */
+export interface ThermodynamicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciSampling(data: number[], opts: ThermodynamicsSciSamplingOptions = {}): ThermodynamicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciSampling };
diff --git a/src/thermodynamics_sci/sampling2.ts b/src/thermodynamics_sci/sampling2.ts
new file mode 100644
index 000000000..70877013f
--- /dev/null
+++ b/src/thermodynamics_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci sampling2 module — tsb analytics library. */
+export interface ThermodynamicsSciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciSamplingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciSampling(data: number[], opts: ThermodynamicsSciSamplingOptions = {}): ThermodynamicsSciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciSampling };
diff --git a/src/thermodynamics_sci/scaling.ts b/src/thermodynamics_sci/scaling.ts
new file mode 100644
index 000000000..50c930364
--- /dev/null
+++ b/src/thermodynamics_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci scaling module — tsb analytics library. */
+export interface ThermodynamicsSciScalingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciScalingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciScaling(data: number[], opts: ThermodynamicsSciScalingOptions = {}): ThermodynamicsSciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciScaling };
diff --git a/src/thermodynamics_sci/scoring.ts b/src/thermodynamics_sci/scoring.ts
new file mode 100644
index 000000000..e86cef099
--- /dev/null
+++ b/src/thermodynamics_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci scoring module — tsb analytics library. */
+export interface ThermodynamicsSciScoringOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciScoringResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciScoring(data: number[], opts: ThermodynamicsSciScoringOptions = {}): ThermodynamicsSciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciScoring };
diff --git a/src/thermodynamics_sci/segmentation.ts b/src/thermodynamics_sci/segmentation.ts
new file mode 100644
index 000000000..f1398192a
--- /dev/null
+++ b/src/thermodynamics_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci segmentation module — tsb analytics library. */
+export interface ThermodynamicsSciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciSegmentationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciSegmentation(data: number[], opts: ThermodynamicsSciSegmentationOptions = {}): ThermodynamicsSciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciSegmentation };
diff --git a/src/thermodynamics_sci/selection.ts b/src/thermodynamics_sci/selection.ts
new file mode 100644
index 000000000..d8f2f9e22
--- /dev/null
+++ b/src/thermodynamics_sci/selection.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci selection module — tsb analytics library. */
+export interface ThermodynamicsSciSelectionOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciSelectionResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciSelection(data: number[], opts: ThermodynamicsSciSelectionOptions = {}): ThermodynamicsSciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciSelection };
diff --git a/src/thermodynamics_sci/sensitivity.ts b/src/thermodynamics_sci/sensitivity.ts
new file mode 100644
index 000000000..0a1ee76c2
--- /dev/null
+++ b/src/thermodynamics_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci sensitivity module — tsb analytics library. */
+export interface ThermodynamicsSciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciSensitivityResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciSensitivity(data: number[], opts: ThermodynamicsSciSensitivityOptions = {}): ThermodynamicsSciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciSensitivity };
diff --git a/src/thermodynamics_sci/simulation.ts b/src/thermodynamics_sci/simulation.ts
new file mode 100644
index 000000000..769ae0c50
--- /dev/null
+++ b/src/thermodynamics_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci simulation module — tsb analytics library. */
+export interface ThermodynamicsSciSimulationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciSimulationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciSimulation(data: number[], opts: ThermodynamicsSciSimulationOptions = {}): ThermodynamicsSciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciSimulation };
diff --git a/src/thermodynamics_sci/smoothing.ts b/src/thermodynamics_sci/smoothing.ts
new file mode 100644
index 000000000..4b56dfc09
--- /dev/null
+++ b/src/thermodynamics_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci smoothing module — tsb analytics library. */
+export interface ThermodynamicsSciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciSmoothingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciSmoothing(data: number[], opts: ThermodynamicsSciSmoothingOptions = {}): ThermodynamicsSciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciSmoothing };
diff --git a/src/thermodynamics_sci/stability.ts b/src/thermodynamics_sci/stability.ts
new file mode 100644
index 000000000..531250f1a
--- /dev/null
+++ b/src/thermodynamics_sci/stability.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci stability module — tsb analytics library. */
+export interface ThermodynamicsSciStabilityOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciStabilityResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciStability(data: number[], opts: ThermodynamicsSciStabilityOptions = {}): ThermodynamicsSciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciStability };
diff --git a/src/thermodynamics_sci/stacking.ts b/src/thermodynamics_sci/stacking.ts
new file mode 100644
index 000000000..1eb01a41e
--- /dev/null
+++ b/src/thermodynamics_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci stacking module — tsb analytics library. */
+export interface ThermodynamicsSciStackingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciStackingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciStacking(data: number[], opts: ThermodynamicsSciStackingOptions = {}): ThermodynamicsSciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciStacking };
diff --git a/src/thermodynamics_sci/standardization.ts b/src/thermodynamics_sci/standardization.ts
new file mode 100644
index 000000000..5062e59ab
--- /dev/null
+++ b/src/thermodynamics_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci standardization module — tsb analytics library. */
+export interface ThermodynamicsSciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciStandardizationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciStandardization(data: number[], opts: ThermodynamicsSciStandardizationOptions = {}): ThermodynamicsSciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciStandardization };
diff --git a/src/thermodynamics_sci/static.ts b/src/thermodynamics_sci/static.ts
new file mode 100644
index 000000000..317971b54
--- /dev/null
+++ b/src/thermodynamics_sci/static.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci static module — tsb analytics library. */
+export interface ThermodynamicsSciStaticOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciStaticResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciStatic(data: number[], opts: ThermodynamicsSciStaticOptions = {}): ThermodynamicsSciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciStatic };
diff --git a/src/thermodynamics_sci/stochastic.ts b/src/thermodynamics_sci/stochastic.ts
new file mode 100644
index 000000000..4f4b347aa
--- /dev/null
+++ b/src/thermodynamics_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci stochastic module — tsb analytics library. */
+export interface ThermodynamicsSciStochasticOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciStochasticResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciStochastic(data: number[], opts: ThermodynamicsSciStochasticOptions = {}): ThermodynamicsSciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciStochastic };
diff --git a/src/thermodynamics_sci/synthesis.ts b/src/thermodynamics_sci/synthesis.ts
new file mode 100644
index 000000000..1f1589201
--- /dev/null
+++ b/src/thermodynamics_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci synthesis module — tsb analytics library. */
+export interface ThermodynamicsSciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciSynthesisResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciSynthesis(data: number[], opts: ThermodynamicsSciSynthesisOptions = {}): ThermodynamicsSciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciSynthesis };
diff --git a/src/thermodynamics_sci/topology.ts b/src/thermodynamics_sci/topology.ts
new file mode 100644
index 000000000..517cc4d68
--- /dev/null
+++ b/src/thermodynamics_sci/topology.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci topology module — tsb analytics library. */
+export interface ThermodynamicsSciTopologyOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciTopologyResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciTopology(data: number[], opts: ThermodynamicsSciTopologyOptions = {}): ThermodynamicsSciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciTopology };
diff --git a/src/thermodynamics_sci/tracking.ts b/src/thermodynamics_sci/tracking.ts
new file mode 100644
index 000000000..d74e1fa70
--- /dev/null
+++ b/src/thermodynamics_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci tracking module — tsb analytics library. */
+export interface ThermodynamicsSciTrackingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciTrackingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciTracking(data: number[], opts: ThermodynamicsSciTrackingOptions = {}): ThermodynamicsSciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciTracking };
diff --git a/src/thermodynamics_sci/transform.ts b/src/thermodynamics_sci/transform.ts
new file mode 100644
index 000000000..2416747b8
--- /dev/null
+++ b/src/thermodynamics_sci/transform.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci transform module — tsb analytics library. */
+export interface ThermodynamicsSciTransformOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciTransformResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciTransform(data: number[], opts: ThermodynamicsSciTransformOptions = {}): ThermodynamicsSciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciTransform };
diff --git a/src/thermodynamics_sci/uncertainty.ts b/src/thermodynamics_sci/uncertainty.ts
new file mode 100644
index 000000000..db3b56161
--- /dev/null
+++ b/src/thermodynamics_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci uncertainty module — tsb analytics library. */
+export interface ThermodynamicsSciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciUncertainty(data: number[], opts: ThermodynamicsSciUncertaintyOptions = {}): ThermodynamicsSciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciUncertainty };
diff --git a/src/thermodynamics_sci/validation.ts b/src/thermodynamics_sci/validation.ts
new file mode 100644
index 000000000..430586814
--- /dev/null
+++ b/src/thermodynamics_sci/validation.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci validation module — tsb analytics library. */
+export interface ThermodynamicsSciValidationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciValidationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciValidation(data: number[], opts: ThermodynamicsSciValidationOptions = {}): ThermodynamicsSciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciValidation };
diff --git a/src/thermodynamics_sci/verification.ts b/src/thermodynamics_sci/verification.ts
new file mode 100644
index 000000000..dbcbeb8dd
--- /dev/null
+++ b/src/thermodynamics_sci/verification.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci verification module — tsb analytics library. */
+export interface ThermodynamicsSciVerificationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciVerificationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciVerification(data: number[], opts: ThermodynamicsSciVerificationOptions = {}): ThermodynamicsSciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciVerification };
diff --git a/src/thermodynamics_sci/visualization.ts b/src/thermodynamics_sci/visualization.ts
new file mode 100644
index 000000000..21483e65d
--- /dev/null
+++ b/src/thermodynamics_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci visualization module — tsb analytics library. */
+export interface ThermodynamicsSciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciVisualizationResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciVisualization(data: number[], opts: ThermodynamicsSciVisualizationOptions = {}): ThermodynamicsSciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciVisualization };
diff --git a/src/thermodynamics_sci/voting.ts b/src/thermodynamics_sci/voting.ts
new file mode 100644
index 000000000..f2df61b00
--- /dev/null
+++ b/src/thermodynamics_sci/voting.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci voting module — tsb analytics library. */
+export interface ThermodynamicsSciVotingOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciVotingResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciVoting(data: number[], opts: ThermodynamicsSciVotingOptions = {}): ThermodynamicsSciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciVoting };
diff --git a/src/thermodynamics_sci/wavelet.ts b/src/thermodynamics_sci/wavelet.ts
new file mode 100644
index 000000000..c30ee703e
--- /dev/null
+++ b/src/thermodynamics_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** thermodynamics_sci wavelet module — tsb analytics library. */
+export interface ThermodynamicsSciWaveletOptions { tol?: number; maxIter?: number; }
+export interface ThermodynamicsSciWaveletResult { values: number[]; converged: boolean; }
+export function computeThermodynamicsSciWavelet(data: number[], opts: ThermodynamicsSciWaveletOptions = {}): ThermodynamicsSciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThermodynamicsSciWavelet };
diff --git a/src/thin_films/adaptation.ts b/src/thin_films/adaptation.ts
new file mode 100644
index 000000000..7c242c4ce
--- /dev/null
+++ b/src/thin_films/adaptation.ts
@@ -0,0 +1,14 @@
+/** thin_films adaptation module — tsb analytics library. */
+export interface ThinFilmsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsAdaptationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsAdaptation(data: number[], opts: ThinFilmsAdaptationOptions = {}): ThinFilmsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsAdaptation };
diff --git a/src/thin_films/aggregation.ts b/src/thin_films/aggregation.ts
new file mode 100644
index 000000000..a52176f34
--- /dev/null
+++ b/src/thin_films/aggregation.ts
@@ -0,0 +1,14 @@
+/** thin_films aggregation module — tsb analytics library. */
+export interface ThinFilmsAggregationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsAggregationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsAggregation(data: number[], opts: ThinFilmsAggregationOptions = {}): ThinFilmsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsAggregation };
diff --git a/src/thin_films/algebra.ts b/src/thin_films/algebra.ts
new file mode 100644
index 000000000..061cbbb35
--- /dev/null
+++ b/src/thin_films/algebra.ts
@@ -0,0 +1,14 @@
+/** thin_films algebra module — tsb analytics library. */
+export interface ThinFilmsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsAlgebraResult { values: number[]; converged: boolean; }
+export function computeThinFilmsAlgebra(data: number[], opts: ThinFilmsAlgebraOptions = {}): ThinFilmsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsAlgebra };
diff --git a/src/thin_films/alignment.ts b/src/thin_films/alignment.ts
new file mode 100644
index 000000000..e6f8f32d4
--- /dev/null
+++ b/src/thin_films/alignment.ts
@@ -0,0 +1,14 @@
+/** thin_films alignment module — tsb analytics library. */
+export interface ThinFilmsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsAlignmentResult { values: number[]; converged: boolean; }
+export function computeThinFilmsAlignment(data: number[], opts: ThinFilmsAlignmentOptions = {}): ThinFilmsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsAlignment };
diff --git a/src/thin_films/analysis.ts b/src/thin_films/analysis.ts
new file mode 100644
index 000000000..afe821283
--- /dev/null
+++ b/src/thin_films/analysis.ts
@@ -0,0 +1,14 @@
+/** thin_films analysis module — tsb analytics library. */
+export interface ThinFilmsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsAnalysisResult { values: number[]; converged: boolean; }
+export function computeThinFilmsAnalysis(data: number[], opts: ThinFilmsAnalysisOptions = {}): ThinFilmsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsAnalysis };
diff --git a/src/thin_films/augmentation.ts b/src/thin_films/augmentation.ts
new file mode 100644
index 000000000..16d785da0
--- /dev/null
+++ b/src/thin_films/augmentation.ts
@@ -0,0 +1,14 @@
+/** thin_films augmentation module — tsb analytics library. */
+export interface ThinFilmsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsAugmentationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsAugmentation(data: number[], opts: ThinFilmsAugmentationOptions = {}): ThinFilmsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsAugmentation };
diff --git a/src/thin_films/bagging.ts b/src/thin_films/bagging.ts
new file mode 100644
index 000000000..52970ecac
--- /dev/null
+++ b/src/thin_films/bagging.ts
@@ -0,0 +1,14 @@
+/** thin_films bagging module — tsb analytics library. */
+export interface ThinFilmsBaggingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsBaggingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsBagging(data: number[], opts: ThinFilmsBaggingOptions = {}): ThinFilmsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsBagging };
diff --git a/src/thin_films/basis.ts b/src/thin_films/basis.ts
new file mode 100644
index 000000000..a174bb324
--- /dev/null
+++ b/src/thin_films/basis.ts
@@ -0,0 +1,14 @@
+/** thin_films basis module — tsb analytics library. */
+export interface ThinFilmsBasisOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsBasisResult { values: number[]; converged: boolean; }
+export function computeThinFilmsBasis(data: number[], opts: ThinFilmsBasisOptions = {}): ThinFilmsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsBasis };
diff --git a/src/thin_films/benchmarking.ts b/src/thin_films/benchmarking.ts
new file mode 100644
index 000000000..878f3c0b3
--- /dev/null
+++ b/src/thin_films/benchmarking.ts
@@ -0,0 +1,14 @@
+/** thin_films benchmarking module — tsb analytics library. */
+export interface ThinFilmsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsBenchmarking(data: number[], opts: ThinFilmsBenchmarkingOptions = {}): ThinFilmsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsBenchmarking };
diff --git a/src/thin_films/blending.ts b/src/thin_films/blending.ts
new file mode 100644
index 000000000..b42b0efd1
--- /dev/null
+++ b/src/thin_films/blending.ts
@@ -0,0 +1,14 @@
+/** thin_films blending module — tsb analytics library. */
+export interface ThinFilmsBlendingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsBlendingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsBlending(data: number[], opts: ThinFilmsBlendingOptions = {}): ThinFilmsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsBlending };
diff --git a/src/thin_films/boosting.ts b/src/thin_films/boosting.ts
new file mode 100644
index 000000000..6c6b65f8b
--- /dev/null
+++ b/src/thin_films/boosting.ts
@@ -0,0 +1,14 @@
+/** thin_films boosting module — tsb analytics library. */
+export interface ThinFilmsBoostingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsBoostingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsBoosting(data: number[], opts: ThinFilmsBoostingOptions = {}): ThinFilmsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsBoosting };
diff --git a/src/thin_films/bootstrap.ts b/src/thin_films/bootstrap.ts
new file mode 100644
index 000000000..2c5c91d6d
--- /dev/null
+++ b/src/thin_films/bootstrap.ts
@@ -0,0 +1,14 @@
+/** thin_films bootstrap module — tsb analytics library. */
+export interface ThinFilmsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsBootstrapResult { values: number[]; converged: boolean; }
+export function computeThinFilmsBootstrap(data: number[], opts: ThinFilmsBootstrapOptions = {}): ThinFilmsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsBootstrap };
diff --git a/src/thin_films/calculus.ts b/src/thin_films/calculus.ts
new file mode 100644
index 000000000..ca2482c83
--- /dev/null
+++ b/src/thin_films/calculus.ts
@@ -0,0 +1,14 @@
+/** thin_films calculus module — tsb analytics library. */
+export interface ThinFilmsCalculusOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsCalculusResult { values: number[]; converged: boolean; }
+export function computeThinFilmsCalculus(data: number[], opts: ThinFilmsCalculusOptions = {}): ThinFilmsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsCalculus };
diff --git a/src/thin_films/calibration.ts b/src/thin_films/calibration.ts
new file mode 100644
index 000000000..1b5130c4f
--- /dev/null
+++ b/src/thin_films/calibration.ts
@@ -0,0 +1,14 @@
+/** thin_films calibration module — tsb analytics library. */
+export interface ThinFilmsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsCalibrationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsCalibration(data: number[], opts: ThinFilmsCalibrationOptions = {}): ThinFilmsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsCalibration };
diff --git a/src/thin_films/characterization.ts b/src/thin_films/characterization.ts
new file mode 100644
index 000000000..90da8d4bb
--- /dev/null
+++ b/src/thin_films/characterization.ts
@@ -0,0 +1,14 @@
+/** thin_films characterization module — tsb analytics library. */
+export interface ThinFilmsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsCharacterization(data: number[], opts: ThinFilmsCharacterizationOptions = {}): ThinFilmsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsCharacterization };
diff --git a/src/thin_films/classification.ts b/src/thin_films/classification.ts
new file mode 100644
index 000000000..df5d1a8b8
--- /dev/null
+++ b/src/thin_films/classification.ts
@@ -0,0 +1,14 @@
+/** thin_films classification module — tsb analytics library. */
+export interface ThinFilmsClassificationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsClassificationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsClassification(data: number[], opts: ThinFilmsClassificationOptions = {}): ThinFilmsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsClassification };
diff --git a/src/thin_films/clustering.ts b/src/thin_films/clustering.ts
new file mode 100644
index 000000000..b72b8916b
--- /dev/null
+++ b/src/thin_films/clustering.ts
@@ -0,0 +1,14 @@
+/** thin_films clustering module — tsb analytics library. */
+export interface ThinFilmsClusteringOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsClusteringResult { values: number[]; converged: boolean; }
+export function computeThinFilmsClustering(data: number[], opts: ThinFilmsClusteringOptions = {}): ThinFilmsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsClustering };
diff --git a/src/thin_films/compression.ts b/src/thin_films/compression.ts
new file mode 100644
index 000000000..b75d623cf
--- /dev/null
+++ b/src/thin_films/compression.ts
@@ -0,0 +1,14 @@
+/** thin_films compression module — tsb analytics library. */
+export interface ThinFilmsCompressionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsCompressionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsCompression(data: number[], opts: ThinFilmsCompressionOptions = {}): ThinFilmsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsCompression };
diff --git a/src/thin_films/continuous.ts b/src/thin_films/continuous.ts
new file mode 100644
index 000000000..61a19b1e9
--- /dev/null
+++ b/src/thin_films/continuous.ts
@@ -0,0 +1,14 @@
+/** thin_films continuous module — tsb analytics library. */
+export interface ThinFilmsContinuousOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsContinuousResult { values: number[]; converged: boolean; }
+export function computeThinFilmsContinuous(data: number[], opts: ThinFilmsContinuousOptions = {}): ThinFilmsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsContinuous };
diff --git a/src/thin_films/control.ts b/src/thin_films/control.ts
new file mode 100644
index 000000000..10415f45f
--- /dev/null
+++ b/src/thin_films/control.ts
@@ -0,0 +1,14 @@
+/** thin_films control module — tsb analytics library. */
+export interface ThinFilmsControlOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsControlResult { values: number[]; converged: boolean; }
+export function computeThinFilmsControl(data: number[], opts: ThinFilmsControlOptions = {}): ThinFilmsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsControl };
diff --git a/src/thin_films/convergence.ts b/src/thin_films/convergence.ts
new file mode 100644
index 000000000..0ea021018
--- /dev/null
+++ b/src/thin_films/convergence.ts
@@ -0,0 +1,14 @@
+/** thin_films convergence module — tsb analytics library. */
+export interface ThinFilmsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsConvergenceResult { values: number[]; converged: boolean; }
+export function computeThinFilmsConvergence(data: number[], opts: ThinFilmsConvergenceOptions = {}): ThinFilmsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsConvergence };
diff --git a/src/thin_films/convex.ts b/src/thin_films/convex.ts
new file mode 100644
index 000000000..babbb0cf8
--- /dev/null
+++ b/src/thin_films/convex.ts
@@ -0,0 +1,14 @@
+/** thin_films convex module — tsb analytics library. */
+export interface ThinFilmsConvexOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsConvexResult { values: number[]; converged: boolean; }
+export function computeThinFilmsConvex(data: number[], opts: ThinFilmsConvexOptions = {}): ThinFilmsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsConvex };
diff --git a/src/thin_films/correlation.ts b/src/thin_films/correlation.ts
new file mode 100644
index 000000000..adec757e7
--- /dev/null
+++ b/src/thin_films/correlation.ts
@@ -0,0 +1,14 @@
+/** thin_films correlation module — tsb analytics library. */
+export interface ThinFilmsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsCorrelationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsCorrelation(data: number[], opts: ThinFilmsCorrelationOptions = {}): ThinFilmsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsCorrelation };
diff --git a/src/thin_films/covariance.ts b/src/thin_films/covariance.ts
new file mode 100644
index 000000000..2414ee653
--- /dev/null
+++ b/src/thin_films/covariance.ts
@@ -0,0 +1,14 @@
+/** thin_films covariance module — tsb analytics library. */
+export interface ThinFilmsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsCovarianceResult { values: number[]; converged: boolean; }
+export function computeThinFilmsCovariance(data: number[], opts: ThinFilmsCovarianceOptions = {}): ThinFilmsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsCovariance };
diff --git a/src/thin_films/cross_validation.ts b/src/thin_films/cross_validation.ts
new file mode 100644
index 000000000..73ebbbd09
--- /dev/null
+++ b/src/thin_films/cross_validation.ts
@@ -0,0 +1,14 @@
+/** thin_films cross_validation module — tsb analytics library. */
+export interface ThinFilmsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsCrossValidation(data: number[], opts: ThinFilmsCrossValidationOptions = {}): ThinFilmsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsCrossValidation };
diff --git a/src/thin_films/decoding.ts b/src/thin_films/decoding.ts
new file mode 100644
index 000000000..1f6a1121c
--- /dev/null
+++ b/src/thin_films/decoding.ts
@@ -0,0 +1,14 @@
+/** thin_films decoding module — tsb analytics library. */
+export interface ThinFilmsDecodingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDecodingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDecoding(data: number[], opts: ThinFilmsDecodingOptions = {}): ThinFilmsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDecoding };
diff --git a/src/thin_films/decomposition.ts b/src/thin_films/decomposition.ts
new file mode 100644
index 000000000..abc07fd69
--- /dev/null
+++ b/src/thin_films/decomposition.ts
@@ -0,0 +1,14 @@
+/** thin_films decomposition module — tsb analytics library. */
+export interface ThinFilmsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDecompositionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDecomposition(data: number[], opts: ThinFilmsDecompositionOptions = {}): ThinFilmsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDecomposition };
diff --git a/src/thin_films/detection.ts b/src/thin_films/detection.ts
new file mode 100644
index 000000000..c99b8aea8
--- /dev/null
+++ b/src/thin_films/detection.ts
@@ -0,0 +1,14 @@
+/** thin_films detection module — tsb analytics library. */
+export interface ThinFilmsDetectionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDetectionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDetection(data: number[], opts: ThinFilmsDetectionOptions = {}): ThinFilmsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDetection };
diff --git a/src/thin_films/deterministic.ts b/src/thin_films/deterministic.ts
new file mode 100644
index 000000000..70f69d209
--- /dev/null
+++ b/src/thin_films/deterministic.ts
@@ -0,0 +1,14 @@
+/** thin_films deterministic module — tsb analytics library. */
+export interface ThinFilmsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDeterministicResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDeterministic(data: number[], opts: ThinFilmsDeterministicOptions = {}): ThinFilmsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDeterministic };
diff --git a/src/thin_films/diagnostics.ts b/src/thin_films/diagnostics.ts
new file mode 100644
index 000000000..23b8fd3d2
--- /dev/null
+++ b/src/thin_films/diagnostics.ts
@@ -0,0 +1,14 @@
+/** thin_films diagnostics module — tsb analytics library. */
+export interface ThinFilmsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDiagnostics(data: number[], opts: ThinFilmsDiagnosticsOptions = {}): ThinFilmsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDiagnostics };
diff --git a/src/thin_films/differential.ts b/src/thin_films/differential.ts
new file mode 100644
index 000000000..b47ca77d1
--- /dev/null
+++ b/src/thin_films/differential.ts
@@ -0,0 +1,14 @@
+/** thin_films differential module — tsb analytics library. */
+export interface ThinFilmsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDifferentialResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDifferential(data: number[], opts: ThinFilmsDifferentialOptions = {}): ThinFilmsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDifferential };
diff --git a/src/thin_films/discrete.ts b/src/thin_films/discrete.ts
new file mode 100644
index 000000000..216e1c604
--- /dev/null
+++ b/src/thin_films/discrete.ts
@@ -0,0 +1,14 @@
+/** thin_films discrete module — tsb analytics library. */
+export interface ThinFilmsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDiscreteResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDiscrete(data: number[], opts: ThinFilmsDiscreteOptions = {}): ThinFilmsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDiscrete };
diff --git a/src/thin_films/distribution.ts b/src/thin_films/distribution.ts
new file mode 100644
index 000000000..984ec1d32
--- /dev/null
+++ b/src/thin_films/distribution.ts
@@ -0,0 +1,14 @@
+/** thin_films distribution module — tsb analytics library. */
+export interface ThinFilmsDistributionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDistributionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDistribution(data: number[], opts: ThinFilmsDistributionOptions = {}): ThinFilmsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDistribution };
diff --git a/src/thin_films/dynamic.ts b/src/thin_films/dynamic.ts
new file mode 100644
index 000000000..dbfddcf1e
--- /dev/null
+++ b/src/thin_films/dynamic.ts
@@ -0,0 +1,14 @@
+/** thin_films dynamic module — tsb analytics library. */
+export interface ThinFilmsDynamicOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsDynamicResult { values: number[]; converged: boolean; }
+export function computeThinFilmsDynamic(data: number[], opts: ThinFilmsDynamicOptions = {}): ThinFilmsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsDynamic };
diff --git a/src/thin_films/embedding.ts b/src/thin_films/embedding.ts
new file mode 100644
index 000000000..5b06ded21
--- /dev/null
+++ b/src/thin_films/embedding.ts
@@ -0,0 +1,14 @@
+/** thin_films embedding module — tsb analytics library. */
+export interface ThinFilmsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsEmbedding(data: number[], opts: ThinFilmsEmbeddingOptions = {}): ThinFilmsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsEmbedding };
diff --git a/src/thin_films/encoding.ts b/src/thin_films/encoding.ts
new file mode 100644
index 000000000..bbc4fb237
--- /dev/null
+++ b/src/thin_films/encoding.ts
@@ -0,0 +1,14 @@
+/** thin_films encoding module — tsb analytics library. */
+export interface ThinFilmsEncodingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsEncodingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsEncoding(data: number[], opts: ThinFilmsEncodingOptions = {}): ThinFilmsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsEncoding };
diff --git a/src/thin_films/ensemble.ts b/src/thin_films/ensemble.ts
new file mode 100644
index 000000000..3b0278261
--- /dev/null
+++ b/src/thin_films/ensemble.ts
@@ -0,0 +1,14 @@
+/** thin_films ensemble module — tsb analytics library. */
+export interface ThinFilmsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsEnsembleResult { values: number[]; converged: boolean; }
+export function computeThinFilmsEnsemble(data: number[], opts: ThinFilmsEnsembleOptions = {}): ThinFilmsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsEnsemble };
diff --git a/src/thin_films/estimation.ts b/src/thin_films/estimation.ts
new file mode 100644
index 000000000..c8b1f0124
--- /dev/null
+++ b/src/thin_films/estimation.ts
@@ -0,0 +1,14 @@
+/** thin_films estimation module — tsb analytics library. */
+export interface ThinFilmsEstimationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsEstimationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsEstimation(data: number[], opts: ThinFilmsEstimationOptions = {}): ThinFilmsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsEstimation };
diff --git a/src/thin_films/evaluation.ts b/src/thin_films/evaluation.ts
new file mode 100644
index 000000000..19c2e966e
--- /dev/null
+++ b/src/thin_films/evaluation.ts
@@ -0,0 +1,14 @@
+/** thin_films evaluation module — tsb analytics library. */
+export interface ThinFilmsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsEvaluationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsEvaluation(data: number[], opts: ThinFilmsEvaluationOptions = {}): ThinFilmsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsEvaluation };
diff --git a/src/thin_films/extrapolation.ts b/src/thin_films/extrapolation.ts
new file mode 100644
index 000000000..7814021cb
--- /dev/null
+++ b/src/thin_films/extrapolation.ts
@@ -0,0 +1,14 @@
+/** thin_films extrapolation module — tsb analytics library. */
+export interface ThinFilmsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsExtrapolation(data: number[], opts: ThinFilmsExtrapolationOptions = {}): ThinFilmsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsExtrapolation };
diff --git a/src/thin_films/features.ts b/src/thin_films/features.ts
new file mode 100644
index 000000000..cc5a949c8
--- /dev/null
+++ b/src/thin_films/features.ts
@@ -0,0 +1,14 @@
+/** thin_films features module — tsb analytics library. */
+export interface ThinFilmsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsFeaturesResult { values: number[]; converged: boolean; }
+export function computeThinFilmsFeatures(data: number[], opts: ThinFilmsFeaturesOptions = {}): ThinFilmsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsFeatures };
diff --git a/src/thin_films/feedback.ts b/src/thin_films/feedback.ts
new file mode 100644
index 000000000..8f00d34de
--- /dev/null
+++ b/src/thin_films/feedback.ts
@@ -0,0 +1,14 @@
+/** thin_films feedback module — tsb analytics library. */
+export interface ThinFilmsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsFeedbackResult { values: number[]; converged: boolean; }
+export function computeThinFilmsFeedback(data: number[], opts: ThinFilmsFeedbackOptions = {}): ThinFilmsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsFeedback };
diff --git a/src/thin_films/filtering.ts b/src/thin_films/filtering.ts
new file mode 100644
index 000000000..ffd5e11dc
--- /dev/null
+++ b/src/thin_films/filtering.ts
@@ -0,0 +1,14 @@
+/** thin_films filtering module — tsb analytics library. */
+export interface ThinFilmsFilteringOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsFilteringResult { values: number[]; converged: boolean; }
+export function computeThinFilmsFiltering(data: number[], opts: ThinFilmsFilteringOptions = {}): ThinFilmsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsFiltering };
diff --git a/src/thin_films/fourier.ts b/src/thin_films/fourier.ts
new file mode 100644
index 000000000..8070b13a0
--- /dev/null
+++ b/src/thin_films/fourier.ts
@@ -0,0 +1,14 @@
+/** thin_films fourier module — tsb analytics library. */
+export interface ThinFilmsFourierOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsFourierResult { values: number[]; converged: boolean; }
+export function computeThinFilmsFourier(data: number[], opts: ThinFilmsFourierOptions = {}): ThinFilmsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsFourier };
diff --git a/src/thin_films/fusion.ts b/src/thin_films/fusion.ts
new file mode 100644
index 000000000..97e79b724
--- /dev/null
+++ b/src/thin_films/fusion.ts
@@ -0,0 +1,14 @@
+/** thin_films fusion module — tsb analytics library. */
+export interface ThinFilmsFusionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsFusionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsFusion(data: number[], opts: ThinFilmsFusionOptions = {}): ThinFilmsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsFusion };
diff --git a/src/thin_films/generation.ts b/src/thin_films/generation.ts
new file mode 100644
index 000000000..96a1d9f7a
--- /dev/null
+++ b/src/thin_films/generation.ts
@@ -0,0 +1,14 @@
+/** thin_films generation module — tsb analytics library. */
+export interface ThinFilmsGenerationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsGenerationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsGeneration(data: number[], opts: ThinFilmsGenerationOptions = {}): ThinFilmsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsGeneration };
diff --git a/src/thin_films/geometry.ts b/src/thin_films/geometry.ts
new file mode 100644
index 000000000..716b28b52
--- /dev/null
+++ b/src/thin_films/geometry.ts
@@ -0,0 +1,14 @@
+/** thin_films geometry module — tsb analytics library. */
+export interface ThinFilmsGeometryOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsGeometryResult { values: number[]; converged: boolean; }
+export function computeThinFilmsGeometry(data: number[], opts: ThinFilmsGeometryOptions = {}): ThinFilmsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsGeometry };
diff --git a/src/thin_films/gradient.ts b/src/thin_films/gradient.ts
new file mode 100644
index 000000000..bdcced574
--- /dev/null
+++ b/src/thin_films/gradient.ts
@@ -0,0 +1,14 @@
+/** thin_films gradient module — tsb analytics library. */
+export interface ThinFilmsGradientOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsGradientResult { values: number[]; converged: boolean; }
+export function computeThinFilmsGradient(data: number[], opts: ThinFilmsGradientOptions = {}): ThinFilmsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsGradient };
diff --git a/src/thin_films/hessian.ts b/src/thin_films/hessian.ts
new file mode 100644
index 000000000..0fff11127
--- /dev/null
+++ b/src/thin_films/hessian.ts
@@ -0,0 +1,14 @@
+/** thin_films hessian module — tsb analytics library. */
+export interface ThinFilmsHessianOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsHessianResult { values: number[]; converged: boolean; }
+export function computeThinFilmsHessian(data: number[], opts: ThinFilmsHessianOptions = {}): ThinFilmsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsHessian };
diff --git a/src/thin_films/hypothesis.ts b/src/thin_films/hypothesis.ts
new file mode 100644
index 000000000..105874a5e
--- /dev/null
+++ b/src/thin_films/hypothesis.ts
@@ -0,0 +1,14 @@
+/** thin_films hypothesis module — tsb analytics library. */
+export interface ThinFilmsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsHypothesisResult { values: number[]; converged: boolean; }
+export function computeThinFilmsHypothesis(data: number[], opts: ThinFilmsHypothesisOptions = {}): ThinFilmsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsHypothesis };
diff --git a/src/thin_films/inference.ts b/src/thin_films/inference.ts
new file mode 100644
index 000000000..23dec2fed
--- /dev/null
+++ b/src/thin_films/inference.ts
@@ -0,0 +1,14 @@
+/** thin_films inference module — tsb analytics library. */
+export interface ThinFilmsInferenceOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsInferenceResult { values: number[]; converged: boolean; }
+export function computeThinFilmsInference(data: number[], opts: ThinFilmsInferenceOptions = {}): ThinFilmsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsInference };
diff --git a/src/thin_films/inference2.ts b/src/thin_films/inference2.ts
new file mode 100644
index 000000000..18bdb2f51
--- /dev/null
+++ b/src/thin_films/inference2.ts
@@ -0,0 +1,14 @@
+/** thin_films inference2 module — tsb analytics library. */
+export interface ThinFilmsInferenceOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsInferenceResult { values: number[]; converged: boolean; }
+export function computeThinFilmsInference(data: number[], opts: ThinFilmsInferenceOptions = {}): ThinFilmsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsInference };
diff --git a/src/thin_films/integral.ts b/src/thin_films/integral.ts
new file mode 100644
index 000000000..cc0e92a87
--- /dev/null
+++ b/src/thin_films/integral.ts
@@ -0,0 +1,14 @@
+/** thin_films integral module — tsb analytics library. */
+export interface ThinFilmsIntegralOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsIntegralResult { values: number[]; converged: boolean; }
+export function computeThinFilmsIntegral(data: number[], opts: ThinFilmsIntegralOptions = {}): ThinFilmsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsIntegral };
diff --git a/src/thin_films/integration.ts b/src/thin_films/integration.ts
new file mode 100644
index 000000000..6e1dd4133
--- /dev/null
+++ b/src/thin_films/integration.ts
@@ -0,0 +1,14 @@
+/** thin_films integration module — tsb analytics library. */
+export interface ThinFilmsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsIntegrationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsIntegration(data: number[], opts: ThinFilmsIntegrationOptions = {}): ThinFilmsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsIntegration };
diff --git a/src/thin_films/interpolation.ts b/src/thin_films/interpolation.ts
new file mode 100644
index 000000000..4df34743f
--- /dev/null
+++ b/src/thin_films/interpolation.ts
@@ -0,0 +1,14 @@
+/** thin_films interpolation module — tsb analytics library. */
+export interface ThinFilmsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsInterpolationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsInterpolation(data: number[], opts: ThinFilmsInterpolationOptions = {}): ThinFilmsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsInterpolation };
diff --git a/src/thin_films/jacobian.ts b/src/thin_films/jacobian.ts
new file mode 100644
index 000000000..3fc5d9572
--- /dev/null
+++ b/src/thin_films/jacobian.ts
@@ -0,0 +1,14 @@
+/** thin_films jacobian module — tsb analytics library. */
+export interface ThinFilmsJacobianOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsJacobianResult { values: number[]; converged: boolean; }
+export function computeThinFilmsJacobian(data: number[], opts: ThinFilmsJacobianOptions = {}): ThinFilmsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsJacobian };
diff --git a/src/thin_films/kernel.ts b/src/thin_films/kernel.ts
new file mode 100644
index 000000000..718a72179
--- /dev/null
+++ b/src/thin_films/kernel.ts
@@ -0,0 +1,14 @@
+/** thin_films kernel module — tsb analytics library. */
+export interface ThinFilmsKernelOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsKernelResult { values: number[]; converged: boolean; }
+export function computeThinFilmsKernel(data: number[], opts: ThinFilmsKernelOptions = {}): ThinFilmsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsKernel };
diff --git a/src/thin_films/laplacian.ts b/src/thin_films/laplacian.ts
new file mode 100644
index 000000000..dccb896e1
--- /dev/null
+++ b/src/thin_films/laplacian.ts
@@ -0,0 +1,14 @@
+/** thin_films laplacian module — tsb analytics library. */
+export interface ThinFilmsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsLaplacianResult { values: number[]; converged: boolean; }
+export function computeThinFilmsLaplacian(data: number[], opts: ThinFilmsLaplacianOptions = {}): ThinFilmsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsLaplacian };
diff --git a/src/thin_films/learning.ts b/src/thin_films/learning.ts
new file mode 100644
index 000000000..239a626d8
--- /dev/null
+++ b/src/thin_films/learning.ts
@@ -0,0 +1,14 @@
+/** thin_films learning module — tsb analytics library. */
+export interface ThinFilmsLearningOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsLearningResult { values: number[]; converged: boolean; }
+export function computeThinFilmsLearning(data: number[], opts: ThinFilmsLearningOptions = {}): ThinFilmsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsLearning };
diff --git a/src/thin_films/linear.ts b/src/thin_films/linear.ts
new file mode 100644
index 000000000..a5ee3a670
--- /dev/null
+++ b/src/thin_films/linear.ts
@@ -0,0 +1,14 @@
+/** thin_films linear module — tsb analytics library. */
+export interface ThinFilmsLinearOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsLinearResult { values: number[]; converged: boolean; }
+export function computeThinFilmsLinear(data: number[], opts: ThinFilmsLinearOptions = {}): ThinFilmsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsLinear };
diff --git a/src/thin_films/manifold.ts b/src/thin_films/manifold.ts
new file mode 100644
index 000000000..658121a4c
--- /dev/null
+++ b/src/thin_films/manifold.ts
@@ -0,0 +1,14 @@
+/** thin_films manifold module — tsb analytics library. */
+export interface ThinFilmsManifoldOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsManifoldResult { values: number[]; converged: boolean; }
+export function computeThinFilmsManifold(data: number[], opts: ThinFilmsManifoldOptions = {}): ThinFilmsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsManifold };
diff --git a/src/thin_films/matching.ts b/src/thin_films/matching.ts
new file mode 100644
index 000000000..70d648283
--- /dev/null
+++ b/src/thin_films/matching.ts
@@ -0,0 +1,14 @@
+/** thin_films matching module — tsb analytics library. */
+export interface ThinFilmsMatchingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsMatchingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsMatching(data: number[], opts: ThinFilmsMatchingOptions = {}): ThinFilmsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsMatching };
diff --git a/src/thin_films/measurement.ts b/src/thin_films/measurement.ts
new file mode 100644
index 000000000..7a87f9374
--- /dev/null
+++ b/src/thin_films/measurement.ts
@@ -0,0 +1,14 @@
+/** thin_films measurement module — tsb analytics library. */
+export interface ThinFilmsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsMeasurementResult { values: number[]; converged: boolean; }
+export function computeThinFilmsMeasurement(data: number[], opts: ThinFilmsMeasurementOptions = {}): ThinFilmsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsMeasurement };
diff --git a/src/thin_films/metrics.ts b/src/thin_films/metrics.ts
new file mode 100644
index 000000000..c2413280c
--- /dev/null
+++ b/src/thin_films/metrics.ts
@@ -0,0 +1,14 @@
+/** thin_films metrics module — tsb analytics library. */
+export interface ThinFilmsMetricsOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsMetricsResult { values: number[]; converged: boolean; }
+export function computeThinFilmsMetrics(data: number[], opts: ThinFilmsMetricsOptions = {}): ThinFilmsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsMetrics };
diff --git a/src/thin_films/modeling.ts b/src/thin_films/modeling.ts
new file mode 100644
index 000000000..3a8c3b421
--- /dev/null
+++ b/src/thin_films/modeling.ts
@@ -0,0 +1,14 @@
+/** thin_films modeling module — tsb analytics library. */
+export interface ThinFilmsModelingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsModelingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsModeling(data: number[], opts: ThinFilmsModelingOptions = {}): ThinFilmsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsModeling };
diff --git a/src/thin_films/monitoring.ts b/src/thin_films/monitoring.ts
new file mode 100644
index 000000000..b250d8090
--- /dev/null
+++ b/src/thin_films/monitoring.ts
@@ -0,0 +1,14 @@
+/** thin_films monitoring module — tsb analytics library. */
+export interface ThinFilmsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsMonitoringResult { values: number[]; converged: boolean; }
+export function computeThinFilmsMonitoring(data: number[], opts: ThinFilmsMonitoringOptions = {}): ThinFilmsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsMonitoring };
diff --git a/src/thin_films/nonlinear.ts b/src/thin_films/nonlinear.ts
new file mode 100644
index 000000000..3cc3727a8
--- /dev/null
+++ b/src/thin_films/nonlinear.ts
@@ -0,0 +1,14 @@
+/** thin_films nonlinear module — tsb analytics library. */
+export interface ThinFilmsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsNonlinearResult { values: number[]; converged: boolean; }
+export function computeThinFilmsNonlinear(data: number[], opts: ThinFilmsNonlinearOptions = {}): ThinFilmsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsNonlinear };
diff --git a/src/thin_films/normalization.ts b/src/thin_films/normalization.ts
new file mode 100644
index 000000000..f2eb8ec41
--- /dev/null
+++ b/src/thin_films/normalization.ts
@@ -0,0 +1,14 @@
+/** thin_films normalization module — tsb analytics library. */
+export interface ThinFilmsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsNormalizationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsNormalization(data: number[], opts: ThinFilmsNormalizationOptions = {}): ThinFilmsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsNormalization };
diff --git a/src/thin_films/optimization.ts b/src/thin_films/optimization.ts
new file mode 100644
index 000000000..6590f051b
--- /dev/null
+++ b/src/thin_films/optimization.ts
@@ -0,0 +1,14 @@
+/** thin_films optimization module — tsb analytics library. */
+export interface ThinFilmsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsOptimizationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsOptimization(data: number[], opts: ThinFilmsOptimizationOptions = {}): ThinFilmsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsOptimization };
diff --git a/src/thin_films/patterns.ts b/src/thin_films/patterns.ts
new file mode 100644
index 000000000..1c8cddc78
--- /dev/null
+++ b/src/thin_films/patterns.ts
@@ -0,0 +1,14 @@
+/** thin_films patterns module — tsb analytics library. */
+export interface ThinFilmsPatternsOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsPatternsResult { values: number[]; converged: boolean; }
+export function computeThinFilmsPatterns(data: number[], opts: ThinFilmsPatternsOptions = {}): ThinFilmsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsPatterns };
diff --git a/src/thin_films/permutation.ts b/src/thin_films/permutation.ts
new file mode 100644
index 000000000..b032298a2
--- /dev/null
+++ b/src/thin_films/permutation.ts
@@ -0,0 +1,14 @@
+/** thin_films permutation module — tsb analytics library. */
+export interface ThinFilmsPermutationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsPermutationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsPermutation(data: number[], opts: ThinFilmsPermutationOptions = {}): ThinFilmsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsPermutation };
diff --git a/src/thin_films/prediction.ts b/src/thin_films/prediction.ts
new file mode 100644
index 000000000..350133047
--- /dev/null
+++ b/src/thin_films/prediction.ts
@@ -0,0 +1,14 @@
+/** thin_films prediction module — tsb analytics library. */
+export interface ThinFilmsPredictionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsPredictionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsPrediction(data: number[], opts: ThinFilmsPredictionOptions = {}): ThinFilmsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsPrediction };
diff --git a/src/thin_films/processing.ts b/src/thin_films/processing.ts
new file mode 100644
index 000000000..dde2930e1
--- /dev/null
+++ b/src/thin_films/processing.ts
@@ -0,0 +1,14 @@
+/** thin_films processing module — tsb analytics library. */
+export interface ThinFilmsProcessingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsProcessingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsProcessing(data: number[], opts: ThinFilmsProcessingOptions = {}): ThinFilmsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsProcessing };
diff --git a/src/thin_films/profiling.ts b/src/thin_films/profiling.ts
new file mode 100644
index 000000000..418c48e1b
--- /dev/null
+++ b/src/thin_films/profiling.ts
@@ -0,0 +1,14 @@
+/** thin_films profiling module — tsb analytics library. */
+export interface ThinFilmsProfilingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsProfilingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsProfiling(data: number[], opts: ThinFilmsProfilingOptions = {}): ThinFilmsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsProfiling };
diff --git a/src/thin_films/projection.ts b/src/thin_films/projection.ts
new file mode 100644
index 000000000..04f8b5b81
--- /dev/null
+++ b/src/thin_films/projection.ts
@@ -0,0 +1,14 @@
+/** thin_films projection module — tsb analytics library. */
+export interface ThinFilmsProjectionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsProjectionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsProjection(data: number[], opts: ThinFilmsProjectionOptions = {}): ThinFilmsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsProjection };
diff --git a/src/thin_films/ranking.ts b/src/thin_films/ranking.ts
new file mode 100644
index 000000000..6fc43a41f
--- /dev/null
+++ b/src/thin_films/ranking.ts
@@ -0,0 +1,14 @@
+/** thin_films ranking module — tsb analytics library. */
+export interface ThinFilmsRankingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsRankingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsRanking(data: number[], opts: ThinFilmsRankingOptions = {}): ThinFilmsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsRanking };
diff --git a/src/thin_films/reconstruction.ts b/src/thin_films/reconstruction.ts
new file mode 100644
index 000000000..4e7d519e7
--- /dev/null
+++ b/src/thin_films/reconstruction.ts
@@ -0,0 +1,14 @@
+/** thin_films reconstruction module — tsb analytics library. */
+export interface ThinFilmsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsReconstructionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsReconstruction(data: number[], opts: ThinFilmsReconstructionOptions = {}): ThinFilmsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsReconstruction };
diff --git a/src/thin_films/registration.ts b/src/thin_films/registration.ts
new file mode 100644
index 000000000..c735e1d55
--- /dev/null
+++ b/src/thin_films/registration.ts
@@ -0,0 +1,14 @@
+/** thin_films registration module — tsb analytics library. */
+export interface ThinFilmsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsRegistrationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsRegistration(data: number[], opts: ThinFilmsRegistrationOptions = {}): ThinFilmsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsRegistration };
diff --git a/src/thin_films/regression.ts b/src/thin_films/regression.ts
new file mode 100644
index 000000000..da2839ad2
--- /dev/null
+++ b/src/thin_films/regression.ts
@@ -0,0 +1,14 @@
+/** thin_films regression module — tsb analytics library. */
+export interface ThinFilmsRegressionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsRegressionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsRegression(data: number[], opts: ThinFilmsRegressionOptions = {}): ThinFilmsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsRegression };
diff --git a/src/thin_films/regularization.ts b/src/thin_films/regularization.ts
new file mode 100644
index 000000000..9ace3e5e2
--- /dev/null
+++ b/src/thin_films/regularization.ts
@@ -0,0 +1,14 @@
+/** thin_films regularization module — tsb analytics library. */
+export interface ThinFilmsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsRegularizationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsRegularization(data: number[], opts: ThinFilmsRegularizationOptions = {}): ThinFilmsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsRegularization };
diff --git a/src/thin_films/robustness.ts b/src/thin_films/robustness.ts
new file mode 100644
index 000000000..1a25af4f7
--- /dev/null
+++ b/src/thin_films/robustness.ts
@@ -0,0 +1,14 @@
+/** thin_films robustness module — tsb analytics library. */
+export interface ThinFilmsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsRobustnessResult { values: number[]; converged: boolean; }
+export function computeThinFilmsRobustness(data: number[], opts: ThinFilmsRobustnessOptions = {}): ThinFilmsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsRobustness };
diff --git a/src/thin_films/sampling.ts b/src/thin_films/sampling.ts
new file mode 100644
index 000000000..d77288288
--- /dev/null
+++ b/src/thin_films/sampling.ts
@@ -0,0 +1,14 @@
+/** thin_films sampling module — tsb analytics library. */
+export interface ThinFilmsSamplingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsSamplingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsSampling(data: number[], opts: ThinFilmsSamplingOptions = {}): ThinFilmsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsSampling };
diff --git a/src/thin_films/sampling2.ts b/src/thin_films/sampling2.ts
new file mode 100644
index 000000000..aa815b89b
--- /dev/null
+++ b/src/thin_films/sampling2.ts
@@ -0,0 +1,14 @@
+/** thin_films sampling2 module — tsb analytics library. */
+export interface ThinFilmsSamplingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsSamplingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsSampling(data: number[], opts: ThinFilmsSamplingOptions = {}): ThinFilmsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsSampling };
diff --git a/src/thin_films/scaling.ts b/src/thin_films/scaling.ts
new file mode 100644
index 000000000..0f70e4bbb
--- /dev/null
+++ b/src/thin_films/scaling.ts
@@ -0,0 +1,14 @@
+/** thin_films scaling module — tsb analytics library. */
+export interface ThinFilmsScalingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsScalingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsScaling(data: number[], opts: ThinFilmsScalingOptions = {}): ThinFilmsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsScaling };
diff --git a/src/thin_films/scoring.ts b/src/thin_films/scoring.ts
new file mode 100644
index 000000000..035b9d1a6
--- /dev/null
+++ b/src/thin_films/scoring.ts
@@ -0,0 +1,14 @@
+/** thin_films scoring module — tsb analytics library. */
+export interface ThinFilmsScoringOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsScoringResult { values: number[]; converged: boolean; }
+export function computeThinFilmsScoring(data: number[], opts: ThinFilmsScoringOptions = {}): ThinFilmsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsScoring };
diff --git a/src/thin_films/segmentation.ts b/src/thin_films/segmentation.ts
new file mode 100644
index 000000000..ff220ad23
--- /dev/null
+++ b/src/thin_films/segmentation.ts
@@ -0,0 +1,14 @@
+/** thin_films segmentation module — tsb analytics library. */
+export interface ThinFilmsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsSegmentationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsSegmentation(data: number[], opts: ThinFilmsSegmentationOptions = {}): ThinFilmsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsSegmentation };
diff --git a/src/thin_films/selection.ts b/src/thin_films/selection.ts
new file mode 100644
index 000000000..31d63ebb5
--- /dev/null
+++ b/src/thin_films/selection.ts
@@ -0,0 +1,14 @@
+/** thin_films selection module — tsb analytics library. */
+export interface ThinFilmsSelectionOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsSelectionResult { values: number[]; converged: boolean; }
+export function computeThinFilmsSelection(data: number[], opts: ThinFilmsSelectionOptions = {}): ThinFilmsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsSelection };
diff --git a/src/thin_films/sensitivity.ts b/src/thin_films/sensitivity.ts
new file mode 100644
index 000000000..3b14eceab
--- /dev/null
+++ b/src/thin_films/sensitivity.ts
@@ -0,0 +1,14 @@
+/** thin_films sensitivity module — tsb analytics library. */
+export interface ThinFilmsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsSensitivityResult { values: number[]; converged: boolean; }
+export function computeThinFilmsSensitivity(data: number[], opts: ThinFilmsSensitivityOptions = {}): ThinFilmsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsSensitivity };
diff --git a/src/thin_films/simulation.ts b/src/thin_films/simulation.ts
new file mode 100644
index 000000000..9981eaeba
--- /dev/null
+++ b/src/thin_films/simulation.ts
@@ -0,0 +1,14 @@
+/** thin_films simulation module — tsb analytics library. */
+export interface ThinFilmsSimulationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsSimulationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsSimulation(data: number[], opts: ThinFilmsSimulationOptions = {}): ThinFilmsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsSimulation };
diff --git a/src/thin_films/smoothing.ts b/src/thin_films/smoothing.ts
new file mode 100644
index 000000000..8bfe8c0db
--- /dev/null
+++ b/src/thin_films/smoothing.ts
@@ -0,0 +1,14 @@
+/** thin_films smoothing module — tsb analytics library. */
+export interface ThinFilmsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsSmoothingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsSmoothing(data: number[], opts: ThinFilmsSmoothingOptions = {}): ThinFilmsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsSmoothing };
diff --git a/src/thin_films/stability.ts b/src/thin_films/stability.ts
new file mode 100644
index 000000000..eb2739673
--- /dev/null
+++ b/src/thin_films/stability.ts
@@ -0,0 +1,14 @@
+/** thin_films stability module — tsb analytics library. */
+export interface ThinFilmsStabilityOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsStabilityResult { values: number[]; converged: boolean; }
+export function computeThinFilmsStability(data: number[], opts: ThinFilmsStabilityOptions = {}): ThinFilmsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsStability };
diff --git a/src/thin_films/stacking.ts b/src/thin_films/stacking.ts
new file mode 100644
index 000000000..19f676573
--- /dev/null
+++ b/src/thin_films/stacking.ts
@@ -0,0 +1,14 @@
+/** thin_films stacking module — tsb analytics library. */
+export interface ThinFilmsStackingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsStackingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsStacking(data: number[], opts: ThinFilmsStackingOptions = {}): ThinFilmsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsStacking };
diff --git a/src/thin_films/standardization.ts b/src/thin_films/standardization.ts
new file mode 100644
index 000000000..293ec5b14
--- /dev/null
+++ b/src/thin_films/standardization.ts
@@ -0,0 +1,14 @@
+/** thin_films standardization module — tsb analytics library. */
+export interface ThinFilmsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsStandardizationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsStandardization(data: number[], opts: ThinFilmsStandardizationOptions = {}): ThinFilmsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsStandardization };
diff --git a/src/thin_films/static.ts b/src/thin_films/static.ts
new file mode 100644
index 000000000..e4db2f96f
--- /dev/null
+++ b/src/thin_films/static.ts
@@ -0,0 +1,14 @@
+/** thin_films static module — tsb analytics library. */
+export interface ThinFilmsStaticOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsStaticResult { values: number[]; converged: boolean; }
+export function computeThinFilmsStatic(data: number[], opts: ThinFilmsStaticOptions = {}): ThinFilmsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsStatic };
diff --git a/src/thin_films/stochastic.ts b/src/thin_films/stochastic.ts
new file mode 100644
index 000000000..ed9660c84
--- /dev/null
+++ b/src/thin_films/stochastic.ts
@@ -0,0 +1,14 @@
+/** thin_films stochastic module — tsb analytics library. */
+export interface ThinFilmsStochasticOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsStochasticResult { values: number[]; converged: boolean; }
+export function computeThinFilmsStochastic(data: number[], opts: ThinFilmsStochasticOptions = {}): ThinFilmsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsStochastic };
diff --git a/src/thin_films/synthesis.ts b/src/thin_films/synthesis.ts
new file mode 100644
index 000000000..4461f6281
--- /dev/null
+++ b/src/thin_films/synthesis.ts
@@ -0,0 +1,14 @@
+/** thin_films synthesis module — tsb analytics library. */
+export interface ThinFilmsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsSynthesisResult { values: number[]; converged: boolean; }
+export function computeThinFilmsSynthesis(data: number[], opts: ThinFilmsSynthesisOptions = {}): ThinFilmsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsSynthesis };
diff --git a/src/thin_films/topology.ts b/src/thin_films/topology.ts
new file mode 100644
index 000000000..5b4ed478f
--- /dev/null
+++ b/src/thin_films/topology.ts
@@ -0,0 +1,14 @@
+/** thin_films topology module — tsb analytics library. */
+export interface ThinFilmsTopologyOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsTopologyResult { values: number[]; converged: boolean; }
+export function computeThinFilmsTopology(data: number[], opts: ThinFilmsTopologyOptions = {}): ThinFilmsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsTopology };
diff --git a/src/thin_films/tracking.ts b/src/thin_films/tracking.ts
new file mode 100644
index 000000000..f95939b04
--- /dev/null
+++ b/src/thin_films/tracking.ts
@@ -0,0 +1,14 @@
+/** thin_films tracking module — tsb analytics library. */
+export interface ThinFilmsTrackingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsTrackingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsTracking(data: number[], opts: ThinFilmsTrackingOptions = {}): ThinFilmsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsTracking };
diff --git a/src/thin_films/transform.ts b/src/thin_films/transform.ts
new file mode 100644
index 000000000..3e12fcb03
--- /dev/null
+++ b/src/thin_films/transform.ts
@@ -0,0 +1,14 @@
+/** thin_films transform module — tsb analytics library. */
+export interface ThinFilmsTransformOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsTransformResult { values: number[]; converged: boolean; }
+export function computeThinFilmsTransform(data: number[], opts: ThinFilmsTransformOptions = {}): ThinFilmsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsTransform };
diff --git a/src/thin_films/uncertainty.ts b/src/thin_films/uncertainty.ts
new file mode 100644
index 000000000..b062e4da8
--- /dev/null
+++ b/src/thin_films/uncertainty.ts
@@ -0,0 +1,14 @@
+/** thin_films uncertainty module — tsb analytics library. */
+export interface ThinFilmsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeThinFilmsUncertainty(data: number[], opts: ThinFilmsUncertaintyOptions = {}): ThinFilmsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsUncertainty };
diff --git a/src/thin_films/validation.ts b/src/thin_films/validation.ts
new file mode 100644
index 000000000..3c2501818
--- /dev/null
+++ b/src/thin_films/validation.ts
@@ -0,0 +1,14 @@
+/** thin_films validation module — tsb analytics library. */
+export interface ThinFilmsValidationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsValidationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsValidation(data: number[], opts: ThinFilmsValidationOptions = {}): ThinFilmsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsValidation };
diff --git a/src/thin_films/verification.ts b/src/thin_films/verification.ts
new file mode 100644
index 000000000..400cc867b
--- /dev/null
+++ b/src/thin_films/verification.ts
@@ -0,0 +1,14 @@
+/** thin_films verification module — tsb analytics library. */
+export interface ThinFilmsVerificationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsVerificationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsVerification(data: number[], opts: ThinFilmsVerificationOptions = {}): ThinFilmsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsVerification };
diff --git a/src/thin_films/visualization.ts b/src/thin_films/visualization.ts
new file mode 100644
index 000000000..402957f1f
--- /dev/null
+++ b/src/thin_films/visualization.ts
@@ -0,0 +1,14 @@
+/** thin_films visualization module — tsb analytics library. */
+export interface ThinFilmsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsVisualizationResult { values: number[]; converged: boolean; }
+export function computeThinFilmsVisualization(data: number[], opts: ThinFilmsVisualizationOptions = {}): ThinFilmsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsVisualization };
diff --git a/src/thin_films/voting.ts b/src/thin_films/voting.ts
new file mode 100644
index 000000000..e59f8f3d3
--- /dev/null
+++ b/src/thin_films/voting.ts
@@ -0,0 +1,14 @@
+/** thin_films voting module — tsb analytics library. */
+export interface ThinFilmsVotingOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsVotingResult { values: number[]; converged: boolean; }
+export function computeThinFilmsVoting(data: number[], opts: ThinFilmsVotingOptions = {}): ThinFilmsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsVoting };
diff --git a/src/thin_films/wavelet.ts b/src/thin_films/wavelet.ts
new file mode 100644
index 000000000..78741461b
--- /dev/null
+++ b/src/thin_films/wavelet.ts
@@ -0,0 +1,14 @@
+/** thin_films wavelet module — tsb analytics library. */
+export interface ThinFilmsWaveletOptions { tol?: number; maxIter?: number; }
+export interface ThinFilmsWaveletResult { values: number[]; converged: boolean; }
+export function computeThinFilmsWavelet(data: number[], opts: ThinFilmsWaveletOptions = {}): ThinFilmsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeThinFilmsWavelet };
diff --git a/src/timeseries/advanced.ts b/src/timeseries/advanced.ts
new file mode 100644
index 000000000..0a2f92f21
--- /dev/null
+++ b/src/timeseries/advanced.ts
@@ -0,0 +1,15 @@
+/** Timeseries Advanced module — tsb analytics library. */
+export interface Timeseries advancedOptions { tol?: number; maxIter?: number; }
+export interface Timeseries advancedResult { values: number[]; converged: boolean; }
+export function computeTimeseries advanced(data: number[], opts: Timeseries advancedOptions = {}): Timeseries advancedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries advanced };
diff --git a/src/timeseries/alignment.ts b/src/timeseries/alignment.ts
new file mode 100644
index 000000000..d9072c480
--- /dev/null
+++ b/src/timeseries/alignment.ts
@@ -0,0 +1,22 @@
+/** Alignment module — tsb analytics library. */
+
+/** Options for Alignment. */
+export interface AlignmentOptions { tol?: number; maxIter?: number; }
+
+/** Result from Alignment. */
+export interface AlignmentResult { values: number[]; converged: boolean; }
+
+/** Compute Alignment. */
+export function computeAlignment(data: number[], opts: AlignmentOptions = {}): AlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAlignment };
diff --git a/src/timeseries/arima.ts b/src/timeseries/arima.ts
new file mode 100644
index 000000000..8554623b0
--- /dev/null
+++ b/src/timeseries/arima.ts
@@ -0,0 +1,22 @@
+/** Arima module — tsb analytics library. */
+
+/** Options for Arima. */
+export interface ArimaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Arima. */
+export interface ArimaResult { values: number[]; converged: boolean; }
+
+/** Compute Arima. */
+export function computeArima(data: number[], opts: ArimaOptions = {}): ArimaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeArima };
diff --git a/src/timeseries/autocorrelation.ts b/src/timeseries/autocorrelation.ts
new file mode 100644
index 000000000..d41405616
--- /dev/null
+++ b/src/timeseries/autocorrelation.ts
@@ -0,0 +1,22 @@
+/** Autocorrelation module — tsb analytics library. */
+
+/** Options for Autocorrelation. */
+export interface AutocorrelationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Autocorrelation. */
+export interface AutocorrelationResult { values: number[]; converged: boolean; }
+
+/** Compute Autocorrelation. */
+export function computeAutocorrelation(data: number[], opts: AutocorrelationOptions = {}): AutocorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeAutocorrelation };
diff --git a/src/timeseries/base2.ts b/src/timeseries/base2.ts
new file mode 100644
index 000000000..98217bd00
--- /dev/null
+++ b/src/timeseries/base2.ts
@@ -0,0 +1,15 @@
+/** Timeseries Base2 module — tsb analytics library. */
+export interface Timeseries base2Options { tol?: number; maxIter?: number; }
+export interface Timeseries base2Result { values: number[]; converged: boolean; }
+export function computeTimeseries base2(data: number[], opts: Timeseries base2Options = {}): Timeseries base2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries base2 };
diff --git a/src/timeseries/batch.ts b/src/timeseries/batch.ts
new file mode 100644
index 000000000..b1bcb48a9
--- /dev/null
+++ b/src/timeseries/batch.ts
@@ -0,0 +1,15 @@
+/** Timeseries Batch module — tsb analytics library. */
+export interface Timeseries batchOptions { tol?: number; maxIter?: number; }
+export interface Timeseries batchResult { values: number[]; converged: boolean; }
+export function computeTimeseries batch(data: number[], opts: Timeseries batchOptions = {}): Timeseries batchResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries batch };
diff --git a/src/timeseries/beta.ts b/src/timeseries/beta.ts
new file mode 100644
index 000000000..04ff99e38
--- /dev/null
+++ b/src/timeseries/beta.ts
@@ -0,0 +1,15 @@
+/** Timeseries Beta module — tsb analytics library. */
+export interface Timeseries betaOptions { tol?: number; maxIter?: number; }
+export interface Timeseries betaResult { values: number[]; converged: boolean; }
+export function computeTimeseries beta(data: number[], opts: Timeseries betaOptions = {}): Timeseries betaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries beta };
diff --git a/src/timeseries/change_point.ts b/src/timeseries/change_point.ts
new file mode 100644
index 000000000..14b9698a3
--- /dev/null
+++ b/src/timeseries/change_point.ts
@@ -0,0 +1,22 @@
+/** Change Point module — tsb analytics library. */
+
+/** Options for Change Point. */
+export interface ChangePointOptions { tol?: number; maxIter?: number; }
+
+/** Result from Change Point. */
+export interface ChangePointResult { values: number[]; converged: boolean; }
+
+/** Compute Change Point. */
+export function computeChangePoint(data: number[], opts: ChangePointOptions = {}): ChangePointResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeChangePoint };
diff --git a/src/timeseries/cointegration.ts b/src/timeseries/cointegration.ts
new file mode 100644
index 000000000..1b657386e
--- /dev/null
+++ b/src/timeseries/cointegration.ts
@@ -0,0 +1,22 @@
+/** Cointegration module — tsb analytics library. */
+
+/** Options for Cointegration. */
+export interface CointegrationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Cointegration. */
+export interface CointegrationResult { values: number[]; converged: boolean; }
+
+/** Compute Cointegration. */
+export function computeCointegration(data: number[], opts: CointegrationOptions = {}): CointegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeCointegration };
diff --git a/src/timeseries/cpu.ts b/src/timeseries/cpu.ts
new file mode 100644
index 000000000..df7cf176e
--- /dev/null
+++ b/src/timeseries/cpu.ts
@@ -0,0 +1,15 @@
+/** Timeseries Cpu module — tsb analytics library. */
+export interface Timeseries cpuOptions { tol?: number; maxIter?: number; }
+export interface Timeseries cpuResult { values: number[]; converged: boolean; }
+export function computeTimeseries cpu(data: number[], opts: Timeseries cpuOptions = {}): Timeseries cpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries cpu };
diff --git a/src/timeseries/decomposition.ts b/src/timeseries/decomposition.ts
new file mode 100644
index 000000000..320eef69a
--- /dev/null
+++ b/src/timeseries/decomposition.ts
@@ -0,0 +1,22 @@
+/** Decomposition module — tsb analytics library. */
+
+/** Options for Decomposition. */
+export interface DecompositionOptions { tol?: number; maxIter?: number; }
+
+/** Result from Decomposition. */
+export interface DecompositionResult { values: number[]; converged: boolean; }
+
+/** Compute Decomposition. */
+export function computeDecomposition(data: number[], opts: DecompositionOptions = {}): DecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDecomposition };
diff --git a/src/timeseries/dense.ts b/src/timeseries/dense.ts
new file mode 100644
index 000000000..6d162dad6
--- /dev/null
+++ b/src/timeseries/dense.ts
@@ -0,0 +1,15 @@
+/** Timeseries Dense module — tsb analytics library. */
+export interface Timeseries denseOptions { tol?: number; maxIter?: number; }
+export interface Timeseries denseResult { values: number[]; converged: boolean; }
+export function computeTimeseries dense(data: number[], opts: Timeseries denseOptions = {}): Timeseries denseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries dense };
diff --git a/src/timeseries/detrending.ts b/src/timeseries/detrending.ts
new file mode 100644
index 000000000..68e3fbc73
--- /dev/null
+++ b/src/timeseries/detrending.ts
@@ -0,0 +1,22 @@
+/** Detrending module — tsb analytics library. */
+
+/** Options for Detrending. */
+export interface DetrendingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Detrending. */
+export interface DetrendingResult { values: number[]; converged: boolean; }
+
+/** Compute Detrending. */
+export function computeDetrending(data: number[], opts: DetrendingOptions = {}): DetrendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeDetrending };
diff --git a/src/timeseries/distributed.ts b/src/timeseries/distributed.ts
new file mode 100644
index 000000000..7b7b6dbac
--- /dev/null
+++ b/src/timeseries/distributed.ts
@@ -0,0 +1,15 @@
+/** Timeseries Distributed module — tsb analytics library. */
+export interface Timeseries distributedOptions { tol?: number; maxIter?: number; }
+export interface Timeseries distributedResult { values: number[]; converged: boolean; }
+export function computeTimeseries distributed(data: number[], opts: Timeseries distributedOptions = {}): Timeseries distributedResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries distributed };
diff --git a/src/timeseries/experimental.ts b/src/timeseries/experimental.ts
new file mode 100644
index 000000000..ec59d3bf9
--- /dev/null
+++ b/src/timeseries/experimental.ts
@@ -0,0 +1,15 @@
+/** Timeseries Experimental module — tsb analytics library. */
+export interface Timeseries experimentalOptions { tol?: number; maxIter?: number; }
+export interface Timeseries experimentalResult { values: number[]; converged: boolean; }
+export function computeTimeseries experimental(data: number[], opts: Timeseries experimentalOptions = {}): Timeseries experimentalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries experimental };
diff --git a/src/timeseries/exponential_smoothing.ts b/src/timeseries/exponential_smoothing.ts
new file mode 100644
index 000000000..119063b37
--- /dev/null
+++ b/src/timeseries/exponential_smoothing.ts
@@ -0,0 +1,22 @@
+/** Exponential Smoothing module — tsb analytics library. */
+
+/** Options for Exponential Smoothing. */
+export interface ExponentialSmoothingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Exponential Smoothing. */
+export interface ExponentialSmoothingResult { values: number[]; converged: boolean; }
+
+/** Compute Exponential Smoothing. */
+export function computeExponentialSmoothing(data: number[], opts: ExponentialSmoothingOptions = {}): ExponentialSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeExponentialSmoothing };
diff --git a/src/timeseries/fast.ts b/src/timeseries/fast.ts
new file mode 100644
index 000000000..a4496fa83
--- /dev/null
+++ b/src/timeseries/fast.ts
@@ -0,0 +1,15 @@
+/** Timeseries Fast module — tsb analytics library. */
+export interface Timeseries fastOptions { tol?: number; maxIter?: number; }
+export interface Timeseries fastResult { values: number[]; converged: boolean; }
+export function computeTimeseries fast(data: number[], opts: Timeseries fastOptions = {}): Timeseries fastResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries fast };
diff --git a/src/timeseries/forecasting.ts b/src/timeseries/forecasting.ts
new file mode 100644
index 000000000..70ac0dc5d
--- /dev/null
+++ b/src/timeseries/forecasting.ts
@@ -0,0 +1,22 @@
+/** Forecasting module — tsb analytics library. */
+
+/** Options for Forecasting. */
+export interface ForecastingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Forecasting. */
+export interface ForecastingResult { values: number[]; converged: boolean; }
+
+/** Compute Forecasting. */
+export function computeForecasting(data: number[], opts: ForecastingOptions = {}): ForecastingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeForecasting };
diff --git a/src/timeseries/functional.ts b/src/timeseries/functional.ts
new file mode 100644
index 000000000..d5ed05e47
--- /dev/null
+++ b/src/timeseries/functional.ts
@@ -0,0 +1,22 @@
+/** Functional module — tsb analytics library. */
+
+/** Options for Functional. */
+export interface FunctionalOptions { tol?: number; maxIter?: number; }
+
+/** Result from Functional. */
+export interface FunctionalResult { values: number[]; converged: boolean; }
+
+/** Compute Functional. */
+export function computeFunctional(data: number[], opts: FunctionalOptions = {}): FunctionalResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeFunctional };
diff --git a/src/timeseries/future.ts b/src/timeseries/future.ts
new file mode 100644
index 000000000..b15f45574
--- /dev/null
+++ b/src/timeseries/future.ts
@@ -0,0 +1,15 @@
+/** Timeseries Future module — tsb analytics library. */
+export interface Timeseries futureOptions { tol?: number; maxIter?: number; }
+export interface Timeseries futureResult { values: number[]; converged: boolean; }
+export function computeTimeseries future(data: number[], opts: Timeseries futureOptions = {}): Timeseries futureResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries future };
diff --git a/src/timeseries/gpu.ts b/src/timeseries/gpu.ts
new file mode 100644
index 000000000..4c9377ce3
--- /dev/null
+++ b/src/timeseries/gpu.ts
@@ -0,0 +1,15 @@
+/** Timeseries Gpu module — tsb analytics library. */
+export interface Timeseries gpuOptions { tol?: number; maxIter?: number; }
+export interface Timeseries gpuResult { values: number[]; converged: boolean; }
+export function computeTimeseries gpu(data: number[], opts: Timeseries gpuOptions = {}): Timeseries gpuResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries gpu };
diff --git a/src/timeseries/granger.ts b/src/timeseries/granger.ts
new file mode 100644
index 000000000..981773f8b
--- /dev/null
+++ b/src/timeseries/granger.ts
@@ -0,0 +1,22 @@
+/** Granger module — tsb analytics library. */
+
+/** Options for Granger. */
+export interface GrangerOptions { tol?: number; maxIter?: number; }
+
+/** Result from Granger. */
+export interface GrangerResult { values: number[]; converged: boolean; }
+
+/** Compute Granger. */
+export function computeGranger(data: number[], opts: GrangerOptions = {}): GrangerResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeGranger };
diff --git a/src/timeseries/impulse.ts b/src/timeseries/impulse.ts
new file mode 100644
index 000000000..6fc39494b
--- /dev/null
+++ b/src/timeseries/impulse.ts
@@ -0,0 +1,22 @@
+/** Impulse module — tsb analytics library. */
+
+/** Options for Impulse. */
+export interface ImpulseOptions { tol?: number; maxIter?: number; }
+
+/** Result from Impulse. */
+export interface ImpulseResult { values: number[]; converged: boolean; }
+
+/** Compute Impulse. */
+export function computeImpulse(data: number[], opts: ImpulseOptions = {}): ImpulseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeImpulse };
diff --git a/src/timeseries/interpolation.ts b/src/timeseries/interpolation.ts
new file mode 100644
index 000000000..ef7af6c1d
--- /dev/null
+++ b/src/timeseries/interpolation.ts
@@ -0,0 +1,22 @@
+/** Interpolation module — tsb analytics library. */
+
+/** Options for Interpolation. */
+export interface InterpolationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Interpolation. */
+export interface InterpolationResult { values: number[]; converged: boolean; }
+
+/** Compute Interpolation. */
+export function computeInterpolation(data: number[], opts: InterpolationOptions = {}): InterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeInterpolation };
diff --git a/src/timeseries/kalman.ts b/src/timeseries/kalman.ts
new file mode 100644
index 000000000..54e983c66
--- /dev/null
+++ b/src/timeseries/kalman.ts
@@ -0,0 +1,22 @@
+/** Kalman module — tsb analytics library. */
+
+/** Options for Kalman. */
+export interface KalmanOptions { tol?: number; maxIter?: number; }
+
+/** Result from Kalman. */
+export interface KalmanResult { values: number[]; converged: boolean; }
+
+/** Compute Kalman. */
+export function computeKalman(data: number[], opts: KalmanOptions = {}): KalmanResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeKalman };
diff --git a/src/timeseries/large.ts b/src/timeseries/large.ts
new file mode 100644
index 000000000..6f11e6833
--- /dev/null
+++ b/src/timeseries/large.ts
@@ -0,0 +1,15 @@
+/** Timeseries Large module — tsb analytics library. */
+export interface Timeseries largeOptions { tol?: number; maxIter?: number; }
+export interface Timeseries largeResult { values: number[]; converged: boolean; }
+export function computeTimeseries large(data: number[], opts: Timeseries largeOptions = {}): Timeseries largeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries large };
diff --git a/src/timeseries/legacy.ts b/src/timeseries/legacy.ts
new file mode 100644
index 000000000..9059bb6e3
--- /dev/null
+++ b/src/timeseries/legacy.ts
@@ -0,0 +1,15 @@
+/** Timeseries Legacy module — tsb analytics library. */
+export interface Timeseries legacyOptions { tol?: number; maxIter?: number; }
+export interface Timeseries legacyResult { values: number[]; converged: boolean; }
+export function computeTimeseries legacy(data: number[], opts: Timeseries legacyOptions = {}): Timeseries legacyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries legacy };
diff --git a/src/timeseries/lite.ts b/src/timeseries/lite.ts
new file mode 100644
index 000000000..44e66d6ee
--- /dev/null
+++ b/src/timeseries/lite.ts
@@ -0,0 +1,15 @@
+/** Timeseries Lite module — tsb analytics library. */
+export interface Timeseries liteOptions { tol?: number; maxIter?: number; }
+export interface Timeseries liteResult { values: number[]; converged: boolean; }
+export function computeTimeseries lite(data: number[], opts: Timeseries liteOptions = {}): Timeseries liteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries lite };
diff --git a/src/timeseries/mini.ts b/src/timeseries/mini.ts
new file mode 100644
index 000000000..e30cc666f
--- /dev/null
+++ b/src/timeseries/mini.ts
@@ -0,0 +1,15 @@
+/** Timeseries Mini module — tsb analytics library. */
+export interface Timeseries miniOptions { tol?: number; maxIter?: number; }
+export interface Timeseries miniResult { values: number[]; converged: boolean; }
+export function computeTimeseries mini(data: number[], opts: Timeseries miniOptions = {}): Timeseries miniResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries mini };
diff --git a/src/timeseries/next.ts b/src/timeseries/next.ts
new file mode 100644
index 000000000..6ac3c1c51
--- /dev/null
+++ b/src/timeseries/next.ts
@@ -0,0 +1,15 @@
+/** Timeseries Next module — tsb analytics library. */
+export interface Timeseries nextOptions { tol?: number; maxIter?: number; }
+export interface Timeseries nextResult { values: number[]; converged: boolean; }
+export function computeTimeseries next(data: number[], opts: Timeseries nextOptions = {}): Timeseries nextResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries next };
diff --git a/src/timeseries/nonlinear.ts b/src/timeseries/nonlinear.ts
new file mode 100644
index 000000000..b8d1b6c7f
--- /dev/null
+++ b/src/timeseries/nonlinear.ts
@@ -0,0 +1,22 @@
+/** Nonlinear module — tsb analytics library. */
+
+/** Options for Nonlinear. */
+export interface NonlinearOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nonlinear. */
+export interface NonlinearResult { values: number[]; converged: boolean; }
+
+/** Compute Nonlinear. */
+export function computeNonlinear(data: number[], opts: NonlinearOptions = {}): NonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNonlinear };
diff --git a/src/timeseries/nowcasting.ts b/src/timeseries/nowcasting.ts
new file mode 100644
index 000000000..b09d513e5
--- /dev/null
+++ b/src/timeseries/nowcasting.ts
@@ -0,0 +1,22 @@
+/** Nowcasting module — tsb analytics library. */
+
+/** Options for Nowcasting. */
+export interface NowcastingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Nowcasting. */
+export interface NowcastingResult { values: number[]; converged: boolean; }
+
+/** Compute Nowcasting. */
+export function computeNowcasting(data: number[], opts: NowcastingOptions = {}): NowcastingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeNowcasting };
diff --git a/src/timeseries/online.ts b/src/timeseries/online.ts
new file mode 100644
index 000000000..7fcb87c66
--- /dev/null
+++ b/src/timeseries/online.ts
@@ -0,0 +1,15 @@
+/** Timeseries Online module — tsb analytics library. */
+export interface Timeseries onlineOptions { tol?: number; maxIter?: number; }
+export interface Timeseries onlineResult { values: number[]; converged: boolean; }
+export function computeTimeseries online(data: number[], opts: Timeseries onlineOptions = {}): Timeseries onlineResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries online };
diff --git a/src/timeseries/parallel.ts b/src/timeseries/parallel.ts
new file mode 100644
index 000000000..9e904dcb0
--- /dev/null
+++ b/src/timeseries/parallel.ts
@@ -0,0 +1,15 @@
+/** Timeseries Parallel module — tsb analytics library. */
+export interface Timeseries parallelOptions { tol?: number; maxIter?: number; }
+export interface Timeseries parallelResult { values: number[]; converged: boolean; }
+export function computeTimeseries parallel(data: number[], opts: Timeseries parallelOptions = {}): Timeseries parallelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries parallel };
diff --git a/src/timeseries/partial_autocorrelation.ts b/src/timeseries/partial_autocorrelation.ts
new file mode 100644
index 000000000..46d5ec83b
--- /dev/null
+++ b/src/timeseries/partial_autocorrelation.ts
@@ -0,0 +1,22 @@
+/** Partial Autocorrelation module — tsb analytics library. */
+
+/** Options for Partial Autocorrelation. */
+export interface PartialAutocorrelationOptions { tol?: number; maxIter?: number; }
+
+/** Result from Partial Autocorrelation. */
+export interface PartialAutocorrelationResult { values: number[]; converged: boolean; }
+
+/** Compute Partial Autocorrelation. */
+export function computePartialAutocorrelation(data: number[], opts: PartialAutocorrelationOptions = {}): PartialAutocorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePartialAutocorrelation };
diff --git a/src/timeseries/particle_filter.ts b/src/timeseries/particle_filter.ts
new file mode 100644
index 000000000..91640e3a0
--- /dev/null
+++ b/src/timeseries/particle_filter.ts
@@ -0,0 +1,22 @@
+/** Particle Filter module — tsb analytics library. */
+
+/** Options for Particle Filter. */
+export interface ParticleFilterOptions { tol?: number; maxIter?: number; }
+
+/** Result from Particle Filter. */
+export interface ParticleFilterResult { values: number[]; converged: boolean; }
+
+/** Compute Particle Filter. */
+export function computeParticleFilter(data: number[], opts: ParticleFilterOptions = {}): ParticleFilterResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeParticleFilter };
diff --git a/src/timeseries/periodicity.ts b/src/timeseries/periodicity.ts
new file mode 100644
index 000000000..143794abe
--- /dev/null
+++ b/src/timeseries/periodicity.ts
@@ -0,0 +1,22 @@
+/** Periodicity module — tsb analytics library. */
+
+/** Options for Periodicity. */
+export interface PeriodicityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Periodicity. */
+export interface PeriodicityResult { values: number[]; converged: boolean; }
+
+/** Compute Periodicity. */
+export function computePeriodicity(data: number[], opts: PeriodicityOptions = {}): PeriodicityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computePeriodicity };
diff --git a/src/timeseries/plus.ts b/src/timeseries/plus.ts
new file mode 100644
index 000000000..b3e2a2b1b
--- /dev/null
+++ b/src/timeseries/plus.ts
@@ -0,0 +1,15 @@
+/** Timeseries Plus module — tsb analytics library. */
+export interface Timeseries plusOptions { tol?: number; maxIter?: number; }
+export interface Timeseries plusResult { values: number[]; converged: boolean; }
+export function computeTimeseries plus(data: number[], opts: Timeseries plusOptions = {}): Timeseries plusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries plus };
diff --git a/src/timeseries/pro.ts b/src/timeseries/pro.ts
new file mode 100644
index 000000000..fcc5331d5
--- /dev/null
+++ b/src/timeseries/pro.ts
@@ -0,0 +1,15 @@
+/** Timeseries Pro module — tsb analytics library. */
+export interface Timeseries proOptions { tol?: number; maxIter?: number; }
+export interface Timeseries proResult { values: number[]; converged: boolean; }
+export function computeTimeseries pro(data: number[], opts: Timeseries proOptions = {}): Timeseries proResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries pro };
diff --git a/src/timeseries/prophet.ts b/src/timeseries/prophet.ts
new file mode 100644
index 000000000..fb72971b1
--- /dev/null
+++ b/src/timeseries/prophet.ts
@@ -0,0 +1,22 @@
+/** Prophet module — tsb analytics library. */
+
+/** Options for Prophet. */
+export interface ProphetOptions { tol?: number; maxIter?: number; }
+
+/** Result from Prophet. */
+export interface ProphetResult { values: number[]; converged: boolean; }
+
+/** Compute Prophet. */
+export function computeProphet(data: number[], opts: ProphetOptions = {}): ProphetResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeProphet };
diff --git a/src/timeseries/resampling.ts b/src/timeseries/resampling.ts
new file mode 100644
index 000000000..1705a1d5e
--- /dev/null
+++ b/src/timeseries/resampling.ts
@@ -0,0 +1,22 @@
+/** Resampling module — tsb analytics library. */
+
+/** Options for Resampling. */
+export interface ResamplingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Resampling. */
+export interface ResamplingResult { values: number[]; converged: boolean; }
+
+/** Compute Resampling. */
+export function computeResampling(data: number[], opts: ResamplingOptions = {}): ResamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeResampling };
diff --git a/src/timeseries/robust.ts b/src/timeseries/robust.ts
new file mode 100644
index 000000000..67eee1a24
--- /dev/null
+++ b/src/timeseries/robust.ts
@@ -0,0 +1,15 @@
+/** Timeseries Robust module — tsb analytics library. */
+export interface Timeseries robustOptions { tol?: number; maxIter?: number; }
+export interface Timeseries robustResult { values: number[]; converged: boolean; }
+export function computeTimeseries robust(data: number[], opts: Timeseries robustOptions = {}): Timeseries robustResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries robust };
diff --git a/src/timeseries/sarima.ts b/src/timeseries/sarima.ts
new file mode 100644
index 000000000..a30236f66
--- /dev/null
+++ b/src/timeseries/sarima.ts
@@ -0,0 +1,22 @@
+/** Sarima module — tsb analytics library. */
+
+/** Options for Sarima. */
+export interface SarimaOptions { tol?: number; maxIter?: number; }
+
+/** Result from Sarima. */
+export interface SarimaResult { values: number[]; converged: boolean; }
+
+/** Compute Sarima. */
+export function computeSarima(data: number[], opts: SarimaOptions = {}): SarimaResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSarima };
diff --git a/src/timeseries/small.ts b/src/timeseries/small.ts
new file mode 100644
index 000000000..3d4768bd7
--- /dev/null
+++ b/src/timeseries/small.ts
@@ -0,0 +1,15 @@
+/** Timeseries Small module — tsb analytics library. */
+export interface Timeseries smallOptions { tol?: number; maxIter?: number; }
+export interface Timeseries smallResult { values: number[]; converged: boolean; }
+export function computeTimeseries small(data: number[], opts: Timeseries smallOptions = {}): Timeseries smallResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries small };
diff --git a/src/timeseries/sparse.ts b/src/timeseries/sparse.ts
new file mode 100644
index 000000000..2a3d7801b
--- /dev/null
+++ b/src/timeseries/sparse.ts
@@ -0,0 +1,15 @@
+/** Timeseries Sparse module — tsb analytics library. */
+export interface Timeseries sparseOptions { tol?: number; maxIter?: number; }
+export interface Timeseries sparseResult { values: number[]; converged: boolean; }
+export function computeTimeseries sparse(data: number[], opts: Timeseries sparseOptions = {}): Timeseries sparseResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries sparse };
diff --git a/src/timeseries/spectral.ts b/src/timeseries/spectral.ts
new file mode 100644
index 000000000..ee14db275
--- /dev/null
+++ b/src/timeseries/spectral.ts
@@ -0,0 +1,22 @@
+/** Spectral module — tsb analytics library. */
+
+/** Options for Spectral. */
+export interface SpectralOptions { tol?: number; maxIter?: number; }
+
+/** Result from Spectral. */
+export interface SpectralResult { values: number[]; converged: boolean; }
+
+/** Compute Spectral. */
+export function computeSpectral(data: number[], opts: SpectralOptions = {}): SpectralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSpectral };
diff --git a/src/timeseries/stable.ts b/src/timeseries/stable.ts
new file mode 100644
index 000000000..9538a161c
--- /dev/null
+++ b/src/timeseries/stable.ts
@@ -0,0 +1,15 @@
+/** Timeseries Stable module — tsb analytics library. */
+export interface Timeseries stableOptions { tol?: number; maxIter?: number; }
+export interface Timeseries stableResult { values: number[]; converged: boolean; }
+export function computeTimeseries stable(data: number[], opts: Timeseries stableOptions = {}): Timeseries stableResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries stable };
diff --git a/src/timeseries/state_space.ts b/src/timeseries/state_space.ts
new file mode 100644
index 000000000..3a9d656b9
--- /dev/null
+++ b/src/timeseries/state_space.ts
@@ -0,0 +1,22 @@
+/** State Space module — tsb analytics library. */
+
+/** Options for State Space. */
+export interface StateSpaceOptions { tol?: number; maxIter?: number; }
+
+/** Result from State Space. */
+export interface StateSpaceResult { values: number[]; converged: boolean; }
+
+/** Compute State Space. */
+export function computeStateSpace(data: number[], opts: StateSpaceOptions = {}): StateSpaceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStateSpace };
diff --git a/src/timeseries/stationarity.ts b/src/timeseries/stationarity.ts
new file mode 100644
index 000000000..3ef76f790
--- /dev/null
+++ b/src/timeseries/stationarity.ts
@@ -0,0 +1,22 @@
+/** Stationarity module — tsb analytics library. */
+
+/** Options for Stationarity. */
+export interface StationarityOptions { tol?: number; maxIter?: number; }
+
+/** Result from Stationarity. */
+export interface StationarityResult { values: number[]; converged: boolean; }
+
+/** Compute Stationarity. */
+export function computeStationarity(data: number[], opts: StationarityOptions = {}): StationarityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeStationarity };
diff --git a/src/timeseries/streaming.ts b/src/timeseries/streaming.ts
new file mode 100644
index 000000000..678633099
--- /dev/null
+++ b/src/timeseries/streaming.ts
@@ -0,0 +1,15 @@
+/** Timeseries Streaming module — tsb analytics library. */
+export interface Timeseries streamingOptions { tol?: number; maxIter?: number; }
+export interface Timeseries streamingResult { values: number[]; converged: boolean; }
+export function computeTimeseries streaming(data: number[], opts: Timeseries streamingOptions = {}): Timeseries streamingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries streaming };
diff --git a/src/timeseries/switching.ts b/src/timeseries/switching.ts
new file mode 100644
index 000000000..a8e140532
--- /dev/null
+++ b/src/timeseries/switching.ts
@@ -0,0 +1,22 @@
+/** Switching module — tsb analytics library. */
+
+/** Options for Switching. */
+export interface SwitchingOptions { tol?: number; maxIter?: number; }
+
+/** Result from Switching. */
+export interface SwitchingResult { values: number[]; converged: boolean; }
+
+/** Compute Switching. */
+export function computeSwitching(data: number[], opts: SwitchingOptions = {}): SwitchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeSwitching };
diff --git a/src/timeseries/threshold.ts b/src/timeseries/threshold.ts
new file mode 100644
index 000000000..f64283ad0
--- /dev/null
+++ b/src/timeseries/threshold.ts
@@ -0,0 +1,22 @@
+/** Threshold module — tsb analytics library. */
+
+/** Options for Threshold. */
+export interface ThresholdOptions { tol?: number; maxIter?: number; }
+
+/** Result from Threshold. */
+export interface ThresholdResult { values: number[]; converged: boolean; }
+
+/** Compute Threshold. */
+export function computeThreshold(data: number[], opts: ThresholdOptions = {}): ThresholdResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeThreshold };
diff --git a/src/timeseries/v2.ts b/src/timeseries/v2.ts
new file mode 100644
index 000000000..7d56638e5
--- /dev/null
+++ b/src/timeseries/v2.ts
@@ -0,0 +1,15 @@
+/** Timeseries V2 module — tsb analytics library. */
+export interface Timeseries v2Options { tol?: number; maxIter?: number; }
+export interface Timeseries v2Result { values: number[]; converged: boolean; }
+export function computeTimeseries v2(data: number[], opts: Timeseries v2Options = {}): Timeseries v2Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries v2 };
diff --git a/src/timeseries/v3.ts b/src/timeseries/v3.ts
new file mode 100644
index 000000000..34718c65e
--- /dev/null
+++ b/src/timeseries/v3.ts
@@ -0,0 +1,15 @@
+/** Timeseries V3 module — tsb analytics library. */
+export interface Timeseries v3Options { tol?: number; maxIter?: number; }
+export interface Timeseries v3Result { values: number[]; converged: boolean; }
+export function computeTimeseries v3(data: number[], opts: Timeseries v3Options = {}): Timeseries v3Result {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries v3 };
diff --git a/src/timeseries/variance_decomp.ts b/src/timeseries/variance_decomp.ts
new file mode 100644
index 000000000..9a1949629
--- /dev/null
+++ b/src/timeseries/variance_decomp.ts
@@ -0,0 +1,22 @@
+/** Variance Decomp module — tsb analytics library. */
+
+/** Options for Variance Decomp. */
+export interface VarianceDecompOptions { tol?: number; maxIter?: number; }
+
+/** Result from Variance Decomp. */
+export interface VarianceDecompResult { values: number[]; converged: boolean; }
+
+/** Compute Variance Decomp. */
+export function computeVarianceDecomp(data: number[], opts: VarianceDecompOptions = {}): VarianceDecompResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeVarianceDecomp };
diff --git a/src/timeseries/wasm.ts b/src/timeseries/wasm.ts
new file mode 100644
index 000000000..11ae64dcb
--- /dev/null
+++ b/src/timeseries/wasm.ts
@@ -0,0 +1,15 @@
+/** Timeseries Wasm module — tsb analytics library. */
+export interface Timeseries wasmOptions { tol?: number; maxIter?: number; }
+export interface Timeseries wasmResult { values: number[]; converged: boolean; }
+export function computeTimeseries wasm(data: number[], opts: Timeseries wasmOptions = {}): Timeseries wasmResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries wasm };
diff --git a/src/timeseries/wavelets.ts b/src/timeseries/wavelets.ts
new file mode 100644
index 000000000..fb25151b5
--- /dev/null
+++ b/src/timeseries/wavelets.ts
@@ -0,0 +1,22 @@
+/** Wavelets module — tsb analytics library. */
+
+/** Options for Wavelets. */
+export interface WaveletsOptions { tol?: number; maxIter?: number; }
+
+/** Result from Wavelets. */
+export interface WaveletsResult { values: number[]; converged: boolean; }
+
+/** Compute Wavelets. */
+export function computeWavelets(data: number[], opts: WaveletsOptions = {}): WaveletsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+
+export default { compute: computeWavelets };
diff --git a/src/timeseries/xlarge.ts b/src/timeseries/xlarge.ts
new file mode 100644
index 000000000..c4c541d86
--- /dev/null
+++ b/src/timeseries/xlarge.ts
@@ -0,0 +1,15 @@
+/** Timeseries Xlarge module — tsb analytics library. */
+export interface Timeseries xlargeOptions { tol?: number; maxIter?: number; }
+export interface Timeseries xlargeResult { values: number[]; converged: boolean; }
+export function computeTimeseries xlarge(data: number[], opts: Timeseries xlargeOptions = {}): Timeseries xlargeResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ if (!data.length) return { values: [], converged: true };
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTimeseries xlarge };
diff --git a/src/toxicology_sci/adaptation.ts b/src/toxicology_sci/adaptation.ts
new file mode 100644
index 000000000..fbad81f02
--- /dev/null
+++ b/src/toxicology_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci adaptation module — tsb analytics library. */
+export interface ToxicologySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciAdaptation(data: number[], opts: ToxicologySciAdaptationOptions = {}): ToxicologySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciAdaptation };
diff --git a/src/toxicology_sci/aggregation.ts b/src/toxicology_sci/aggregation.ts
new file mode 100644
index 000000000..4749790bc
--- /dev/null
+++ b/src/toxicology_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci aggregation module — tsb analytics library. */
+export interface ToxicologySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciAggregationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciAggregation(data: number[], opts: ToxicologySciAggregationOptions = {}): ToxicologySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciAggregation };
diff --git a/src/toxicology_sci/algebra.ts b/src/toxicology_sci/algebra.ts
new file mode 100644
index 000000000..fb4b3d72f
--- /dev/null
+++ b/src/toxicology_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci algebra module — tsb analytics library. */
+export interface ToxicologySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeToxicologySciAlgebra(data: number[], opts: ToxicologySciAlgebraOptions = {}): ToxicologySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciAlgebra };
diff --git a/src/toxicology_sci/alignment.ts b/src/toxicology_sci/alignment.ts
new file mode 100644
index 000000000..be2888d8b
--- /dev/null
+++ b/src/toxicology_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci alignment module — tsb analytics library. */
+export interface ToxicologySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeToxicologySciAlignment(data: number[], opts: ToxicologySciAlignmentOptions = {}): ToxicologySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciAlignment };
diff --git a/src/toxicology_sci/analysis.ts b/src/toxicology_sci/analysis.ts
new file mode 100644
index 000000000..d6bc015bc
--- /dev/null
+++ b/src/toxicology_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci analysis module — tsb analytics library. */
+export interface ToxicologySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeToxicologySciAnalysis(data: number[], opts: ToxicologySciAnalysisOptions = {}): ToxicologySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciAnalysis };
diff --git a/src/toxicology_sci/augmentation.ts b/src/toxicology_sci/augmentation.ts
new file mode 100644
index 000000000..f41d3cf9a
--- /dev/null
+++ b/src/toxicology_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci augmentation module — tsb analytics library. */
+export interface ToxicologySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciAugmentation(data: number[], opts: ToxicologySciAugmentationOptions = {}): ToxicologySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciAugmentation };
diff --git a/src/toxicology_sci/bagging.ts b/src/toxicology_sci/bagging.ts
new file mode 100644
index 000000000..adccb81ff
--- /dev/null
+++ b/src/toxicology_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci bagging module — tsb analytics library. */
+export interface ToxicologySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciBaggingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciBagging(data: number[], opts: ToxicologySciBaggingOptions = {}): ToxicologySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciBagging };
diff --git a/src/toxicology_sci/basis.ts b/src/toxicology_sci/basis.ts
new file mode 100644
index 000000000..551724156
--- /dev/null
+++ b/src/toxicology_sci/basis.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci basis module — tsb analytics library. */
+export interface ToxicologySciBasisOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciBasisResult { values: number[]; converged: boolean; }
+export function computeToxicologySciBasis(data: number[], opts: ToxicologySciBasisOptions = {}): ToxicologySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciBasis };
diff --git a/src/toxicology_sci/benchmarking.ts b/src/toxicology_sci/benchmarking.ts
new file mode 100644
index 000000000..35afaa7c0
--- /dev/null
+++ b/src/toxicology_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci benchmarking module — tsb analytics library. */
+export interface ToxicologySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciBenchmarking(data: number[], opts: ToxicologySciBenchmarkingOptions = {}): ToxicologySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciBenchmarking };
diff --git a/src/toxicology_sci/blending.ts b/src/toxicology_sci/blending.ts
new file mode 100644
index 000000000..2835b5f85
--- /dev/null
+++ b/src/toxicology_sci/blending.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci blending module — tsb analytics library. */
+export interface ToxicologySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciBlendingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciBlending(data: number[], opts: ToxicologySciBlendingOptions = {}): ToxicologySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciBlending };
diff --git a/src/toxicology_sci/boosting.ts b/src/toxicology_sci/boosting.ts
new file mode 100644
index 000000000..6201969e7
--- /dev/null
+++ b/src/toxicology_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci boosting module — tsb analytics library. */
+export interface ToxicologySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciBoostingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciBoosting(data: number[], opts: ToxicologySciBoostingOptions = {}): ToxicologySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciBoosting };
diff --git a/src/toxicology_sci/bootstrap.ts b/src/toxicology_sci/bootstrap.ts
new file mode 100644
index 000000000..b33354682
--- /dev/null
+++ b/src/toxicology_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci bootstrap module — tsb analytics library. */
+export interface ToxicologySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeToxicologySciBootstrap(data: number[], opts: ToxicologySciBootstrapOptions = {}): ToxicologySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciBootstrap };
diff --git a/src/toxicology_sci/calculus.ts b/src/toxicology_sci/calculus.ts
new file mode 100644
index 000000000..f0bf2b8a9
--- /dev/null
+++ b/src/toxicology_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci calculus module — tsb analytics library. */
+export interface ToxicologySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciCalculusResult { values: number[]; converged: boolean; }
+export function computeToxicologySciCalculus(data: number[], opts: ToxicologySciCalculusOptions = {}): ToxicologySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciCalculus };
diff --git a/src/toxicology_sci/calibration.ts b/src/toxicology_sci/calibration.ts
new file mode 100644
index 000000000..8e94dda95
--- /dev/null
+++ b/src/toxicology_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci calibration module — tsb analytics library. */
+export interface ToxicologySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciCalibration(data: number[], opts: ToxicologySciCalibrationOptions = {}): ToxicologySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciCalibration };
diff --git a/src/toxicology_sci/characterization.ts b/src/toxicology_sci/characterization.ts
new file mode 100644
index 000000000..f6bc21c68
--- /dev/null
+++ b/src/toxicology_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci characterization module — tsb analytics library. */
+export interface ToxicologySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciCharacterization(data: number[], opts: ToxicologySciCharacterizationOptions = {}): ToxicologySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciCharacterization };
diff --git a/src/toxicology_sci/classification.ts b/src/toxicology_sci/classification.ts
new file mode 100644
index 000000000..d7fb05db2
--- /dev/null
+++ b/src/toxicology_sci/classification.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci classification module — tsb analytics library. */
+export interface ToxicologySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciClassificationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciClassification(data: number[], opts: ToxicologySciClassificationOptions = {}): ToxicologySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciClassification };
diff --git a/src/toxicology_sci/clustering.ts b/src/toxicology_sci/clustering.ts
new file mode 100644
index 000000000..8b5f984a4
--- /dev/null
+++ b/src/toxicology_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci clustering module — tsb analytics library. */
+export interface ToxicologySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciClusteringResult { values: number[]; converged: boolean; }
+export function computeToxicologySciClustering(data: number[], opts: ToxicologySciClusteringOptions = {}): ToxicologySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciClustering };
diff --git a/src/toxicology_sci/compression.ts b/src/toxicology_sci/compression.ts
new file mode 100644
index 000000000..4246374de
--- /dev/null
+++ b/src/toxicology_sci/compression.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci compression module — tsb analytics library. */
+export interface ToxicologySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciCompressionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciCompression(data: number[], opts: ToxicologySciCompressionOptions = {}): ToxicologySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciCompression };
diff --git a/src/toxicology_sci/continuous.ts b/src/toxicology_sci/continuous.ts
new file mode 100644
index 000000000..4c18cc01d
--- /dev/null
+++ b/src/toxicology_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci continuous module — tsb analytics library. */
+export interface ToxicologySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciContinuousResult { values: number[]; converged: boolean; }
+export function computeToxicologySciContinuous(data: number[], opts: ToxicologySciContinuousOptions = {}): ToxicologySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciContinuous };
diff --git a/src/toxicology_sci/control.ts b/src/toxicology_sci/control.ts
new file mode 100644
index 000000000..837ad4044
--- /dev/null
+++ b/src/toxicology_sci/control.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci control module — tsb analytics library. */
+export interface ToxicologySciControlOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciControlResult { values: number[]; converged: boolean; }
+export function computeToxicologySciControl(data: number[], opts: ToxicologySciControlOptions = {}): ToxicologySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciControl };
diff --git a/src/toxicology_sci/convergence.ts b/src/toxicology_sci/convergence.ts
new file mode 100644
index 000000000..119647279
--- /dev/null
+++ b/src/toxicology_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci convergence module — tsb analytics library. */
+export interface ToxicologySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeToxicologySciConvergence(data: number[], opts: ToxicologySciConvergenceOptions = {}): ToxicologySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciConvergence };
diff --git a/src/toxicology_sci/convex.ts b/src/toxicology_sci/convex.ts
new file mode 100644
index 000000000..c2856ae67
--- /dev/null
+++ b/src/toxicology_sci/convex.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci convex module — tsb analytics library. */
+export interface ToxicologySciConvexOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciConvexResult { values: number[]; converged: boolean; }
+export function computeToxicologySciConvex(data: number[], opts: ToxicologySciConvexOptions = {}): ToxicologySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciConvex };
diff --git a/src/toxicology_sci/correlation.ts b/src/toxicology_sci/correlation.ts
new file mode 100644
index 000000000..b0d0c472b
--- /dev/null
+++ b/src/toxicology_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci correlation module — tsb analytics library. */
+export interface ToxicologySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciCorrelation(data: number[], opts: ToxicologySciCorrelationOptions = {}): ToxicologySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciCorrelation };
diff --git a/src/toxicology_sci/covariance.ts b/src/toxicology_sci/covariance.ts
new file mode 100644
index 000000000..2b9c61345
--- /dev/null
+++ b/src/toxicology_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci covariance module — tsb analytics library. */
+export interface ToxicologySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeToxicologySciCovariance(data: number[], opts: ToxicologySciCovarianceOptions = {}): ToxicologySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciCovariance };
diff --git a/src/toxicology_sci/cross_validation.ts b/src/toxicology_sci/cross_validation.ts
new file mode 100644
index 000000000..04acfbfc7
--- /dev/null
+++ b/src/toxicology_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci cross_validation module — tsb analytics library. */
+export interface ToxicologySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciCrossValidation(data: number[], opts: ToxicologySciCrossValidationOptions = {}): ToxicologySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciCrossValidation };
diff --git a/src/toxicology_sci/decoding.ts b/src/toxicology_sci/decoding.ts
new file mode 100644
index 000000000..68c0d25ca
--- /dev/null
+++ b/src/toxicology_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci decoding module — tsb analytics library. */
+export interface ToxicologySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDecodingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDecoding(data: number[], opts: ToxicologySciDecodingOptions = {}): ToxicologySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDecoding };
diff --git a/src/toxicology_sci/decomposition.ts b/src/toxicology_sci/decomposition.ts
new file mode 100644
index 000000000..7a8c3ff88
--- /dev/null
+++ b/src/toxicology_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci decomposition module — tsb analytics library. */
+export interface ToxicologySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDecomposition(data: number[], opts: ToxicologySciDecompositionOptions = {}): ToxicologySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDecomposition };
diff --git a/src/toxicology_sci/detection.ts b/src/toxicology_sci/detection.ts
new file mode 100644
index 000000000..f668f2f0d
--- /dev/null
+++ b/src/toxicology_sci/detection.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci detection module — tsb analytics library. */
+export interface ToxicologySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDetectionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDetection(data: number[], opts: ToxicologySciDetectionOptions = {}): ToxicologySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDetection };
diff --git a/src/toxicology_sci/deterministic.ts b/src/toxicology_sci/deterministic.ts
new file mode 100644
index 000000000..bcd6cc4aa
--- /dev/null
+++ b/src/toxicology_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci deterministic module — tsb analytics library. */
+export interface ToxicologySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDeterministic(data: number[], opts: ToxicologySciDeterministicOptions = {}): ToxicologySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDeterministic };
diff --git a/src/toxicology_sci/diagnostics.ts b/src/toxicology_sci/diagnostics.ts
new file mode 100644
index 000000000..84ce08295
--- /dev/null
+++ b/src/toxicology_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci diagnostics module — tsb analytics library. */
+export interface ToxicologySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDiagnostics(data: number[], opts: ToxicologySciDiagnosticsOptions = {}): ToxicologySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDiagnostics };
diff --git a/src/toxicology_sci/differential.ts b/src/toxicology_sci/differential.ts
new file mode 100644
index 000000000..6b511a214
--- /dev/null
+++ b/src/toxicology_sci/differential.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci differential module — tsb analytics library. */
+export interface ToxicologySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDifferential(data: number[], opts: ToxicologySciDifferentialOptions = {}): ToxicologySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDifferential };
diff --git a/src/toxicology_sci/discrete.ts b/src/toxicology_sci/discrete.ts
new file mode 100644
index 000000000..46b27b1a6
--- /dev/null
+++ b/src/toxicology_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci discrete module — tsb analytics library. */
+export interface ToxicologySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDiscrete(data: number[], opts: ToxicologySciDiscreteOptions = {}): ToxicologySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDiscrete };
diff --git a/src/toxicology_sci/distribution.ts b/src/toxicology_sci/distribution.ts
new file mode 100644
index 000000000..47e6ecc9e
--- /dev/null
+++ b/src/toxicology_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci distribution module — tsb analytics library. */
+export interface ToxicologySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDistributionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDistribution(data: number[], opts: ToxicologySciDistributionOptions = {}): ToxicologySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDistribution };
diff --git a/src/toxicology_sci/dynamic.ts b/src/toxicology_sci/dynamic.ts
new file mode 100644
index 000000000..7b09c124c
--- /dev/null
+++ b/src/toxicology_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci dynamic module — tsb analytics library. */
+export interface ToxicologySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciDynamicResult { values: number[]; converged: boolean; }
+export function computeToxicologySciDynamic(data: number[], opts: ToxicologySciDynamicOptions = {}): ToxicologySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciDynamic };
diff --git a/src/toxicology_sci/embedding.ts b/src/toxicology_sci/embedding.ts
new file mode 100644
index 000000000..dff3fd703
--- /dev/null
+++ b/src/toxicology_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci embedding module — tsb analytics library. */
+export interface ToxicologySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciEmbedding(data: number[], opts: ToxicologySciEmbeddingOptions = {}): ToxicologySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciEmbedding };
diff --git a/src/toxicology_sci/encoding.ts b/src/toxicology_sci/encoding.ts
new file mode 100644
index 000000000..5d2aebc21
--- /dev/null
+++ b/src/toxicology_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci encoding module — tsb analytics library. */
+export interface ToxicologySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciEncodingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciEncoding(data: number[], opts: ToxicologySciEncodingOptions = {}): ToxicologySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciEncoding };
diff --git a/src/toxicology_sci/ensemble.ts b/src/toxicology_sci/ensemble.ts
new file mode 100644
index 000000000..81d99e5a8
--- /dev/null
+++ b/src/toxicology_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci ensemble module — tsb analytics library. */
+export interface ToxicologySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeToxicologySciEnsemble(data: number[], opts: ToxicologySciEnsembleOptions = {}): ToxicologySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciEnsemble };
diff --git a/src/toxicology_sci/estimation.ts b/src/toxicology_sci/estimation.ts
new file mode 100644
index 000000000..46f4fe219
--- /dev/null
+++ b/src/toxicology_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci estimation module — tsb analytics library. */
+export interface ToxicologySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciEstimationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciEstimation(data: number[], opts: ToxicologySciEstimationOptions = {}): ToxicologySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciEstimation };
diff --git a/src/toxicology_sci/evaluation.ts b/src/toxicology_sci/evaluation.ts
new file mode 100644
index 000000000..7ede88935
--- /dev/null
+++ b/src/toxicology_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci evaluation module — tsb analytics library. */
+export interface ToxicologySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciEvaluation(data: number[], opts: ToxicologySciEvaluationOptions = {}): ToxicologySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciEvaluation };
diff --git a/src/toxicology_sci/extrapolation.ts b/src/toxicology_sci/extrapolation.ts
new file mode 100644
index 000000000..fa9f1dfdd
--- /dev/null
+++ b/src/toxicology_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci extrapolation module — tsb analytics library. */
+export interface ToxicologySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciExtrapolation(data: number[], opts: ToxicologySciExtrapolationOptions = {}): ToxicologySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciExtrapolation };
diff --git a/src/toxicology_sci/features.ts b/src/toxicology_sci/features.ts
new file mode 100644
index 000000000..36bfb8592
--- /dev/null
+++ b/src/toxicology_sci/features.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci features module — tsb analytics library. */
+export interface ToxicologySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeToxicologySciFeatures(data: number[], opts: ToxicologySciFeaturesOptions = {}): ToxicologySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciFeatures };
diff --git a/src/toxicology_sci/feedback.ts b/src/toxicology_sci/feedback.ts
new file mode 100644
index 000000000..0a1530b1d
--- /dev/null
+++ b/src/toxicology_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci feedback module — tsb analytics library. */
+export interface ToxicologySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeToxicologySciFeedback(data: number[], opts: ToxicologySciFeedbackOptions = {}): ToxicologySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciFeedback };
diff --git a/src/toxicology_sci/filtering.ts b/src/toxicology_sci/filtering.ts
new file mode 100644
index 000000000..b8e44991f
--- /dev/null
+++ b/src/toxicology_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci filtering module — tsb analytics library. */
+export interface ToxicologySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciFilteringResult { values: number[]; converged: boolean; }
+export function computeToxicologySciFiltering(data: number[], opts: ToxicologySciFilteringOptions = {}): ToxicologySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciFiltering };
diff --git a/src/toxicology_sci/fourier.ts b/src/toxicology_sci/fourier.ts
new file mode 100644
index 000000000..0841bd156
--- /dev/null
+++ b/src/toxicology_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci fourier module — tsb analytics library. */
+export interface ToxicologySciFourierOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciFourierResult { values: number[]; converged: boolean; }
+export function computeToxicologySciFourier(data: number[], opts: ToxicologySciFourierOptions = {}): ToxicologySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciFourier };
diff --git a/src/toxicology_sci/fusion.ts b/src/toxicology_sci/fusion.ts
new file mode 100644
index 000000000..b4fa7451f
--- /dev/null
+++ b/src/toxicology_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci fusion module — tsb analytics library. */
+export interface ToxicologySciFusionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciFusionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciFusion(data: number[], opts: ToxicologySciFusionOptions = {}): ToxicologySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciFusion };
diff --git a/src/toxicology_sci/generation.ts b/src/toxicology_sci/generation.ts
new file mode 100644
index 000000000..1e1601f7f
--- /dev/null
+++ b/src/toxicology_sci/generation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci generation module — tsb analytics library. */
+export interface ToxicologySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciGenerationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciGeneration(data: number[], opts: ToxicologySciGenerationOptions = {}): ToxicologySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciGeneration };
diff --git a/src/toxicology_sci/geometry.ts b/src/toxicology_sci/geometry.ts
new file mode 100644
index 000000000..23105be7c
--- /dev/null
+++ b/src/toxicology_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci geometry module — tsb analytics library. */
+export interface ToxicologySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciGeometryResult { values: number[]; converged: boolean; }
+export function computeToxicologySciGeometry(data: number[], opts: ToxicologySciGeometryOptions = {}): ToxicologySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciGeometry };
diff --git a/src/toxicology_sci/gradient.ts b/src/toxicology_sci/gradient.ts
new file mode 100644
index 000000000..31e5dbb3a
--- /dev/null
+++ b/src/toxicology_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci gradient module — tsb analytics library. */
+export interface ToxicologySciGradientOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciGradientResult { values: number[]; converged: boolean; }
+export function computeToxicologySciGradient(data: number[], opts: ToxicologySciGradientOptions = {}): ToxicologySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciGradient };
diff --git a/src/toxicology_sci/hessian.ts b/src/toxicology_sci/hessian.ts
new file mode 100644
index 000000000..05a8fa039
--- /dev/null
+++ b/src/toxicology_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci hessian module — tsb analytics library. */
+export interface ToxicologySciHessianOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciHessianResult { values: number[]; converged: boolean; }
+export function computeToxicologySciHessian(data: number[], opts: ToxicologySciHessianOptions = {}): ToxicologySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciHessian };
diff --git a/src/toxicology_sci/hypothesis.ts b/src/toxicology_sci/hypothesis.ts
new file mode 100644
index 000000000..84c901d7e
--- /dev/null
+++ b/src/toxicology_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci hypothesis module — tsb analytics library. */
+export interface ToxicologySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeToxicologySciHypothesis(data: number[], opts: ToxicologySciHypothesisOptions = {}): ToxicologySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciHypothesis };
diff --git a/src/toxicology_sci/inference.ts b/src/toxicology_sci/inference.ts
new file mode 100644
index 000000000..21b66ccbe
--- /dev/null
+++ b/src/toxicology_sci/inference.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci inference module — tsb analytics library. */
+export interface ToxicologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeToxicologySciInference(data: number[], opts: ToxicologySciInferenceOptions = {}): ToxicologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciInference };
diff --git a/src/toxicology_sci/inference2.ts b/src/toxicology_sci/inference2.ts
new file mode 100644
index 000000000..cedc4e0d3
--- /dev/null
+++ b/src/toxicology_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci inference2 module — tsb analytics library. */
+export interface ToxicologySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciInferenceResult { values: number[]; converged: boolean; }
+export function computeToxicologySciInference(data: number[], opts: ToxicologySciInferenceOptions = {}): ToxicologySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciInference };
diff --git a/src/toxicology_sci/integral.ts b/src/toxicology_sci/integral.ts
new file mode 100644
index 000000000..753ac78a2
--- /dev/null
+++ b/src/toxicology_sci/integral.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci integral module — tsb analytics library. */
+export interface ToxicologySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciIntegralResult { values: number[]; converged: boolean; }
+export function computeToxicologySciIntegral(data: number[], opts: ToxicologySciIntegralOptions = {}): ToxicologySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciIntegral };
diff --git a/src/toxicology_sci/integration.ts b/src/toxicology_sci/integration.ts
new file mode 100644
index 000000000..bbce6b097
--- /dev/null
+++ b/src/toxicology_sci/integration.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci integration module — tsb analytics library. */
+export interface ToxicologySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciIntegration(data: number[], opts: ToxicologySciIntegrationOptions = {}): ToxicologySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciIntegration };
diff --git a/src/toxicology_sci/interpolation.ts b/src/toxicology_sci/interpolation.ts
new file mode 100644
index 000000000..c4a9dcea0
--- /dev/null
+++ b/src/toxicology_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci interpolation module — tsb analytics library. */
+export interface ToxicologySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciInterpolation(data: number[], opts: ToxicologySciInterpolationOptions = {}): ToxicologySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciInterpolation };
diff --git a/src/toxicology_sci/jacobian.ts b/src/toxicology_sci/jacobian.ts
new file mode 100644
index 000000000..958373302
--- /dev/null
+++ b/src/toxicology_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci jacobian module — tsb analytics library. */
+export interface ToxicologySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciJacobianResult { values: number[]; converged: boolean; }
+export function computeToxicologySciJacobian(data: number[], opts: ToxicologySciJacobianOptions = {}): ToxicologySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciJacobian };
diff --git a/src/toxicology_sci/kernel.ts b/src/toxicology_sci/kernel.ts
new file mode 100644
index 000000000..c48279eb7
--- /dev/null
+++ b/src/toxicology_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci kernel module — tsb analytics library. */
+export interface ToxicologySciKernelOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciKernelResult { values: number[]; converged: boolean; }
+export function computeToxicologySciKernel(data: number[], opts: ToxicologySciKernelOptions = {}): ToxicologySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciKernel };
diff --git a/src/toxicology_sci/laplacian.ts b/src/toxicology_sci/laplacian.ts
new file mode 100644
index 000000000..5384bd4e6
--- /dev/null
+++ b/src/toxicology_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci laplacian module — tsb analytics library. */
+export interface ToxicologySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeToxicologySciLaplacian(data: number[], opts: ToxicologySciLaplacianOptions = {}): ToxicologySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciLaplacian };
diff --git a/src/toxicology_sci/learning.ts b/src/toxicology_sci/learning.ts
new file mode 100644
index 000000000..f597dfdad
--- /dev/null
+++ b/src/toxicology_sci/learning.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci learning module — tsb analytics library. */
+export interface ToxicologySciLearningOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciLearningResult { values: number[]; converged: boolean; }
+export function computeToxicologySciLearning(data: number[], opts: ToxicologySciLearningOptions = {}): ToxicologySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciLearning };
diff --git a/src/toxicology_sci/linear.ts b/src/toxicology_sci/linear.ts
new file mode 100644
index 000000000..e5f83228b
--- /dev/null
+++ b/src/toxicology_sci/linear.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci linear module — tsb analytics library. */
+export interface ToxicologySciLinearOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciLinearResult { values: number[]; converged: boolean; }
+export function computeToxicologySciLinear(data: number[], opts: ToxicologySciLinearOptions = {}): ToxicologySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciLinear };
diff --git a/src/toxicology_sci/manifold.ts b/src/toxicology_sci/manifold.ts
new file mode 100644
index 000000000..d2f67774f
--- /dev/null
+++ b/src/toxicology_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci manifold module — tsb analytics library. */
+export interface ToxicologySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciManifoldResult { values: number[]; converged: boolean; }
+export function computeToxicologySciManifold(data: number[], opts: ToxicologySciManifoldOptions = {}): ToxicologySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciManifold };
diff --git a/src/toxicology_sci/matching.ts b/src/toxicology_sci/matching.ts
new file mode 100644
index 000000000..a9942f5b7
--- /dev/null
+++ b/src/toxicology_sci/matching.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci matching module — tsb analytics library. */
+export interface ToxicologySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciMatchingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciMatching(data: number[], opts: ToxicologySciMatchingOptions = {}): ToxicologySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciMatching };
diff --git a/src/toxicology_sci/measurement.ts b/src/toxicology_sci/measurement.ts
new file mode 100644
index 000000000..e63f8dceb
--- /dev/null
+++ b/src/toxicology_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci measurement module — tsb analytics library. */
+export interface ToxicologySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeToxicologySciMeasurement(data: number[], opts: ToxicologySciMeasurementOptions = {}): ToxicologySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciMeasurement };
diff --git a/src/toxicology_sci/metrics.ts b/src/toxicology_sci/metrics.ts
new file mode 100644
index 000000000..709b46251
--- /dev/null
+++ b/src/toxicology_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci metrics module — tsb analytics library. */
+export interface ToxicologySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciMetricsResult { values: number[]; converged: boolean; }
+export function computeToxicologySciMetrics(data: number[], opts: ToxicologySciMetricsOptions = {}): ToxicologySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciMetrics };
diff --git a/src/toxicology_sci/modeling.ts b/src/toxicology_sci/modeling.ts
new file mode 100644
index 000000000..246b337a1
--- /dev/null
+++ b/src/toxicology_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci modeling module — tsb analytics library. */
+export interface ToxicologySciModelingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciModelingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciModeling(data: number[], opts: ToxicologySciModelingOptions = {}): ToxicologySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciModeling };
diff --git a/src/toxicology_sci/monitoring.ts b/src/toxicology_sci/monitoring.ts
new file mode 100644
index 000000000..cc2cd5dd8
--- /dev/null
+++ b/src/toxicology_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci monitoring module — tsb analytics library. */
+export interface ToxicologySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeToxicologySciMonitoring(data: number[], opts: ToxicologySciMonitoringOptions = {}): ToxicologySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciMonitoring };
diff --git a/src/toxicology_sci/nonlinear.ts b/src/toxicology_sci/nonlinear.ts
new file mode 100644
index 000000000..61a000a5b
--- /dev/null
+++ b/src/toxicology_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci nonlinear module — tsb analytics library. */
+export interface ToxicologySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeToxicologySciNonlinear(data: number[], opts: ToxicologySciNonlinearOptions = {}): ToxicologySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciNonlinear };
diff --git a/src/toxicology_sci/normalization.ts b/src/toxicology_sci/normalization.ts
new file mode 100644
index 000000000..9746b1328
--- /dev/null
+++ b/src/toxicology_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci normalization module — tsb analytics library. */
+export interface ToxicologySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciNormalization(data: number[], opts: ToxicologySciNormalizationOptions = {}): ToxicologySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciNormalization };
diff --git a/src/toxicology_sci/optimization.ts b/src/toxicology_sci/optimization.ts
new file mode 100644
index 000000000..dec655071
--- /dev/null
+++ b/src/toxicology_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci optimization module — tsb analytics library. */
+export interface ToxicologySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciOptimization(data: number[], opts: ToxicologySciOptimizationOptions = {}): ToxicologySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciOptimization };
diff --git a/src/toxicology_sci/patterns.ts b/src/toxicology_sci/patterns.ts
new file mode 100644
index 000000000..f4c31ccb3
--- /dev/null
+++ b/src/toxicology_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci patterns module — tsb analytics library. */
+export interface ToxicologySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciPatternsResult { values: number[]; converged: boolean; }
+export function computeToxicologySciPatterns(data: number[], opts: ToxicologySciPatternsOptions = {}): ToxicologySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciPatterns };
diff --git a/src/toxicology_sci/permutation.ts b/src/toxicology_sci/permutation.ts
new file mode 100644
index 000000000..6ef096cd0
--- /dev/null
+++ b/src/toxicology_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci permutation module — tsb analytics library. */
+export interface ToxicologySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciPermutationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciPermutation(data: number[], opts: ToxicologySciPermutationOptions = {}): ToxicologySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciPermutation };
diff --git a/src/toxicology_sci/prediction.ts b/src/toxicology_sci/prediction.ts
new file mode 100644
index 000000000..4e76e5326
--- /dev/null
+++ b/src/toxicology_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci prediction module — tsb analytics library. */
+export interface ToxicologySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciPredictionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciPrediction(data: number[], opts: ToxicologySciPredictionOptions = {}): ToxicologySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciPrediction };
diff --git a/src/toxicology_sci/processing.ts b/src/toxicology_sci/processing.ts
new file mode 100644
index 000000000..9cfdbbf2f
--- /dev/null
+++ b/src/toxicology_sci/processing.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci processing module — tsb analytics library. */
+export interface ToxicologySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciProcessingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciProcessing(data: number[], opts: ToxicologySciProcessingOptions = {}): ToxicologySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciProcessing };
diff --git a/src/toxicology_sci/profiling.ts b/src/toxicology_sci/profiling.ts
new file mode 100644
index 000000000..80b8888c5
--- /dev/null
+++ b/src/toxicology_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci profiling module — tsb analytics library. */
+export interface ToxicologySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciProfilingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciProfiling(data: number[], opts: ToxicologySciProfilingOptions = {}): ToxicologySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciProfiling };
diff --git a/src/toxicology_sci/projection.ts b/src/toxicology_sci/projection.ts
new file mode 100644
index 000000000..9e4c54eb6
--- /dev/null
+++ b/src/toxicology_sci/projection.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci projection module — tsb analytics library. */
+export interface ToxicologySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciProjectionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciProjection(data: number[], opts: ToxicologySciProjectionOptions = {}): ToxicologySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciProjection };
diff --git a/src/toxicology_sci/ranking.ts b/src/toxicology_sci/ranking.ts
new file mode 100644
index 000000000..d2ead5e4d
--- /dev/null
+++ b/src/toxicology_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci ranking module — tsb analytics library. */
+export interface ToxicologySciRankingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciRankingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciRanking(data: number[], opts: ToxicologySciRankingOptions = {}): ToxicologySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciRanking };
diff --git a/src/toxicology_sci/reconstruction.ts b/src/toxicology_sci/reconstruction.ts
new file mode 100644
index 000000000..f9cb9236a
--- /dev/null
+++ b/src/toxicology_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci reconstruction module — tsb analytics library. */
+export interface ToxicologySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciReconstruction(data: number[], opts: ToxicologySciReconstructionOptions = {}): ToxicologySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciReconstruction };
diff --git a/src/toxicology_sci/registration.ts b/src/toxicology_sci/registration.ts
new file mode 100644
index 000000000..e27691934
--- /dev/null
+++ b/src/toxicology_sci/registration.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci registration module — tsb analytics library. */
+export interface ToxicologySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciRegistration(data: number[], opts: ToxicologySciRegistrationOptions = {}): ToxicologySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciRegistration };
diff --git a/src/toxicology_sci/regression.ts b/src/toxicology_sci/regression.ts
new file mode 100644
index 000000000..316cba12f
--- /dev/null
+++ b/src/toxicology_sci/regression.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci regression module — tsb analytics library. */
+export interface ToxicologySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciRegressionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciRegression(data: number[], opts: ToxicologySciRegressionOptions = {}): ToxicologySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciRegression };
diff --git a/src/toxicology_sci/regularization.ts b/src/toxicology_sci/regularization.ts
new file mode 100644
index 000000000..4329f6375
--- /dev/null
+++ b/src/toxicology_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci regularization module — tsb analytics library. */
+export interface ToxicologySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciRegularization(data: number[], opts: ToxicologySciRegularizationOptions = {}): ToxicologySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciRegularization };
diff --git a/src/toxicology_sci/robustness.ts b/src/toxicology_sci/robustness.ts
new file mode 100644
index 000000000..95249c389
--- /dev/null
+++ b/src/toxicology_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci robustness module — tsb analytics library. */
+export interface ToxicologySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeToxicologySciRobustness(data: number[], opts: ToxicologySciRobustnessOptions = {}): ToxicologySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciRobustness };
diff --git a/src/toxicology_sci/sampling.ts b/src/toxicology_sci/sampling.ts
new file mode 100644
index 000000000..b85843613
--- /dev/null
+++ b/src/toxicology_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci sampling module — tsb analytics library. */
+export interface ToxicologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciSampling(data: number[], opts: ToxicologySciSamplingOptions = {}): ToxicologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciSampling };
diff --git a/src/toxicology_sci/sampling2.ts b/src/toxicology_sci/sampling2.ts
new file mode 100644
index 000000000..b383781e7
--- /dev/null
+++ b/src/toxicology_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci sampling2 module — tsb analytics library. */
+export interface ToxicologySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciSamplingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciSampling(data: number[], opts: ToxicologySciSamplingOptions = {}): ToxicologySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciSampling };
diff --git a/src/toxicology_sci/scaling.ts b/src/toxicology_sci/scaling.ts
new file mode 100644
index 000000000..e367a37d1
--- /dev/null
+++ b/src/toxicology_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci scaling module — tsb analytics library. */
+export interface ToxicologySciScalingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciScalingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciScaling(data: number[], opts: ToxicologySciScalingOptions = {}): ToxicologySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciScaling };
diff --git a/src/toxicology_sci/scoring.ts b/src/toxicology_sci/scoring.ts
new file mode 100644
index 000000000..ba5546276
--- /dev/null
+++ b/src/toxicology_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci scoring module — tsb analytics library. */
+export interface ToxicologySciScoringOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciScoringResult { values: number[]; converged: boolean; }
+export function computeToxicologySciScoring(data: number[], opts: ToxicologySciScoringOptions = {}): ToxicologySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciScoring };
diff --git a/src/toxicology_sci/segmentation.ts b/src/toxicology_sci/segmentation.ts
new file mode 100644
index 000000000..471068796
--- /dev/null
+++ b/src/toxicology_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci segmentation module — tsb analytics library. */
+export interface ToxicologySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciSegmentation(data: number[], opts: ToxicologySciSegmentationOptions = {}): ToxicologySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciSegmentation };
diff --git a/src/toxicology_sci/selection.ts b/src/toxicology_sci/selection.ts
new file mode 100644
index 000000000..27ad60c92
--- /dev/null
+++ b/src/toxicology_sci/selection.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci selection module — tsb analytics library. */
+export interface ToxicologySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciSelectionResult { values: number[]; converged: boolean; }
+export function computeToxicologySciSelection(data: number[], opts: ToxicologySciSelectionOptions = {}): ToxicologySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciSelection };
diff --git a/src/toxicology_sci/sensitivity.ts b/src/toxicology_sci/sensitivity.ts
new file mode 100644
index 000000000..3c4b4d902
--- /dev/null
+++ b/src/toxicology_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci sensitivity module — tsb analytics library. */
+export interface ToxicologySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeToxicologySciSensitivity(data: number[], opts: ToxicologySciSensitivityOptions = {}): ToxicologySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciSensitivity };
diff --git a/src/toxicology_sci/simulation.ts b/src/toxicology_sci/simulation.ts
new file mode 100644
index 000000000..89a5c036b
--- /dev/null
+++ b/src/toxicology_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci simulation module — tsb analytics library. */
+export interface ToxicologySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciSimulationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciSimulation(data: number[], opts: ToxicologySciSimulationOptions = {}): ToxicologySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciSimulation };
diff --git a/src/toxicology_sci/smoothing.ts b/src/toxicology_sci/smoothing.ts
new file mode 100644
index 000000000..723fcf60a
--- /dev/null
+++ b/src/toxicology_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci smoothing module — tsb analytics library. */
+export interface ToxicologySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciSmoothing(data: number[], opts: ToxicologySciSmoothingOptions = {}): ToxicologySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciSmoothing };
diff --git a/src/toxicology_sci/stability.ts b/src/toxicology_sci/stability.ts
new file mode 100644
index 000000000..219b96057
--- /dev/null
+++ b/src/toxicology_sci/stability.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci stability module — tsb analytics library. */
+export interface ToxicologySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciStabilityResult { values: number[]; converged: boolean; }
+export function computeToxicologySciStability(data: number[], opts: ToxicologySciStabilityOptions = {}): ToxicologySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciStability };
diff --git a/src/toxicology_sci/stacking.ts b/src/toxicology_sci/stacking.ts
new file mode 100644
index 000000000..7afc2b215
--- /dev/null
+++ b/src/toxicology_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci stacking module — tsb analytics library. */
+export interface ToxicologySciStackingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciStackingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciStacking(data: number[], opts: ToxicologySciStackingOptions = {}): ToxicologySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciStacking };
diff --git a/src/toxicology_sci/standardization.ts b/src/toxicology_sci/standardization.ts
new file mode 100644
index 000000000..ce90cac3b
--- /dev/null
+++ b/src/toxicology_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci standardization module — tsb analytics library. */
+export interface ToxicologySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciStandardization(data: number[], opts: ToxicologySciStandardizationOptions = {}): ToxicologySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciStandardization };
diff --git a/src/toxicology_sci/static.ts b/src/toxicology_sci/static.ts
new file mode 100644
index 000000000..c99025f8a
--- /dev/null
+++ b/src/toxicology_sci/static.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci static module — tsb analytics library. */
+export interface ToxicologySciStaticOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciStaticResult { values: number[]; converged: boolean; }
+export function computeToxicologySciStatic(data: number[], opts: ToxicologySciStaticOptions = {}): ToxicologySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciStatic };
diff --git a/src/toxicology_sci/stochastic.ts b/src/toxicology_sci/stochastic.ts
new file mode 100644
index 000000000..07cb30e17
--- /dev/null
+++ b/src/toxicology_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci stochastic module — tsb analytics library. */
+export interface ToxicologySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciStochasticResult { values: number[]; converged: boolean; }
+export function computeToxicologySciStochastic(data: number[], opts: ToxicologySciStochasticOptions = {}): ToxicologySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciStochastic };
diff --git a/src/toxicology_sci/synthesis.ts b/src/toxicology_sci/synthesis.ts
new file mode 100644
index 000000000..124cee5b3
--- /dev/null
+++ b/src/toxicology_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci synthesis module — tsb analytics library. */
+export interface ToxicologySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeToxicologySciSynthesis(data: number[], opts: ToxicologySciSynthesisOptions = {}): ToxicologySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciSynthesis };
diff --git a/src/toxicology_sci/topology.ts b/src/toxicology_sci/topology.ts
new file mode 100644
index 000000000..825937659
--- /dev/null
+++ b/src/toxicology_sci/topology.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci topology module — tsb analytics library. */
+export interface ToxicologySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciTopologyResult { values: number[]; converged: boolean; }
+export function computeToxicologySciTopology(data: number[], opts: ToxicologySciTopologyOptions = {}): ToxicologySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciTopology };
diff --git a/src/toxicology_sci/tracking.ts b/src/toxicology_sci/tracking.ts
new file mode 100644
index 000000000..d7a26e314
--- /dev/null
+++ b/src/toxicology_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci tracking module — tsb analytics library. */
+export interface ToxicologySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciTrackingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciTracking(data: number[], opts: ToxicologySciTrackingOptions = {}): ToxicologySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciTracking };
diff --git a/src/toxicology_sci/transform.ts b/src/toxicology_sci/transform.ts
new file mode 100644
index 000000000..c78febfc9
--- /dev/null
+++ b/src/toxicology_sci/transform.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci transform module — tsb analytics library. */
+export interface ToxicologySciTransformOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciTransformResult { values: number[]; converged: boolean; }
+export function computeToxicologySciTransform(data: number[], opts: ToxicologySciTransformOptions = {}): ToxicologySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciTransform };
diff --git a/src/toxicology_sci/uncertainty.ts b/src/toxicology_sci/uncertainty.ts
new file mode 100644
index 000000000..3b5dd50b2
--- /dev/null
+++ b/src/toxicology_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci uncertainty module — tsb analytics library. */
+export interface ToxicologySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeToxicologySciUncertainty(data: number[], opts: ToxicologySciUncertaintyOptions = {}): ToxicologySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciUncertainty };
diff --git a/src/toxicology_sci/validation.ts b/src/toxicology_sci/validation.ts
new file mode 100644
index 000000000..15544e13e
--- /dev/null
+++ b/src/toxicology_sci/validation.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci validation module — tsb analytics library. */
+export interface ToxicologySciValidationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciValidationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciValidation(data: number[], opts: ToxicologySciValidationOptions = {}): ToxicologySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciValidation };
diff --git a/src/toxicology_sci/verification.ts b/src/toxicology_sci/verification.ts
new file mode 100644
index 000000000..64d1b524f
--- /dev/null
+++ b/src/toxicology_sci/verification.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci verification module — tsb analytics library. */
+export interface ToxicologySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciVerificationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciVerification(data: number[], opts: ToxicologySciVerificationOptions = {}): ToxicologySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciVerification };
diff --git a/src/toxicology_sci/visualization.ts b/src/toxicology_sci/visualization.ts
new file mode 100644
index 000000000..08f2be44f
--- /dev/null
+++ b/src/toxicology_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci visualization module — tsb analytics library. */
+export interface ToxicologySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeToxicologySciVisualization(data: number[], opts: ToxicologySciVisualizationOptions = {}): ToxicologySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciVisualization };
diff --git a/src/toxicology_sci/voting.ts b/src/toxicology_sci/voting.ts
new file mode 100644
index 000000000..ed74c3c15
--- /dev/null
+++ b/src/toxicology_sci/voting.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci voting module — tsb analytics library. */
+export interface ToxicologySciVotingOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciVotingResult { values: number[]; converged: boolean; }
+export function computeToxicologySciVoting(data: number[], opts: ToxicologySciVotingOptions = {}): ToxicologySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciVoting };
diff --git a/src/toxicology_sci/wavelet.ts b/src/toxicology_sci/wavelet.ts
new file mode 100644
index 000000000..a3a85806b
--- /dev/null
+++ b/src/toxicology_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** toxicology_sci wavelet module — tsb analytics library. */
+export interface ToxicologySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface ToxicologySciWaveletResult { values: number[]; converged: boolean; }
+export function computeToxicologySciWavelet(data: number[], opts: ToxicologySciWaveletOptions = {}): ToxicologySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeToxicologySciWavelet };
diff --git a/src/transcriptomics/adaptation.ts b/src/transcriptomics/adaptation.ts
new file mode 100644
index 000000000..1e08f5e03
--- /dev/null
+++ b/src/transcriptomics/adaptation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics adaptation module — tsb analytics library. */
+export interface TranscriptomicsAdaptationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsAdaptationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsAdaptation(data: number[], opts: TranscriptomicsAdaptationOptions = {}): TranscriptomicsAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsAdaptation };
diff --git a/src/transcriptomics/aggregation.ts b/src/transcriptomics/aggregation.ts
new file mode 100644
index 000000000..6697ea740
--- /dev/null
+++ b/src/transcriptomics/aggregation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics aggregation module — tsb analytics library. */
+export interface TranscriptomicsAggregationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsAggregationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsAggregation(data: number[], opts: TranscriptomicsAggregationOptions = {}): TranscriptomicsAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsAggregation };
diff --git a/src/transcriptomics/algebra.ts b/src/transcriptomics/algebra.ts
new file mode 100644
index 000000000..002b000a9
--- /dev/null
+++ b/src/transcriptomics/algebra.ts
@@ -0,0 +1,14 @@
+/** transcriptomics algebra module — tsb analytics library. */
+export interface TranscriptomicsAlgebraOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsAlgebraResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsAlgebra(data: number[], opts: TranscriptomicsAlgebraOptions = {}): TranscriptomicsAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsAlgebra };
diff --git a/src/transcriptomics/alignment.ts b/src/transcriptomics/alignment.ts
new file mode 100644
index 000000000..08618f640
--- /dev/null
+++ b/src/transcriptomics/alignment.ts
@@ -0,0 +1,14 @@
+/** transcriptomics alignment module — tsb analytics library. */
+export interface TranscriptomicsAlignmentOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsAlignmentResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsAlignment(data: number[], opts: TranscriptomicsAlignmentOptions = {}): TranscriptomicsAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsAlignment };
diff --git a/src/transcriptomics/analysis.ts b/src/transcriptomics/analysis.ts
new file mode 100644
index 000000000..0ba0d4601
--- /dev/null
+++ b/src/transcriptomics/analysis.ts
@@ -0,0 +1,14 @@
+/** transcriptomics analysis module — tsb analytics library. */
+export interface TranscriptomicsAnalysisOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsAnalysisResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsAnalysis(data: number[], opts: TranscriptomicsAnalysisOptions = {}): TranscriptomicsAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsAnalysis };
diff --git a/src/transcriptomics/augmentation.ts b/src/transcriptomics/augmentation.ts
new file mode 100644
index 000000000..f36fd4da2
--- /dev/null
+++ b/src/transcriptomics/augmentation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics augmentation module — tsb analytics library. */
+export interface TranscriptomicsAugmentationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsAugmentationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsAugmentation(data: number[], opts: TranscriptomicsAugmentationOptions = {}): TranscriptomicsAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsAugmentation };
diff --git a/src/transcriptomics/bagging.ts b/src/transcriptomics/bagging.ts
new file mode 100644
index 000000000..67715a6f8
--- /dev/null
+++ b/src/transcriptomics/bagging.ts
@@ -0,0 +1,14 @@
+/** transcriptomics bagging module — tsb analytics library. */
+export interface TranscriptomicsBaggingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsBaggingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsBagging(data: number[], opts: TranscriptomicsBaggingOptions = {}): TranscriptomicsBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsBagging };
diff --git a/src/transcriptomics/basis.ts b/src/transcriptomics/basis.ts
new file mode 100644
index 000000000..906588284
--- /dev/null
+++ b/src/transcriptomics/basis.ts
@@ -0,0 +1,14 @@
+/** transcriptomics basis module — tsb analytics library. */
+export interface TranscriptomicsBasisOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsBasisResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsBasis(data: number[], opts: TranscriptomicsBasisOptions = {}): TranscriptomicsBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsBasis };
diff --git a/src/transcriptomics/benchmarking.ts b/src/transcriptomics/benchmarking.ts
new file mode 100644
index 000000000..e26474864
--- /dev/null
+++ b/src/transcriptomics/benchmarking.ts
@@ -0,0 +1,14 @@
+/** transcriptomics benchmarking module — tsb analytics library. */
+export interface TranscriptomicsBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsBenchmarking(data: number[], opts: TranscriptomicsBenchmarkingOptions = {}): TranscriptomicsBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsBenchmarking };
diff --git a/src/transcriptomics/blending.ts b/src/transcriptomics/blending.ts
new file mode 100644
index 000000000..ed8448504
--- /dev/null
+++ b/src/transcriptomics/blending.ts
@@ -0,0 +1,14 @@
+/** transcriptomics blending module — tsb analytics library. */
+export interface TranscriptomicsBlendingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsBlendingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsBlending(data: number[], opts: TranscriptomicsBlendingOptions = {}): TranscriptomicsBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsBlending };
diff --git a/src/transcriptomics/boosting.ts b/src/transcriptomics/boosting.ts
new file mode 100644
index 000000000..b8f9b0bf6
--- /dev/null
+++ b/src/transcriptomics/boosting.ts
@@ -0,0 +1,14 @@
+/** transcriptomics boosting module — tsb analytics library. */
+export interface TranscriptomicsBoostingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsBoostingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsBoosting(data: number[], opts: TranscriptomicsBoostingOptions = {}): TranscriptomicsBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsBoosting };
diff --git a/src/transcriptomics/bootstrap.ts b/src/transcriptomics/bootstrap.ts
new file mode 100644
index 000000000..9a93c955b
--- /dev/null
+++ b/src/transcriptomics/bootstrap.ts
@@ -0,0 +1,14 @@
+/** transcriptomics bootstrap module — tsb analytics library. */
+export interface TranscriptomicsBootstrapOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsBootstrapResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsBootstrap(data: number[], opts: TranscriptomicsBootstrapOptions = {}): TranscriptomicsBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsBootstrap };
diff --git a/src/transcriptomics/calculus.ts b/src/transcriptomics/calculus.ts
new file mode 100644
index 000000000..1f853c530
--- /dev/null
+++ b/src/transcriptomics/calculus.ts
@@ -0,0 +1,14 @@
+/** transcriptomics calculus module — tsb analytics library. */
+export interface TranscriptomicsCalculusOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsCalculusResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsCalculus(data: number[], opts: TranscriptomicsCalculusOptions = {}): TranscriptomicsCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsCalculus };
diff --git a/src/transcriptomics/calibration.ts b/src/transcriptomics/calibration.ts
new file mode 100644
index 000000000..b5e003e71
--- /dev/null
+++ b/src/transcriptomics/calibration.ts
@@ -0,0 +1,14 @@
+/** transcriptomics calibration module — tsb analytics library. */
+export interface TranscriptomicsCalibrationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsCalibrationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsCalibration(data: number[], opts: TranscriptomicsCalibrationOptions = {}): TranscriptomicsCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsCalibration };
diff --git a/src/transcriptomics/characterization.ts b/src/transcriptomics/characterization.ts
new file mode 100644
index 000000000..1ba5ff31c
--- /dev/null
+++ b/src/transcriptomics/characterization.ts
@@ -0,0 +1,14 @@
+/** transcriptomics characterization module — tsb analytics library. */
+export interface TranscriptomicsCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsCharacterizationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsCharacterization(data: number[], opts: TranscriptomicsCharacterizationOptions = {}): TranscriptomicsCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsCharacterization };
diff --git a/src/transcriptomics/classification.ts b/src/transcriptomics/classification.ts
new file mode 100644
index 000000000..734651a35
--- /dev/null
+++ b/src/transcriptomics/classification.ts
@@ -0,0 +1,14 @@
+/** transcriptomics classification module — tsb analytics library. */
+export interface TranscriptomicsClassificationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsClassificationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsClassification(data: number[], opts: TranscriptomicsClassificationOptions = {}): TranscriptomicsClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsClassification };
diff --git a/src/transcriptomics/clustering.ts b/src/transcriptomics/clustering.ts
new file mode 100644
index 000000000..0b2f6e6c2
--- /dev/null
+++ b/src/transcriptomics/clustering.ts
@@ -0,0 +1,14 @@
+/** transcriptomics clustering module — tsb analytics library. */
+export interface TranscriptomicsClusteringOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsClusteringResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsClustering(data: number[], opts: TranscriptomicsClusteringOptions = {}): TranscriptomicsClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsClustering };
diff --git a/src/transcriptomics/compression.ts b/src/transcriptomics/compression.ts
new file mode 100644
index 000000000..6e7d10bfe
--- /dev/null
+++ b/src/transcriptomics/compression.ts
@@ -0,0 +1,14 @@
+/** transcriptomics compression module — tsb analytics library. */
+export interface TranscriptomicsCompressionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsCompressionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsCompression(data: number[], opts: TranscriptomicsCompressionOptions = {}): TranscriptomicsCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsCompression };
diff --git a/src/transcriptomics/continuous.ts b/src/transcriptomics/continuous.ts
new file mode 100644
index 000000000..b5a27d564
--- /dev/null
+++ b/src/transcriptomics/continuous.ts
@@ -0,0 +1,14 @@
+/** transcriptomics continuous module — tsb analytics library. */
+export interface TranscriptomicsContinuousOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsContinuousResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsContinuous(data: number[], opts: TranscriptomicsContinuousOptions = {}): TranscriptomicsContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsContinuous };
diff --git a/src/transcriptomics/control.ts b/src/transcriptomics/control.ts
new file mode 100644
index 000000000..b3dda4bb8
--- /dev/null
+++ b/src/transcriptomics/control.ts
@@ -0,0 +1,14 @@
+/** transcriptomics control module — tsb analytics library. */
+export interface TranscriptomicsControlOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsControlResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsControl(data: number[], opts: TranscriptomicsControlOptions = {}): TranscriptomicsControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsControl };
diff --git a/src/transcriptomics/convergence.ts b/src/transcriptomics/convergence.ts
new file mode 100644
index 000000000..1e8391893
--- /dev/null
+++ b/src/transcriptomics/convergence.ts
@@ -0,0 +1,14 @@
+/** transcriptomics convergence module — tsb analytics library. */
+export interface TranscriptomicsConvergenceOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsConvergenceResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsConvergence(data: number[], opts: TranscriptomicsConvergenceOptions = {}): TranscriptomicsConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsConvergence };
diff --git a/src/transcriptomics/convex.ts b/src/transcriptomics/convex.ts
new file mode 100644
index 000000000..ff0ecf221
--- /dev/null
+++ b/src/transcriptomics/convex.ts
@@ -0,0 +1,14 @@
+/** transcriptomics convex module — tsb analytics library. */
+export interface TranscriptomicsConvexOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsConvexResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsConvex(data: number[], opts: TranscriptomicsConvexOptions = {}): TranscriptomicsConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsConvex };
diff --git a/src/transcriptomics/correlation.ts b/src/transcriptomics/correlation.ts
new file mode 100644
index 000000000..eb5572c2d
--- /dev/null
+++ b/src/transcriptomics/correlation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics correlation module — tsb analytics library. */
+export interface TranscriptomicsCorrelationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsCorrelationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsCorrelation(data: number[], opts: TranscriptomicsCorrelationOptions = {}): TranscriptomicsCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsCorrelation };
diff --git a/src/transcriptomics/covariance.ts b/src/transcriptomics/covariance.ts
new file mode 100644
index 000000000..bade50443
--- /dev/null
+++ b/src/transcriptomics/covariance.ts
@@ -0,0 +1,14 @@
+/** transcriptomics covariance module — tsb analytics library. */
+export interface TranscriptomicsCovarianceOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsCovarianceResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsCovariance(data: number[], opts: TranscriptomicsCovarianceOptions = {}): TranscriptomicsCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsCovariance };
diff --git a/src/transcriptomics/cross_validation.ts b/src/transcriptomics/cross_validation.ts
new file mode 100644
index 000000000..fd26a8e49
--- /dev/null
+++ b/src/transcriptomics/cross_validation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics cross_validation module — tsb analytics library. */
+export interface TranscriptomicsCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsCrossValidationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsCrossValidation(data: number[], opts: TranscriptomicsCrossValidationOptions = {}): TranscriptomicsCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsCrossValidation };
diff --git a/src/transcriptomics/decoding.ts b/src/transcriptomics/decoding.ts
new file mode 100644
index 000000000..5ff9974e9
--- /dev/null
+++ b/src/transcriptomics/decoding.ts
@@ -0,0 +1,14 @@
+/** transcriptomics decoding module — tsb analytics library. */
+export interface TranscriptomicsDecodingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDecodingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDecoding(data: number[], opts: TranscriptomicsDecodingOptions = {}): TranscriptomicsDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDecoding };
diff --git a/src/transcriptomics/decomposition.ts b/src/transcriptomics/decomposition.ts
new file mode 100644
index 000000000..4d2c28290
--- /dev/null
+++ b/src/transcriptomics/decomposition.ts
@@ -0,0 +1,14 @@
+/** transcriptomics decomposition module — tsb analytics library. */
+export interface TranscriptomicsDecompositionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDecompositionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDecomposition(data: number[], opts: TranscriptomicsDecompositionOptions = {}): TranscriptomicsDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDecomposition };
diff --git a/src/transcriptomics/detection.ts b/src/transcriptomics/detection.ts
new file mode 100644
index 000000000..d01616245
--- /dev/null
+++ b/src/transcriptomics/detection.ts
@@ -0,0 +1,14 @@
+/** transcriptomics detection module — tsb analytics library. */
+export interface TranscriptomicsDetectionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDetectionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDetection(data: number[], opts: TranscriptomicsDetectionOptions = {}): TranscriptomicsDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDetection };
diff --git a/src/transcriptomics/deterministic.ts b/src/transcriptomics/deterministic.ts
new file mode 100644
index 000000000..7735c1921
--- /dev/null
+++ b/src/transcriptomics/deterministic.ts
@@ -0,0 +1,14 @@
+/** transcriptomics deterministic module — tsb analytics library. */
+export interface TranscriptomicsDeterministicOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDeterministicResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDeterministic(data: number[], opts: TranscriptomicsDeterministicOptions = {}): TranscriptomicsDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDeterministic };
diff --git a/src/transcriptomics/diagnostics.ts b/src/transcriptomics/diagnostics.ts
new file mode 100644
index 000000000..29d298eb0
--- /dev/null
+++ b/src/transcriptomics/diagnostics.ts
@@ -0,0 +1,14 @@
+/** transcriptomics diagnostics module — tsb analytics library. */
+export interface TranscriptomicsDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDiagnostics(data: number[], opts: TranscriptomicsDiagnosticsOptions = {}): TranscriptomicsDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDiagnostics };
diff --git a/src/transcriptomics/differential.ts b/src/transcriptomics/differential.ts
new file mode 100644
index 000000000..8f96ebdd4
--- /dev/null
+++ b/src/transcriptomics/differential.ts
@@ -0,0 +1,14 @@
+/** transcriptomics differential module — tsb analytics library. */
+export interface TranscriptomicsDifferentialOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDifferentialResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDifferential(data: number[], opts: TranscriptomicsDifferentialOptions = {}): TranscriptomicsDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDifferential };
diff --git a/src/transcriptomics/discrete.ts b/src/transcriptomics/discrete.ts
new file mode 100644
index 000000000..7748a78c1
--- /dev/null
+++ b/src/transcriptomics/discrete.ts
@@ -0,0 +1,14 @@
+/** transcriptomics discrete module — tsb analytics library. */
+export interface TranscriptomicsDiscreteOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDiscreteResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDiscrete(data: number[], opts: TranscriptomicsDiscreteOptions = {}): TranscriptomicsDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDiscrete };
diff --git a/src/transcriptomics/distribution.ts b/src/transcriptomics/distribution.ts
new file mode 100644
index 000000000..493b1b527
--- /dev/null
+++ b/src/transcriptomics/distribution.ts
@@ -0,0 +1,14 @@
+/** transcriptomics distribution module — tsb analytics library. */
+export interface TranscriptomicsDistributionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDistributionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDistribution(data: number[], opts: TranscriptomicsDistributionOptions = {}): TranscriptomicsDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDistribution };
diff --git a/src/transcriptomics/dynamic.ts b/src/transcriptomics/dynamic.ts
new file mode 100644
index 000000000..5a582accd
--- /dev/null
+++ b/src/transcriptomics/dynamic.ts
@@ -0,0 +1,14 @@
+/** transcriptomics dynamic module — tsb analytics library. */
+export interface TranscriptomicsDynamicOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsDynamicResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsDynamic(data: number[], opts: TranscriptomicsDynamicOptions = {}): TranscriptomicsDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsDynamic };
diff --git a/src/transcriptomics/embedding.ts b/src/transcriptomics/embedding.ts
new file mode 100644
index 000000000..8942b0feb
--- /dev/null
+++ b/src/transcriptomics/embedding.ts
@@ -0,0 +1,14 @@
+/** transcriptomics embedding module — tsb analytics library. */
+export interface TranscriptomicsEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsEmbeddingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsEmbedding(data: number[], opts: TranscriptomicsEmbeddingOptions = {}): TranscriptomicsEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsEmbedding };
diff --git a/src/transcriptomics/encoding.ts b/src/transcriptomics/encoding.ts
new file mode 100644
index 000000000..fca813859
--- /dev/null
+++ b/src/transcriptomics/encoding.ts
@@ -0,0 +1,14 @@
+/** transcriptomics encoding module — tsb analytics library. */
+export interface TranscriptomicsEncodingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsEncodingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsEncoding(data: number[], opts: TranscriptomicsEncodingOptions = {}): TranscriptomicsEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsEncoding };
diff --git a/src/transcriptomics/ensemble.ts b/src/transcriptomics/ensemble.ts
new file mode 100644
index 000000000..ee508d75c
--- /dev/null
+++ b/src/transcriptomics/ensemble.ts
@@ -0,0 +1,14 @@
+/** transcriptomics ensemble module — tsb analytics library. */
+export interface TranscriptomicsEnsembleOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsEnsembleResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsEnsemble(data: number[], opts: TranscriptomicsEnsembleOptions = {}): TranscriptomicsEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsEnsemble };
diff --git a/src/transcriptomics/estimation.ts b/src/transcriptomics/estimation.ts
new file mode 100644
index 000000000..02607576f
--- /dev/null
+++ b/src/transcriptomics/estimation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics estimation module — tsb analytics library. */
+export interface TranscriptomicsEstimationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsEstimationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsEstimation(data: number[], opts: TranscriptomicsEstimationOptions = {}): TranscriptomicsEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsEstimation };
diff --git a/src/transcriptomics/evaluation.ts b/src/transcriptomics/evaluation.ts
new file mode 100644
index 000000000..29edeeb24
--- /dev/null
+++ b/src/transcriptomics/evaluation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics evaluation module — tsb analytics library. */
+export interface TranscriptomicsEvaluationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsEvaluationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsEvaluation(data: number[], opts: TranscriptomicsEvaluationOptions = {}): TranscriptomicsEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsEvaluation };
diff --git a/src/transcriptomics/extrapolation.ts b/src/transcriptomics/extrapolation.ts
new file mode 100644
index 000000000..3b44cc0dd
--- /dev/null
+++ b/src/transcriptomics/extrapolation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics extrapolation module — tsb analytics library. */
+export interface TranscriptomicsExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsExtrapolationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsExtrapolation(data: number[], opts: TranscriptomicsExtrapolationOptions = {}): TranscriptomicsExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsExtrapolation };
diff --git a/src/transcriptomics/features.ts b/src/transcriptomics/features.ts
new file mode 100644
index 000000000..12ba418d8
--- /dev/null
+++ b/src/transcriptomics/features.ts
@@ -0,0 +1,14 @@
+/** transcriptomics features module — tsb analytics library. */
+export interface TranscriptomicsFeaturesOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsFeaturesResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsFeatures(data: number[], opts: TranscriptomicsFeaturesOptions = {}): TranscriptomicsFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsFeatures };
diff --git a/src/transcriptomics/feedback.ts b/src/transcriptomics/feedback.ts
new file mode 100644
index 000000000..79b838dd7
--- /dev/null
+++ b/src/transcriptomics/feedback.ts
@@ -0,0 +1,14 @@
+/** transcriptomics feedback module — tsb analytics library. */
+export interface TranscriptomicsFeedbackOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsFeedbackResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsFeedback(data: number[], opts: TranscriptomicsFeedbackOptions = {}): TranscriptomicsFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsFeedback };
diff --git a/src/transcriptomics/filtering.ts b/src/transcriptomics/filtering.ts
new file mode 100644
index 000000000..a4a0fab4f
--- /dev/null
+++ b/src/transcriptomics/filtering.ts
@@ -0,0 +1,14 @@
+/** transcriptomics filtering module — tsb analytics library. */
+export interface TranscriptomicsFilteringOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsFilteringResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsFiltering(data: number[], opts: TranscriptomicsFilteringOptions = {}): TranscriptomicsFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsFiltering };
diff --git a/src/transcriptomics/fourier.ts b/src/transcriptomics/fourier.ts
new file mode 100644
index 000000000..d027c500e
--- /dev/null
+++ b/src/transcriptomics/fourier.ts
@@ -0,0 +1,14 @@
+/** transcriptomics fourier module — tsb analytics library. */
+export interface TranscriptomicsFourierOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsFourierResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsFourier(data: number[], opts: TranscriptomicsFourierOptions = {}): TranscriptomicsFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsFourier };
diff --git a/src/transcriptomics/fusion.ts b/src/transcriptomics/fusion.ts
new file mode 100644
index 000000000..6711cbe77
--- /dev/null
+++ b/src/transcriptomics/fusion.ts
@@ -0,0 +1,14 @@
+/** transcriptomics fusion module — tsb analytics library. */
+export interface TranscriptomicsFusionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsFusionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsFusion(data: number[], opts: TranscriptomicsFusionOptions = {}): TranscriptomicsFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsFusion };
diff --git a/src/transcriptomics/generation.ts b/src/transcriptomics/generation.ts
new file mode 100644
index 000000000..760f69cea
--- /dev/null
+++ b/src/transcriptomics/generation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics generation module — tsb analytics library. */
+export interface TranscriptomicsGenerationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsGenerationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsGeneration(data: number[], opts: TranscriptomicsGenerationOptions = {}): TranscriptomicsGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsGeneration };
diff --git a/src/transcriptomics/geometry.ts b/src/transcriptomics/geometry.ts
new file mode 100644
index 000000000..2163602fb
--- /dev/null
+++ b/src/transcriptomics/geometry.ts
@@ -0,0 +1,14 @@
+/** transcriptomics geometry module — tsb analytics library. */
+export interface TranscriptomicsGeometryOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsGeometryResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsGeometry(data: number[], opts: TranscriptomicsGeometryOptions = {}): TranscriptomicsGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsGeometry };
diff --git a/src/transcriptomics/gradient.ts b/src/transcriptomics/gradient.ts
new file mode 100644
index 000000000..bba7edfec
--- /dev/null
+++ b/src/transcriptomics/gradient.ts
@@ -0,0 +1,14 @@
+/** transcriptomics gradient module — tsb analytics library. */
+export interface TranscriptomicsGradientOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsGradientResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsGradient(data: number[], opts: TranscriptomicsGradientOptions = {}): TranscriptomicsGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsGradient };
diff --git a/src/transcriptomics/hessian.ts b/src/transcriptomics/hessian.ts
new file mode 100644
index 000000000..ed31976d6
--- /dev/null
+++ b/src/transcriptomics/hessian.ts
@@ -0,0 +1,14 @@
+/** transcriptomics hessian module — tsb analytics library. */
+export interface TranscriptomicsHessianOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsHessianResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsHessian(data: number[], opts: TranscriptomicsHessianOptions = {}): TranscriptomicsHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsHessian };
diff --git a/src/transcriptomics/hypothesis.ts b/src/transcriptomics/hypothesis.ts
new file mode 100644
index 000000000..5295757f8
--- /dev/null
+++ b/src/transcriptomics/hypothesis.ts
@@ -0,0 +1,14 @@
+/** transcriptomics hypothesis module — tsb analytics library. */
+export interface TranscriptomicsHypothesisOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsHypothesisResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsHypothesis(data: number[], opts: TranscriptomicsHypothesisOptions = {}): TranscriptomicsHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsHypothesis };
diff --git a/src/transcriptomics/inference.ts b/src/transcriptomics/inference.ts
new file mode 100644
index 000000000..9c8f0f364
--- /dev/null
+++ b/src/transcriptomics/inference.ts
@@ -0,0 +1,14 @@
+/** transcriptomics inference module — tsb analytics library. */
+export interface TranscriptomicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsInferenceResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsInference(data: number[], opts: TranscriptomicsInferenceOptions = {}): TranscriptomicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsInference };
diff --git a/src/transcriptomics/inference2.ts b/src/transcriptomics/inference2.ts
new file mode 100644
index 000000000..6866591bb
--- /dev/null
+++ b/src/transcriptomics/inference2.ts
@@ -0,0 +1,14 @@
+/** transcriptomics inference2 module — tsb analytics library. */
+export interface TranscriptomicsInferenceOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsInferenceResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsInference(data: number[], opts: TranscriptomicsInferenceOptions = {}): TranscriptomicsInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsInference };
diff --git a/src/transcriptomics/integral.ts b/src/transcriptomics/integral.ts
new file mode 100644
index 000000000..59b2996fe
--- /dev/null
+++ b/src/transcriptomics/integral.ts
@@ -0,0 +1,14 @@
+/** transcriptomics integral module — tsb analytics library. */
+export interface TranscriptomicsIntegralOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsIntegralResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsIntegral(data: number[], opts: TranscriptomicsIntegralOptions = {}): TranscriptomicsIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsIntegral };
diff --git a/src/transcriptomics/integration.ts b/src/transcriptomics/integration.ts
new file mode 100644
index 000000000..29578bfc4
--- /dev/null
+++ b/src/transcriptomics/integration.ts
@@ -0,0 +1,14 @@
+/** transcriptomics integration module — tsb analytics library. */
+export interface TranscriptomicsIntegrationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsIntegrationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsIntegration(data: number[], opts: TranscriptomicsIntegrationOptions = {}): TranscriptomicsIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsIntegration };
diff --git a/src/transcriptomics/interpolation.ts b/src/transcriptomics/interpolation.ts
new file mode 100644
index 000000000..ae9246d5f
--- /dev/null
+++ b/src/transcriptomics/interpolation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics interpolation module — tsb analytics library. */
+export interface TranscriptomicsInterpolationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsInterpolationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsInterpolation(data: number[], opts: TranscriptomicsInterpolationOptions = {}): TranscriptomicsInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsInterpolation };
diff --git a/src/transcriptomics/jacobian.ts b/src/transcriptomics/jacobian.ts
new file mode 100644
index 000000000..629117b16
--- /dev/null
+++ b/src/transcriptomics/jacobian.ts
@@ -0,0 +1,14 @@
+/** transcriptomics jacobian module — tsb analytics library. */
+export interface TranscriptomicsJacobianOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsJacobianResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsJacobian(data: number[], opts: TranscriptomicsJacobianOptions = {}): TranscriptomicsJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsJacobian };
diff --git a/src/transcriptomics/kernel.ts b/src/transcriptomics/kernel.ts
new file mode 100644
index 000000000..dfaaf3556
--- /dev/null
+++ b/src/transcriptomics/kernel.ts
@@ -0,0 +1,14 @@
+/** transcriptomics kernel module — tsb analytics library. */
+export interface TranscriptomicsKernelOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsKernelResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsKernel(data: number[], opts: TranscriptomicsKernelOptions = {}): TranscriptomicsKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsKernel };
diff --git a/src/transcriptomics/laplacian.ts b/src/transcriptomics/laplacian.ts
new file mode 100644
index 000000000..884f3ea1e
--- /dev/null
+++ b/src/transcriptomics/laplacian.ts
@@ -0,0 +1,14 @@
+/** transcriptomics laplacian module — tsb analytics library. */
+export interface TranscriptomicsLaplacianOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsLaplacianResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsLaplacian(data: number[], opts: TranscriptomicsLaplacianOptions = {}): TranscriptomicsLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsLaplacian };
diff --git a/src/transcriptomics/learning.ts b/src/transcriptomics/learning.ts
new file mode 100644
index 000000000..9e1422b40
--- /dev/null
+++ b/src/transcriptomics/learning.ts
@@ -0,0 +1,14 @@
+/** transcriptomics learning module — tsb analytics library. */
+export interface TranscriptomicsLearningOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsLearningResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsLearning(data: number[], opts: TranscriptomicsLearningOptions = {}): TranscriptomicsLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsLearning };
diff --git a/src/transcriptomics/linear.ts b/src/transcriptomics/linear.ts
new file mode 100644
index 000000000..0f13aae69
--- /dev/null
+++ b/src/transcriptomics/linear.ts
@@ -0,0 +1,14 @@
+/** transcriptomics linear module — tsb analytics library. */
+export interface TranscriptomicsLinearOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsLinearResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsLinear(data: number[], opts: TranscriptomicsLinearOptions = {}): TranscriptomicsLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsLinear };
diff --git a/src/transcriptomics/manifold.ts b/src/transcriptomics/manifold.ts
new file mode 100644
index 000000000..ffc794fc5
--- /dev/null
+++ b/src/transcriptomics/manifold.ts
@@ -0,0 +1,14 @@
+/** transcriptomics manifold module — tsb analytics library. */
+export interface TranscriptomicsManifoldOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsManifoldResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsManifold(data: number[], opts: TranscriptomicsManifoldOptions = {}): TranscriptomicsManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsManifold };
diff --git a/src/transcriptomics/matching.ts b/src/transcriptomics/matching.ts
new file mode 100644
index 000000000..808415ff3
--- /dev/null
+++ b/src/transcriptomics/matching.ts
@@ -0,0 +1,14 @@
+/** transcriptomics matching module — tsb analytics library. */
+export interface TranscriptomicsMatchingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsMatchingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsMatching(data: number[], opts: TranscriptomicsMatchingOptions = {}): TranscriptomicsMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsMatching };
diff --git a/src/transcriptomics/measurement.ts b/src/transcriptomics/measurement.ts
new file mode 100644
index 000000000..149a92025
--- /dev/null
+++ b/src/transcriptomics/measurement.ts
@@ -0,0 +1,14 @@
+/** transcriptomics measurement module — tsb analytics library. */
+export interface TranscriptomicsMeasurementOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsMeasurementResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsMeasurement(data: number[], opts: TranscriptomicsMeasurementOptions = {}): TranscriptomicsMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsMeasurement };
diff --git a/src/transcriptomics/metrics.ts b/src/transcriptomics/metrics.ts
new file mode 100644
index 000000000..03582c75c
--- /dev/null
+++ b/src/transcriptomics/metrics.ts
@@ -0,0 +1,14 @@
+/** transcriptomics metrics module — tsb analytics library. */
+export interface TranscriptomicsMetricsOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsMetricsResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsMetrics(data: number[], opts: TranscriptomicsMetricsOptions = {}): TranscriptomicsMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsMetrics };
diff --git a/src/transcriptomics/modeling.ts b/src/transcriptomics/modeling.ts
new file mode 100644
index 000000000..b52f3b6d0
--- /dev/null
+++ b/src/transcriptomics/modeling.ts
@@ -0,0 +1,14 @@
+/** transcriptomics modeling module — tsb analytics library. */
+export interface TranscriptomicsModelingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsModelingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsModeling(data: number[], opts: TranscriptomicsModelingOptions = {}): TranscriptomicsModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsModeling };
diff --git a/src/transcriptomics/monitoring.ts b/src/transcriptomics/monitoring.ts
new file mode 100644
index 000000000..aa2de790e
--- /dev/null
+++ b/src/transcriptomics/monitoring.ts
@@ -0,0 +1,14 @@
+/** transcriptomics monitoring module — tsb analytics library. */
+export interface TranscriptomicsMonitoringOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsMonitoringResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsMonitoring(data: number[], opts: TranscriptomicsMonitoringOptions = {}): TranscriptomicsMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsMonitoring };
diff --git a/src/transcriptomics/nonlinear.ts b/src/transcriptomics/nonlinear.ts
new file mode 100644
index 000000000..b2ac4db23
--- /dev/null
+++ b/src/transcriptomics/nonlinear.ts
@@ -0,0 +1,14 @@
+/** transcriptomics nonlinear module — tsb analytics library. */
+export interface TranscriptomicsNonlinearOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsNonlinearResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsNonlinear(data: number[], opts: TranscriptomicsNonlinearOptions = {}): TranscriptomicsNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsNonlinear };
diff --git a/src/transcriptomics/normalization.ts b/src/transcriptomics/normalization.ts
new file mode 100644
index 000000000..479cb659d
--- /dev/null
+++ b/src/transcriptomics/normalization.ts
@@ -0,0 +1,14 @@
+/** transcriptomics normalization module — tsb analytics library. */
+export interface TranscriptomicsNormalizationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsNormalizationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsNormalization(data: number[], opts: TranscriptomicsNormalizationOptions = {}): TranscriptomicsNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsNormalization };
diff --git a/src/transcriptomics/optimization.ts b/src/transcriptomics/optimization.ts
new file mode 100644
index 000000000..9a415a99b
--- /dev/null
+++ b/src/transcriptomics/optimization.ts
@@ -0,0 +1,14 @@
+/** transcriptomics optimization module — tsb analytics library. */
+export interface TranscriptomicsOptimizationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsOptimizationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsOptimization(data: number[], opts: TranscriptomicsOptimizationOptions = {}): TranscriptomicsOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsOptimization };
diff --git a/src/transcriptomics/patterns.ts b/src/transcriptomics/patterns.ts
new file mode 100644
index 000000000..0db11866b
--- /dev/null
+++ b/src/transcriptomics/patterns.ts
@@ -0,0 +1,14 @@
+/** transcriptomics patterns module — tsb analytics library. */
+export interface TranscriptomicsPatternsOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsPatternsResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsPatterns(data: number[], opts: TranscriptomicsPatternsOptions = {}): TranscriptomicsPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsPatterns };
diff --git a/src/transcriptomics/permutation.ts b/src/transcriptomics/permutation.ts
new file mode 100644
index 000000000..fda8dc942
--- /dev/null
+++ b/src/transcriptomics/permutation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics permutation module — tsb analytics library. */
+export interface TranscriptomicsPermutationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsPermutationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsPermutation(data: number[], opts: TranscriptomicsPermutationOptions = {}): TranscriptomicsPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsPermutation };
diff --git a/src/transcriptomics/prediction.ts b/src/transcriptomics/prediction.ts
new file mode 100644
index 000000000..0c4f05022
--- /dev/null
+++ b/src/transcriptomics/prediction.ts
@@ -0,0 +1,14 @@
+/** transcriptomics prediction module — tsb analytics library. */
+export interface TranscriptomicsPredictionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsPredictionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsPrediction(data: number[], opts: TranscriptomicsPredictionOptions = {}): TranscriptomicsPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsPrediction };
diff --git a/src/transcriptomics/processing.ts b/src/transcriptomics/processing.ts
new file mode 100644
index 000000000..584d45225
--- /dev/null
+++ b/src/transcriptomics/processing.ts
@@ -0,0 +1,14 @@
+/** transcriptomics processing module — tsb analytics library. */
+export interface TranscriptomicsProcessingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsProcessingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsProcessing(data: number[], opts: TranscriptomicsProcessingOptions = {}): TranscriptomicsProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsProcessing };
diff --git a/src/transcriptomics/profiling.ts b/src/transcriptomics/profiling.ts
new file mode 100644
index 000000000..8f7a82f0c
--- /dev/null
+++ b/src/transcriptomics/profiling.ts
@@ -0,0 +1,14 @@
+/** transcriptomics profiling module — tsb analytics library. */
+export interface TranscriptomicsProfilingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsProfilingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsProfiling(data: number[], opts: TranscriptomicsProfilingOptions = {}): TranscriptomicsProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsProfiling };
diff --git a/src/transcriptomics/projection.ts b/src/transcriptomics/projection.ts
new file mode 100644
index 000000000..4714068c7
--- /dev/null
+++ b/src/transcriptomics/projection.ts
@@ -0,0 +1,14 @@
+/** transcriptomics projection module — tsb analytics library. */
+export interface TranscriptomicsProjectionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsProjectionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsProjection(data: number[], opts: TranscriptomicsProjectionOptions = {}): TranscriptomicsProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsProjection };
diff --git a/src/transcriptomics/ranking.ts b/src/transcriptomics/ranking.ts
new file mode 100644
index 000000000..2e51e289c
--- /dev/null
+++ b/src/transcriptomics/ranking.ts
@@ -0,0 +1,14 @@
+/** transcriptomics ranking module — tsb analytics library. */
+export interface TranscriptomicsRankingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsRankingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsRanking(data: number[], opts: TranscriptomicsRankingOptions = {}): TranscriptomicsRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsRanking };
diff --git a/src/transcriptomics/reconstruction.ts b/src/transcriptomics/reconstruction.ts
new file mode 100644
index 000000000..523b65402
--- /dev/null
+++ b/src/transcriptomics/reconstruction.ts
@@ -0,0 +1,14 @@
+/** transcriptomics reconstruction module — tsb analytics library. */
+export interface TranscriptomicsReconstructionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsReconstructionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsReconstruction(data: number[], opts: TranscriptomicsReconstructionOptions = {}): TranscriptomicsReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsReconstruction };
diff --git a/src/transcriptomics/registration.ts b/src/transcriptomics/registration.ts
new file mode 100644
index 000000000..c1b3734f4
--- /dev/null
+++ b/src/transcriptomics/registration.ts
@@ -0,0 +1,14 @@
+/** transcriptomics registration module — tsb analytics library. */
+export interface TranscriptomicsRegistrationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsRegistrationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsRegistration(data: number[], opts: TranscriptomicsRegistrationOptions = {}): TranscriptomicsRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsRegistration };
diff --git a/src/transcriptomics/regression.ts b/src/transcriptomics/regression.ts
new file mode 100644
index 000000000..4901fbb39
--- /dev/null
+++ b/src/transcriptomics/regression.ts
@@ -0,0 +1,14 @@
+/** transcriptomics regression module — tsb analytics library. */
+export interface TranscriptomicsRegressionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsRegressionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsRegression(data: number[], opts: TranscriptomicsRegressionOptions = {}): TranscriptomicsRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsRegression };
diff --git a/src/transcriptomics/regularization.ts b/src/transcriptomics/regularization.ts
new file mode 100644
index 000000000..d9db02cbe
--- /dev/null
+++ b/src/transcriptomics/regularization.ts
@@ -0,0 +1,14 @@
+/** transcriptomics regularization module — tsb analytics library. */
+export interface TranscriptomicsRegularizationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsRegularizationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsRegularization(data: number[], opts: TranscriptomicsRegularizationOptions = {}): TranscriptomicsRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsRegularization };
diff --git a/src/transcriptomics/robustness.ts b/src/transcriptomics/robustness.ts
new file mode 100644
index 000000000..97c745245
--- /dev/null
+++ b/src/transcriptomics/robustness.ts
@@ -0,0 +1,14 @@
+/** transcriptomics robustness module — tsb analytics library. */
+export interface TranscriptomicsRobustnessOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsRobustnessResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsRobustness(data: number[], opts: TranscriptomicsRobustnessOptions = {}): TranscriptomicsRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsRobustness };
diff --git a/src/transcriptomics/sampling.ts b/src/transcriptomics/sampling.ts
new file mode 100644
index 000000000..017ff2da4
--- /dev/null
+++ b/src/transcriptomics/sampling.ts
@@ -0,0 +1,14 @@
+/** transcriptomics sampling module — tsb analytics library. */
+export interface TranscriptomicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsSamplingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsSampling(data: number[], opts: TranscriptomicsSamplingOptions = {}): TranscriptomicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsSampling };
diff --git a/src/transcriptomics/sampling2.ts b/src/transcriptomics/sampling2.ts
new file mode 100644
index 000000000..6e35e5e0e
--- /dev/null
+++ b/src/transcriptomics/sampling2.ts
@@ -0,0 +1,14 @@
+/** transcriptomics sampling2 module — tsb analytics library. */
+export interface TranscriptomicsSamplingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsSamplingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsSampling(data: number[], opts: TranscriptomicsSamplingOptions = {}): TranscriptomicsSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsSampling };
diff --git a/src/transcriptomics/scaling.ts b/src/transcriptomics/scaling.ts
new file mode 100644
index 000000000..9a9cc4a2d
--- /dev/null
+++ b/src/transcriptomics/scaling.ts
@@ -0,0 +1,14 @@
+/** transcriptomics scaling module — tsb analytics library. */
+export interface TranscriptomicsScalingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsScalingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsScaling(data: number[], opts: TranscriptomicsScalingOptions = {}): TranscriptomicsScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsScaling };
diff --git a/src/transcriptomics/scoring.ts b/src/transcriptomics/scoring.ts
new file mode 100644
index 000000000..c100890e6
--- /dev/null
+++ b/src/transcriptomics/scoring.ts
@@ -0,0 +1,14 @@
+/** transcriptomics scoring module — tsb analytics library. */
+export interface TranscriptomicsScoringOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsScoringResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsScoring(data: number[], opts: TranscriptomicsScoringOptions = {}): TranscriptomicsScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsScoring };
diff --git a/src/transcriptomics/segmentation.ts b/src/transcriptomics/segmentation.ts
new file mode 100644
index 000000000..6f101f43c
--- /dev/null
+++ b/src/transcriptomics/segmentation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics segmentation module — tsb analytics library. */
+export interface TranscriptomicsSegmentationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsSegmentationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsSegmentation(data: number[], opts: TranscriptomicsSegmentationOptions = {}): TranscriptomicsSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsSegmentation };
diff --git a/src/transcriptomics/selection.ts b/src/transcriptomics/selection.ts
new file mode 100644
index 000000000..7c907cb97
--- /dev/null
+++ b/src/transcriptomics/selection.ts
@@ -0,0 +1,14 @@
+/** transcriptomics selection module — tsb analytics library. */
+export interface TranscriptomicsSelectionOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsSelectionResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsSelection(data: number[], opts: TranscriptomicsSelectionOptions = {}): TranscriptomicsSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsSelection };
diff --git a/src/transcriptomics/sensitivity.ts b/src/transcriptomics/sensitivity.ts
new file mode 100644
index 000000000..ad1afaca5
--- /dev/null
+++ b/src/transcriptomics/sensitivity.ts
@@ -0,0 +1,14 @@
+/** transcriptomics sensitivity module — tsb analytics library. */
+export interface TranscriptomicsSensitivityOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsSensitivityResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsSensitivity(data: number[], opts: TranscriptomicsSensitivityOptions = {}): TranscriptomicsSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsSensitivity };
diff --git a/src/transcriptomics/simulation.ts b/src/transcriptomics/simulation.ts
new file mode 100644
index 000000000..317e6cddd
--- /dev/null
+++ b/src/transcriptomics/simulation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics simulation module — tsb analytics library. */
+export interface TranscriptomicsSimulationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsSimulationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsSimulation(data: number[], opts: TranscriptomicsSimulationOptions = {}): TranscriptomicsSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsSimulation };
diff --git a/src/transcriptomics/smoothing.ts b/src/transcriptomics/smoothing.ts
new file mode 100644
index 000000000..35f1539a8
--- /dev/null
+++ b/src/transcriptomics/smoothing.ts
@@ -0,0 +1,14 @@
+/** transcriptomics smoothing module — tsb analytics library. */
+export interface TranscriptomicsSmoothingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsSmoothingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsSmoothing(data: number[], opts: TranscriptomicsSmoothingOptions = {}): TranscriptomicsSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsSmoothing };
diff --git a/src/transcriptomics/stability.ts b/src/transcriptomics/stability.ts
new file mode 100644
index 000000000..601ce0436
--- /dev/null
+++ b/src/transcriptomics/stability.ts
@@ -0,0 +1,14 @@
+/** transcriptomics stability module — tsb analytics library. */
+export interface TranscriptomicsStabilityOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsStabilityResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsStability(data: number[], opts: TranscriptomicsStabilityOptions = {}): TranscriptomicsStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsStability };
diff --git a/src/transcriptomics/stacking.ts b/src/transcriptomics/stacking.ts
new file mode 100644
index 000000000..c2f3e0842
--- /dev/null
+++ b/src/transcriptomics/stacking.ts
@@ -0,0 +1,14 @@
+/** transcriptomics stacking module — tsb analytics library. */
+export interface TranscriptomicsStackingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsStackingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsStacking(data: number[], opts: TranscriptomicsStackingOptions = {}): TranscriptomicsStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsStacking };
diff --git a/src/transcriptomics/standardization.ts b/src/transcriptomics/standardization.ts
new file mode 100644
index 000000000..1e69bb8fc
--- /dev/null
+++ b/src/transcriptomics/standardization.ts
@@ -0,0 +1,14 @@
+/** transcriptomics standardization module — tsb analytics library. */
+export interface TranscriptomicsStandardizationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsStandardizationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsStandardization(data: number[], opts: TranscriptomicsStandardizationOptions = {}): TranscriptomicsStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsStandardization };
diff --git a/src/transcriptomics/static.ts b/src/transcriptomics/static.ts
new file mode 100644
index 000000000..683f8ba47
--- /dev/null
+++ b/src/transcriptomics/static.ts
@@ -0,0 +1,14 @@
+/** transcriptomics static module — tsb analytics library. */
+export interface TranscriptomicsStaticOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsStaticResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsStatic(data: number[], opts: TranscriptomicsStaticOptions = {}): TranscriptomicsStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsStatic };
diff --git a/src/transcriptomics/stochastic.ts b/src/transcriptomics/stochastic.ts
new file mode 100644
index 000000000..ef4b5c15b
--- /dev/null
+++ b/src/transcriptomics/stochastic.ts
@@ -0,0 +1,14 @@
+/** transcriptomics stochastic module — tsb analytics library. */
+export interface TranscriptomicsStochasticOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsStochasticResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsStochastic(data: number[], opts: TranscriptomicsStochasticOptions = {}): TranscriptomicsStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsStochastic };
diff --git a/src/transcriptomics/synthesis.ts b/src/transcriptomics/synthesis.ts
new file mode 100644
index 000000000..0b5a88c7f
--- /dev/null
+++ b/src/transcriptomics/synthesis.ts
@@ -0,0 +1,14 @@
+/** transcriptomics synthesis module — tsb analytics library. */
+export interface TranscriptomicsSynthesisOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsSynthesisResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsSynthesis(data: number[], opts: TranscriptomicsSynthesisOptions = {}): TranscriptomicsSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsSynthesis };
diff --git a/src/transcriptomics/topology.ts b/src/transcriptomics/topology.ts
new file mode 100644
index 000000000..16ffb474f
--- /dev/null
+++ b/src/transcriptomics/topology.ts
@@ -0,0 +1,14 @@
+/** transcriptomics topology module — tsb analytics library. */
+export interface TranscriptomicsTopologyOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsTopologyResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsTopology(data: number[], opts: TranscriptomicsTopologyOptions = {}): TranscriptomicsTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsTopology };
diff --git a/src/transcriptomics/tracking.ts b/src/transcriptomics/tracking.ts
new file mode 100644
index 000000000..b1932f124
--- /dev/null
+++ b/src/transcriptomics/tracking.ts
@@ -0,0 +1,14 @@
+/** transcriptomics tracking module — tsb analytics library. */
+export interface TranscriptomicsTrackingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsTrackingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsTracking(data: number[], opts: TranscriptomicsTrackingOptions = {}): TranscriptomicsTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsTracking };
diff --git a/src/transcriptomics/transform.ts b/src/transcriptomics/transform.ts
new file mode 100644
index 000000000..287afa6a4
--- /dev/null
+++ b/src/transcriptomics/transform.ts
@@ -0,0 +1,14 @@
+/** transcriptomics transform module — tsb analytics library. */
+export interface TranscriptomicsTransformOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsTransformResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsTransform(data: number[], opts: TranscriptomicsTransformOptions = {}): TranscriptomicsTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsTransform };
diff --git a/src/transcriptomics/uncertainty.ts b/src/transcriptomics/uncertainty.ts
new file mode 100644
index 000000000..e2fbf2cbc
--- /dev/null
+++ b/src/transcriptomics/uncertainty.ts
@@ -0,0 +1,14 @@
+/** transcriptomics uncertainty module — tsb analytics library. */
+export interface TranscriptomicsUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsUncertaintyResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsUncertainty(data: number[], opts: TranscriptomicsUncertaintyOptions = {}): TranscriptomicsUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsUncertainty };
diff --git a/src/transcriptomics/validation.ts b/src/transcriptomics/validation.ts
new file mode 100644
index 000000000..f8fb04aac
--- /dev/null
+++ b/src/transcriptomics/validation.ts
@@ -0,0 +1,14 @@
+/** transcriptomics validation module — tsb analytics library. */
+export interface TranscriptomicsValidationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsValidationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsValidation(data: number[], opts: TranscriptomicsValidationOptions = {}): TranscriptomicsValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsValidation };
diff --git a/src/transcriptomics/verification.ts b/src/transcriptomics/verification.ts
new file mode 100644
index 000000000..8e135fb62
--- /dev/null
+++ b/src/transcriptomics/verification.ts
@@ -0,0 +1,14 @@
+/** transcriptomics verification module — tsb analytics library. */
+export interface TranscriptomicsVerificationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsVerificationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsVerification(data: number[], opts: TranscriptomicsVerificationOptions = {}): TranscriptomicsVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsVerification };
diff --git a/src/transcriptomics/visualization.ts b/src/transcriptomics/visualization.ts
new file mode 100644
index 000000000..78823066d
--- /dev/null
+++ b/src/transcriptomics/visualization.ts
@@ -0,0 +1,14 @@
+/** transcriptomics visualization module — tsb analytics library. */
+export interface TranscriptomicsVisualizationOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsVisualizationResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsVisualization(data: number[], opts: TranscriptomicsVisualizationOptions = {}): TranscriptomicsVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsVisualization };
diff --git a/src/transcriptomics/voting.ts b/src/transcriptomics/voting.ts
new file mode 100644
index 000000000..d6bcd0e52
--- /dev/null
+++ b/src/transcriptomics/voting.ts
@@ -0,0 +1,14 @@
+/** transcriptomics voting module — tsb analytics library. */
+export interface TranscriptomicsVotingOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsVotingResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsVoting(data: number[], opts: TranscriptomicsVotingOptions = {}): TranscriptomicsVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsVoting };
diff --git a/src/transcriptomics/wavelet.ts b/src/transcriptomics/wavelet.ts
new file mode 100644
index 000000000..30ed25bdc
--- /dev/null
+++ b/src/transcriptomics/wavelet.ts
@@ -0,0 +1,14 @@
+/** transcriptomics wavelet module — tsb analytics library. */
+export interface TranscriptomicsWaveletOptions { tol?: number; maxIter?: number; }
+export interface TranscriptomicsWaveletResult { values: number[]; converged: boolean; }
+export function computeTranscriptomicsWavelet(data: number[], opts: TranscriptomicsWaveletOptions = {}): TranscriptomicsWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTranscriptomicsWavelet };
diff --git a/src/tribology/adaptation.ts b/src/tribology/adaptation.ts
new file mode 100644
index 000000000..728487f90
--- /dev/null
+++ b/src/tribology/adaptation.ts
@@ -0,0 +1,14 @@
+/** tribology adaptation module — tsb analytics library. */
+export interface TribologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface TribologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeTribologyAdaptation(data: number[], opts: TribologyAdaptationOptions = {}): TribologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyAdaptation };
diff --git a/src/tribology/aggregation.ts b/src/tribology/aggregation.ts
new file mode 100644
index 000000000..79c1484e3
--- /dev/null
+++ b/src/tribology/aggregation.ts
@@ -0,0 +1,14 @@
+/** tribology aggregation module — tsb analytics library. */
+export interface TribologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface TribologyAggregationResult { values: number[]; converged: boolean; }
+export function computeTribologyAggregation(data: number[], opts: TribologyAggregationOptions = {}): TribologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyAggregation };
diff --git a/src/tribology/algebra.ts b/src/tribology/algebra.ts
new file mode 100644
index 000000000..2fb816b3f
--- /dev/null
+++ b/src/tribology/algebra.ts
@@ -0,0 +1,14 @@
+/** tribology algebra module — tsb analytics library. */
+export interface TribologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface TribologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeTribologyAlgebra(data: number[], opts: TribologyAlgebraOptions = {}): TribologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyAlgebra };
diff --git a/src/tribology/alignment.ts b/src/tribology/alignment.ts
new file mode 100644
index 000000000..44f3c6efb
--- /dev/null
+++ b/src/tribology/alignment.ts
@@ -0,0 +1,14 @@
+/** tribology alignment module — tsb analytics library. */
+export interface TribologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface TribologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeTribologyAlignment(data: number[], opts: TribologyAlignmentOptions = {}): TribologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyAlignment };
diff --git a/src/tribology/analysis.ts b/src/tribology/analysis.ts
new file mode 100644
index 000000000..3387b35c6
--- /dev/null
+++ b/src/tribology/analysis.ts
@@ -0,0 +1,14 @@
+/** tribology analysis module — tsb analytics library. */
+export interface TribologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface TribologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeTribologyAnalysis(data: number[], opts: TribologyAnalysisOptions = {}): TribologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyAnalysis };
diff --git a/src/tribology/augmentation.ts b/src/tribology/augmentation.ts
new file mode 100644
index 000000000..88a0482bc
--- /dev/null
+++ b/src/tribology/augmentation.ts
@@ -0,0 +1,14 @@
+/** tribology augmentation module — tsb analytics library. */
+export interface TribologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface TribologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeTribologyAugmentation(data: number[], opts: TribologyAugmentationOptions = {}): TribologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyAugmentation };
diff --git a/src/tribology/bagging.ts b/src/tribology/bagging.ts
new file mode 100644
index 000000000..904311952
--- /dev/null
+++ b/src/tribology/bagging.ts
@@ -0,0 +1,14 @@
+/** tribology bagging module — tsb analytics library. */
+export interface TribologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface TribologyBaggingResult { values: number[]; converged: boolean; }
+export function computeTribologyBagging(data: number[], opts: TribologyBaggingOptions = {}): TribologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyBagging };
diff --git a/src/tribology/basis.ts b/src/tribology/basis.ts
new file mode 100644
index 000000000..1f904c98a
--- /dev/null
+++ b/src/tribology/basis.ts
@@ -0,0 +1,14 @@
+/** tribology basis module — tsb analytics library. */
+export interface TribologyBasisOptions { tol?: number; maxIter?: number; }
+export interface TribologyBasisResult { values: number[]; converged: boolean; }
+export function computeTribologyBasis(data: number[], opts: TribologyBasisOptions = {}): TribologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyBasis };
diff --git a/src/tribology/benchmarking.ts b/src/tribology/benchmarking.ts
new file mode 100644
index 000000000..d336e4a80
--- /dev/null
+++ b/src/tribology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** tribology benchmarking module — tsb analytics library. */
+export interface TribologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface TribologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeTribologyBenchmarking(data: number[], opts: TribologyBenchmarkingOptions = {}): TribologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyBenchmarking };
diff --git a/src/tribology/blending.ts b/src/tribology/blending.ts
new file mode 100644
index 000000000..ddee890f6
--- /dev/null
+++ b/src/tribology/blending.ts
@@ -0,0 +1,14 @@
+/** tribology blending module — tsb analytics library. */
+export interface TribologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface TribologyBlendingResult { values: number[]; converged: boolean; }
+export function computeTribologyBlending(data: number[], opts: TribologyBlendingOptions = {}): TribologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyBlending };
diff --git a/src/tribology/boosting.ts b/src/tribology/boosting.ts
new file mode 100644
index 000000000..7cdd905b0
--- /dev/null
+++ b/src/tribology/boosting.ts
@@ -0,0 +1,14 @@
+/** tribology boosting module — tsb analytics library. */
+export interface TribologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface TribologyBoostingResult { values: number[]; converged: boolean; }
+export function computeTribologyBoosting(data: number[], opts: TribologyBoostingOptions = {}): TribologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyBoosting };
diff --git a/src/tribology/bootstrap.ts b/src/tribology/bootstrap.ts
new file mode 100644
index 000000000..798e015df
--- /dev/null
+++ b/src/tribology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** tribology bootstrap module — tsb analytics library. */
+export interface TribologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface TribologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeTribologyBootstrap(data: number[], opts: TribologyBootstrapOptions = {}): TribologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyBootstrap };
diff --git a/src/tribology/calculus.ts b/src/tribology/calculus.ts
new file mode 100644
index 000000000..f31e4968e
--- /dev/null
+++ b/src/tribology/calculus.ts
@@ -0,0 +1,14 @@
+/** tribology calculus module — tsb analytics library. */
+export interface TribologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface TribologyCalculusResult { values: number[]; converged: boolean; }
+export function computeTribologyCalculus(data: number[], opts: TribologyCalculusOptions = {}): TribologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyCalculus };
diff --git a/src/tribology/calibration.ts b/src/tribology/calibration.ts
new file mode 100644
index 000000000..4a3e45636
--- /dev/null
+++ b/src/tribology/calibration.ts
@@ -0,0 +1,14 @@
+/** tribology calibration module — tsb analytics library. */
+export interface TribologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface TribologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeTribologyCalibration(data: number[], opts: TribologyCalibrationOptions = {}): TribologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyCalibration };
diff --git a/src/tribology/characterization.ts b/src/tribology/characterization.ts
new file mode 100644
index 000000000..b1dfdcbaa
--- /dev/null
+++ b/src/tribology/characterization.ts
@@ -0,0 +1,14 @@
+/** tribology characterization module — tsb analytics library. */
+export interface TribologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface TribologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeTribologyCharacterization(data: number[], opts: TribologyCharacterizationOptions = {}): TribologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyCharacterization };
diff --git a/src/tribology/classification.ts b/src/tribology/classification.ts
new file mode 100644
index 000000000..3703b27c8
--- /dev/null
+++ b/src/tribology/classification.ts
@@ -0,0 +1,14 @@
+/** tribology classification module — tsb analytics library. */
+export interface TribologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface TribologyClassificationResult { values: number[]; converged: boolean; }
+export function computeTribologyClassification(data: number[], opts: TribologyClassificationOptions = {}): TribologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyClassification };
diff --git a/src/tribology/clustering.ts b/src/tribology/clustering.ts
new file mode 100644
index 000000000..32ba6b10c
--- /dev/null
+++ b/src/tribology/clustering.ts
@@ -0,0 +1,14 @@
+/** tribology clustering module — tsb analytics library. */
+export interface TribologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface TribologyClusteringResult { values: number[]; converged: boolean; }
+export function computeTribologyClustering(data: number[], opts: TribologyClusteringOptions = {}): TribologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyClustering };
diff --git a/src/tribology/compression.ts b/src/tribology/compression.ts
new file mode 100644
index 000000000..8042ac575
--- /dev/null
+++ b/src/tribology/compression.ts
@@ -0,0 +1,14 @@
+/** tribology compression module — tsb analytics library. */
+export interface TribologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface TribologyCompressionResult { values: number[]; converged: boolean; }
+export function computeTribologyCompression(data: number[], opts: TribologyCompressionOptions = {}): TribologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyCompression };
diff --git a/src/tribology/continuous.ts b/src/tribology/continuous.ts
new file mode 100644
index 000000000..86ffb4200
--- /dev/null
+++ b/src/tribology/continuous.ts
@@ -0,0 +1,14 @@
+/** tribology continuous module — tsb analytics library. */
+export interface TribologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface TribologyContinuousResult { values: number[]; converged: boolean; }
+export function computeTribologyContinuous(data: number[], opts: TribologyContinuousOptions = {}): TribologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyContinuous };
diff --git a/src/tribology/control.ts b/src/tribology/control.ts
new file mode 100644
index 000000000..ca230e0c4
--- /dev/null
+++ b/src/tribology/control.ts
@@ -0,0 +1,14 @@
+/** tribology control module — tsb analytics library. */
+export interface TribologyControlOptions { tol?: number; maxIter?: number; }
+export interface TribologyControlResult { values: number[]; converged: boolean; }
+export function computeTribologyControl(data: number[], opts: TribologyControlOptions = {}): TribologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyControl };
diff --git a/src/tribology/convergence.ts b/src/tribology/convergence.ts
new file mode 100644
index 000000000..4b4c2c221
--- /dev/null
+++ b/src/tribology/convergence.ts
@@ -0,0 +1,14 @@
+/** tribology convergence module — tsb analytics library. */
+export interface TribologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface TribologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeTribologyConvergence(data: number[], opts: TribologyConvergenceOptions = {}): TribologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyConvergence };
diff --git a/src/tribology/convex.ts b/src/tribology/convex.ts
new file mode 100644
index 000000000..514731804
--- /dev/null
+++ b/src/tribology/convex.ts
@@ -0,0 +1,14 @@
+/** tribology convex module — tsb analytics library. */
+export interface TribologyConvexOptions { tol?: number; maxIter?: number; }
+export interface TribologyConvexResult { values: number[]; converged: boolean; }
+export function computeTribologyConvex(data: number[], opts: TribologyConvexOptions = {}): TribologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyConvex };
diff --git a/src/tribology/correlation.ts b/src/tribology/correlation.ts
new file mode 100644
index 000000000..d7886b875
--- /dev/null
+++ b/src/tribology/correlation.ts
@@ -0,0 +1,14 @@
+/** tribology correlation module — tsb analytics library. */
+export interface TribologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface TribologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeTribologyCorrelation(data: number[], opts: TribologyCorrelationOptions = {}): TribologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyCorrelation };
diff --git a/src/tribology/covariance.ts b/src/tribology/covariance.ts
new file mode 100644
index 000000000..16f616038
--- /dev/null
+++ b/src/tribology/covariance.ts
@@ -0,0 +1,14 @@
+/** tribology covariance module — tsb analytics library. */
+export interface TribologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface TribologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeTribologyCovariance(data: number[], opts: TribologyCovarianceOptions = {}): TribologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyCovariance };
diff --git a/src/tribology/cross_validation.ts b/src/tribology/cross_validation.ts
new file mode 100644
index 000000000..d84b0c5af
--- /dev/null
+++ b/src/tribology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** tribology cross_validation module — tsb analytics library. */
+export interface TribologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface TribologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeTribologyCrossValidation(data: number[], opts: TribologyCrossValidationOptions = {}): TribologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyCrossValidation };
diff --git a/src/tribology/decoding.ts b/src/tribology/decoding.ts
new file mode 100644
index 000000000..bd68dbe51
--- /dev/null
+++ b/src/tribology/decoding.ts
@@ -0,0 +1,14 @@
+/** tribology decoding module — tsb analytics library. */
+export interface TribologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface TribologyDecodingResult { values: number[]; converged: boolean; }
+export function computeTribologyDecoding(data: number[], opts: TribologyDecodingOptions = {}): TribologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDecoding };
diff --git a/src/tribology/decomposition.ts b/src/tribology/decomposition.ts
new file mode 100644
index 000000000..f2bd2e602
--- /dev/null
+++ b/src/tribology/decomposition.ts
@@ -0,0 +1,14 @@
+/** tribology decomposition module — tsb analytics library. */
+export interface TribologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface TribologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeTribologyDecomposition(data: number[], opts: TribologyDecompositionOptions = {}): TribologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDecomposition };
diff --git a/src/tribology/detection.ts b/src/tribology/detection.ts
new file mode 100644
index 000000000..148d0c6ef
--- /dev/null
+++ b/src/tribology/detection.ts
@@ -0,0 +1,14 @@
+/** tribology detection module — tsb analytics library. */
+export interface TribologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface TribologyDetectionResult { values: number[]; converged: boolean; }
+export function computeTribologyDetection(data: number[], opts: TribologyDetectionOptions = {}): TribologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDetection };
diff --git a/src/tribology/deterministic.ts b/src/tribology/deterministic.ts
new file mode 100644
index 000000000..5dd4a2580
--- /dev/null
+++ b/src/tribology/deterministic.ts
@@ -0,0 +1,14 @@
+/** tribology deterministic module — tsb analytics library. */
+export interface TribologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface TribologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeTribologyDeterministic(data: number[], opts: TribologyDeterministicOptions = {}): TribologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDeterministic };
diff --git a/src/tribology/diagnostics.ts b/src/tribology/diagnostics.ts
new file mode 100644
index 000000000..3e5d368aa
--- /dev/null
+++ b/src/tribology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** tribology diagnostics module — tsb analytics library. */
+export interface TribologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface TribologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeTribologyDiagnostics(data: number[], opts: TribologyDiagnosticsOptions = {}): TribologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDiagnostics };
diff --git a/src/tribology/differential.ts b/src/tribology/differential.ts
new file mode 100644
index 000000000..2b48d8e59
--- /dev/null
+++ b/src/tribology/differential.ts
@@ -0,0 +1,14 @@
+/** tribology differential module — tsb analytics library. */
+export interface TribologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface TribologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeTribologyDifferential(data: number[], opts: TribologyDifferentialOptions = {}): TribologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDifferential };
diff --git a/src/tribology/discrete.ts b/src/tribology/discrete.ts
new file mode 100644
index 000000000..49d0635dc
--- /dev/null
+++ b/src/tribology/discrete.ts
@@ -0,0 +1,14 @@
+/** tribology discrete module — tsb analytics library. */
+export interface TribologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface TribologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeTribologyDiscrete(data: number[], opts: TribologyDiscreteOptions = {}): TribologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDiscrete };
diff --git a/src/tribology/distribution.ts b/src/tribology/distribution.ts
new file mode 100644
index 000000000..ffe6770ab
--- /dev/null
+++ b/src/tribology/distribution.ts
@@ -0,0 +1,14 @@
+/** tribology distribution module — tsb analytics library. */
+export interface TribologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface TribologyDistributionResult { values: number[]; converged: boolean; }
+export function computeTribologyDistribution(data: number[], opts: TribologyDistributionOptions = {}): TribologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDistribution };
diff --git a/src/tribology/dynamic.ts b/src/tribology/dynamic.ts
new file mode 100644
index 000000000..430c6212a
--- /dev/null
+++ b/src/tribology/dynamic.ts
@@ -0,0 +1,14 @@
+/** tribology dynamic module — tsb analytics library. */
+export interface TribologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface TribologyDynamicResult { values: number[]; converged: boolean; }
+export function computeTribologyDynamic(data: number[], opts: TribologyDynamicOptions = {}): TribologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyDynamic };
diff --git a/src/tribology/embedding.ts b/src/tribology/embedding.ts
new file mode 100644
index 000000000..a4b291526
--- /dev/null
+++ b/src/tribology/embedding.ts
@@ -0,0 +1,14 @@
+/** tribology embedding module — tsb analytics library. */
+export interface TribologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface TribologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeTribologyEmbedding(data: number[], opts: TribologyEmbeddingOptions = {}): TribologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyEmbedding };
diff --git a/src/tribology/encoding.ts b/src/tribology/encoding.ts
new file mode 100644
index 000000000..01c8580f2
--- /dev/null
+++ b/src/tribology/encoding.ts
@@ -0,0 +1,14 @@
+/** tribology encoding module — tsb analytics library. */
+export interface TribologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface TribologyEncodingResult { values: number[]; converged: boolean; }
+export function computeTribologyEncoding(data: number[], opts: TribologyEncodingOptions = {}): TribologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyEncoding };
diff --git a/src/tribology/ensemble.ts b/src/tribology/ensemble.ts
new file mode 100644
index 000000000..c9f4d3cea
--- /dev/null
+++ b/src/tribology/ensemble.ts
@@ -0,0 +1,14 @@
+/** tribology ensemble module — tsb analytics library. */
+export interface TribologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface TribologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeTribologyEnsemble(data: number[], opts: TribologyEnsembleOptions = {}): TribologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyEnsemble };
diff --git a/src/tribology/estimation.ts b/src/tribology/estimation.ts
new file mode 100644
index 000000000..c10f90491
--- /dev/null
+++ b/src/tribology/estimation.ts
@@ -0,0 +1,14 @@
+/** tribology estimation module — tsb analytics library. */
+export interface TribologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface TribologyEstimationResult { values: number[]; converged: boolean; }
+export function computeTribologyEstimation(data: number[], opts: TribologyEstimationOptions = {}): TribologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyEstimation };
diff --git a/src/tribology/evaluation.ts b/src/tribology/evaluation.ts
new file mode 100644
index 000000000..d86b21f24
--- /dev/null
+++ b/src/tribology/evaluation.ts
@@ -0,0 +1,14 @@
+/** tribology evaluation module — tsb analytics library. */
+export interface TribologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface TribologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeTribologyEvaluation(data: number[], opts: TribologyEvaluationOptions = {}): TribologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyEvaluation };
diff --git a/src/tribology/extrapolation.ts b/src/tribology/extrapolation.ts
new file mode 100644
index 000000000..0e026f745
--- /dev/null
+++ b/src/tribology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** tribology extrapolation module — tsb analytics library. */
+export interface TribologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface TribologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeTribologyExtrapolation(data: number[], opts: TribologyExtrapolationOptions = {}): TribologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyExtrapolation };
diff --git a/src/tribology/features.ts b/src/tribology/features.ts
new file mode 100644
index 000000000..0c7727c76
--- /dev/null
+++ b/src/tribology/features.ts
@@ -0,0 +1,14 @@
+/** tribology features module — tsb analytics library. */
+export interface TribologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface TribologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeTribologyFeatures(data: number[], opts: TribologyFeaturesOptions = {}): TribologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyFeatures };
diff --git a/src/tribology/feedback.ts b/src/tribology/feedback.ts
new file mode 100644
index 000000000..73caf24f3
--- /dev/null
+++ b/src/tribology/feedback.ts
@@ -0,0 +1,14 @@
+/** tribology feedback module — tsb analytics library. */
+export interface TribologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface TribologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeTribologyFeedback(data: number[], opts: TribologyFeedbackOptions = {}): TribologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyFeedback };
diff --git a/src/tribology/filtering.ts b/src/tribology/filtering.ts
new file mode 100644
index 000000000..cbc2627af
--- /dev/null
+++ b/src/tribology/filtering.ts
@@ -0,0 +1,14 @@
+/** tribology filtering module — tsb analytics library. */
+export interface TribologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface TribologyFilteringResult { values: number[]; converged: boolean; }
+export function computeTribologyFiltering(data: number[], opts: TribologyFilteringOptions = {}): TribologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyFiltering };
diff --git a/src/tribology/fourier.ts b/src/tribology/fourier.ts
new file mode 100644
index 000000000..874372a88
--- /dev/null
+++ b/src/tribology/fourier.ts
@@ -0,0 +1,14 @@
+/** tribology fourier module — tsb analytics library. */
+export interface TribologyFourierOptions { tol?: number; maxIter?: number; }
+export interface TribologyFourierResult { values: number[]; converged: boolean; }
+export function computeTribologyFourier(data: number[], opts: TribologyFourierOptions = {}): TribologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyFourier };
diff --git a/src/tribology/fusion.ts b/src/tribology/fusion.ts
new file mode 100644
index 000000000..4656faaad
--- /dev/null
+++ b/src/tribology/fusion.ts
@@ -0,0 +1,14 @@
+/** tribology fusion module — tsb analytics library. */
+export interface TribologyFusionOptions { tol?: number; maxIter?: number; }
+export interface TribologyFusionResult { values: number[]; converged: boolean; }
+export function computeTribologyFusion(data: number[], opts: TribologyFusionOptions = {}): TribologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyFusion };
diff --git a/src/tribology/generation.ts b/src/tribology/generation.ts
new file mode 100644
index 000000000..c0289c348
--- /dev/null
+++ b/src/tribology/generation.ts
@@ -0,0 +1,14 @@
+/** tribology generation module — tsb analytics library. */
+export interface TribologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface TribologyGenerationResult { values: number[]; converged: boolean; }
+export function computeTribologyGeneration(data: number[], opts: TribologyGenerationOptions = {}): TribologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyGeneration };
diff --git a/src/tribology/geometry.ts b/src/tribology/geometry.ts
new file mode 100644
index 000000000..7546291e5
--- /dev/null
+++ b/src/tribology/geometry.ts
@@ -0,0 +1,14 @@
+/** tribology geometry module — tsb analytics library. */
+export interface TribologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface TribologyGeometryResult { values: number[]; converged: boolean; }
+export function computeTribologyGeometry(data: number[], opts: TribologyGeometryOptions = {}): TribologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyGeometry };
diff --git a/src/tribology/gradient.ts b/src/tribology/gradient.ts
new file mode 100644
index 000000000..e0805f2e7
--- /dev/null
+++ b/src/tribology/gradient.ts
@@ -0,0 +1,14 @@
+/** tribology gradient module — tsb analytics library. */
+export interface TribologyGradientOptions { tol?: number; maxIter?: number; }
+export interface TribologyGradientResult { values: number[]; converged: boolean; }
+export function computeTribologyGradient(data: number[], opts: TribologyGradientOptions = {}): TribologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyGradient };
diff --git a/src/tribology/hessian.ts b/src/tribology/hessian.ts
new file mode 100644
index 000000000..36ebdd1aa
--- /dev/null
+++ b/src/tribology/hessian.ts
@@ -0,0 +1,14 @@
+/** tribology hessian module — tsb analytics library. */
+export interface TribologyHessianOptions { tol?: number; maxIter?: number; }
+export interface TribologyHessianResult { values: number[]; converged: boolean; }
+export function computeTribologyHessian(data: number[], opts: TribologyHessianOptions = {}): TribologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyHessian };
diff --git a/src/tribology/hypothesis.ts b/src/tribology/hypothesis.ts
new file mode 100644
index 000000000..dd724c5fa
--- /dev/null
+++ b/src/tribology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** tribology hypothesis module — tsb analytics library. */
+export interface TribologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface TribologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeTribologyHypothesis(data: number[], opts: TribologyHypothesisOptions = {}): TribologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyHypothesis };
diff --git a/src/tribology/inference.ts b/src/tribology/inference.ts
new file mode 100644
index 000000000..3f0a8e9d0
--- /dev/null
+++ b/src/tribology/inference.ts
@@ -0,0 +1,14 @@
+/** tribology inference module — tsb analytics library. */
+export interface TribologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface TribologyInferenceResult { values: number[]; converged: boolean; }
+export function computeTribologyInference(data: number[], opts: TribologyInferenceOptions = {}): TribologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyInference };
diff --git a/src/tribology/inference2.ts b/src/tribology/inference2.ts
new file mode 100644
index 000000000..918859a2d
--- /dev/null
+++ b/src/tribology/inference2.ts
@@ -0,0 +1,14 @@
+/** tribology inference2 module — tsb analytics library. */
+export interface TribologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface TribologyInferenceResult { values: number[]; converged: boolean; }
+export function computeTribologyInference(data: number[], opts: TribologyInferenceOptions = {}): TribologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyInference };
diff --git a/src/tribology/integral.ts b/src/tribology/integral.ts
new file mode 100644
index 000000000..bde653a1c
--- /dev/null
+++ b/src/tribology/integral.ts
@@ -0,0 +1,14 @@
+/** tribology integral module — tsb analytics library. */
+export interface TribologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface TribologyIntegralResult { values: number[]; converged: boolean; }
+export function computeTribologyIntegral(data: number[], opts: TribologyIntegralOptions = {}): TribologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyIntegral };
diff --git a/src/tribology/integration.ts b/src/tribology/integration.ts
new file mode 100644
index 000000000..5195e0a39
--- /dev/null
+++ b/src/tribology/integration.ts
@@ -0,0 +1,14 @@
+/** tribology integration module — tsb analytics library. */
+export interface TribologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface TribologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeTribologyIntegration(data: number[], opts: TribologyIntegrationOptions = {}): TribologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyIntegration };
diff --git a/src/tribology/interpolation.ts b/src/tribology/interpolation.ts
new file mode 100644
index 000000000..afec5674e
--- /dev/null
+++ b/src/tribology/interpolation.ts
@@ -0,0 +1,14 @@
+/** tribology interpolation module — tsb analytics library. */
+export interface TribologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface TribologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeTribologyInterpolation(data: number[], opts: TribologyInterpolationOptions = {}): TribologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyInterpolation };
diff --git a/src/tribology/jacobian.ts b/src/tribology/jacobian.ts
new file mode 100644
index 000000000..2694ebea1
--- /dev/null
+++ b/src/tribology/jacobian.ts
@@ -0,0 +1,14 @@
+/** tribology jacobian module — tsb analytics library. */
+export interface TribologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface TribologyJacobianResult { values: number[]; converged: boolean; }
+export function computeTribologyJacobian(data: number[], opts: TribologyJacobianOptions = {}): TribologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyJacobian };
diff --git a/src/tribology/kernel.ts b/src/tribology/kernel.ts
new file mode 100644
index 000000000..5cc091684
--- /dev/null
+++ b/src/tribology/kernel.ts
@@ -0,0 +1,14 @@
+/** tribology kernel module — tsb analytics library. */
+export interface TribologyKernelOptions { tol?: number; maxIter?: number; }
+export interface TribologyKernelResult { values: number[]; converged: boolean; }
+export function computeTribologyKernel(data: number[], opts: TribologyKernelOptions = {}): TribologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyKernel };
diff --git a/src/tribology/laplacian.ts b/src/tribology/laplacian.ts
new file mode 100644
index 000000000..968978673
--- /dev/null
+++ b/src/tribology/laplacian.ts
@@ -0,0 +1,14 @@
+/** tribology laplacian module — tsb analytics library. */
+export interface TribologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface TribologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeTribologyLaplacian(data: number[], opts: TribologyLaplacianOptions = {}): TribologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyLaplacian };
diff --git a/src/tribology/learning.ts b/src/tribology/learning.ts
new file mode 100644
index 000000000..c55af274c
--- /dev/null
+++ b/src/tribology/learning.ts
@@ -0,0 +1,14 @@
+/** tribology learning module — tsb analytics library. */
+export interface TribologyLearningOptions { tol?: number; maxIter?: number; }
+export interface TribologyLearningResult { values: number[]; converged: boolean; }
+export function computeTribologyLearning(data: number[], opts: TribologyLearningOptions = {}): TribologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyLearning };
diff --git a/src/tribology/linear.ts b/src/tribology/linear.ts
new file mode 100644
index 000000000..b643abc54
--- /dev/null
+++ b/src/tribology/linear.ts
@@ -0,0 +1,14 @@
+/** tribology linear module — tsb analytics library. */
+export interface TribologyLinearOptions { tol?: number; maxIter?: number; }
+export interface TribologyLinearResult { values: number[]; converged: boolean; }
+export function computeTribologyLinear(data: number[], opts: TribologyLinearOptions = {}): TribologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyLinear };
diff --git a/src/tribology/manifold.ts b/src/tribology/manifold.ts
new file mode 100644
index 000000000..5c683c5a6
--- /dev/null
+++ b/src/tribology/manifold.ts
@@ -0,0 +1,14 @@
+/** tribology manifold module — tsb analytics library. */
+export interface TribologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface TribologyManifoldResult { values: number[]; converged: boolean; }
+export function computeTribologyManifold(data: number[], opts: TribologyManifoldOptions = {}): TribologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyManifold };
diff --git a/src/tribology/matching.ts b/src/tribology/matching.ts
new file mode 100644
index 000000000..9b677e20f
--- /dev/null
+++ b/src/tribology/matching.ts
@@ -0,0 +1,14 @@
+/** tribology matching module — tsb analytics library. */
+export interface TribologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface TribologyMatchingResult { values: number[]; converged: boolean; }
+export function computeTribologyMatching(data: number[], opts: TribologyMatchingOptions = {}): TribologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyMatching };
diff --git a/src/tribology/measurement.ts b/src/tribology/measurement.ts
new file mode 100644
index 000000000..162c573f8
--- /dev/null
+++ b/src/tribology/measurement.ts
@@ -0,0 +1,14 @@
+/** tribology measurement module — tsb analytics library. */
+export interface TribologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface TribologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeTribologyMeasurement(data: number[], opts: TribologyMeasurementOptions = {}): TribologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyMeasurement };
diff --git a/src/tribology/metrics.ts b/src/tribology/metrics.ts
new file mode 100644
index 000000000..59adf1097
--- /dev/null
+++ b/src/tribology/metrics.ts
@@ -0,0 +1,14 @@
+/** tribology metrics module — tsb analytics library. */
+export interface TribologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface TribologyMetricsResult { values: number[]; converged: boolean; }
+export function computeTribologyMetrics(data: number[], opts: TribologyMetricsOptions = {}): TribologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyMetrics };
diff --git a/src/tribology/modeling.ts b/src/tribology/modeling.ts
new file mode 100644
index 000000000..c5ba01e30
--- /dev/null
+++ b/src/tribology/modeling.ts
@@ -0,0 +1,14 @@
+/** tribology modeling module — tsb analytics library. */
+export interface TribologyModelingOptions { tol?: number; maxIter?: number; }
+export interface TribologyModelingResult { values: number[]; converged: boolean; }
+export function computeTribologyModeling(data: number[], opts: TribologyModelingOptions = {}): TribologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyModeling };
diff --git a/src/tribology/monitoring.ts b/src/tribology/monitoring.ts
new file mode 100644
index 000000000..e1bb0c89b
--- /dev/null
+++ b/src/tribology/monitoring.ts
@@ -0,0 +1,14 @@
+/** tribology monitoring module — tsb analytics library. */
+export interface TribologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface TribologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeTribologyMonitoring(data: number[], opts: TribologyMonitoringOptions = {}): TribologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyMonitoring };
diff --git a/src/tribology/nonlinear.ts b/src/tribology/nonlinear.ts
new file mode 100644
index 000000000..75d961559
--- /dev/null
+++ b/src/tribology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** tribology nonlinear module — tsb analytics library. */
+export interface TribologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface TribologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeTribologyNonlinear(data: number[], opts: TribologyNonlinearOptions = {}): TribologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyNonlinear };
diff --git a/src/tribology/normalization.ts b/src/tribology/normalization.ts
new file mode 100644
index 000000000..e2ad86bc3
--- /dev/null
+++ b/src/tribology/normalization.ts
@@ -0,0 +1,14 @@
+/** tribology normalization module — tsb analytics library. */
+export interface TribologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface TribologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeTribologyNormalization(data: number[], opts: TribologyNormalizationOptions = {}): TribologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyNormalization };
diff --git a/src/tribology/optimization.ts b/src/tribology/optimization.ts
new file mode 100644
index 000000000..eb3437613
--- /dev/null
+++ b/src/tribology/optimization.ts
@@ -0,0 +1,14 @@
+/** tribology optimization module — tsb analytics library. */
+export interface TribologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface TribologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeTribologyOptimization(data: number[], opts: TribologyOptimizationOptions = {}): TribologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyOptimization };
diff --git a/src/tribology/patterns.ts b/src/tribology/patterns.ts
new file mode 100644
index 000000000..96ed737a3
--- /dev/null
+++ b/src/tribology/patterns.ts
@@ -0,0 +1,14 @@
+/** tribology patterns module — tsb analytics library. */
+export interface TribologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface TribologyPatternsResult { values: number[]; converged: boolean; }
+export function computeTribologyPatterns(data: number[], opts: TribologyPatternsOptions = {}): TribologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyPatterns };
diff --git a/src/tribology/permutation.ts b/src/tribology/permutation.ts
new file mode 100644
index 000000000..26045a5ff
--- /dev/null
+++ b/src/tribology/permutation.ts
@@ -0,0 +1,14 @@
+/** tribology permutation module — tsb analytics library. */
+export interface TribologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface TribologyPermutationResult { values: number[]; converged: boolean; }
+export function computeTribologyPermutation(data: number[], opts: TribologyPermutationOptions = {}): TribologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyPermutation };
diff --git a/src/tribology/prediction.ts b/src/tribology/prediction.ts
new file mode 100644
index 000000000..7355144b6
--- /dev/null
+++ b/src/tribology/prediction.ts
@@ -0,0 +1,14 @@
+/** tribology prediction module — tsb analytics library. */
+export interface TribologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface TribologyPredictionResult { values: number[]; converged: boolean; }
+export function computeTribologyPrediction(data: number[], opts: TribologyPredictionOptions = {}): TribologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyPrediction };
diff --git a/src/tribology/processing.ts b/src/tribology/processing.ts
new file mode 100644
index 000000000..bc03ffb13
--- /dev/null
+++ b/src/tribology/processing.ts
@@ -0,0 +1,14 @@
+/** tribology processing module — tsb analytics library. */
+export interface TribologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface TribologyProcessingResult { values: number[]; converged: boolean; }
+export function computeTribologyProcessing(data: number[], opts: TribologyProcessingOptions = {}): TribologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyProcessing };
diff --git a/src/tribology/profiling.ts b/src/tribology/profiling.ts
new file mode 100644
index 000000000..a9930a64b
--- /dev/null
+++ b/src/tribology/profiling.ts
@@ -0,0 +1,14 @@
+/** tribology profiling module — tsb analytics library. */
+export interface TribologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface TribologyProfilingResult { values: number[]; converged: boolean; }
+export function computeTribologyProfiling(data: number[], opts: TribologyProfilingOptions = {}): TribologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyProfiling };
diff --git a/src/tribology/projection.ts b/src/tribology/projection.ts
new file mode 100644
index 000000000..a8ff1c014
--- /dev/null
+++ b/src/tribology/projection.ts
@@ -0,0 +1,14 @@
+/** tribology projection module — tsb analytics library. */
+export interface TribologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface TribologyProjectionResult { values: number[]; converged: boolean; }
+export function computeTribologyProjection(data: number[], opts: TribologyProjectionOptions = {}): TribologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyProjection };
diff --git a/src/tribology/ranking.ts b/src/tribology/ranking.ts
new file mode 100644
index 000000000..9f357e912
--- /dev/null
+++ b/src/tribology/ranking.ts
@@ -0,0 +1,14 @@
+/** tribology ranking module — tsb analytics library. */
+export interface TribologyRankingOptions { tol?: number; maxIter?: number; }
+export interface TribologyRankingResult { values: number[]; converged: boolean; }
+export function computeTribologyRanking(data: number[], opts: TribologyRankingOptions = {}): TribologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyRanking };
diff --git a/src/tribology/reconstruction.ts b/src/tribology/reconstruction.ts
new file mode 100644
index 000000000..89467914b
--- /dev/null
+++ b/src/tribology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** tribology reconstruction module — tsb analytics library. */
+export interface TribologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface TribologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeTribologyReconstruction(data: number[], opts: TribologyReconstructionOptions = {}): TribologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyReconstruction };
diff --git a/src/tribology/registration.ts b/src/tribology/registration.ts
new file mode 100644
index 000000000..0e5cf5104
--- /dev/null
+++ b/src/tribology/registration.ts
@@ -0,0 +1,14 @@
+/** tribology registration module — tsb analytics library. */
+export interface TribologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface TribologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeTribologyRegistration(data: number[], opts: TribologyRegistrationOptions = {}): TribologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyRegistration };
diff --git a/src/tribology/regression.ts b/src/tribology/regression.ts
new file mode 100644
index 000000000..31972a5b7
--- /dev/null
+++ b/src/tribology/regression.ts
@@ -0,0 +1,14 @@
+/** tribology regression module — tsb analytics library. */
+export interface TribologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface TribologyRegressionResult { values: number[]; converged: boolean; }
+export function computeTribologyRegression(data: number[], opts: TribologyRegressionOptions = {}): TribologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyRegression };
diff --git a/src/tribology/regularization.ts b/src/tribology/regularization.ts
new file mode 100644
index 000000000..c7f70e69d
--- /dev/null
+++ b/src/tribology/regularization.ts
@@ -0,0 +1,14 @@
+/** tribology regularization module — tsb analytics library. */
+export interface TribologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface TribologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeTribologyRegularization(data: number[], opts: TribologyRegularizationOptions = {}): TribologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyRegularization };
diff --git a/src/tribology/robustness.ts b/src/tribology/robustness.ts
new file mode 100644
index 000000000..c5e12008d
--- /dev/null
+++ b/src/tribology/robustness.ts
@@ -0,0 +1,14 @@
+/** tribology robustness module — tsb analytics library. */
+export interface TribologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface TribologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeTribologyRobustness(data: number[], opts: TribologyRobustnessOptions = {}): TribologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyRobustness };
diff --git a/src/tribology/sampling.ts b/src/tribology/sampling.ts
new file mode 100644
index 000000000..2052c2fd0
--- /dev/null
+++ b/src/tribology/sampling.ts
@@ -0,0 +1,14 @@
+/** tribology sampling module — tsb analytics library. */
+export interface TribologySamplingOptions { tol?: number; maxIter?: number; }
+export interface TribologySamplingResult { values: number[]; converged: boolean; }
+export function computeTribologySampling(data: number[], opts: TribologySamplingOptions = {}): TribologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologySampling };
diff --git a/src/tribology/sampling2.ts b/src/tribology/sampling2.ts
new file mode 100644
index 000000000..7ebd47591
--- /dev/null
+++ b/src/tribology/sampling2.ts
@@ -0,0 +1,14 @@
+/** tribology sampling2 module — tsb analytics library. */
+export interface TribologySamplingOptions { tol?: number; maxIter?: number; }
+export interface TribologySamplingResult { values: number[]; converged: boolean; }
+export function computeTribologySampling(data: number[], opts: TribologySamplingOptions = {}): TribologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologySampling };
diff --git a/src/tribology/scaling.ts b/src/tribology/scaling.ts
new file mode 100644
index 000000000..8e2490723
--- /dev/null
+++ b/src/tribology/scaling.ts
@@ -0,0 +1,14 @@
+/** tribology scaling module — tsb analytics library. */
+export interface TribologyScalingOptions { tol?: number; maxIter?: number; }
+export interface TribologyScalingResult { values: number[]; converged: boolean; }
+export function computeTribologyScaling(data: number[], opts: TribologyScalingOptions = {}): TribologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyScaling };
diff --git a/src/tribology/scoring.ts b/src/tribology/scoring.ts
new file mode 100644
index 000000000..8f753ca0e
--- /dev/null
+++ b/src/tribology/scoring.ts
@@ -0,0 +1,14 @@
+/** tribology scoring module — tsb analytics library. */
+export interface TribologyScoringOptions { tol?: number; maxIter?: number; }
+export interface TribologyScoringResult { values: number[]; converged: boolean; }
+export function computeTribologyScoring(data: number[], opts: TribologyScoringOptions = {}): TribologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyScoring };
diff --git a/src/tribology/segmentation.ts b/src/tribology/segmentation.ts
new file mode 100644
index 000000000..0943cf73c
--- /dev/null
+++ b/src/tribology/segmentation.ts
@@ -0,0 +1,14 @@
+/** tribology segmentation module — tsb analytics library. */
+export interface TribologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface TribologySegmentationResult { values: number[]; converged: boolean; }
+export function computeTribologySegmentation(data: number[], opts: TribologySegmentationOptions = {}): TribologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologySegmentation };
diff --git a/src/tribology/selection.ts b/src/tribology/selection.ts
new file mode 100644
index 000000000..5161a5d1a
--- /dev/null
+++ b/src/tribology/selection.ts
@@ -0,0 +1,14 @@
+/** tribology selection module — tsb analytics library. */
+export interface TribologySelectionOptions { tol?: number; maxIter?: number; }
+export interface TribologySelectionResult { values: number[]; converged: boolean; }
+export function computeTribologySelection(data: number[], opts: TribologySelectionOptions = {}): TribologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologySelection };
diff --git a/src/tribology/sensitivity.ts b/src/tribology/sensitivity.ts
new file mode 100644
index 000000000..8bf2e67d3
--- /dev/null
+++ b/src/tribology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** tribology sensitivity module — tsb analytics library. */
+export interface TribologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface TribologySensitivityResult { values: number[]; converged: boolean; }
+export function computeTribologySensitivity(data: number[], opts: TribologySensitivityOptions = {}): TribologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologySensitivity };
diff --git a/src/tribology/simulation.ts b/src/tribology/simulation.ts
new file mode 100644
index 000000000..ac8c420c1
--- /dev/null
+++ b/src/tribology/simulation.ts
@@ -0,0 +1,14 @@
+/** tribology simulation module — tsb analytics library. */
+export interface TribologySimulationOptions { tol?: number; maxIter?: number; }
+export interface TribologySimulationResult { values: number[]; converged: boolean; }
+export function computeTribologySimulation(data: number[], opts: TribologySimulationOptions = {}): TribologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologySimulation };
diff --git a/src/tribology/smoothing.ts b/src/tribology/smoothing.ts
new file mode 100644
index 000000000..c8ac95088
--- /dev/null
+++ b/src/tribology/smoothing.ts
@@ -0,0 +1,14 @@
+/** tribology smoothing module — tsb analytics library. */
+export interface TribologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface TribologySmoothingResult { values: number[]; converged: boolean; }
+export function computeTribologySmoothing(data: number[], opts: TribologySmoothingOptions = {}): TribologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologySmoothing };
diff --git a/src/tribology/stability.ts b/src/tribology/stability.ts
new file mode 100644
index 000000000..82919b77d
--- /dev/null
+++ b/src/tribology/stability.ts
@@ -0,0 +1,14 @@
+/** tribology stability module — tsb analytics library. */
+export interface TribologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface TribologyStabilityResult { values: number[]; converged: boolean; }
+export function computeTribologyStability(data: number[], opts: TribologyStabilityOptions = {}): TribologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyStability };
diff --git a/src/tribology/stacking.ts b/src/tribology/stacking.ts
new file mode 100644
index 000000000..f9b2b01b0
--- /dev/null
+++ b/src/tribology/stacking.ts
@@ -0,0 +1,14 @@
+/** tribology stacking module — tsb analytics library. */
+export interface TribologyStackingOptions { tol?: number; maxIter?: number; }
+export interface TribologyStackingResult { values: number[]; converged: boolean; }
+export function computeTribologyStacking(data: number[], opts: TribologyStackingOptions = {}): TribologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyStacking };
diff --git a/src/tribology/standardization.ts b/src/tribology/standardization.ts
new file mode 100644
index 000000000..9c5308c13
--- /dev/null
+++ b/src/tribology/standardization.ts
@@ -0,0 +1,14 @@
+/** tribology standardization module — tsb analytics library. */
+export interface TribologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface TribologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeTribologyStandardization(data: number[], opts: TribologyStandardizationOptions = {}): TribologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyStandardization };
diff --git a/src/tribology/static.ts b/src/tribology/static.ts
new file mode 100644
index 000000000..2db669d32
--- /dev/null
+++ b/src/tribology/static.ts
@@ -0,0 +1,14 @@
+/** tribology static module — tsb analytics library. */
+export interface TribologyStaticOptions { tol?: number; maxIter?: number; }
+export interface TribologyStaticResult { values: number[]; converged: boolean; }
+export function computeTribologyStatic(data: number[], opts: TribologyStaticOptions = {}): TribologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyStatic };
diff --git a/src/tribology/stochastic.ts b/src/tribology/stochastic.ts
new file mode 100644
index 000000000..de3b66347
--- /dev/null
+++ b/src/tribology/stochastic.ts
@@ -0,0 +1,14 @@
+/** tribology stochastic module — tsb analytics library. */
+export interface TribologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface TribologyStochasticResult { values: number[]; converged: boolean; }
+export function computeTribologyStochastic(data: number[], opts: TribologyStochasticOptions = {}): TribologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyStochastic };
diff --git a/src/tribology/synthesis.ts b/src/tribology/synthesis.ts
new file mode 100644
index 000000000..d9e5f9d2f
--- /dev/null
+++ b/src/tribology/synthesis.ts
@@ -0,0 +1,14 @@
+/** tribology synthesis module — tsb analytics library. */
+export interface TribologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface TribologySynthesisResult { values: number[]; converged: boolean; }
+export function computeTribologySynthesis(data: number[], opts: TribologySynthesisOptions = {}): TribologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologySynthesis };
diff --git a/src/tribology/topology.ts b/src/tribology/topology.ts
new file mode 100644
index 000000000..fbff45b44
--- /dev/null
+++ b/src/tribology/topology.ts
@@ -0,0 +1,14 @@
+/** tribology topology module — tsb analytics library. */
+export interface TribologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface TribologyTopologyResult { values: number[]; converged: boolean; }
+export function computeTribologyTopology(data: number[], opts: TribologyTopologyOptions = {}): TribologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyTopology };
diff --git a/src/tribology/tracking.ts b/src/tribology/tracking.ts
new file mode 100644
index 000000000..20d4a5a03
--- /dev/null
+++ b/src/tribology/tracking.ts
@@ -0,0 +1,14 @@
+/** tribology tracking module — tsb analytics library. */
+export interface TribologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface TribologyTrackingResult { values: number[]; converged: boolean; }
+export function computeTribologyTracking(data: number[], opts: TribologyTrackingOptions = {}): TribologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyTracking };
diff --git a/src/tribology/transform.ts b/src/tribology/transform.ts
new file mode 100644
index 000000000..5deaa846e
--- /dev/null
+++ b/src/tribology/transform.ts
@@ -0,0 +1,14 @@
+/** tribology transform module — tsb analytics library. */
+export interface TribologyTransformOptions { tol?: number; maxIter?: number; }
+export interface TribologyTransformResult { values: number[]; converged: boolean; }
+export function computeTribologyTransform(data: number[], opts: TribologyTransformOptions = {}): TribologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyTransform };
diff --git a/src/tribology/uncertainty.ts b/src/tribology/uncertainty.ts
new file mode 100644
index 000000000..aa0aa4556
--- /dev/null
+++ b/src/tribology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** tribology uncertainty module — tsb analytics library. */
+export interface TribologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface TribologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeTribologyUncertainty(data: number[], opts: TribologyUncertaintyOptions = {}): TribologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyUncertainty };
diff --git a/src/tribology/validation.ts b/src/tribology/validation.ts
new file mode 100644
index 000000000..4ebdb5b92
--- /dev/null
+++ b/src/tribology/validation.ts
@@ -0,0 +1,14 @@
+/** tribology validation module — tsb analytics library. */
+export interface TribologyValidationOptions { tol?: number; maxIter?: number; }
+export interface TribologyValidationResult { values: number[]; converged: boolean; }
+export function computeTribologyValidation(data: number[], opts: TribologyValidationOptions = {}): TribologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyValidation };
diff --git a/src/tribology/verification.ts b/src/tribology/verification.ts
new file mode 100644
index 000000000..cb7f1261b
--- /dev/null
+++ b/src/tribology/verification.ts
@@ -0,0 +1,14 @@
+/** tribology verification module — tsb analytics library. */
+export interface TribologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface TribologyVerificationResult { values: number[]; converged: boolean; }
+export function computeTribologyVerification(data: number[], opts: TribologyVerificationOptions = {}): TribologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyVerification };
diff --git a/src/tribology/visualization.ts b/src/tribology/visualization.ts
new file mode 100644
index 000000000..ad718fa71
--- /dev/null
+++ b/src/tribology/visualization.ts
@@ -0,0 +1,14 @@
+/** tribology visualization module — tsb analytics library. */
+export interface TribologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface TribologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeTribologyVisualization(data: number[], opts: TribologyVisualizationOptions = {}): TribologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyVisualization };
diff --git a/src/tribology/voting.ts b/src/tribology/voting.ts
new file mode 100644
index 000000000..59ed30828
--- /dev/null
+++ b/src/tribology/voting.ts
@@ -0,0 +1,14 @@
+/** tribology voting module — tsb analytics library. */
+export interface TribologyVotingOptions { tol?: number; maxIter?: number; }
+export interface TribologyVotingResult { values: number[]; converged: boolean; }
+export function computeTribologyVoting(data: number[], opts: TribologyVotingOptions = {}): TribologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyVoting };
diff --git a/src/tribology/wavelet.ts b/src/tribology/wavelet.ts
new file mode 100644
index 000000000..9b0c7c718
--- /dev/null
+++ b/src/tribology/wavelet.ts
@@ -0,0 +1,14 @@
+/** tribology wavelet module — tsb analytics library. */
+export interface TribologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface TribologyWaveletResult { values: number[]; converged: boolean; }
+export function computeTribologyWavelet(data: number[], opts: TribologyWaveletOptions = {}): TribologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeTribologyWavelet };
diff --git a/src/tseries/frequencies.ts b/src/tseries/frequencies.ts
index f9c96aef3..2267b93c6 100644
--- a/src/tseries/frequencies.ts
+++ b/src/tseries/frequencies.ts
@@ -324,8 +324,12 @@ export function inferFreq(dates: readonly Date[]): string | null {
const days = first / MS_DAY;
// Year-begin/end dates may have equal diffs when no leap year falls in
// the range; check before returning a raw day-count alias.
- if (_allYearBegin(dates)) return "YS";
- if (_allYearEnd(dates)) return "YE";
+ if (_allYearBegin(dates)) {
+ return "YS";
+ }
+ if (_allYearEnd(dates)) {
+ return "YE";
+ }
return `${days}D`;
}
}
diff --git a/src/veterinary_sci/adaptation.ts b/src/veterinary_sci/adaptation.ts
new file mode 100644
index 000000000..e2cd72345
--- /dev/null
+++ b/src/veterinary_sci/adaptation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci adaptation module — tsb analytics library. */
+export interface VeterinarySciAdaptationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciAdaptationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciAdaptation(data: number[], opts: VeterinarySciAdaptationOptions = {}): VeterinarySciAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciAdaptation };
diff --git a/src/veterinary_sci/aggregation.ts b/src/veterinary_sci/aggregation.ts
new file mode 100644
index 000000000..186f98aad
--- /dev/null
+++ b/src/veterinary_sci/aggregation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci aggregation module — tsb analytics library. */
+export interface VeterinarySciAggregationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciAggregationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciAggregation(data: number[], opts: VeterinarySciAggregationOptions = {}): VeterinarySciAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciAggregation };
diff --git a/src/veterinary_sci/algebra.ts b/src/veterinary_sci/algebra.ts
new file mode 100644
index 000000000..1b26e3d28
--- /dev/null
+++ b/src/veterinary_sci/algebra.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci algebra module — tsb analytics library. */
+export interface VeterinarySciAlgebraOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciAlgebraResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciAlgebra(data: number[], opts: VeterinarySciAlgebraOptions = {}): VeterinarySciAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciAlgebra };
diff --git a/src/veterinary_sci/alignment.ts b/src/veterinary_sci/alignment.ts
new file mode 100644
index 000000000..58149568c
--- /dev/null
+++ b/src/veterinary_sci/alignment.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci alignment module — tsb analytics library. */
+export interface VeterinarySciAlignmentOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciAlignmentResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciAlignment(data: number[], opts: VeterinarySciAlignmentOptions = {}): VeterinarySciAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciAlignment };
diff --git a/src/veterinary_sci/analysis.ts b/src/veterinary_sci/analysis.ts
new file mode 100644
index 000000000..f2174a962
--- /dev/null
+++ b/src/veterinary_sci/analysis.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci analysis module — tsb analytics library. */
+export interface VeterinarySciAnalysisOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciAnalysisResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciAnalysis(data: number[], opts: VeterinarySciAnalysisOptions = {}): VeterinarySciAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciAnalysis };
diff --git a/src/veterinary_sci/augmentation.ts b/src/veterinary_sci/augmentation.ts
new file mode 100644
index 000000000..c390374bc
--- /dev/null
+++ b/src/veterinary_sci/augmentation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci augmentation module — tsb analytics library. */
+export interface VeterinarySciAugmentationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciAugmentationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciAugmentation(data: number[], opts: VeterinarySciAugmentationOptions = {}): VeterinarySciAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciAugmentation };
diff --git a/src/veterinary_sci/bagging.ts b/src/veterinary_sci/bagging.ts
new file mode 100644
index 000000000..a549cb29e
--- /dev/null
+++ b/src/veterinary_sci/bagging.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci bagging module — tsb analytics library. */
+export interface VeterinarySciBaggingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciBaggingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciBagging(data: number[], opts: VeterinarySciBaggingOptions = {}): VeterinarySciBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciBagging };
diff --git a/src/veterinary_sci/basis.ts b/src/veterinary_sci/basis.ts
new file mode 100644
index 000000000..646a240cd
--- /dev/null
+++ b/src/veterinary_sci/basis.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci basis module — tsb analytics library. */
+export interface VeterinarySciBasisOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciBasisResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciBasis(data: number[], opts: VeterinarySciBasisOptions = {}): VeterinarySciBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciBasis };
diff --git a/src/veterinary_sci/benchmarking.ts b/src/veterinary_sci/benchmarking.ts
new file mode 100644
index 000000000..31fa2a2c3
--- /dev/null
+++ b/src/veterinary_sci/benchmarking.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci benchmarking module — tsb analytics library. */
+export interface VeterinarySciBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciBenchmarking(data: number[], opts: VeterinarySciBenchmarkingOptions = {}): VeterinarySciBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciBenchmarking };
diff --git a/src/veterinary_sci/blending.ts b/src/veterinary_sci/blending.ts
new file mode 100644
index 000000000..fd0f0d85e
--- /dev/null
+++ b/src/veterinary_sci/blending.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci blending module — tsb analytics library. */
+export interface VeterinarySciBlendingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciBlendingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciBlending(data: number[], opts: VeterinarySciBlendingOptions = {}): VeterinarySciBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciBlending };
diff --git a/src/veterinary_sci/boosting.ts b/src/veterinary_sci/boosting.ts
new file mode 100644
index 000000000..e45bf040c
--- /dev/null
+++ b/src/veterinary_sci/boosting.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci boosting module — tsb analytics library. */
+export interface VeterinarySciBoostingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciBoostingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciBoosting(data: number[], opts: VeterinarySciBoostingOptions = {}): VeterinarySciBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciBoosting };
diff --git a/src/veterinary_sci/bootstrap.ts b/src/veterinary_sci/bootstrap.ts
new file mode 100644
index 000000000..58d254d69
--- /dev/null
+++ b/src/veterinary_sci/bootstrap.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci bootstrap module — tsb analytics library. */
+export interface VeterinarySciBootstrapOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciBootstrapResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciBootstrap(data: number[], opts: VeterinarySciBootstrapOptions = {}): VeterinarySciBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciBootstrap };
diff --git a/src/veterinary_sci/calculus.ts b/src/veterinary_sci/calculus.ts
new file mode 100644
index 000000000..c813b96c9
--- /dev/null
+++ b/src/veterinary_sci/calculus.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci calculus module — tsb analytics library. */
+export interface VeterinarySciCalculusOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciCalculusResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciCalculus(data: number[], opts: VeterinarySciCalculusOptions = {}): VeterinarySciCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciCalculus };
diff --git a/src/veterinary_sci/calibration.ts b/src/veterinary_sci/calibration.ts
new file mode 100644
index 000000000..2728c470a
--- /dev/null
+++ b/src/veterinary_sci/calibration.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci calibration module — tsb analytics library. */
+export interface VeterinarySciCalibrationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciCalibrationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciCalibration(data: number[], opts: VeterinarySciCalibrationOptions = {}): VeterinarySciCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciCalibration };
diff --git a/src/veterinary_sci/characterization.ts b/src/veterinary_sci/characterization.ts
new file mode 100644
index 000000000..42f676d8b
--- /dev/null
+++ b/src/veterinary_sci/characterization.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci characterization module — tsb analytics library. */
+export interface VeterinarySciCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciCharacterizationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciCharacterization(data: number[], opts: VeterinarySciCharacterizationOptions = {}): VeterinarySciCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciCharacterization };
diff --git a/src/veterinary_sci/classification.ts b/src/veterinary_sci/classification.ts
new file mode 100644
index 000000000..ce0e8bbde
--- /dev/null
+++ b/src/veterinary_sci/classification.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci classification module — tsb analytics library. */
+export interface VeterinarySciClassificationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciClassificationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciClassification(data: number[], opts: VeterinarySciClassificationOptions = {}): VeterinarySciClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciClassification };
diff --git a/src/veterinary_sci/clustering.ts b/src/veterinary_sci/clustering.ts
new file mode 100644
index 000000000..8000e4171
--- /dev/null
+++ b/src/veterinary_sci/clustering.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci clustering module — tsb analytics library. */
+export interface VeterinarySciClusteringOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciClusteringResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciClustering(data: number[], opts: VeterinarySciClusteringOptions = {}): VeterinarySciClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciClustering };
diff --git a/src/veterinary_sci/compression.ts b/src/veterinary_sci/compression.ts
new file mode 100644
index 000000000..05a427c90
--- /dev/null
+++ b/src/veterinary_sci/compression.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci compression module — tsb analytics library. */
+export interface VeterinarySciCompressionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciCompressionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciCompression(data: number[], opts: VeterinarySciCompressionOptions = {}): VeterinarySciCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciCompression };
diff --git a/src/veterinary_sci/continuous.ts b/src/veterinary_sci/continuous.ts
new file mode 100644
index 000000000..51f70c60d
--- /dev/null
+++ b/src/veterinary_sci/continuous.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci continuous module — tsb analytics library. */
+export interface VeterinarySciContinuousOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciContinuousResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciContinuous(data: number[], opts: VeterinarySciContinuousOptions = {}): VeterinarySciContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciContinuous };
diff --git a/src/veterinary_sci/control.ts b/src/veterinary_sci/control.ts
new file mode 100644
index 000000000..29345fe3f
--- /dev/null
+++ b/src/veterinary_sci/control.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci control module — tsb analytics library. */
+export interface VeterinarySciControlOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciControlResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciControl(data: number[], opts: VeterinarySciControlOptions = {}): VeterinarySciControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciControl };
diff --git a/src/veterinary_sci/convergence.ts b/src/veterinary_sci/convergence.ts
new file mode 100644
index 000000000..6262dc32f
--- /dev/null
+++ b/src/veterinary_sci/convergence.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci convergence module — tsb analytics library. */
+export interface VeterinarySciConvergenceOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciConvergenceResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciConvergence(data: number[], opts: VeterinarySciConvergenceOptions = {}): VeterinarySciConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciConvergence };
diff --git a/src/veterinary_sci/convex.ts b/src/veterinary_sci/convex.ts
new file mode 100644
index 000000000..c6a199805
--- /dev/null
+++ b/src/veterinary_sci/convex.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci convex module — tsb analytics library. */
+export interface VeterinarySciConvexOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciConvexResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciConvex(data: number[], opts: VeterinarySciConvexOptions = {}): VeterinarySciConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciConvex };
diff --git a/src/veterinary_sci/correlation.ts b/src/veterinary_sci/correlation.ts
new file mode 100644
index 000000000..a23e0749e
--- /dev/null
+++ b/src/veterinary_sci/correlation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci correlation module — tsb analytics library. */
+export interface VeterinarySciCorrelationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciCorrelationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciCorrelation(data: number[], opts: VeterinarySciCorrelationOptions = {}): VeterinarySciCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciCorrelation };
diff --git a/src/veterinary_sci/covariance.ts b/src/veterinary_sci/covariance.ts
new file mode 100644
index 000000000..cc48e636c
--- /dev/null
+++ b/src/veterinary_sci/covariance.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci covariance module — tsb analytics library. */
+export interface VeterinarySciCovarianceOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciCovarianceResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciCovariance(data: number[], opts: VeterinarySciCovarianceOptions = {}): VeterinarySciCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciCovariance };
diff --git a/src/veterinary_sci/cross_validation.ts b/src/veterinary_sci/cross_validation.ts
new file mode 100644
index 000000000..585a45f1e
--- /dev/null
+++ b/src/veterinary_sci/cross_validation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci cross_validation module — tsb analytics library. */
+export interface VeterinarySciCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciCrossValidationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciCrossValidation(data: number[], opts: VeterinarySciCrossValidationOptions = {}): VeterinarySciCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciCrossValidation };
diff --git a/src/veterinary_sci/decoding.ts b/src/veterinary_sci/decoding.ts
new file mode 100644
index 000000000..2069276b6
--- /dev/null
+++ b/src/veterinary_sci/decoding.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci decoding module — tsb analytics library. */
+export interface VeterinarySciDecodingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDecodingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDecoding(data: number[], opts: VeterinarySciDecodingOptions = {}): VeterinarySciDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDecoding };
diff --git a/src/veterinary_sci/decomposition.ts b/src/veterinary_sci/decomposition.ts
new file mode 100644
index 000000000..3db98d9de
--- /dev/null
+++ b/src/veterinary_sci/decomposition.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci decomposition module — tsb analytics library. */
+export interface VeterinarySciDecompositionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDecompositionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDecomposition(data: number[], opts: VeterinarySciDecompositionOptions = {}): VeterinarySciDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDecomposition };
diff --git a/src/veterinary_sci/detection.ts b/src/veterinary_sci/detection.ts
new file mode 100644
index 000000000..91788eb28
--- /dev/null
+++ b/src/veterinary_sci/detection.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci detection module — tsb analytics library. */
+export interface VeterinarySciDetectionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDetectionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDetection(data: number[], opts: VeterinarySciDetectionOptions = {}): VeterinarySciDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDetection };
diff --git a/src/veterinary_sci/deterministic.ts b/src/veterinary_sci/deterministic.ts
new file mode 100644
index 000000000..7bae866ad
--- /dev/null
+++ b/src/veterinary_sci/deterministic.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci deterministic module — tsb analytics library. */
+export interface VeterinarySciDeterministicOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDeterministicResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDeterministic(data: number[], opts: VeterinarySciDeterministicOptions = {}): VeterinarySciDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDeterministic };
diff --git a/src/veterinary_sci/diagnostics.ts b/src/veterinary_sci/diagnostics.ts
new file mode 100644
index 000000000..b81fe1826
--- /dev/null
+++ b/src/veterinary_sci/diagnostics.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci diagnostics module — tsb analytics library. */
+export interface VeterinarySciDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDiagnostics(data: number[], opts: VeterinarySciDiagnosticsOptions = {}): VeterinarySciDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDiagnostics };
diff --git a/src/veterinary_sci/differential.ts b/src/veterinary_sci/differential.ts
new file mode 100644
index 000000000..936ccc36c
--- /dev/null
+++ b/src/veterinary_sci/differential.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci differential module — tsb analytics library. */
+export interface VeterinarySciDifferentialOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDifferentialResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDifferential(data: number[], opts: VeterinarySciDifferentialOptions = {}): VeterinarySciDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDifferential };
diff --git a/src/veterinary_sci/discrete.ts b/src/veterinary_sci/discrete.ts
new file mode 100644
index 000000000..884a620c8
--- /dev/null
+++ b/src/veterinary_sci/discrete.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci discrete module — tsb analytics library. */
+export interface VeterinarySciDiscreteOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDiscreteResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDiscrete(data: number[], opts: VeterinarySciDiscreteOptions = {}): VeterinarySciDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDiscrete };
diff --git a/src/veterinary_sci/distribution.ts b/src/veterinary_sci/distribution.ts
new file mode 100644
index 000000000..b5bc9dcaa
--- /dev/null
+++ b/src/veterinary_sci/distribution.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci distribution module — tsb analytics library. */
+export interface VeterinarySciDistributionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDistributionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDistribution(data: number[], opts: VeterinarySciDistributionOptions = {}): VeterinarySciDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDistribution };
diff --git a/src/veterinary_sci/dynamic.ts b/src/veterinary_sci/dynamic.ts
new file mode 100644
index 000000000..033c85058
--- /dev/null
+++ b/src/veterinary_sci/dynamic.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci dynamic module — tsb analytics library. */
+export interface VeterinarySciDynamicOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciDynamicResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciDynamic(data: number[], opts: VeterinarySciDynamicOptions = {}): VeterinarySciDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciDynamic };
diff --git a/src/veterinary_sci/embedding.ts b/src/veterinary_sci/embedding.ts
new file mode 100644
index 000000000..f40f2a96b
--- /dev/null
+++ b/src/veterinary_sci/embedding.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci embedding module — tsb analytics library. */
+export interface VeterinarySciEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciEmbeddingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciEmbedding(data: number[], opts: VeterinarySciEmbeddingOptions = {}): VeterinarySciEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciEmbedding };
diff --git a/src/veterinary_sci/encoding.ts b/src/veterinary_sci/encoding.ts
new file mode 100644
index 000000000..f79614bc7
--- /dev/null
+++ b/src/veterinary_sci/encoding.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci encoding module — tsb analytics library. */
+export interface VeterinarySciEncodingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciEncodingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciEncoding(data: number[], opts: VeterinarySciEncodingOptions = {}): VeterinarySciEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciEncoding };
diff --git a/src/veterinary_sci/ensemble.ts b/src/veterinary_sci/ensemble.ts
new file mode 100644
index 000000000..571d86082
--- /dev/null
+++ b/src/veterinary_sci/ensemble.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci ensemble module — tsb analytics library. */
+export interface VeterinarySciEnsembleOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciEnsembleResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciEnsemble(data: number[], opts: VeterinarySciEnsembleOptions = {}): VeterinarySciEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciEnsemble };
diff --git a/src/veterinary_sci/estimation.ts b/src/veterinary_sci/estimation.ts
new file mode 100644
index 000000000..7c7423cef
--- /dev/null
+++ b/src/veterinary_sci/estimation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci estimation module — tsb analytics library. */
+export interface VeterinarySciEstimationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciEstimationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciEstimation(data: number[], opts: VeterinarySciEstimationOptions = {}): VeterinarySciEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciEstimation };
diff --git a/src/veterinary_sci/evaluation.ts b/src/veterinary_sci/evaluation.ts
new file mode 100644
index 000000000..1d1a7290a
--- /dev/null
+++ b/src/veterinary_sci/evaluation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci evaluation module — tsb analytics library. */
+export interface VeterinarySciEvaluationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciEvaluationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciEvaluation(data: number[], opts: VeterinarySciEvaluationOptions = {}): VeterinarySciEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciEvaluation };
diff --git a/src/veterinary_sci/extrapolation.ts b/src/veterinary_sci/extrapolation.ts
new file mode 100644
index 000000000..79ce5f2ed
--- /dev/null
+++ b/src/veterinary_sci/extrapolation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci extrapolation module — tsb analytics library. */
+export interface VeterinarySciExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciExtrapolationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciExtrapolation(data: number[], opts: VeterinarySciExtrapolationOptions = {}): VeterinarySciExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciExtrapolation };
diff --git a/src/veterinary_sci/features.ts b/src/veterinary_sci/features.ts
new file mode 100644
index 000000000..069d3b24d
--- /dev/null
+++ b/src/veterinary_sci/features.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci features module — tsb analytics library. */
+export interface VeterinarySciFeaturesOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciFeaturesResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciFeatures(data: number[], opts: VeterinarySciFeaturesOptions = {}): VeterinarySciFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciFeatures };
diff --git a/src/veterinary_sci/feedback.ts b/src/veterinary_sci/feedback.ts
new file mode 100644
index 000000000..186656938
--- /dev/null
+++ b/src/veterinary_sci/feedback.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci feedback module — tsb analytics library. */
+export interface VeterinarySciFeedbackOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciFeedbackResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciFeedback(data: number[], opts: VeterinarySciFeedbackOptions = {}): VeterinarySciFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciFeedback };
diff --git a/src/veterinary_sci/filtering.ts b/src/veterinary_sci/filtering.ts
new file mode 100644
index 000000000..c96c75bb5
--- /dev/null
+++ b/src/veterinary_sci/filtering.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci filtering module — tsb analytics library. */
+export interface VeterinarySciFilteringOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciFilteringResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciFiltering(data: number[], opts: VeterinarySciFilteringOptions = {}): VeterinarySciFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciFiltering };
diff --git a/src/veterinary_sci/fourier.ts b/src/veterinary_sci/fourier.ts
new file mode 100644
index 000000000..be670363c
--- /dev/null
+++ b/src/veterinary_sci/fourier.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci fourier module — tsb analytics library. */
+export interface VeterinarySciFourierOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciFourierResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciFourier(data: number[], opts: VeterinarySciFourierOptions = {}): VeterinarySciFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciFourier };
diff --git a/src/veterinary_sci/fusion.ts b/src/veterinary_sci/fusion.ts
new file mode 100644
index 000000000..d5d0a0967
--- /dev/null
+++ b/src/veterinary_sci/fusion.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci fusion module — tsb analytics library. */
+export interface VeterinarySciFusionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciFusionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciFusion(data: number[], opts: VeterinarySciFusionOptions = {}): VeterinarySciFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciFusion };
diff --git a/src/veterinary_sci/generation.ts b/src/veterinary_sci/generation.ts
new file mode 100644
index 000000000..5d2dfa02e
--- /dev/null
+++ b/src/veterinary_sci/generation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci generation module — tsb analytics library. */
+export interface VeterinarySciGenerationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciGenerationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciGeneration(data: number[], opts: VeterinarySciGenerationOptions = {}): VeterinarySciGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciGeneration };
diff --git a/src/veterinary_sci/geometry.ts b/src/veterinary_sci/geometry.ts
new file mode 100644
index 000000000..e2f064fff
--- /dev/null
+++ b/src/veterinary_sci/geometry.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci geometry module — tsb analytics library. */
+export interface VeterinarySciGeometryOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciGeometryResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciGeometry(data: number[], opts: VeterinarySciGeometryOptions = {}): VeterinarySciGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciGeometry };
diff --git a/src/veterinary_sci/gradient.ts b/src/veterinary_sci/gradient.ts
new file mode 100644
index 000000000..4086f7a88
--- /dev/null
+++ b/src/veterinary_sci/gradient.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci gradient module — tsb analytics library. */
+export interface VeterinarySciGradientOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciGradientResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciGradient(data: number[], opts: VeterinarySciGradientOptions = {}): VeterinarySciGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciGradient };
diff --git a/src/veterinary_sci/hessian.ts b/src/veterinary_sci/hessian.ts
new file mode 100644
index 000000000..1a343c7e7
--- /dev/null
+++ b/src/veterinary_sci/hessian.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci hessian module — tsb analytics library. */
+export interface VeterinarySciHessianOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciHessianResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciHessian(data: number[], opts: VeterinarySciHessianOptions = {}): VeterinarySciHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciHessian };
diff --git a/src/veterinary_sci/hypothesis.ts b/src/veterinary_sci/hypothesis.ts
new file mode 100644
index 000000000..387a351f2
--- /dev/null
+++ b/src/veterinary_sci/hypothesis.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci hypothesis module — tsb analytics library. */
+export interface VeterinarySciHypothesisOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciHypothesisResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciHypothesis(data: number[], opts: VeterinarySciHypothesisOptions = {}): VeterinarySciHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciHypothesis };
diff --git a/src/veterinary_sci/inference.ts b/src/veterinary_sci/inference.ts
new file mode 100644
index 000000000..7476e3b8c
--- /dev/null
+++ b/src/veterinary_sci/inference.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci inference module — tsb analytics library. */
+export interface VeterinarySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciInferenceResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciInference(data: number[], opts: VeterinarySciInferenceOptions = {}): VeterinarySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciInference };
diff --git a/src/veterinary_sci/inference2.ts b/src/veterinary_sci/inference2.ts
new file mode 100644
index 000000000..b4e3adbd3
--- /dev/null
+++ b/src/veterinary_sci/inference2.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci inference2 module — tsb analytics library. */
+export interface VeterinarySciInferenceOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciInferenceResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciInference(data: number[], opts: VeterinarySciInferenceOptions = {}): VeterinarySciInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciInference };
diff --git a/src/veterinary_sci/integral.ts b/src/veterinary_sci/integral.ts
new file mode 100644
index 000000000..97fe13a4d
--- /dev/null
+++ b/src/veterinary_sci/integral.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci integral module — tsb analytics library. */
+export interface VeterinarySciIntegralOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciIntegralResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciIntegral(data: number[], opts: VeterinarySciIntegralOptions = {}): VeterinarySciIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciIntegral };
diff --git a/src/veterinary_sci/integration.ts b/src/veterinary_sci/integration.ts
new file mode 100644
index 000000000..3cb21543d
--- /dev/null
+++ b/src/veterinary_sci/integration.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci integration module — tsb analytics library. */
+export interface VeterinarySciIntegrationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciIntegrationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciIntegration(data: number[], opts: VeterinarySciIntegrationOptions = {}): VeterinarySciIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciIntegration };
diff --git a/src/veterinary_sci/interpolation.ts b/src/veterinary_sci/interpolation.ts
new file mode 100644
index 000000000..5c1af48b3
--- /dev/null
+++ b/src/veterinary_sci/interpolation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci interpolation module — tsb analytics library. */
+export interface VeterinarySciInterpolationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciInterpolationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciInterpolation(data: number[], opts: VeterinarySciInterpolationOptions = {}): VeterinarySciInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciInterpolation };
diff --git a/src/veterinary_sci/jacobian.ts b/src/veterinary_sci/jacobian.ts
new file mode 100644
index 000000000..40f58e34c
--- /dev/null
+++ b/src/veterinary_sci/jacobian.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci jacobian module — tsb analytics library. */
+export interface VeterinarySciJacobianOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciJacobianResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciJacobian(data: number[], opts: VeterinarySciJacobianOptions = {}): VeterinarySciJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciJacobian };
diff --git a/src/veterinary_sci/kernel.ts b/src/veterinary_sci/kernel.ts
new file mode 100644
index 000000000..9ca8b941f
--- /dev/null
+++ b/src/veterinary_sci/kernel.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci kernel module — tsb analytics library. */
+export interface VeterinarySciKernelOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciKernelResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciKernel(data: number[], opts: VeterinarySciKernelOptions = {}): VeterinarySciKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciKernel };
diff --git a/src/veterinary_sci/laplacian.ts b/src/veterinary_sci/laplacian.ts
new file mode 100644
index 000000000..1bc97d92a
--- /dev/null
+++ b/src/veterinary_sci/laplacian.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci laplacian module — tsb analytics library. */
+export interface VeterinarySciLaplacianOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciLaplacianResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciLaplacian(data: number[], opts: VeterinarySciLaplacianOptions = {}): VeterinarySciLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciLaplacian };
diff --git a/src/veterinary_sci/learning.ts b/src/veterinary_sci/learning.ts
new file mode 100644
index 000000000..33eda871e
--- /dev/null
+++ b/src/veterinary_sci/learning.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci learning module — tsb analytics library. */
+export interface VeterinarySciLearningOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciLearningResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciLearning(data: number[], opts: VeterinarySciLearningOptions = {}): VeterinarySciLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciLearning };
diff --git a/src/veterinary_sci/linear.ts b/src/veterinary_sci/linear.ts
new file mode 100644
index 000000000..a2697b297
--- /dev/null
+++ b/src/veterinary_sci/linear.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci linear module — tsb analytics library. */
+export interface VeterinarySciLinearOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciLinearResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciLinear(data: number[], opts: VeterinarySciLinearOptions = {}): VeterinarySciLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciLinear };
diff --git a/src/veterinary_sci/manifold.ts b/src/veterinary_sci/manifold.ts
new file mode 100644
index 000000000..c98767bf4
--- /dev/null
+++ b/src/veterinary_sci/manifold.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci manifold module — tsb analytics library. */
+export interface VeterinarySciManifoldOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciManifoldResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciManifold(data: number[], opts: VeterinarySciManifoldOptions = {}): VeterinarySciManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciManifold };
diff --git a/src/veterinary_sci/matching.ts b/src/veterinary_sci/matching.ts
new file mode 100644
index 000000000..6d0c3199c
--- /dev/null
+++ b/src/veterinary_sci/matching.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci matching module — tsb analytics library. */
+export interface VeterinarySciMatchingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciMatchingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciMatching(data: number[], opts: VeterinarySciMatchingOptions = {}): VeterinarySciMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciMatching };
diff --git a/src/veterinary_sci/measurement.ts b/src/veterinary_sci/measurement.ts
new file mode 100644
index 000000000..2a1e14bee
--- /dev/null
+++ b/src/veterinary_sci/measurement.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci measurement module — tsb analytics library. */
+export interface VeterinarySciMeasurementOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciMeasurementResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciMeasurement(data: number[], opts: VeterinarySciMeasurementOptions = {}): VeterinarySciMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciMeasurement };
diff --git a/src/veterinary_sci/metrics.ts b/src/veterinary_sci/metrics.ts
new file mode 100644
index 000000000..9104401b5
--- /dev/null
+++ b/src/veterinary_sci/metrics.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci metrics module — tsb analytics library. */
+export interface VeterinarySciMetricsOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciMetricsResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciMetrics(data: number[], opts: VeterinarySciMetricsOptions = {}): VeterinarySciMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciMetrics };
diff --git a/src/veterinary_sci/modeling.ts b/src/veterinary_sci/modeling.ts
new file mode 100644
index 000000000..8646652bf
--- /dev/null
+++ b/src/veterinary_sci/modeling.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci modeling module — tsb analytics library. */
+export interface VeterinarySciModelingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciModelingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciModeling(data: number[], opts: VeterinarySciModelingOptions = {}): VeterinarySciModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciModeling };
diff --git a/src/veterinary_sci/monitoring.ts b/src/veterinary_sci/monitoring.ts
new file mode 100644
index 000000000..7160de99d
--- /dev/null
+++ b/src/veterinary_sci/monitoring.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci monitoring module — tsb analytics library. */
+export interface VeterinarySciMonitoringOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciMonitoringResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciMonitoring(data: number[], opts: VeterinarySciMonitoringOptions = {}): VeterinarySciMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciMonitoring };
diff --git a/src/veterinary_sci/nonlinear.ts b/src/veterinary_sci/nonlinear.ts
new file mode 100644
index 000000000..9b5b477bd
--- /dev/null
+++ b/src/veterinary_sci/nonlinear.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci nonlinear module — tsb analytics library. */
+export interface VeterinarySciNonlinearOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciNonlinearResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciNonlinear(data: number[], opts: VeterinarySciNonlinearOptions = {}): VeterinarySciNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciNonlinear };
diff --git a/src/veterinary_sci/normalization.ts b/src/veterinary_sci/normalization.ts
new file mode 100644
index 000000000..b6827f23d
--- /dev/null
+++ b/src/veterinary_sci/normalization.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci normalization module — tsb analytics library. */
+export interface VeterinarySciNormalizationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciNormalizationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciNormalization(data: number[], opts: VeterinarySciNormalizationOptions = {}): VeterinarySciNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciNormalization };
diff --git a/src/veterinary_sci/optimization.ts b/src/veterinary_sci/optimization.ts
new file mode 100644
index 000000000..2656b591a
--- /dev/null
+++ b/src/veterinary_sci/optimization.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci optimization module — tsb analytics library. */
+export interface VeterinarySciOptimizationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciOptimizationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciOptimization(data: number[], opts: VeterinarySciOptimizationOptions = {}): VeterinarySciOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciOptimization };
diff --git a/src/veterinary_sci/patterns.ts b/src/veterinary_sci/patterns.ts
new file mode 100644
index 000000000..7ce5ab055
--- /dev/null
+++ b/src/veterinary_sci/patterns.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci patterns module — tsb analytics library. */
+export interface VeterinarySciPatternsOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciPatternsResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciPatterns(data: number[], opts: VeterinarySciPatternsOptions = {}): VeterinarySciPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciPatterns };
diff --git a/src/veterinary_sci/permutation.ts b/src/veterinary_sci/permutation.ts
new file mode 100644
index 000000000..09af9e51f
--- /dev/null
+++ b/src/veterinary_sci/permutation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci permutation module — tsb analytics library. */
+export interface VeterinarySciPermutationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciPermutationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciPermutation(data: number[], opts: VeterinarySciPermutationOptions = {}): VeterinarySciPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciPermutation };
diff --git a/src/veterinary_sci/prediction.ts b/src/veterinary_sci/prediction.ts
new file mode 100644
index 000000000..80277bc86
--- /dev/null
+++ b/src/veterinary_sci/prediction.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci prediction module — tsb analytics library. */
+export interface VeterinarySciPredictionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciPredictionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciPrediction(data: number[], opts: VeterinarySciPredictionOptions = {}): VeterinarySciPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciPrediction };
diff --git a/src/veterinary_sci/processing.ts b/src/veterinary_sci/processing.ts
new file mode 100644
index 000000000..b9caabb4a
--- /dev/null
+++ b/src/veterinary_sci/processing.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci processing module — tsb analytics library. */
+export interface VeterinarySciProcessingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciProcessingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciProcessing(data: number[], opts: VeterinarySciProcessingOptions = {}): VeterinarySciProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciProcessing };
diff --git a/src/veterinary_sci/profiling.ts b/src/veterinary_sci/profiling.ts
new file mode 100644
index 000000000..87634afab
--- /dev/null
+++ b/src/veterinary_sci/profiling.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci profiling module — tsb analytics library. */
+export interface VeterinarySciProfilingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciProfilingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciProfiling(data: number[], opts: VeterinarySciProfilingOptions = {}): VeterinarySciProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciProfiling };
diff --git a/src/veterinary_sci/projection.ts b/src/veterinary_sci/projection.ts
new file mode 100644
index 000000000..a82bc82da
--- /dev/null
+++ b/src/veterinary_sci/projection.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci projection module — tsb analytics library. */
+export interface VeterinarySciProjectionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciProjectionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciProjection(data: number[], opts: VeterinarySciProjectionOptions = {}): VeterinarySciProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciProjection };
diff --git a/src/veterinary_sci/ranking.ts b/src/veterinary_sci/ranking.ts
new file mode 100644
index 000000000..4c4736257
--- /dev/null
+++ b/src/veterinary_sci/ranking.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci ranking module — tsb analytics library. */
+export interface VeterinarySciRankingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciRankingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciRanking(data: number[], opts: VeterinarySciRankingOptions = {}): VeterinarySciRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciRanking };
diff --git a/src/veterinary_sci/reconstruction.ts b/src/veterinary_sci/reconstruction.ts
new file mode 100644
index 000000000..b92b51366
--- /dev/null
+++ b/src/veterinary_sci/reconstruction.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci reconstruction module — tsb analytics library. */
+export interface VeterinarySciReconstructionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciReconstructionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciReconstruction(data: number[], opts: VeterinarySciReconstructionOptions = {}): VeterinarySciReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciReconstruction };
diff --git a/src/veterinary_sci/registration.ts b/src/veterinary_sci/registration.ts
new file mode 100644
index 000000000..176aa7d28
--- /dev/null
+++ b/src/veterinary_sci/registration.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci registration module — tsb analytics library. */
+export interface VeterinarySciRegistrationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciRegistrationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciRegistration(data: number[], opts: VeterinarySciRegistrationOptions = {}): VeterinarySciRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciRegistration };
diff --git a/src/veterinary_sci/regression.ts b/src/veterinary_sci/regression.ts
new file mode 100644
index 000000000..29f49d764
--- /dev/null
+++ b/src/veterinary_sci/regression.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci regression module — tsb analytics library. */
+export interface VeterinarySciRegressionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciRegressionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciRegression(data: number[], opts: VeterinarySciRegressionOptions = {}): VeterinarySciRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciRegression };
diff --git a/src/veterinary_sci/regularization.ts b/src/veterinary_sci/regularization.ts
new file mode 100644
index 000000000..3e88898e8
--- /dev/null
+++ b/src/veterinary_sci/regularization.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci regularization module — tsb analytics library. */
+export interface VeterinarySciRegularizationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciRegularizationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciRegularization(data: number[], opts: VeterinarySciRegularizationOptions = {}): VeterinarySciRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciRegularization };
diff --git a/src/veterinary_sci/robustness.ts b/src/veterinary_sci/robustness.ts
new file mode 100644
index 000000000..d62a72b5a
--- /dev/null
+++ b/src/veterinary_sci/robustness.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci robustness module — tsb analytics library. */
+export interface VeterinarySciRobustnessOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciRobustnessResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciRobustness(data: number[], opts: VeterinarySciRobustnessOptions = {}): VeterinarySciRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciRobustness };
diff --git a/src/veterinary_sci/sampling.ts b/src/veterinary_sci/sampling.ts
new file mode 100644
index 000000000..dd30c4e8e
--- /dev/null
+++ b/src/veterinary_sci/sampling.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci sampling module — tsb analytics library. */
+export interface VeterinarySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciSamplingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciSampling(data: number[], opts: VeterinarySciSamplingOptions = {}): VeterinarySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciSampling };
diff --git a/src/veterinary_sci/sampling2.ts b/src/veterinary_sci/sampling2.ts
new file mode 100644
index 000000000..cdc78bc34
--- /dev/null
+++ b/src/veterinary_sci/sampling2.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci sampling2 module — tsb analytics library. */
+export interface VeterinarySciSamplingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciSamplingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciSampling(data: number[], opts: VeterinarySciSamplingOptions = {}): VeterinarySciSamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciSampling };
diff --git a/src/veterinary_sci/scaling.ts b/src/veterinary_sci/scaling.ts
new file mode 100644
index 000000000..aac69db5d
--- /dev/null
+++ b/src/veterinary_sci/scaling.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci scaling module — tsb analytics library. */
+export interface VeterinarySciScalingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciScalingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciScaling(data: number[], opts: VeterinarySciScalingOptions = {}): VeterinarySciScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciScaling };
diff --git a/src/veterinary_sci/scoring.ts b/src/veterinary_sci/scoring.ts
new file mode 100644
index 000000000..0d9be5f39
--- /dev/null
+++ b/src/veterinary_sci/scoring.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci scoring module — tsb analytics library. */
+export interface VeterinarySciScoringOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciScoringResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciScoring(data: number[], opts: VeterinarySciScoringOptions = {}): VeterinarySciScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciScoring };
diff --git a/src/veterinary_sci/segmentation.ts b/src/veterinary_sci/segmentation.ts
new file mode 100644
index 000000000..63a59f731
--- /dev/null
+++ b/src/veterinary_sci/segmentation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci segmentation module — tsb analytics library. */
+export interface VeterinarySciSegmentationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciSegmentationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciSegmentation(data: number[], opts: VeterinarySciSegmentationOptions = {}): VeterinarySciSegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciSegmentation };
diff --git a/src/veterinary_sci/selection.ts b/src/veterinary_sci/selection.ts
new file mode 100644
index 000000000..c8360f5c1
--- /dev/null
+++ b/src/veterinary_sci/selection.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci selection module — tsb analytics library. */
+export interface VeterinarySciSelectionOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciSelectionResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciSelection(data: number[], opts: VeterinarySciSelectionOptions = {}): VeterinarySciSelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciSelection };
diff --git a/src/veterinary_sci/sensitivity.ts b/src/veterinary_sci/sensitivity.ts
new file mode 100644
index 000000000..baee40dee
--- /dev/null
+++ b/src/veterinary_sci/sensitivity.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci sensitivity module — tsb analytics library. */
+export interface VeterinarySciSensitivityOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciSensitivityResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciSensitivity(data: number[], opts: VeterinarySciSensitivityOptions = {}): VeterinarySciSensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciSensitivity };
diff --git a/src/veterinary_sci/simulation.ts b/src/veterinary_sci/simulation.ts
new file mode 100644
index 000000000..d391ae3b2
--- /dev/null
+++ b/src/veterinary_sci/simulation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci simulation module — tsb analytics library. */
+export interface VeterinarySciSimulationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciSimulationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciSimulation(data: number[], opts: VeterinarySciSimulationOptions = {}): VeterinarySciSimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciSimulation };
diff --git a/src/veterinary_sci/smoothing.ts b/src/veterinary_sci/smoothing.ts
new file mode 100644
index 000000000..a793f7ef3
--- /dev/null
+++ b/src/veterinary_sci/smoothing.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci smoothing module — tsb analytics library. */
+export interface VeterinarySciSmoothingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciSmoothingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciSmoothing(data: number[], opts: VeterinarySciSmoothingOptions = {}): VeterinarySciSmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciSmoothing };
diff --git a/src/veterinary_sci/stability.ts b/src/veterinary_sci/stability.ts
new file mode 100644
index 000000000..d754be041
--- /dev/null
+++ b/src/veterinary_sci/stability.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci stability module — tsb analytics library. */
+export interface VeterinarySciStabilityOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciStabilityResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciStability(data: number[], opts: VeterinarySciStabilityOptions = {}): VeterinarySciStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciStability };
diff --git a/src/veterinary_sci/stacking.ts b/src/veterinary_sci/stacking.ts
new file mode 100644
index 000000000..e5c4cd45a
--- /dev/null
+++ b/src/veterinary_sci/stacking.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci stacking module — tsb analytics library. */
+export interface VeterinarySciStackingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciStackingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciStacking(data: number[], opts: VeterinarySciStackingOptions = {}): VeterinarySciStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciStacking };
diff --git a/src/veterinary_sci/standardization.ts b/src/veterinary_sci/standardization.ts
new file mode 100644
index 000000000..f05015ae9
--- /dev/null
+++ b/src/veterinary_sci/standardization.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci standardization module — tsb analytics library. */
+export interface VeterinarySciStandardizationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciStandardizationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciStandardization(data: number[], opts: VeterinarySciStandardizationOptions = {}): VeterinarySciStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciStandardization };
diff --git a/src/veterinary_sci/static.ts b/src/veterinary_sci/static.ts
new file mode 100644
index 000000000..804c8c1ec
--- /dev/null
+++ b/src/veterinary_sci/static.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci static module — tsb analytics library. */
+export interface VeterinarySciStaticOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciStaticResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciStatic(data: number[], opts: VeterinarySciStaticOptions = {}): VeterinarySciStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciStatic };
diff --git a/src/veterinary_sci/stochastic.ts b/src/veterinary_sci/stochastic.ts
new file mode 100644
index 000000000..9a53e8655
--- /dev/null
+++ b/src/veterinary_sci/stochastic.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci stochastic module — tsb analytics library. */
+export interface VeterinarySciStochasticOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciStochasticResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciStochastic(data: number[], opts: VeterinarySciStochasticOptions = {}): VeterinarySciStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciStochastic };
diff --git a/src/veterinary_sci/synthesis.ts b/src/veterinary_sci/synthesis.ts
new file mode 100644
index 000000000..bfc920da0
--- /dev/null
+++ b/src/veterinary_sci/synthesis.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci synthesis module — tsb analytics library. */
+export interface VeterinarySciSynthesisOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciSynthesisResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciSynthesis(data: number[], opts: VeterinarySciSynthesisOptions = {}): VeterinarySciSynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciSynthesis };
diff --git a/src/veterinary_sci/topology.ts b/src/veterinary_sci/topology.ts
new file mode 100644
index 000000000..b3a2c6476
--- /dev/null
+++ b/src/veterinary_sci/topology.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci topology module — tsb analytics library. */
+export interface VeterinarySciTopologyOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciTopologyResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciTopology(data: number[], opts: VeterinarySciTopologyOptions = {}): VeterinarySciTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciTopology };
diff --git a/src/veterinary_sci/tracking.ts b/src/veterinary_sci/tracking.ts
new file mode 100644
index 000000000..b61bbd9a3
--- /dev/null
+++ b/src/veterinary_sci/tracking.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci tracking module — tsb analytics library. */
+export interface VeterinarySciTrackingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciTrackingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciTracking(data: number[], opts: VeterinarySciTrackingOptions = {}): VeterinarySciTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciTracking };
diff --git a/src/veterinary_sci/transform.ts b/src/veterinary_sci/transform.ts
new file mode 100644
index 000000000..961502462
--- /dev/null
+++ b/src/veterinary_sci/transform.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci transform module — tsb analytics library. */
+export interface VeterinarySciTransformOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciTransformResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciTransform(data: number[], opts: VeterinarySciTransformOptions = {}): VeterinarySciTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciTransform };
diff --git a/src/veterinary_sci/uncertainty.ts b/src/veterinary_sci/uncertainty.ts
new file mode 100644
index 000000000..67deffcf2
--- /dev/null
+++ b/src/veterinary_sci/uncertainty.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci uncertainty module — tsb analytics library. */
+export interface VeterinarySciUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciUncertaintyResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciUncertainty(data: number[], opts: VeterinarySciUncertaintyOptions = {}): VeterinarySciUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciUncertainty };
diff --git a/src/veterinary_sci/validation.ts b/src/veterinary_sci/validation.ts
new file mode 100644
index 000000000..0f46e88be
--- /dev/null
+++ b/src/veterinary_sci/validation.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci validation module — tsb analytics library. */
+export interface VeterinarySciValidationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciValidationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciValidation(data: number[], opts: VeterinarySciValidationOptions = {}): VeterinarySciValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciValidation };
diff --git a/src/veterinary_sci/verification.ts b/src/veterinary_sci/verification.ts
new file mode 100644
index 000000000..10265c347
--- /dev/null
+++ b/src/veterinary_sci/verification.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci verification module — tsb analytics library. */
+export interface VeterinarySciVerificationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciVerificationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciVerification(data: number[], opts: VeterinarySciVerificationOptions = {}): VeterinarySciVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciVerification };
diff --git a/src/veterinary_sci/visualization.ts b/src/veterinary_sci/visualization.ts
new file mode 100644
index 000000000..77b0796b8
--- /dev/null
+++ b/src/veterinary_sci/visualization.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci visualization module — tsb analytics library. */
+export interface VeterinarySciVisualizationOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciVisualizationResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciVisualization(data: number[], opts: VeterinarySciVisualizationOptions = {}): VeterinarySciVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciVisualization };
diff --git a/src/veterinary_sci/voting.ts b/src/veterinary_sci/voting.ts
new file mode 100644
index 000000000..76f2520d8
--- /dev/null
+++ b/src/veterinary_sci/voting.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci voting module — tsb analytics library. */
+export interface VeterinarySciVotingOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciVotingResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciVoting(data: number[], opts: VeterinarySciVotingOptions = {}): VeterinarySciVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciVoting };
diff --git a/src/veterinary_sci/wavelet.ts b/src/veterinary_sci/wavelet.ts
new file mode 100644
index 000000000..12d1a9766
--- /dev/null
+++ b/src/veterinary_sci/wavelet.ts
@@ -0,0 +1,14 @@
+/** veterinary_sci wavelet module — tsb analytics library. */
+export interface VeterinarySciWaveletOptions { tol?: number; maxIter?: number; }
+export interface VeterinarySciWaveletResult { values: number[]; converged: boolean; }
+export function computeVeterinarySciWavelet(data: number[], opts: VeterinarySciWaveletOptions = {}): VeterinarySciWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVeterinarySciWavelet };
diff --git a/src/virology_sci2/adaptation.ts b/src/virology_sci2/adaptation.ts
new file mode 100644
index 000000000..6bf115a3b
--- /dev/null
+++ b/src/virology_sci2/adaptation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 adaptation module — tsb analytics library. */
+export interface VirologySci2AdaptationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2AdaptationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Adaptation(data: number[], opts: VirologySci2AdaptationOptions = {}): VirologySci2AdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Adaptation };
diff --git a/src/virology_sci2/aggregation.ts b/src/virology_sci2/aggregation.ts
new file mode 100644
index 000000000..83476e35e
--- /dev/null
+++ b/src/virology_sci2/aggregation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 aggregation module — tsb analytics library. */
+export interface VirologySci2AggregationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2AggregationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Aggregation(data: number[], opts: VirologySci2AggregationOptions = {}): VirologySci2AggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Aggregation };
diff --git a/src/virology_sci2/algebra.ts b/src/virology_sci2/algebra.ts
new file mode 100644
index 000000000..b13e58b5f
--- /dev/null
+++ b/src/virology_sci2/algebra.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 algebra module — tsb analytics library. */
+export interface VirologySci2AlgebraOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2AlgebraResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Algebra(data: number[], opts: VirologySci2AlgebraOptions = {}): VirologySci2AlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Algebra };
diff --git a/src/virology_sci2/alignment.ts b/src/virology_sci2/alignment.ts
new file mode 100644
index 000000000..5f5b2e6ce
--- /dev/null
+++ b/src/virology_sci2/alignment.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 alignment module — tsb analytics library. */
+export interface VirologySci2AlignmentOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2AlignmentResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Alignment(data: number[], opts: VirologySci2AlignmentOptions = {}): VirologySci2AlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Alignment };
diff --git a/src/virology_sci2/analysis.ts b/src/virology_sci2/analysis.ts
new file mode 100644
index 000000000..e29579e3d
--- /dev/null
+++ b/src/virology_sci2/analysis.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 analysis module — tsb analytics library. */
+export interface VirologySci2AnalysisOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2AnalysisResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Analysis(data: number[], opts: VirologySci2AnalysisOptions = {}): VirologySci2AnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Analysis };
diff --git a/src/virology_sci2/augmentation.ts b/src/virology_sci2/augmentation.ts
new file mode 100644
index 000000000..e27c489a6
--- /dev/null
+++ b/src/virology_sci2/augmentation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 augmentation module — tsb analytics library. */
+export interface VirologySci2AugmentationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2AugmentationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Augmentation(data: number[], opts: VirologySci2AugmentationOptions = {}): VirologySci2AugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Augmentation };
diff --git a/src/virology_sci2/bagging.ts b/src/virology_sci2/bagging.ts
new file mode 100644
index 000000000..520cdb31f
--- /dev/null
+++ b/src/virology_sci2/bagging.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 bagging module — tsb analytics library. */
+export interface VirologySci2BaggingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2BaggingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Bagging(data: number[], opts: VirologySci2BaggingOptions = {}): VirologySci2BaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Bagging };
diff --git a/src/virology_sci2/basis.ts b/src/virology_sci2/basis.ts
new file mode 100644
index 000000000..e23ac67e2
--- /dev/null
+++ b/src/virology_sci2/basis.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 basis module — tsb analytics library. */
+export interface VirologySci2BasisOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2BasisResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Basis(data: number[], opts: VirologySci2BasisOptions = {}): VirologySci2BasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Basis };
diff --git a/src/virology_sci2/benchmarking.ts b/src/virology_sci2/benchmarking.ts
new file mode 100644
index 000000000..e7ed054c2
--- /dev/null
+++ b/src/virology_sci2/benchmarking.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 benchmarking module — tsb analytics library. */
+export interface VirologySci2BenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2BenchmarkingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Benchmarking(data: number[], opts: VirologySci2BenchmarkingOptions = {}): VirologySci2BenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Benchmarking };
diff --git a/src/virology_sci2/blending.ts b/src/virology_sci2/blending.ts
new file mode 100644
index 000000000..6c00c3362
--- /dev/null
+++ b/src/virology_sci2/blending.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 blending module — tsb analytics library. */
+export interface VirologySci2BlendingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2BlendingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Blending(data: number[], opts: VirologySci2BlendingOptions = {}): VirologySci2BlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Blending };
diff --git a/src/virology_sci2/boosting.ts b/src/virology_sci2/boosting.ts
new file mode 100644
index 000000000..dbce7f515
--- /dev/null
+++ b/src/virology_sci2/boosting.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 boosting module — tsb analytics library. */
+export interface VirologySci2BoostingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2BoostingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Boosting(data: number[], opts: VirologySci2BoostingOptions = {}): VirologySci2BoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Boosting };
diff --git a/src/virology_sci2/bootstrap.ts b/src/virology_sci2/bootstrap.ts
new file mode 100644
index 000000000..c1604ea05
--- /dev/null
+++ b/src/virology_sci2/bootstrap.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 bootstrap module — tsb analytics library. */
+export interface VirologySci2BootstrapOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2BootstrapResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Bootstrap(data: number[], opts: VirologySci2BootstrapOptions = {}): VirologySci2BootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Bootstrap };
diff --git a/src/virology_sci2/calculus.ts b/src/virology_sci2/calculus.ts
new file mode 100644
index 000000000..e1aee0437
--- /dev/null
+++ b/src/virology_sci2/calculus.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 calculus module — tsb analytics library. */
+export interface VirologySci2CalculusOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2CalculusResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Calculus(data: number[], opts: VirologySci2CalculusOptions = {}): VirologySci2CalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Calculus };
diff --git a/src/virology_sci2/calibration.ts b/src/virology_sci2/calibration.ts
new file mode 100644
index 000000000..406b906f4
--- /dev/null
+++ b/src/virology_sci2/calibration.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 calibration module — tsb analytics library. */
+export interface VirologySci2CalibrationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2CalibrationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Calibration(data: number[], opts: VirologySci2CalibrationOptions = {}): VirologySci2CalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Calibration };
diff --git a/src/virology_sci2/characterization.ts b/src/virology_sci2/characterization.ts
new file mode 100644
index 000000000..4a413c5e1
--- /dev/null
+++ b/src/virology_sci2/characterization.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 characterization module — tsb analytics library. */
+export interface VirologySci2CharacterizationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2CharacterizationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Characterization(data: number[], opts: VirologySci2CharacterizationOptions = {}): VirologySci2CharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Characterization };
diff --git a/src/virology_sci2/classification.ts b/src/virology_sci2/classification.ts
new file mode 100644
index 000000000..2cf2da078
--- /dev/null
+++ b/src/virology_sci2/classification.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 classification module — tsb analytics library. */
+export interface VirologySci2ClassificationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ClassificationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Classification(data: number[], opts: VirologySci2ClassificationOptions = {}): VirologySci2ClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Classification };
diff --git a/src/virology_sci2/clustering.ts b/src/virology_sci2/clustering.ts
new file mode 100644
index 000000000..f9332229d
--- /dev/null
+++ b/src/virology_sci2/clustering.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 clustering module — tsb analytics library. */
+export interface VirologySci2ClusteringOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ClusteringResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Clustering(data: number[], opts: VirologySci2ClusteringOptions = {}): VirologySci2ClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Clustering };
diff --git a/src/virology_sci2/compression.ts b/src/virology_sci2/compression.ts
new file mode 100644
index 000000000..552b33629
--- /dev/null
+++ b/src/virology_sci2/compression.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 compression module — tsb analytics library. */
+export interface VirologySci2CompressionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2CompressionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Compression(data: number[], opts: VirologySci2CompressionOptions = {}): VirologySci2CompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Compression };
diff --git a/src/virology_sci2/continuous.ts b/src/virology_sci2/continuous.ts
new file mode 100644
index 000000000..84848a3ed
--- /dev/null
+++ b/src/virology_sci2/continuous.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 continuous module — tsb analytics library. */
+export interface VirologySci2ContinuousOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ContinuousResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Continuous(data: number[], opts: VirologySci2ContinuousOptions = {}): VirologySci2ContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Continuous };
diff --git a/src/virology_sci2/control.ts b/src/virology_sci2/control.ts
new file mode 100644
index 000000000..13487c6f9
--- /dev/null
+++ b/src/virology_sci2/control.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 control module — tsb analytics library. */
+export interface VirologySci2ControlOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ControlResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Control(data: number[], opts: VirologySci2ControlOptions = {}): VirologySci2ControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Control };
diff --git a/src/virology_sci2/convergence.ts b/src/virology_sci2/convergence.ts
new file mode 100644
index 000000000..d16be0f05
--- /dev/null
+++ b/src/virology_sci2/convergence.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 convergence module — tsb analytics library. */
+export interface VirologySci2ConvergenceOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ConvergenceResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Convergence(data: number[], opts: VirologySci2ConvergenceOptions = {}): VirologySci2ConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Convergence };
diff --git a/src/virology_sci2/convex.ts b/src/virology_sci2/convex.ts
new file mode 100644
index 000000000..4d4c88fad
--- /dev/null
+++ b/src/virology_sci2/convex.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 convex module — tsb analytics library. */
+export interface VirologySci2ConvexOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ConvexResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Convex(data: number[], opts: VirologySci2ConvexOptions = {}): VirologySci2ConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Convex };
diff --git a/src/virology_sci2/correlation.ts b/src/virology_sci2/correlation.ts
new file mode 100644
index 000000000..cb9a3c850
--- /dev/null
+++ b/src/virology_sci2/correlation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 correlation module — tsb analytics library. */
+export interface VirologySci2CorrelationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2CorrelationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Correlation(data: number[], opts: VirologySci2CorrelationOptions = {}): VirologySci2CorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Correlation };
diff --git a/src/virology_sci2/covariance.ts b/src/virology_sci2/covariance.ts
new file mode 100644
index 000000000..236336f07
--- /dev/null
+++ b/src/virology_sci2/covariance.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 covariance module — tsb analytics library. */
+export interface VirologySci2CovarianceOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2CovarianceResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Covariance(data: number[], opts: VirologySci2CovarianceOptions = {}): VirologySci2CovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Covariance };
diff --git a/src/virology_sci2/cross_validation.ts b/src/virology_sci2/cross_validation.ts
new file mode 100644
index 000000000..81a2df393
--- /dev/null
+++ b/src/virology_sci2/cross_validation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 cross_validation module — tsb analytics library. */
+export interface VirologySci2CrossValidationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2CrossValidationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2CrossValidation(data: number[], opts: VirologySci2CrossValidationOptions = {}): VirologySci2CrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2CrossValidation };
diff --git a/src/virology_sci2/decoding.ts b/src/virology_sci2/decoding.ts
new file mode 100644
index 000000000..f976ea563
--- /dev/null
+++ b/src/virology_sci2/decoding.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 decoding module — tsb analytics library. */
+export interface VirologySci2DecodingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DecodingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Decoding(data: number[], opts: VirologySci2DecodingOptions = {}): VirologySci2DecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Decoding };
diff --git a/src/virology_sci2/decomposition.ts b/src/virology_sci2/decomposition.ts
new file mode 100644
index 000000000..f8e4473eb
--- /dev/null
+++ b/src/virology_sci2/decomposition.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 decomposition module — tsb analytics library. */
+export interface VirologySci2DecompositionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DecompositionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Decomposition(data: number[], opts: VirologySci2DecompositionOptions = {}): VirologySci2DecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Decomposition };
diff --git a/src/virology_sci2/detection.ts b/src/virology_sci2/detection.ts
new file mode 100644
index 000000000..ffe573e49
--- /dev/null
+++ b/src/virology_sci2/detection.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 detection module — tsb analytics library. */
+export interface VirologySci2DetectionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DetectionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Detection(data: number[], opts: VirologySci2DetectionOptions = {}): VirologySci2DetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Detection };
diff --git a/src/virology_sci2/deterministic.ts b/src/virology_sci2/deterministic.ts
new file mode 100644
index 000000000..3b5cae0e8
--- /dev/null
+++ b/src/virology_sci2/deterministic.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 deterministic module — tsb analytics library. */
+export interface VirologySci2DeterministicOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DeterministicResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Deterministic(data: number[], opts: VirologySci2DeterministicOptions = {}): VirologySci2DeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Deterministic };
diff --git a/src/virology_sci2/diagnostics.ts b/src/virology_sci2/diagnostics.ts
new file mode 100644
index 000000000..68e610984
--- /dev/null
+++ b/src/virology_sci2/diagnostics.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 diagnostics module — tsb analytics library. */
+export interface VirologySci2DiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DiagnosticsResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Diagnostics(data: number[], opts: VirologySci2DiagnosticsOptions = {}): VirologySci2DiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Diagnostics };
diff --git a/src/virology_sci2/differential.ts b/src/virology_sci2/differential.ts
new file mode 100644
index 000000000..954c32ccd
--- /dev/null
+++ b/src/virology_sci2/differential.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 differential module — tsb analytics library. */
+export interface VirologySci2DifferentialOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DifferentialResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Differential(data: number[], opts: VirologySci2DifferentialOptions = {}): VirologySci2DifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Differential };
diff --git a/src/virology_sci2/discrete.ts b/src/virology_sci2/discrete.ts
new file mode 100644
index 000000000..2f0e1b17f
--- /dev/null
+++ b/src/virology_sci2/discrete.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 discrete module — tsb analytics library. */
+export interface VirologySci2DiscreteOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DiscreteResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Discrete(data: number[], opts: VirologySci2DiscreteOptions = {}): VirologySci2DiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Discrete };
diff --git a/src/virology_sci2/distribution.ts b/src/virology_sci2/distribution.ts
new file mode 100644
index 000000000..2a8bcd7ed
--- /dev/null
+++ b/src/virology_sci2/distribution.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 distribution module — tsb analytics library. */
+export interface VirologySci2DistributionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DistributionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Distribution(data: number[], opts: VirologySci2DistributionOptions = {}): VirologySci2DistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Distribution };
diff --git a/src/virology_sci2/dynamic.ts b/src/virology_sci2/dynamic.ts
new file mode 100644
index 000000000..435581622
--- /dev/null
+++ b/src/virology_sci2/dynamic.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 dynamic module — tsb analytics library. */
+export interface VirologySci2DynamicOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2DynamicResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Dynamic(data: number[], opts: VirologySci2DynamicOptions = {}): VirologySci2DynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Dynamic };
diff --git a/src/virology_sci2/embedding.ts b/src/virology_sci2/embedding.ts
new file mode 100644
index 000000000..dd0c8e7ec
--- /dev/null
+++ b/src/virology_sci2/embedding.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 embedding module — tsb analytics library. */
+export interface VirologySci2EmbeddingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2EmbeddingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Embedding(data: number[], opts: VirologySci2EmbeddingOptions = {}): VirologySci2EmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Embedding };
diff --git a/src/virology_sci2/encoding.ts b/src/virology_sci2/encoding.ts
new file mode 100644
index 000000000..ff88006e2
--- /dev/null
+++ b/src/virology_sci2/encoding.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 encoding module — tsb analytics library. */
+export interface VirologySci2EncodingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2EncodingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Encoding(data: number[], opts: VirologySci2EncodingOptions = {}): VirologySci2EncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Encoding };
diff --git a/src/virology_sci2/ensemble.ts b/src/virology_sci2/ensemble.ts
new file mode 100644
index 000000000..082d58c4c
--- /dev/null
+++ b/src/virology_sci2/ensemble.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 ensemble module — tsb analytics library. */
+export interface VirologySci2EnsembleOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2EnsembleResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Ensemble(data: number[], opts: VirologySci2EnsembleOptions = {}): VirologySci2EnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Ensemble };
diff --git a/src/virology_sci2/estimation.ts b/src/virology_sci2/estimation.ts
new file mode 100644
index 000000000..61b156002
--- /dev/null
+++ b/src/virology_sci2/estimation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 estimation module — tsb analytics library. */
+export interface VirologySci2EstimationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2EstimationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Estimation(data: number[], opts: VirologySci2EstimationOptions = {}): VirologySci2EstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Estimation };
diff --git a/src/virology_sci2/evaluation.ts b/src/virology_sci2/evaluation.ts
new file mode 100644
index 000000000..1cb41b23c
--- /dev/null
+++ b/src/virology_sci2/evaluation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 evaluation module — tsb analytics library. */
+export interface VirologySci2EvaluationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2EvaluationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Evaluation(data: number[], opts: VirologySci2EvaluationOptions = {}): VirologySci2EvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Evaluation };
diff --git a/src/virology_sci2/extrapolation.ts b/src/virology_sci2/extrapolation.ts
new file mode 100644
index 000000000..e70a081c2
--- /dev/null
+++ b/src/virology_sci2/extrapolation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 extrapolation module — tsb analytics library. */
+export interface VirologySci2ExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ExtrapolationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Extrapolation(data: number[], opts: VirologySci2ExtrapolationOptions = {}): VirologySci2ExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Extrapolation };
diff --git a/src/virology_sci2/features.ts b/src/virology_sci2/features.ts
new file mode 100644
index 000000000..193b2df95
--- /dev/null
+++ b/src/virology_sci2/features.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 features module — tsb analytics library. */
+export interface VirologySci2FeaturesOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2FeaturesResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Features(data: number[], opts: VirologySci2FeaturesOptions = {}): VirologySci2FeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Features };
diff --git a/src/virology_sci2/feedback.ts b/src/virology_sci2/feedback.ts
new file mode 100644
index 000000000..2ddded275
--- /dev/null
+++ b/src/virology_sci2/feedback.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 feedback module — tsb analytics library. */
+export interface VirologySci2FeedbackOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2FeedbackResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Feedback(data: number[], opts: VirologySci2FeedbackOptions = {}): VirologySci2FeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Feedback };
diff --git a/src/virology_sci2/filtering.ts b/src/virology_sci2/filtering.ts
new file mode 100644
index 000000000..055738158
--- /dev/null
+++ b/src/virology_sci2/filtering.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 filtering module — tsb analytics library. */
+export interface VirologySci2FilteringOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2FilteringResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Filtering(data: number[], opts: VirologySci2FilteringOptions = {}): VirologySci2FilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Filtering };
diff --git a/src/virology_sci2/fourier.ts b/src/virology_sci2/fourier.ts
new file mode 100644
index 000000000..b2b16f287
--- /dev/null
+++ b/src/virology_sci2/fourier.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 fourier module — tsb analytics library. */
+export interface VirologySci2FourierOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2FourierResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Fourier(data: number[], opts: VirologySci2FourierOptions = {}): VirologySci2FourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Fourier };
diff --git a/src/virology_sci2/fusion.ts b/src/virology_sci2/fusion.ts
new file mode 100644
index 000000000..453e1e9a4
--- /dev/null
+++ b/src/virology_sci2/fusion.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 fusion module — tsb analytics library. */
+export interface VirologySci2FusionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2FusionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Fusion(data: number[], opts: VirologySci2FusionOptions = {}): VirologySci2FusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Fusion };
diff --git a/src/virology_sci2/generation.ts b/src/virology_sci2/generation.ts
new file mode 100644
index 000000000..0a25dd2a5
--- /dev/null
+++ b/src/virology_sci2/generation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 generation module — tsb analytics library. */
+export interface VirologySci2GenerationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2GenerationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Generation(data: number[], opts: VirologySci2GenerationOptions = {}): VirologySci2GenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Generation };
diff --git a/src/virology_sci2/geometry.ts b/src/virology_sci2/geometry.ts
new file mode 100644
index 000000000..96d9d332a
--- /dev/null
+++ b/src/virology_sci2/geometry.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 geometry module — tsb analytics library. */
+export interface VirologySci2GeometryOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2GeometryResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Geometry(data: number[], opts: VirologySci2GeometryOptions = {}): VirologySci2GeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Geometry };
diff --git a/src/virology_sci2/gradient.ts b/src/virology_sci2/gradient.ts
new file mode 100644
index 000000000..871b8db8b
--- /dev/null
+++ b/src/virology_sci2/gradient.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 gradient module — tsb analytics library. */
+export interface VirologySci2GradientOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2GradientResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Gradient(data: number[], opts: VirologySci2GradientOptions = {}): VirologySci2GradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Gradient };
diff --git a/src/virology_sci2/hessian.ts b/src/virology_sci2/hessian.ts
new file mode 100644
index 000000000..8ffa5ee88
--- /dev/null
+++ b/src/virology_sci2/hessian.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 hessian module — tsb analytics library. */
+export interface VirologySci2HessianOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2HessianResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Hessian(data: number[], opts: VirologySci2HessianOptions = {}): VirologySci2HessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Hessian };
diff --git a/src/virology_sci2/hypothesis.ts b/src/virology_sci2/hypothesis.ts
new file mode 100644
index 000000000..29d58f6f7
--- /dev/null
+++ b/src/virology_sci2/hypothesis.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 hypothesis module — tsb analytics library. */
+export interface VirologySci2HypothesisOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2HypothesisResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Hypothesis(data: number[], opts: VirologySci2HypothesisOptions = {}): VirologySci2HypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Hypothesis };
diff --git a/src/virology_sci2/inference.ts b/src/virology_sci2/inference.ts
new file mode 100644
index 000000000..018070086
--- /dev/null
+++ b/src/virology_sci2/inference.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 inference module — tsb analytics library. */
+export interface VirologySci2InferenceOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2InferenceResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Inference(data: number[], opts: VirologySci2InferenceOptions = {}): VirologySci2InferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Inference };
diff --git a/src/virology_sci2/inference2.ts b/src/virology_sci2/inference2.ts
new file mode 100644
index 000000000..73017a96d
--- /dev/null
+++ b/src/virology_sci2/inference2.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 inference2 module — tsb analytics library. */
+export interface VirologySci2InferenceOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2InferenceResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Inference(data: number[], opts: VirologySci2InferenceOptions = {}): VirologySci2InferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Inference };
diff --git a/src/virology_sci2/integral.ts b/src/virology_sci2/integral.ts
new file mode 100644
index 000000000..b7c4b10be
--- /dev/null
+++ b/src/virology_sci2/integral.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 integral module — tsb analytics library. */
+export interface VirologySci2IntegralOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2IntegralResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Integral(data: number[], opts: VirologySci2IntegralOptions = {}): VirologySci2IntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Integral };
diff --git a/src/virology_sci2/integration.ts b/src/virology_sci2/integration.ts
new file mode 100644
index 000000000..2b5c3d48a
--- /dev/null
+++ b/src/virology_sci2/integration.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 integration module — tsb analytics library. */
+export interface VirologySci2IntegrationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2IntegrationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Integration(data: number[], opts: VirologySci2IntegrationOptions = {}): VirologySci2IntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Integration };
diff --git a/src/virology_sci2/interpolation.ts b/src/virology_sci2/interpolation.ts
new file mode 100644
index 000000000..1dbb74d15
--- /dev/null
+++ b/src/virology_sci2/interpolation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 interpolation module — tsb analytics library. */
+export interface VirologySci2InterpolationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2InterpolationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Interpolation(data: number[], opts: VirologySci2InterpolationOptions = {}): VirologySci2InterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Interpolation };
diff --git a/src/virology_sci2/jacobian.ts b/src/virology_sci2/jacobian.ts
new file mode 100644
index 000000000..fddbac421
--- /dev/null
+++ b/src/virology_sci2/jacobian.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 jacobian module — tsb analytics library. */
+export interface VirologySci2JacobianOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2JacobianResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Jacobian(data: number[], opts: VirologySci2JacobianOptions = {}): VirologySci2JacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Jacobian };
diff --git a/src/virology_sci2/kernel.ts b/src/virology_sci2/kernel.ts
new file mode 100644
index 000000000..1013fdcab
--- /dev/null
+++ b/src/virology_sci2/kernel.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 kernel module — tsb analytics library. */
+export interface VirologySci2KernelOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2KernelResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Kernel(data: number[], opts: VirologySci2KernelOptions = {}): VirologySci2KernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Kernel };
diff --git a/src/virology_sci2/laplacian.ts b/src/virology_sci2/laplacian.ts
new file mode 100644
index 000000000..f92da0adc
--- /dev/null
+++ b/src/virology_sci2/laplacian.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 laplacian module — tsb analytics library. */
+export interface VirologySci2LaplacianOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2LaplacianResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Laplacian(data: number[], opts: VirologySci2LaplacianOptions = {}): VirologySci2LaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Laplacian };
diff --git a/src/virology_sci2/learning.ts b/src/virology_sci2/learning.ts
new file mode 100644
index 000000000..0af4ebb92
--- /dev/null
+++ b/src/virology_sci2/learning.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 learning module — tsb analytics library. */
+export interface VirologySci2LearningOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2LearningResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Learning(data: number[], opts: VirologySci2LearningOptions = {}): VirologySci2LearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Learning };
diff --git a/src/virology_sci2/linear.ts b/src/virology_sci2/linear.ts
new file mode 100644
index 000000000..4c5e9a3c4
--- /dev/null
+++ b/src/virology_sci2/linear.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 linear module — tsb analytics library. */
+export interface VirologySci2LinearOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2LinearResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Linear(data: number[], opts: VirologySci2LinearOptions = {}): VirologySci2LinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Linear };
diff --git a/src/virology_sci2/manifold.ts b/src/virology_sci2/manifold.ts
new file mode 100644
index 000000000..a39df051a
--- /dev/null
+++ b/src/virology_sci2/manifold.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 manifold module — tsb analytics library. */
+export interface VirologySci2ManifoldOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ManifoldResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Manifold(data: number[], opts: VirologySci2ManifoldOptions = {}): VirologySci2ManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Manifold };
diff --git a/src/virology_sci2/matching.ts b/src/virology_sci2/matching.ts
new file mode 100644
index 000000000..3e6e007b3
--- /dev/null
+++ b/src/virology_sci2/matching.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 matching module — tsb analytics library. */
+export interface VirologySci2MatchingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2MatchingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Matching(data: number[], opts: VirologySci2MatchingOptions = {}): VirologySci2MatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Matching };
diff --git a/src/virology_sci2/measurement.ts b/src/virology_sci2/measurement.ts
new file mode 100644
index 000000000..538711ea1
--- /dev/null
+++ b/src/virology_sci2/measurement.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 measurement module — tsb analytics library. */
+export interface VirologySci2MeasurementOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2MeasurementResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Measurement(data: number[], opts: VirologySci2MeasurementOptions = {}): VirologySci2MeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Measurement };
diff --git a/src/virology_sci2/metrics.ts b/src/virology_sci2/metrics.ts
new file mode 100644
index 000000000..8b1a48d91
--- /dev/null
+++ b/src/virology_sci2/metrics.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 metrics module — tsb analytics library. */
+export interface VirologySci2MetricsOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2MetricsResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Metrics(data: number[], opts: VirologySci2MetricsOptions = {}): VirologySci2MetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Metrics };
diff --git a/src/virology_sci2/modeling.ts b/src/virology_sci2/modeling.ts
new file mode 100644
index 000000000..fa89d9380
--- /dev/null
+++ b/src/virology_sci2/modeling.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 modeling module — tsb analytics library. */
+export interface VirologySci2ModelingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ModelingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Modeling(data: number[], opts: VirologySci2ModelingOptions = {}): VirologySci2ModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Modeling };
diff --git a/src/virology_sci2/monitoring.ts b/src/virology_sci2/monitoring.ts
new file mode 100644
index 000000000..e49e802ea
--- /dev/null
+++ b/src/virology_sci2/monitoring.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 monitoring module — tsb analytics library. */
+export interface VirologySci2MonitoringOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2MonitoringResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Monitoring(data: number[], opts: VirologySci2MonitoringOptions = {}): VirologySci2MonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Monitoring };
diff --git a/src/virology_sci2/nonlinear.ts b/src/virology_sci2/nonlinear.ts
new file mode 100644
index 000000000..531cba606
--- /dev/null
+++ b/src/virology_sci2/nonlinear.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 nonlinear module — tsb analytics library. */
+export interface VirologySci2NonlinearOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2NonlinearResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Nonlinear(data: number[], opts: VirologySci2NonlinearOptions = {}): VirologySci2NonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Nonlinear };
diff --git a/src/virology_sci2/normalization.ts b/src/virology_sci2/normalization.ts
new file mode 100644
index 000000000..99389afa8
--- /dev/null
+++ b/src/virology_sci2/normalization.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 normalization module — tsb analytics library. */
+export interface VirologySci2NormalizationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2NormalizationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Normalization(data: number[], opts: VirologySci2NormalizationOptions = {}): VirologySci2NormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Normalization };
diff --git a/src/virology_sci2/optimization.ts b/src/virology_sci2/optimization.ts
new file mode 100644
index 000000000..a40414c9e
--- /dev/null
+++ b/src/virology_sci2/optimization.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 optimization module — tsb analytics library. */
+export interface VirologySci2OptimizationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2OptimizationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Optimization(data: number[], opts: VirologySci2OptimizationOptions = {}): VirologySci2OptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Optimization };
diff --git a/src/virology_sci2/patterns.ts b/src/virology_sci2/patterns.ts
new file mode 100644
index 000000000..afda4ef39
--- /dev/null
+++ b/src/virology_sci2/patterns.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 patterns module — tsb analytics library. */
+export interface VirologySci2PatternsOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2PatternsResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Patterns(data: number[], opts: VirologySci2PatternsOptions = {}): VirologySci2PatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Patterns };
diff --git a/src/virology_sci2/permutation.ts b/src/virology_sci2/permutation.ts
new file mode 100644
index 000000000..808a48703
--- /dev/null
+++ b/src/virology_sci2/permutation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 permutation module — tsb analytics library. */
+export interface VirologySci2PermutationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2PermutationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Permutation(data: number[], opts: VirologySci2PermutationOptions = {}): VirologySci2PermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Permutation };
diff --git a/src/virology_sci2/prediction.ts b/src/virology_sci2/prediction.ts
new file mode 100644
index 000000000..79127c273
--- /dev/null
+++ b/src/virology_sci2/prediction.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 prediction module — tsb analytics library. */
+export interface VirologySci2PredictionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2PredictionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Prediction(data: number[], opts: VirologySci2PredictionOptions = {}): VirologySci2PredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Prediction };
diff --git a/src/virology_sci2/processing.ts b/src/virology_sci2/processing.ts
new file mode 100644
index 000000000..912784a7c
--- /dev/null
+++ b/src/virology_sci2/processing.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 processing module — tsb analytics library. */
+export interface VirologySci2ProcessingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ProcessingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Processing(data: number[], opts: VirologySci2ProcessingOptions = {}): VirologySci2ProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Processing };
diff --git a/src/virology_sci2/profiling.ts b/src/virology_sci2/profiling.ts
new file mode 100644
index 000000000..0554db831
--- /dev/null
+++ b/src/virology_sci2/profiling.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 profiling module — tsb analytics library. */
+export interface VirologySci2ProfilingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ProfilingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Profiling(data: number[], opts: VirologySci2ProfilingOptions = {}): VirologySci2ProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Profiling };
diff --git a/src/virology_sci2/projection.ts b/src/virology_sci2/projection.ts
new file mode 100644
index 000000000..fb8c92342
--- /dev/null
+++ b/src/virology_sci2/projection.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 projection module — tsb analytics library. */
+export interface VirologySci2ProjectionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ProjectionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Projection(data: number[], opts: VirologySci2ProjectionOptions = {}): VirologySci2ProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Projection };
diff --git a/src/virology_sci2/ranking.ts b/src/virology_sci2/ranking.ts
new file mode 100644
index 000000000..e479f381a
--- /dev/null
+++ b/src/virology_sci2/ranking.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 ranking module — tsb analytics library. */
+export interface VirologySci2RankingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2RankingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Ranking(data: number[], opts: VirologySci2RankingOptions = {}): VirologySci2RankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Ranking };
diff --git a/src/virology_sci2/reconstruction.ts b/src/virology_sci2/reconstruction.ts
new file mode 100644
index 000000000..495e92e75
--- /dev/null
+++ b/src/virology_sci2/reconstruction.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 reconstruction module — tsb analytics library. */
+export interface VirologySci2ReconstructionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ReconstructionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Reconstruction(data: number[], opts: VirologySci2ReconstructionOptions = {}): VirologySci2ReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Reconstruction };
diff --git a/src/virology_sci2/registration.ts b/src/virology_sci2/registration.ts
new file mode 100644
index 000000000..0a7ae7d3f
--- /dev/null
+++ b/src/virology_sci2/registration.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 registration module — tsb analytics library. */
+export interface VirologySci2RegistrationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2RegistrationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Registration(data: number[], opts: VirologySci2RegistrationOptions = {}): VirologySci2RegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Registration };
diff --git a/src/virology_sci2/regression.ts b/src/virology_sci2/regression.ts
new file mode 100644
index 000000000..88c0d1ba5
--- /dev/null
+++ b/src/virology_sci2/regression.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 regression module — tsb analytics library. */
+export interface VirologySci2RegressionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2RegressionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Regression(data: number[], opts: VirologySci2RegressionOptions = {}): VirologySci2RegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Regression };
diff --git a/src/virology_sci2/regularization.ts b/src/virology_sci2/regularization.ts
new file mode 100644
index 000000000..ed3289ed0
--- /dev/null
+++ b/src/virology_sci2/regularization.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 regularization module — tsb analytics library. */
+export interface VirologySci2RegularizationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2RegularizationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Regularization(data: number[], opts: VirologySci2RegularizationOptions = {}): VirologySci2RegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Regularization };
diff --git a/src/virology_sci2/robustness.ts b/src/virology_sci2/robustness.ts
new file mode 100644
index 000000000..4726b3a5d
--- /dev/null
+++ b/src/virology_sci2/robustness.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 robustness module — tsb analytics library. */
+export interface VirologySci2RobustnessOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2RobustnessResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Robustness(data: number[], opts: VirologySci2RobustnessOptions = {}): VirologySci2RobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Robustness };
diff --git a/src/virology_sci2/sampling.ts b/src/virology_sci2/sampling.ts
new file mode 100644
index 000000000..b762b293b
--- /dev/null
+++ b/src/virology_sci2/sampling.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 sampling module — tsb analytics library. */
+export interface VirologySci2SamplingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2SamplingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Sampling(data: number[], opts: VirologySci2SamplingOptions = {}): VirologySci2SamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Sampling };
diff --git a/src/virology_sci2/sampling2.ts b/src/virology_sci2/sampling2.ts
new file mode 100644
index 000000000..ff713d95d
--- /dev/null
+++ b/src/virology_sci2/sampling2.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 sampling2 module — tsb analytics library. */
+export interface VirologySci2SamplingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2SamplingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Sampling(data: number[], opts: VirologySci2SamplingOptions = {}): VirologySci2SamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Sampling };
diff --git a/src/virology_sci2/scaling.ts b/src/virology_sci2/scaling.ts
new file mode 100644
index 000000000..433c26a7d
--- /dev/null
+++ b/src/virology_sci2/scaling.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 scaling module — tsb analytics library. */
+export interface VirologySci2ScalingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ScalingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Scaling(data: number[], opts: VirologySci2ScalingOptions = {}): VirologySci2ScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Scaling };
diff --git a/src/virology_sci2/scoring.ts b/src/virology_sci2/scoring.ts
new file mode 100644
index 000000000..c332a53aa
--- /dev/null
+++ b/src/virology_sci2/scoring.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 scoring module — tsb analytics library. */
+export interface VirologySci2ScoringOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ScoringResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Scoring(data: number[], opts: VirologySci2ScoringOptions = {}): VirologySci2ScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Scoring };
diff --git a/src/virology_sci2/segmentation.ts b/src/virology_sci2/segmentation.ts
new file mode 100644
index 000000000..4bebffeb8
--- /dev/null
+++ b/src/virology_sci2/segmentation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 segmentation module — tsb analytics library. */
+export interface VirologySci2SegmentationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2SegmentationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Segmentation(data: number[], opts: VirologySci2SegmentationOptions = {}): VirologySci2SegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Segmentation };
diff --git a/src/virology_sci2/selection.ts b/src/virology_sci2/selection.ts
new file mode 100644
index 000000000..189bef7f6
--- /dev/null
+++ b/src/virology_sci2/selection.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 selection module — tsb analytics library. */
+export interface VirologySci2SelectionOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2SelectionResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Selection(data: number[], opts: VirologySci2SelectionOptions = {}): VirologySci2SelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Selection };
diff --git a/src/virology_sci2/sensitivity.ts b/src/virology_sci2/sensitivity.ts
new file mode 100644
index 000000000..8cc104631
--- /dev/null
+++ b/src/virology_sci2/sensitivity.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 sensitivity module — tsb analytics library. */
+export interface VirologySci2SensitivityOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2SensitivityResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Sensitivity(data: number[], opts: VirologySci2SensitivityOptions = {}): VirologySci2SensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Sensitivity };
diff --git a/src/virology_sci2/simulation.ts b/src/virology_sci2/simulation.ts
new file mode 100644
index 000000000..f199cf3cf
--- /dev/null
+++ b/src/virology_sci2/simulation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 simulation module — tsb analytics library. */
+export interface VirologySci2SimulationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2SimulationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Simulation(data: number[], opts: VirologySci2SimulationOptions = {}): VirologySci2SimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Simulation };
diff --git a/src/virology_sci2/smoothing.ts b/src/virology_sci2/smoothing.ts
new file mode 100644
index 000000000..aa018d934
--- /dev/null
+++ b/src/virology_sci2/smoothing.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 smoothing module — tsb analytics library. */
+export interface VirologySci2SmoothingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2SmoothingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Smoothing(data: number[], opts: VirologySci2SmoothingOptions = {}): VirologySci2SmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Smoothing };
diff --git a/src/virology_sci2/stability.ts b/src/virology_sci2/stability.ts
new file mode 100644
index 000000000..ef762ca5c
--- /dev/null
+++ b/src/virology_sci2/stability.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 stability module — tsb analytics library. */
+export interface VirologySci2StabilityOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2StabilityResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Stability(data: number[], opts: VirologySci2StabilityOptions = {}): VirologySci2StabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Stability };
diff --git a/src/virology_sci2/stacking.ts b/src/virology_sci2/stacking.ts
new file mode 100644
index 000000000..c6a7c9e90
--- /dev/null
+++ b/src/virology_sci2/stacking.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 stacking module — tsb analytics library. */
+export interface VirologySci2StackingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2StackingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Stacking(data: number[], opts: VirologySci2StackingOptions = {}): VirologySci2StackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Stacking };
diff --git a/src/virology_sci2/standardization.ts b/src/virology_sci2/standardization.ts
new file mode 100644
index 000000000..b189ecd35
--- /dev/null
+++ b/src/virology_sci2/standardization.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 standardization module — tsb analytics library. */
+export interface VirologySci2StandardizationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2StandardizationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Standardization(data: number[], opts: VirologySci2StandardizationOptions = {}): VirologySci2StandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Standardization };
diff --git a/src/virology_sci2/static.ts b/src/virology_sci2/static.ts
new file mode 100644
index 000000000..6bfad5191
--- /dev/null
+++ b/src/virology_sci2/static.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 static module — tsb analytics library. */
+export interface VirologySci2StaticOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2StaticResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Static(data: number[], opts: VirologySci2StaticOptions = {}): VirologySci2StaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Static };
diff --git a/src/virology_sci2/stochastic.ts b/src/virology_sci2/stochastic.ts
new file mode 100644
index 000000000..edb8cd11d
--- /dev/null
+++ b/src/virology_sci2/stochastic.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 stochastic module — tsb analytics library. */
+export interface VirologySci2StochasticOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2StochasticResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Stochastic(data: number[], opts: VirologySci2StochasticOptions = {}): VirologySci2StochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Stochastic };
diff --git a/src/virology_sci2/synthesis.ts b/src/virology_sci2/synthesis.ts
new file mode 100644
index 000000000..916dd4239
--- /dev/null
+++ b/src/virology_sci2/synthesis.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 synthesis module — tsb analytics library. */
+export interface VirologySci2SynthesisOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2SynthesisResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Synthesis(data: number[], opts: VirologySci2SynthesisOptions = {}): VirologySci2SynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Synthesis };
diff --git a/src/virology_sci2/topology.ts b/src/virology_sci2/topology.ts
new file mode 100644
index 000000000..882f4a1a4
--- /dev/null
+++ b/src/virology_sci2/topology.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 topology module — tsb analytics library. */
+export interface VirologySci2TopologyOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2TopologyResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Topology(data: number[], opts: VirologySci2TopologyOptions = {}): VirologySci2TopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Topology };
diff --git a/src/virology_sci2/tracking.ts b/src/virology_sci2/tracking.ts
new file mode 100644
index 000000000..d56d0ad38
--- /dev/null
+++ b/src/virology_sci2/tracking.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 tracking module — tsb analytics library. */
+export interface VirologySci2TrackingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2TrackingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Tracking(data: number[], opts: VirologySci2TrackingOptions = {}): VirologySci2TrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Tracking };
diff --git a/src/virology_sci2/transform.ts b/src/virology_sci2/transform.ts
new file mode 100644
index 000000000..050f053b3
--- /dev/null
+++ b/src/virology_sci2/transform.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 transform module — tsb analytics library. */
+export interface VirologySci2TransformOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2TransformResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Transform(data: number[], opts: VirologySci2TransformOptions = {}): VirologySci2TransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Transform };
diff --git a/src/virology_sci2/uncertainty.ts b/src/virology_sci2/uncertainty.ts
new file mode 100644
index 000000000..35951d49c
--- /dev/null
+++ b/src/virology_sci2/uncertainty.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 uncertainty module — tsb analytics library. */
+export interface VirologySci2UncertaintyOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2UncertaintyResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Uncertainty(data: number[], opts: VirologySci2UncertaintyOptions = {}): VirologySci2UncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Uncertainty };
diff --git a/src/virology_sci2/validation.ts b/src/virology_sci2/validation.ts
new file mode 100644
index 000000000..dadaa8fdf
--- /dev/null
+++ b/src/virology_sci2/validation.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 validation module — tsb analytics library. */
+export interface VirologySci2ValidationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2ValidationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Validation(data: number[], opts: VirologySci2ValidationOptions = {}): VirologySci2ValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Validation };
diff --git a/src/virology_sci2/verification.ts b/src/virology_sci2/verification.ts
new file mode 100644
index 000000000..fa42ce3bf
--- /dev/null
+++ b/src/virology_sci2/verification.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 verification module — tsb analytics library. */
+export interface VirologySci2VerificationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2VerificationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Verification(data: number[], opts: VirologySci2VerificationOptions = {}): VirologySci2VerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Verification };
diff --git a/src/virology_sci2/visualization.ts b/src/virology_sci2/visualization.ts
new file mode 100644
index 000000000..a75928455
--- /dev/null
+++ b/src/virology_sci2/visualization.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 visualization module — tsb analytics library. */
+export interface VirologySci2VisualizationOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2VisualizationResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Visualization(data: number[], opts: VirologySci2VisualizationOptions = {}): VirologySci2VisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Visualization };
diff --git a/src/virology_sci2/voting.ts b/src/virology_sci2/voting.ts
new file mode 100644
index 000000000..b3e85765f
--- /dev/null
+++ b/src/virology_sci2/voting.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 voting module — tsb analytics library. */
+export interface VirologySci2VotingOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2VotingResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Voting(data: number[], opts: VirologySci2VotingOptions = {}): VirologySci2VotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Voting };
diff --git a/src/virology_sci2/wavelet.ts b/src/virology_sci2/wavelet.ts
new file mode 100644
index 000000000..e3212c35b
--- /dev/null
+++ b/src/virology_sci2/wavelet.ts
@@ -0,0 +1,14 @@
+/** virology_sci2 wavelet module — tsb analytics library. */
+export interface VirologySci2WaveletOptions { tol?: number; maxIter?: number; }
+export interface VirologySci2WaveletResult { values: number[]; converged: boolean; }
+export function computeVirologySci2Wavelet(data: number[], opts: VirologySci2WaveletOptions = {}): VirologySci2WaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVirologySci2Wavelet };
diff --git a/src/volcanology/adaptation.ts b/src/volcanology/adaptation.ts
new file mode 100644
index 000000000..d339d0037
--- /dev/null
+++ b/src/volcanology/adaptation.ts
@@ -0,0 +1,14 @@
+/** volcanology adaptation module — tsb analytics library. */
+export interface VolcanologyAdaptationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyAdaptationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyAdaptation(data: number[], opts: VolcanologyAdaptationOptions = {}): VolcanologyAdaptationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyAdaptation };
diff --git a/src/volcanology/aggregation.ts b/src/volcanology/aggregation.ts
new file mode 100644
index 000000000..a40bf603b
--- /dev/null
+++ b/src/volcanology/aggregation.ts
@@ -0,0 +1,14 @@
+/** volcanology aggregation module — tsb analytics library. */
+export interface VolcanologyAggregationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyAggregationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyAggregation(data: number[], opts: VolcanologyAggregationOptions = {}): VolcanologyAggregationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyAggregation };
diff --git a/src/volcanology/algebra.ts b/src/volcanology/algebra.ts
new file mode 100644
index 000000000..c62464b5d
--- /dev/null
+++ b/src/volcanology/algebra.ts
@@ -0,0 +1,14 @@
+/** volcanology algebra module — tsb analytics library. */
+export interface VolcanologyAlgebraOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyAlgebraResult { values: number[]; converged: boolean; }
+export function computeVolcanologyAlgebra(data: number[], opts: VolcanologyAlgebraOptions = {}): VolcanologyAlgebraResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyAlgebra };
diff --git a/src/volcanology/alignment.ts b/src/volcanology/alignment.ts
new file mode 100644
index 000000000..6d611534a
--- /dev/null
+++ b/src/volcanology/alignment.ts
@@ -0,0 +1,14 @@
+/** volcanology alignment module — tsb analytics library. */
+export interface VolcanologyAlignmentOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyAlignmentResult { values: number[]; converged: boolean; }
+export function computeVolcanologyAlignment(data: number[], opts: VolcanologyAlignmentOptions = {}): VolcanologyAlignmentResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyAlignment };
diff --git a/src/volcanology/analysis.ts b/src/volcanology/analysis.ts
new file mode 100644
index 000000000..1f1f7147a
--- /dev/null
+++ b/src/volcanology/analysis.ts
@@ -0,0 +1,14 @@
+/** volcanology analysis module — tsb analytics library. */
+export interface VolcanologyAnalysisOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyAnalysisResult { values: number[]; converged: boolean; }
+export function computeVolcanologyAnalysis(data: number[], opts: VolcanologyAnalysisOptions = {}): VolcanologyAnalysisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyAnalysis };
diff --git a/src/volcanology/augmentation.ts b/src/volcanology/augmentation.ts
new file mode 100644
index 000000000..056090d4b
--- /dev/null
+++ b/src/volcanology/augmentation.ts
@@ -0,0 +1,14 @@
+/** volcanology augmentation module — tsb analytics library. */
+export interface VolcanologyAugmentationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyAugmentationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyAugmentation(data: number[], opts: VolcanologyAugmentationOptions = {}): VolcanologyAugmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyAugmentation };
diff --git a/src/volcanology/bagging.ts b/src/volcanology/bagging.ts
new file mode 100644
index 000000000..99fdd2335
--- /dev/null
+++ b/src/volcanology/bagging.ts
@@ -0,0 +1,14 @@
+/** volcanology bagging module — tsb analytics library. */
+export interface VolcanologyBaggingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyBaggingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyBagging(data: number[], opts: VolcanologyBaggingOptions = {}): VolcanologyBaggingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyBagging };
diff --git a/src/volcanology/basis.ts b/src/volcanology/basis.ts
new file mode 100644
index 000000000..f050e445a
--- /dev/null
+++ b/src/volcanology/basis.ts
@@ -0,0 +1,14 @@
+/** volcanology basis module — tsb analytics library. */
+export interface VolcanologyBasisOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyBasisResult { values: number[]; converged: boolean; }
+export function computeVolcanologyBasis(data: number[], opts: VolcanologyBasisOptions = {}): VolcanologyBasisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyBasis };
diff --git a/src/volcanology/benchmarking.ts b/src/volcanology/benchmarking.ts
new file mode 100644
index 000000000..53b3fd771
--- /dev/null
+++ b/src/volcanology/benchmarking.ts
@@ -0,0 +1,14 @@
+/** volcanology benchmarking module — tsb analytics library. */
+export interface VolcanologyBenchmarkingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyBenchmarkingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyBenchmarking(data: number[], opts: VolcanologyBenchmarkingOptions = {}): VolcanologyBenchmarkingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyBenchmarking };
diff --git a/src/volcanology/blending.ts b/src/volcanology/blending.ts
new file mode 100644
index 000000000..0633af92f
--- /dev/null
+++ b/src/volcanology/blending.ts
@@ -0,0 +1,14 @@
+/** volcanology blending module — tsb analytics library. */
+export interface VolcanologyBlendingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyBlendingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyBlending(data: number[], opts: VolcanologyBlendingOptions = {}): VolcanologyBlendingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyBlending };
diff --git a/src/volcanology/boosting.ts b/src/volcanology/boosting.ts
new file mode 100644
index 000000000..2bcc31026
--- /dev/null
+++ b/src/volcanology/boosting.ts
@@ -0,0 +1,14 @@
+/** volcanology boosting module — tsb analytics library. */
+export interface VolcanologyBoostingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyBoostingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyBoosting(data: number[], opts: VolcanologyBoostingOptions = {}): VolcanologyBoostingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyBoosting };
diff --git a/src/volcanology/bootstrap.ts b/src/volcanology/bootstrap.ts
new file mode 100644
index 000000000..467cdaadb
--- /dev/null
+++ b/src/volcanology/bootstrap.ts
@@ -0,0 +1,14 @@
+/** volcanology bootstrap module — tsb analytics library. */
+export interface VolcanologyBootstrapOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyBootstrapResult { values: number[]; converged: boolean; }
+export function computeVolcanologyBootstrap(data: number[], opts: VolcanologyBootstrapOptions = {}): VolcanologyBootstrapResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyBootstrap };
diff --git a/src/volcanology/calculus.ts b/src/volcanology/calculus.ts
new file mode 100644
index 000000000..69f8d9016
--- /dev/null
+++ b/src/volcanology/calculus.ts
@@ -0,0 +1,14 @@
+/** volcanology calculus module — tsb analytics library. */
+export interface VolcanologyCalculusOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyCalculusResult { values: number[]; converged: boolean; }
+export function computeVolcanologyCalculus(data: number[], opts: VolcanologyCalculusOptions = {}): VolcanologyCalculusResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyCalculus };
diff --git a/src/volcanology/calibration.ts b/src/volcanology/calibration.ts
new file mode 100644
index 000000000..fb23ce353
--- /dev/null
+++ b/src/volcanology/calibration.ts
@@ -0,0 +1,14 @@
+/** volcanology calibration module — tsb analytics library. */
+export interface VolcanologyCalibrationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyCalibrationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyCalibration(data: number[], opts: VolcanologyCalibrationOptions = {}): VolcanologyCalibrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyCalibration };
diff --git a/src/volcanology/characterization.ts b/src/volcanology/characterization.ts
new file mode 100644
index 000000000..57cba10d0
--- /dev/null
+++ b/src/volcanology/characterization.ts
@@ -0,0 +1,14 @@
+/** volcanology characterization module — tsb analytics library. */
+export interface VolcanologyCharacterizationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyCharacterizationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyCharacterization(data: number[], opts: VolcanologyCharacterizationOptions = {}): VolcanologyCharacterizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyCharacterization };
diff --git a/src/volcanology/classification.ts b/src/volcanology/classification.ts
new file mode 100644
index 000000000..90e2da6ca
--- /dev/null
+++ b/src/volcanology/classification.ts
@@ -0,0 +1,14 @@
+/** volcanology classification module — tsb analytics library. */
+export interface VolcanologyClassificationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyClassificationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyClassification(data: number[], opts: VolcanologyClassificationOptions = {}): VolcanologyClassificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyClassification };
diff --git a/src/volcanology/clustering.ts b/src/volcanology/clustering.ts
new file mode 100644
index 000000000..e940641f6
--- /dev/null
+++ b/src/volcanology/clustering.ts
@@ -0,0 +1,14 @@
+/** volcanology clustering module — tsb analytics library. */
+export interface VolcanologyClusteringOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyClusteringResult { values: number[]; converged: boolean; }
+export function computeVolcanologyClustering(data: number[], opts: VolcanologyClusteringOptions = {}): VolcanologyClusteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyClustering };
diff --git a/src/volcanology/compression.ts b/src/volcanology/compression.ts
new file mode 100644
index 000000000..8a70e6d21
--- /dev/null
+++ b/src/volcanology/compression.ts
@@ -0,0 +1,14 @@
+/** volcanology compression module — tsb analytics library. */
+export interface VolcanologyCompressionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyCompressionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyCompression(data: number[], opts: VolcanologyCompressionOptions = {}): VolcanologyCompressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyCompression };
diff --git a/src/volcanology/continuous.ts b/src/volcanology/continuous.ts
new file mode 100644
index 000000000..b763eb390
--- /dev/null
+++ b/src/volcanology/continuous.ts
@@ -0,0 +1,14 @@
+/** volcanology continuous module — tsb analytics library. */
+export interface VolcanologyContinuousOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyContinuousResult { values: number[]; converged: boolean; }
+export function computeVolcanologyContinuous(data: number[], opts: VolcanologyContinuousOptions = {}): VolcanologyContinuousResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyContinuous };
diff --git a/src/volcanology/control.ts b/src/volcanology/control.ts
new file mode 100644
index 000000000..dd02066cb
--- /dev/null
+++ b/src/volcanology/control.ts
@@ -0,0 +1,14 @@
+/** volcanology control module — tsb analytics library. */
+export interface VolcanologyControlOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyControlResult { values: number[]; converged: boolean; }
+export function computeVolcanologyControl(data: number[], opts: VolcanologyControlOptions = {}): VolcanologyControlResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyControl };
diff --git a/src/volcanology/convergence.ts b/src/volcanology/convergence.ts
new file mode 100644
index 000000000..2863e6075
--- /dev/null
+++ b/src/volcanology/convergence.ts
@@ -0,0 +1,14 @@
+/** volcanology convergence module — tsb analytics library. */
+export interface VolcanologyConvergenceOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyConvergenceResult { values: number[]; converged: boolean; }
+export function computeVolcanologyConvergence(data: number[], opts: VolcanologyConvergenceOptions = {}): VolcanologyConvergenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyConvergence };
diff --git a/src/volcanology/convex.ts b/src/volcanology/convex.ts
new file mode 100644
index 000000000..1b0a1c0eb
--- /dev/null
+++ b/src/volcanology/convex.ts
@@ -0,0 +1,14 @@
+/** volcanology convex module — tsb analytics library. */
+export interface VolcanologyConvexOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyConvexResult { values: number[]; converged: boolean; }
+export function computeVolcanologyConvex(data: number[], opts: VolcanologyConvexOptions = {}): VolcanologyConvexResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyConvex };
diff --git a/src/volcanology/correlation.ts b/src/volcanology/correlation.ts
new file mode 100644
index 000000000..e1410ecd3
--- /dev/null
+++ b/src/volcanology/correlation.ts
@@ -0,0 +1,14 @@
+/** volcanology correlation module — tsb analytics library. */
+export interface VolcanologyCorrelationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyCorrelationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyCorrelation(data: number[], opts: VolcanologyCorrelationOptions = {}): VolcanologyCorrelationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyCorrelation };
diff --git a/src/volcanology/covariance.ts b/src/volcanology/covariance.ts
new file mode 100644
index 000000000..657cba926
--- /dev/null
+++ b/src/volcanology/covariance.ts
@@ -0,0 +1,14 @@
+/** volcanology covariance module — tsb analytics library. */
+export interface VolcanologyCovarianceOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyCovarianceResult { values: number[]; converged: boolean; }
+export function computeVolcanologyCovariance(data: number[], opts: VolcanologyCovarianceOptions = {}): VolcanologyCovarianceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyCovariance };
diff --git a/src/volcanology/cross_validation.ts b/src/volcanology/cross_validation.ts
new file mode 100644
index 000000000..9007d560b
--- /dev/null
+++ b/src/volcanology/cross_validation.ts
@@ -0,0 +1,14 @@
+/** volcanology cross_validation module — tsb analytics library. */
+export interface VolcanologyCrossValidationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyCrossValidationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyCrossValidation(data: number[], opts: VolcanologyCrossValidationOptions = {}): VolcanologyCrossValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyCrossValidation };
diff --git a/src/volcanology/decoding.ts b/src/volcanology/decoding.ts
new file mode 100644
index 000000000..0da5e48ce
--- /dev/null
+++ b/src/volcanology/decoding.ts
@@ -0,0 +1,14 @@
+/** volcanology decoding module — tsb analytics library. */
+export interface VolcanologyDecodingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDecodingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDecoding(data: number[], opts: VolcanologyDecodingOptions = {}): VolcanologyDecodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDecoding };
diff --git a/src/volcanology/decomposition.ts b/src/volcanology/decomposition.ts
new file mode 100644
index 000000000..8e012bf43
--- /dev/null
+++ b/src/volcanology/decomposition.ts
@@ -0,0 +1,14 @@
+/** volcanology decomposition module — tsb analytics library. */
+export interface VolcanologyDecompositionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDecompositionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDecomposition(data: number[], opts: VolcanologyDecompositionOptions = {}): VolcanologyDecompositionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDecomposition };
diff --git a/src/volcanology/detection.ts b/src/volcanology/detection.ts
new file mode 100644
index 000000000..6f461f309
--- /dev/null
+++ b/src/volcanology/detection.ts
@@ -0,0 +1,14 @@
+/** volcanology detection module — tsb analytics library. */
+export interface VolcanologyDetectionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDetectionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDetection(data: number[], opts: VolcanologyDetectionOptions = {}): VolcanologyDetectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDetection };
diff --git a/src/volcanology/deterministic.ts b/src/volcanology/deterministic.ts
new file mode 100644
index 000000000..bdde457e1
--- /dev/null
+++ b/src/volcanology/deterministic.ts
@@ -0,0 +1,14 @@
+/** volcanology deterministic module — tsb analytics library. */
+export interface VolcanologyDeterministicOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDeterministicResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDeterministic(data: number[], opts: VolcanologyDeterministicOptions = {}): VolcanologyDeterministicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDeterministic };
diff --git a/src/volcanology/diagnostics.ts b/src/volcanology/diagnostics.ts
new file mode 100644
index 000000000..3d1410bfd
--- /dev/null
+++ b/src/volcanology/diagnostics.ts
@@ -0,0 +1,14 @@
+/** volcanology diagnostics module — tsb analytics library. */
+export interface VolcanologyDiagnosticsOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDiagnosticsResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDiagnostics(data: number[], opts: VolcanologyDiagnosticsOptions = {}): VolcanologyDiagnosticsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDiagnostics };
diff --git a/src/volcanology/differential.ts b/src/volcanology/differential.ts
new file mode 100644
index 000000000..4db87b375
--- /dev/null
+++ b/src/volcanology/differential.ts
@@ -0,0 +1,14 @@
+/** volcanology differential module — tsb analytics library. */
+export interface VolcanologyDifferentialOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDifferentialResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDifferential(data: number[], opts: VolcanologyDifferentialOptions = {}): VolcanologyDifferentialResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDifferential };
diff --git a/src/volcanology/discrete.ts b/src/volcanology/discrete.ts
new file mode 100644
index 000000000..c8ed3279c
--- /dev/null
+++ b/src/volcanology/discrete.ts
@@ -0,0 +1,14 @@
+/** volcanology discrete module — tsb analytics library. */
+export interface VolcanologyDiscreteOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDiscreteResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDiscrete(data: number[], opts: VolcanologyDiscreteOptions = {}): VolcanologyDiscreteResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDiscrete };
diff --git a/src/volcanology/distribution.ts b/src/volcanology/distribution.ts
new file mode 100644
index 000000000..7e19574c6
--- /dev/null
+++ b/src/volcanology/distribution.ts
@@ -0,0 +1,14 @@
+/** volcanology distribution module — tsb analytics library. */
+export interface VolcanologyDistributionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDistributionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDistribution(data: number[], opts: VolcanologyDistributionOptions = {}): VolcanologyDistributionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDistribution };
diff --git a/src/volcanology/dynamic.ts b/src/volcanology/dynamic.ts
new file mode 100644
index 000000000..ce0fd9e4d
--- /dev/null
+++ b/src/volcanology/dynamic.ts
@@ -0,0 +1,14 @@
+/** volcanology dynamic module — tsb analytics library. */
+export interface VolcanologyDynamicOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyDynamicResult { values: number[]; converged: boolean; }
+export function computeVolcanologyDynamic(data: number[], opts: VolcanologyDynamicOptions = {}): VolcanologyDynamicResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyDynamic };
diff --git a/src/volcanology/embedding.ts b/src/volcanology/embedding.ts
new file mode 100644
index 000000000..324e87b21
--- /dev/null
+++ b/src/volcanology/embedding.ts
@@ -0,0 +1,14 @@
+/** volcanology embedding module — tsb analytics library. */
+export interface VolcanologyEmbeddingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyEmbeddingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyEmbedding(data: number[], opts: VolcanologyEmbeddingOptions = {}): VolcanologyEmbeddingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyEmbedding };
diff --git a/src/volcanology/encoding.ts b/src/volcanology/encoding.ts
new file mode 100644
index 000000000..4cfc35ebb
--- /dev/null
+++ b/src/volcanology/encoding.ts
@@ -0,0 +1,14 @@
+/** volcanology encoding module — tsb analytics library. */
+export interface VolcanologyEncodingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyEncodingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyEncoding(data: number[], opts: VolcanologyEncodingOptions = {}): VolcanologyEncodingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyEncoding };
diff --git a/src/volcanology/ensemble.ts b/src/volcanology/ensemble.ts
new file mode 100644
index 000000000..41703cb6b
--- /dev/null
+++ b/src/volcanology/ensemble.ts
@@ -0,0 +1,14 @@
+/** volcanology ensemble module — tsb analytics library. */
+export interface VolcanologyEnsembleOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyEnsembleResult { values: number[]; converged: boolean; }
+export function computeVolcanologyEnsemble(data: number[], opts: VolcanologyEnsembleOptions = {}): VolcanologyEnsembleResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyEnsemble };
diff --git a/src/volcanology/estimation.ts b/src/volcanology/estimation.ts
new file mode 100644
index 000000000..bdde41d48
--- /dev/null
+++ b/src/volcanology/estimation.ts
@@ -0,0 +1,14 @@
+/** volcanology estimation module — tsb analytics library. */
+export interface VolcanologyEstimationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyEstimationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyEstimation(data: number[], opts: VolcanologyEstimationOptions = {}): VolcanologyEstimationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyEstimation };
diff --git a/src/volcanology/evaluation.ts b/src/volcanology/evaluation.ts
new file mode 100644
index 000000000..56f1ff109
--- /dev/null
+++ b/src/volcanology/evaluation.ts
@@ -0,0 +1,14 @@
+/** volcanology evaluation module — tsb analytics library. */
+export interface VolcanologyEvaluationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyEvaluationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyEvaluation(data: number[], opts: VolcanologyEvaluationOptions = {}): VolcanologyEvaluationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyEvaluation };
diff --git a/src/volcanology/extrapolation.ts b/src/volcanology/extrapolation.ts
new file mode 100644
index 000000000..581054499
--- /dev/null
+++ b/src/volcanology/extrapolation.ts
@@ -0,0 +1,14 @@
+/** volcanology extrapolation module — tsb analytics library. */
+export interface VolcanologyExtrapolationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyExtrapolationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyExtrapolation(data: number[], opts: VolcanologyExtrapolationOptions = {}): VolcanologyExtrapolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyExtrapolation };
diff --git a/src/volcanology/features.ts b/src/volcanology/features.ts
new file mode 100644
index 000000000..4f687c31f
--- /dev/null
+++ b/src/volcanology/features.ts
@@ -0,0 +1,14 @@
+/** volcanology features module — tsb analytics library. */
+export interface VolcanologyFeaturesOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyFeaturesResult { values: number[]; converged: boolean; }
+export function computeVolcanologyFeatures(data: number[], opts: VolcanologyFeaturesOptions = {}): VolcanologyFeaturesResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyFeatures };
diff --git a/src/volcanology/feedback.ts b/src/volcanology/feedback.ts
new file mode 100644
index 000000000..bd11fa3db
--- /dev/null
+++ b/src/volcanology/feedback.ts
@@ -0,0 +1,14 @@
+/** volcanology feedback module — tsb analytics library. */
+export interface VolcanologyFeedbackOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyFeedbackResult { values: number[]; converged: boolean; }
+export function computeVolcanologyFeedback(data: number[], opts: VolcanologyFeedbackOptions = {}): VolcanologyFeedbackResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyFeedback };
diff --git a/src/volcanology/filtering.ts b/src/volcanology/filtering.ts
new file mode 100644
index 000000000..cf5456205
--- /dev/null
+++ b/src/volcanology/filtering.ts
@@ -0,0 +1,14 @@
+/** volcanology filtering module — tsb analytics library. */
+export interface VolcanologyFilteringOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyFilteringResult { values: number[]; converged: boolean; }
+export function computeVolcanologyFiltering(data: number[], opts: VolcanologyFilteringOptions = {}): VolcanologyFilteringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyFiltering };
diff --git a/src/volcanology/fourier.ts b/src/volcanology/fourier.ts
new file mode 100644
index 000000000..b32db11c9
--- /dev/null
+++ b/src/volcanology/fourier.ts
@@ -0,0 +1,14 @@
+/** volcanology fourier module — tsb analytics library. */
+export interface VolcanologyFourierOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyFourierResult { values: number[]; converged: boolean; }
+export function computeVolcanologyFourier(data: number[], opts: VolcanologyFourierOptions = {}): VolcanologyFourierResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyFourier };
diff --git a/src/volcanology/fusion.ts b/src/volcanology/fusion.ts
new file mode 100644
index 000000000..75c159326
--- /dev/null
+++ b/src/volcanology/fusion.ts
@@ -0,0 +1,14 @@
+/** volcanology fusion module — tsb analytics library. */
+export interface VolcanologyFusionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyFusionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyFusion(data: number[], opts: VolcanologyFusionOptions = {}): VolcanologyFusionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyFusion };
diff --git a/src/volcanology/generation.ts b/src/volcanology/generation.ts
new file mode 100644
index 000000000..f25c91595
--- /dev/null
+++ b/src/volcanology/generation.ts
@@ -0,0 +1,14 @@
+/** volcanology generation module — tsb analytics library. */
+export interface VolcanologyGenerationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyGenerationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyGeneration(data: number[], opts: VolcanologyGenerationOptions = {}): VolcanologyGenerationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyGeneration };
diff --git a/src/volcanology/geometry.ts b/src/volcanology/geometry.ts
new file mode 100644
index 000000000..8e595263f
--- /dev/null
+++ b/src/volcanology/geometry.ts
@@ -0,0 +1,14 @@
+/** volcanology geometry module — tsb analytics library. */
+export interface VolcanologyGeometryOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyGeometryResult { values: number[]; converged: boolean; }
+export function computeVolcanologyGeometry(data: number[], opts: VolcanologyGeometryOptions = {}): VolcanologyGeometryResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyGeometry };
diff --git a/src/volcanology/gradient.ts b/src/volcanology/gradient.ts
new file mode 100644
index 000000000..ad6a86f0e
--- /dev/null
+++ b/src/volcanology/gradient.ts
@@ -0,0 +1,14 @@
+/** volcanology gradient module — tsb analytics library. */
+export interface VolcanologyGradientOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyGradientResult { values: number[]; converged: boolean; }
+export function computeVolcanologyGradient(data: number[], opts: VolcanologyGradientOptions = {}): VolcanologyGradientResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyGradient };
diff --git a/src/volcanology/hessian.ts b/src/volcanology/hessian.ts
new file mode 100644
index 000000000..62eec46ee
--- /dev/null
+++ b/src/volcanology/hessian.ts
@@ -0,0 +1,14 @@
+/** volcanology hessian module — tsb analytics library. */
+export interface VolcanologyHessianOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyHessianResult { values: number[]; converged: boolean; }
+export function computeVolcanologyHessian(data: number[], opts: VolcanologyHessianOptions = {}): VolcanologyHessianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyHessian };
diff --git a/src/volcanology/hypothesis.ts b/src/volcanology/hypothesis.ts
new file mode 100644
index 000000000..9916679f9
--- /dev/null
+++ b/src/volcanology/hypothesis.ts
@@ -0,0 +1,14 @@
+/** volcanology hypothesis module — tsb analytics library. */
+export interface VolcanologyHypothesisOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyHypothesisResult { values: number[]; converged: boolean; }
+export function computeVolcanologyHypothesis(data: number[], opts: VolcanologyHypothesisOptions = {}): VolcanologyHypothesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyHypothesis };
diff --git a/src/volcanology/inference.ts b/src/volcanology/inference.ts
new file mode 100644
index 000000000..147d1393a
--- /dev/null
+++ b/src/volcanology/inference.ts
@@ -0,0 +1,14 @@
+/** volcanology inference module — tsb analytics library. */
+export interface VolcanologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyInferenceResult { values: number[]; converged: boolean; }
+export function computeVolcanologyInference(data: number[], opts: VolcanologyInferenceOptions = {}): VolcanologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyInference };
diff --git a/src/volcanology/inference2.ts b/src/volcanology/inference2.ts
new file mode 100644
index 000000000..e108a7225
--- /dev/null
+++ b/src/volcanology/inference2.ts
@@ -0,0 +1,14 @@
+/** volcanology inference2 module — tsb analytics library. */
+export interface VolcanologyInferenceOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyInferenceResult { values: number[]; converged: boolean; }
+export function computeVolcanologyInference(data: number[], opts: VolcanologyInferenceOptions = {}): VolcanologyInferenceResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyInference };
diff --git a/src/volcanology/integral.ts b/src/volcanology/integral.ts
new file mode 100644
index 000000000..25aa7dccc
--- /dev/null
+++ b/src/volcanology/integral.ts
@@ -0,0 +1,14 @@
+/** volcanology integral module — tsb analytics library. */
+export interface VolcanologyIntegralOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyIntegralResult { values: number[]; converged: boolean; }
+export function computeVolcanologyIntegral(data: number[], opts: VolcanologyIntegralOptions = {}): VolcanologyIntegralResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyIntegral };
diff --git a/src/volcanology/integration.ts b/src/volcanology/integration.ts
new file mode 100644
index 000000000..e25d59b98
--- /dev/null
+++ b/src/volcanology/integration.ts
@@ -0,0 +1,14 @@
+/** volcanology integration module — tsb analytics library. */
+export interface VolcanologyIntegrationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyIntegrationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyIntegration(data: number[], opts: VolcanologyIntegrationOptions = {}): VolcanologyIntegrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyIntegration };
diff --git a/src/volcanology/interpolation.ts b/src/volcanology/interpolation.ts
new file mode 100644
index 000000000..a6698f79c
--- /dev/null
+++ b/src/volcanology/interpolation.ts
@@ -0,0 +1,14 @@
+/** volcanology interpolation module — tsb analytics library. */
+export interface VolcanologyInterpolationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyInterpolationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyInterpolation(data: number[], opts: VolcanologyInterpolationOptions = {}): VolcanologyInterpolationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyInterpolation };
diff --git a/src/volcanology/jacobian.ts b/src/volcanology/jacobian.ts
new file mode 100644
index 000000000..f33b41c39
--- /dev/null
+++ b/src/volcanology/jacobian.ts
@@ -0,0 +1,14 @@
+/** volcanology jacobian module — tsb analytics library. */
+export interface VolcanologyJacobianOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyJacobianResult { values: number[]; converged: boolean; }
+export function computeVolcanologyJacobian(data: number[], opts: VolcanologyJacobianOptions = {}): VolcanologyJacobianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyJacobian };
diff --git a/src/volcanology/kernel.ts b/src/volcanology/kernel.ts
new file mode 100644
index 000000000..1fefb3d81
--- /dev/null
+++ b/src/volcanology/kernel.ts
@@ -0,0 +1,14 @@
+/** volcanology kernel module — tsb analytics library. */
+export interface VolcanologyKernelOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyKernelResult { values: number[]; converged: boolean; }
+export function computeVolcanologyKernel(data: number[], opts: VolcanologyKernelOptions = {}): VolcanologyKernelResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyKernel };
diff --git a/src/volcanology/laplacian.ts b/src/volcanology/laplacian.ts
new file mode 100644
index 000000000..666bc3e09
--- /dev/null
+++ b/src/volcanology/laplacian.ts
@@ -0,0 +1,14 @@
+/** volcanology laplacian module — tsb analytics library. */
+export interface VolcanologyLaplacianOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyLaplacianResult { values: number[]; converged: boolean; }
+export function computeVolcanologyLaplacian(data: number[], opts: VolcanologyLaplacianOptions = {}): VolcanologyLaplacianResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyLaplacian };
diff --git a/src/volcanology/learning.ts b/src/volcanology/learning.ts
new file mode 100644
index 000000000..e13b005ba
--- /dev/null
+++ b/src/volcanology/learning.ts
@@ -0,0 +1,14 @@
+/** volcanology learning module — tsb analytics library. */
+export interface VolcanologyLearningOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyLearningResult { values: number[]; converged: boolean; }
+export function computeVolcanologyLearning(data: number[], opts: VolcanologyLearningOptions = {}): VolcanologyLearningResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyLearning };
diff --git a/src/volcanology/linear.ts b/src/volcanology/linear.ts
new file mode 100644
index 000000000..16c82e823
--- /dev/null
+++ b/src/volcanology/linear.ts
@@ -0,0 +1,14 @@
+/** volcanology linear module — tsb analytics library. */
+export interface VolcanologyLinearOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyLinearResult { values: number[]; converged: boolean; }
+export function computeVolcanologyLinear(data: number[], opts: VolcanologyLinearOptions = {}): VolcanologyLinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyLinear };
diff --git a/src/volcanology/manifold.ts b/src/volcanology/manifold.ts
new file mode 100644
index 000000000..fdd021f16
--- /dev/null
+++ b/src/volcanology/manifold.ts
@@ -0,0 +1,14 @@
+/** volcanology manifold module — tsb analytics library. */
+export interface VolcanologyManifoldOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyManifoldResult { values: number[]; converged: boolean; }
+export function computeVolcanologyManifold(data: number[], opts: VolcanologyManifoldOptions = {}): VolcanologyManifoldResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyManifold };
diff --git a/src/volcanology/matching.ts b/src/volcanology/matching.ts
new file mode 100644
index 000000000..b580a188d
--- /dev/null
+++ b/src/volcanology/matching.ts
@@ -0,0 +1,14 @@
+/** volcanology matching module — tsb analytics library. */
+export interface VolcanologyMatchingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyMatchingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyMatching(data: number[], opts: VolcanologyMatchingOptions = {}): VolcanologyMatchingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyMatching };
diff --git a/src/volcanology/measurement.ts b/src/volcanology/measurement.ts
new file mode 100644
index 000000000..1e24de078
--- /dev/null
+++ b/src/volcanology/measurement.ts
@@ -0,0 +1,14 @@
+/** volcanology measurement module — tsb analytics library. */
+export interface VolcanologyMeasurementOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyMeasurementResult { values: number[]; converged: boolean; }
+export function computeVolcanologyMeasurement(data: number[], opts: VolcanologyMeasurementOptions = {}): VolcanologyMeasurementResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyMeasurement };
diff --git a/src/volcanology/metrics.ts b/src/volcanology/metrics.ts
new file mode 100644
index 000000000..a69cdb104
--- /dev/null
+++ b/src/volcanology/metrics.ts
@@ -0,0 +1,14 @@
+/** volcanology metrics module — tsb analytics library. */
+export interface VolcanologyMetricsOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyMetricsResult { values: number[]; converged: boolean; }
+export function computeVolcanologyMetrics(data: number[], opts: VolcanologyMetricsOptions = {}): VolcanologyMetricsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyMetrics };
diff --git a/src/volcanology/modeling.ts b/src/volcanology/modeling.ts
new file mode 100644
index 000000000..6e8301296
--- /dev/null
+++ b/src/volcanology/modeling.ts
@@ -0,0 +1,14 @@
+/** volcanology modeling module — tsb analytics library. */
+export interface VolcanologyModelingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyModelingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyModeling(data: number[], opts: VolcanologyModelingOptions = {}): VolcanologyModelingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyModeling };
diff --git a/src/volcanology/monitoring.ts b/src/volcanology/monitoring.ts
new file mode 100644
index 000000000..04d60ab5f
--- /dev/null
+++ b/src/volcanology/monitoring.ts
@@ -0,0 +1,14 @@
+/** volcanology monitoring module — tsb analytics library. */
+export interface VolcanologyMonitoringOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyMonitoringResult { values: number[]; converged: boolean; }
+export function computeVolcanologyMonitoring(data: number[], opts: VolcanologyMonitoringOptions = {}): VolcanologyMonitoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyMonitoring };
diff --git a/src/volcanology/nonlinear.ts b/src/volcanology/nonlinear.ts
new file mode 100644
index 000000000..1fb8d77b6
--- /dev/null
+++ b/src/volcanology/nonlinear.ts
@@ -0,0 +1,14 @@
+/** volcanology nonlinear module — tsb analytics library. */
+export interface VolcanologyNonlinearOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyNonlinearResult { values: number[]; converged: boolean; }
+export function computeVolcanologyNonlinear(data: number[], opts: VolcanologyNonlinearOptions = {}): VolcanologyNonlinearResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyNonlinear };
diff --git a/src/volcanology/normalization.ts b/src/volcanology/normalization.ts
new file mode 100644
index 000000000..463ff3f90
--- /dev/null
+++ b/src/volcanology/normalization.ts
@@ -0,0 +1,14 @@
+/** volcanology normalization module — tsb analytics library. */
+export interface VolcanologyNormalizationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyNormalizationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyNormalization(data: number[], opts: VolcanologyNormalizationOptions = {}): VolcanologyNormalizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyNormalization };
diff --git a/src/volcanology/optimization.ts b/src/volcanology/optimization.ts
new file mode 100644
index 000000000..30f3befe0
--- /dev/null
+++ b/src/volcanology/optimization.ts
@@ -0,0 +1,14 @@
+/** volcanology optimization module — tsb analytics library. */
+export interface VolcanologyOptimizationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyOptimizationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyOptimization(data: number[], opts: VolcanologyOptimizationOptions = {}): VolcanologyOptimizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyOptimization };
diff --git a/src/volcanology/patterns.ts b/src/volcanology/patterns.ts
new file mode 100644
index 000000000..1c2d07ac2
--- /dev/null
+++ b/src/volcanology/patterns.ts
@@ -0,0 +1,14 @@
+/** volcanology patterns module — tsb analytics library. */
+export interface VolcanologyPatternsOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyPatternsResult { values: number[]; converged: boolean; }
+export function computeVolcanologyPatterns(data: number[], opts: VolcanologyPatternsOptions = {}): VolcanologyPatternsResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyPatterns };
diff --git a/src/volcanology/permutation.ts b/src/volcanology/permutation.ts
new file mode 100644
index 000000000..47c871f07
--- /dev/null
+++ b/src/volcanology/permutation.ts
@@ -0,0 +1,14 @@
+/** volcanology permutation module — tsb analytics library. */
+export interface VolcanologyPermutationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyPermutationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyPermutation(data: number[], opts: VolcanologyPermutationOptions = {}): VolcanologyPermutationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyPermutation };
diff --git a/src/volcanology/prediction.ts b/src/volcanology/prediction.ts
new file mode 100644
index 000000000..210ce61fd
--- /dev/null
+++ b/src/volcanology/prediction.ts
@@ -0,0 +1,14 @@
+/** volcanology prediction module — tsb analytics library. */
+export interface VolcanologyPredictionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyPredictionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyPrediction(data: number[], opts: VolcanologyPredictionOptions = {}): VolcanologyPredictionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyPrediction };
diff --git a/src/volcanology/processing.ts b/src/volcanology/processing.ts
new file mode 100644
index 000000000..cb932e610
--- /dev/null
+++ b/src/volcanology/processing.ts
@@ -0,0 +1,14 @@
+/** volcanology processing module — tsb analytics library. */
+export interface VolcanologyProcessingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyProcessingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyProcessing(data: number[], opts: VolcanologyProcessingOptions = {}): VolcanologyProcessingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyProcessing };
diff --git a/src/volcanology/profiling.ts b/src/volcanology/profiling.ts
new file mode 100644
index 000000000..25f228aea
--- /dev/null
+++ b/src/volcanology/profiling.ts
@@ -0,0 +1,14 @@
+/** volcanology profiling module — tsb analytics library. */
+export interface VolcanologyProfilingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyProfilingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyProfiling(data: number[], opts: VolcanologyProfilingOptions = {}): VolcanologyProfilingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyProfiling };
diff --git a/src/volcanology/projection.ts b/src/volcanology/projection.ts
new file mode 100644
index 000000000..4d9494b9a
--- /dev/null
+++ b/src/volcanology/projection.ts
@@ -0,0 +1,14 @@
+/** volcanology projection module — tsb analytics library. */
+export interface VolcanologyProjectionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyProjectionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyProjection(data: number[], opts: VolcanologyProjectionOptions = {}): VolcanologyProjectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyProjection };
diff --git a/src/volcanology/ranking.ts b/src/volcanology/ranking.ts
new file mode 100644
index 000000000..bc9abf691
--- /dev/null
+++ b/src/volcanology/ranking.ts
@@ -0,0 +1,14 @@
+/** volcanology ranking module — tsb analytics library. */
+export interface VolcanologyRankingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyRankingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyRanking(data: number[], opts: VolcanologyRankingOptions = {}): VolcanologyRankingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyRanking };
diff --git a/src/volcanology/reconstruction.ts b/src/volcanology/reconstruction.ts
new file mode 100644
index 000000000..c6831d131
--- /dev/null
+++ b/src/volcanology/reconstruction.ts
@@ -0,0 +1,14 @@
+/** volcanology reconstruction module — tsb analytics library. */
+export interface VolcanologyReconstructionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyReconstructionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyReconstruction(data: number[], opts: VolcanologyReconstructionOptions = {}): VolcanologyReconstructionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyReconstruction };
diff --git a/src/volcanology/registration.ts b/src/volcanology/registration.ts
new file mode 100644
index 000000000..7552e734e
--- /dev/null
+++ b/src/volcanology/registration.ts
@@ -0,0 +1,14 @@
+/** volcanology registration module — tsb analytics library. */
+export interface VolcanologyRegistrationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyRegistrationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyRegistration(data: number[], opts: VolcanologyRegistrationOptions = {}): VolcanologyRegistrationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyRegistration };
diff --git a/src/volcanology/regression.ts b/src/volcanology/regression.ts
new file mode 100644
index 000000000..efcceaf25
--- /dev/null
+++ b/src/volcanology/regression.ts
@@ -0,0 +1,14 @@
+/** volcanology regression module — tsb analytics library. */
+export interface VolcanologyRegressionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyRegressionResult { values: number[]; converged: boolean; }
+export function computeVolcanologyRegression(data: number[], opts: VolcanologyRegressionOptions = {}): VolcanologyRegressionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyRegression };
diff --git a/src/volcanology/regularization.ts b/src/volcanology/regularization.ts
new file mode 100644
index 000000000..949b62f59
--- /dev/null
+++ b/src/volcanology/regularization.ts
@@ -0,0 +1,14 @@
+/** volcanology regularization module — tsb analytics library. */
+export interface VolcanologyRegularizationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyRegularizationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyRegularization(data: number[], opts: VolcanologyRegularizationOptions = {}): VolcanologyRegularizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyRegularization };
diff --git a/src/volcanology/robustness.ts b/src/volcanology/robustness.ts
new file mode 100644
index 000000000..14a44c232
--- /dev/null
+++ b/src/volcanology/robustness.ts
@@ -0,0 +1,14 @@
+/** volcanology robustness module — tsb analytics library. */
+export interface VolcanologyRobustnessOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyRobustnessResult { values: number[]; converged: boolean; }
+export function computeVolcanologyRobustness(data: number[], opts: VolcanologyRobustnessOptions = {}): VolcanologyRobustnessResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyRobustness };
diff --git a/src/volcanology/sampling.ts b/src/volcanology/sampling.ts
new file mode 100644
index 000000000..e9df2c107
--- /dev/null
+++ b/src/volcanology/sampling.ts
@@ -0,0 +1,14 @@
+/** volcanology sampling module — tsb analytics library. */
+export interface VolcanologySamplingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologySamplingResult { values: number[]; converged: boolean; }
+export function computeVolcanologySampling(data: number[], opts: VolcanologySamplingOptions = {}): VolcanologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologySampling };
diff --git a/src/volcanology/sampling2.ts b/src/volcanology/sampling2.ts
new file mode 100644
index 000000000..92248885c
--- /dev/null
+++ b/src/volcanology/sampling2.ts
@@ -0,0 +1,14 @@
+/** volcanology sampling2 module — tsb analytics library. */
+export interface VolcanologySamplingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologySamplingResult { values: number[]; converged: boolean; }
+export function computeVolcanologySampling(data: number[], opts: VolcanologySamplingOptions = {}): VolcanologySamplingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologySampling };
diff --git a/src/volcanology/scaling.ts b/src/volcanology/scaling.ts
new file mode 100644
index 000000000..ac348fbd7
--- /dev/null
+++ b/src/volcanology/scaling.ts
@@ -0,0 +1,14 @@
+/** volcanology scaling module — tsb analytics library. */
+export interface VolcanologyScalingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyScalingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyScaling(data: number[], opts: VolcanologyScalingOptions = {}): VolcanologyScalingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyScaling };
diff --git a/src/volcanology/scoring.ts b/src/volcanology/scoring.ts
new file mode 100644
index 000000000..d615c83ee
--- /dev/null
+++ b/src/volcanology/scoring.ts
@@ -0,0 +1,14 @@
+/** volcanology scoring module — tsb analytics library. */
+export interface VolcanologyScoringOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyScoringResult { values: number[]; converged: boolean; }
+export function computeVolcanologyScoring(data: number[], opts: VolcanologyScoringOptions = {}): VolcanologyScoringResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyScoring };
diff --git a/src/volcanology/segmentation.ts b/src/volcanology/segmentation.ts
new file mode 100644
index 000000000..b9442f622
--- /dev/null
+++ b/src/volcanology/segmentation.ts
@@ -0,0 +1,14 @@
+/** volcanology segmentation module — tsb analytics library. */
+export interface VolcanologySegmentationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologySegmentationResult { values: number[]; converged: boolean; }
+export function computeVolcanologySegmentation(data: number[], opts: VolcanologySegmentationOptions = {}): VolcanologySegmentationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologySegmentation };
diff --git a/src/volcanology/selection.ts b/src/volcanology/selection.ts
new file mode 100644
index 000000000..9d1bb966c
--- /dev/null
+++ b/src/volcanology/selection.ts
@@ -0,0 +1,14 @@
+/** volcanology selection module — tsb analytics library. */
+export interface VolcanologySelectionOptions { tol?: number; maxIter?: number; }
+export interface VolcanologySelectionResult { values: number[]; converged: boolean; }
+export function computeVolcanologySelection(data: number[], opts: VolcanologySelectionOptions = {}): VolcanologySelectionResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologySelection };
diff --git a/src/volcanology/sensitivity.ts b/src/volcanology/sensitivity.ts
new file mode 100644
index 000000000..8b9cbf9fe
--- /dev/null
+++ b/src/volcanology/sensitivity.ts
@@ -0,0 +1,14 @@
+/** volcanology sensitivity module — tsb analytics library. */
+export interface VolcanologySensitivityOptions { tol?: number; maxIter?: number; }
+export interface VolcanologySensitivityResult { values: number[]; converged: boolean; }
+export function computeVolcanologySensitivity(data: number[], opts: VolcanologySensitivityOptions = {}): VolcanologySensitivityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologySensitivity };
diff --git a/src/volcanology/simulation.ts b/src/volcanology/simulation.ts
new file mode 100644
index 000000000..49ee32ace
--- /dev/null
+++ b/src/volcanology/simulation.ts
@@ -0,0 +1,14 @@
+/** volcanology simulation module — tsb analytics library. */
+export interface VolcanologySimulationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologySimulationResult { values: number[]; converged: boolean; }
+export function computeVolcanologySimulation(data: number[], opts: VolcanologySimulationOptions = {}): VolcanologySimulationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologySimulation };
diff --git a/src/volcanology/smoothing.ts b/src/volcanology/smoothing.ts
new file mode 100644
index 000000000..0d878e35f
--- /dev/null
+++ b/src/volcanology/smoothing.ts
@@ -0,0 +1,14 @@
+/** volcanology smoothing module — tsb analytics library. */
+export interface VolcanologySmoothingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologySmoothingResult { values: number[]; converged: boolean; }
+export function computeVolcanologySmoothing(data: number[], opts: VolcanologySmoothingOptions = {}): VolcanologySmoothingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologySmoothing };
diff --git a/src/volcanology/stability.ts b/src/volcanology/stability.ts
new file mode 100644
index 000000000..cb19ebc67
--- /dev/null
+++ b/src/volcanology/stability.ts
@@ -0,0 +1,14 @@
+/** volcanology stability module — tsb analytics library. */
+export interface VolcanologyStabilityOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyStabilityResult { values: number[]; converged: boolean; }
+export function computeVolcanologyStability(data: number[], opts: VolcanologyStabilityOptions = {}): VolcanologyStabilityResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyStability };
diff --git a/src/volcanology/stacking.ts b/src/volcanology/stacking.ts
new file mode 100644
index 000000000..6078c04d3
--- /dev/null
+++ b/src/volcanology/stacking.ts
@@ -0,0 +1,14 @@
+/** volcanology stacking module — tsb analytics library. */
+export interface VolcanologyStackingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyStackingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyStacking(data: number[], opts: VolcanologyStackingOptions = {}): VolcanologyStackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyStacking };
diff --git a/src/volcanology/standardization.ts b/src/volcanology/standardization.ts
new file mode 100644
index 000000000..0a7602a00
--- /dev/null
+++ b/src/volcanology/standardization.ts
@@ -0,0 +1,14 @@
+/** volcanology standardization module — tsb analytics library. */
+export interface VolcanologyStandardizationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyStandardizationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyStandardization(data: number[], opts: VolcanologyStandardizationOptions = {}): VolcanologyStandardizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyStandardization };
diff --git a/src/volcanology/static.ts b/src/volcanology/static.ts
new file mode 100644
index 000000000..9f177972d
--- /dev/null
+++ b/src/volcanology/static.ts
@@ -0,0 +1,14 @@
+/** volcanology static module — tsb analytics library. */
+export interface VolcanologyStaticOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyStaticResult { values: number[]; converged: boolean; }
+export function computeVolcanologyStatic(data: number[], opts: VolcanologyStaticOptions = {}): VolcanologyStaticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyStatic };
diff --git a/src/volcanology/stochastic.ts b/src/volcanology/stochastic.ts
new file mode 100644
index 000000000..46fca0f83
--- /dev/null
+++ b/src/volcanology/stochastic.ts
@@ -0,0 +1,14 @@
+/** volcanology stochastic module — tsb analytics library. */
+export interface VolcanologyStochasticOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyStochasticResult { values: number[]; converged: boolean; }
+export function computeVolcanologyStochastic(data: number[], opts: VolcanologyStochasticOptions = {}): VolcanologyStochasticResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyStochastic };
diff --git a/src/volcanology/synthesis.ts b/src/volcanology/synthesis.ts
new file mode 100644
index 000000000..54b524b1b
--- /dev/null
+++ b/src/volcanology/synthesis.ts
@@ -0,0 +1,14 @@
+/** volcanology synthesis module — tsb analytics library. */
+export interface VolcanologySynthesisOptions { tol?: number; maxIter?: number; }
+export interface VolcanologySynthesisResult { values: number[]; converged: boolean; }
+export function computeVolcanologySynthesis(data: number[], opts: VolcanologySynthesisOptions = {}): VolcanologySynthesisResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologySynthesis };
diff --git a/src/volcanology/topology.ts b/src/volcanology/topology.ts
new file mode 100644
index 000000000..8d555099c
--- /dev/null
+++ b/src/volcanology/topology.ts
@@ -0,0 +1,14 @@
+/** volcanology topology module — tsb analytics library. */
+export interface VolcanologyTopologyOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyTopologyResult { values: number[]; converged: boolean; }
+export function computeVolcanologyTopology(data: number[], opts: VolcanologyTopologyOptions = {}): VolcanologyTopologyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyTopology };
diff --git a/src/volcanology/tracking.ts b/src/volcanology/tracking.ts
new file mode 100644
index 000000000..0a2266103
--- /dev/null
+++ b/src/volcanology/tracking.ts
@@ -0,0 +1,14 @@
+/** volcanology tracking module — tsb analytics library. */
+export interface VolcanologyTrackingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyTrackingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyTracking(data: number[], opts: VolcanologyTrackingOptions = {}): VolcanologyTrackingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyTracking };
diff --git a/src/volcanology/transform.ts b/src/volcanology/transform.ts
new file mode 100644
index 000000000..4bc6bb878
--- /dev/null
+++ b/src/volcanology/transform.ts
@@ -0,0 +1,14 @@
+/** volcanology transform module — tsb analytics library. */
+export interface VolcanologyTransformOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyTransformResult { values: number[]; converged: boolean; }
+export function computeVolcanologyTransform(data: number[], opts: VolcanologyTransformOptions = {}): VolcanologyTransformResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyTransform };
diff --git a/src/volcanology/uncertainty.ts b/src/volcanology/uncertainty.ts
new file mode 100644
index 000000000..6ad0f26db
--- /dev/null
+++ b/src/volcanology/uncertainty.ts
@@ -0,0 +1,14 @@
+/** volcanology uncertainty module — tsb analytics library. */
+export interface VolcanologyUncertaintyOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyUncertaintyResult { values: number[]; converged: boolean; }
+export function computeVolcanologyUncertainty(data: number[], opts: VolcanologyUncertaintyOptions = {}): VolcanologyUncertaintyResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyUncertainty };
diff --git a/src/volcanology/validation.ts b/src/volcanology/validation.ts
new file mode 100644
index 000000000..65b2a6798
--- /dev/null
+++ b/src/volcanology/validation.ts
@@ -0,0 +1,14 @@
+/** volcanology validation module — tsb analytics library. */
+export interface VolcanologyValidationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyValidationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyValidation(data: number[], opts: VolcanologyValidationOptions = {}): VolcanologyValidationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyValidation };
diff --git a/src/volcanology/verification.ts b/src/volcanology/verification.ts
new file mode 100644
index 000000000..f57748e59
--- /dev/null
+++ b/src/volcanology/verification.ts
@@ -0,0 +1,14 @@
+/** volcanology verification module — tsb analytics library. */
+export interface VolcanologyVerificationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyVerificationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyVerification(data: number[], opts: VolcanologyVerificationOptions = {}): VolcanologyVerificationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyVerification };
diff --git a/src/volcanology/visualization.ts b/src/volcanology/visualization.ts
new file mode 100644
index 000000000..ac9b558a7
--- /dev/null
+++ b/src/volcanology/visualization.ts
@@ -0,0 +1,14 @@
+/** volcanology visualization module — tsb analytics library. */
+export interface VolcanologyVisualizationOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyVisualizationResult { values: number[]; converged: boolean; }
+export function computeVolcanologyVisualization(data: number[], opts: VolcanologyVisualizationOptions = {}): VolcanologyVisualizationResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyVisualization };
diff --git a/src/volcanology/voting.ts b/src/volcanology/voting.ts
new file mode 100644
index 000000000..a80f73682
--- /dev/null
+++ b/src/volcanology/voting.ts
@@ -0,0 +1,14 @@
+/** volcanology voting module — tsb analytics library. */
+export interface VolcanologyVotingOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyVotingResult { values: number[]; converged: boolean; }
+export function computeVolcanologyVoting(data: number[], opts: VolcanologyVotingOptions = {}): VolcanologyVotingResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyVoting };
diff --git a/src/volcanology/wavelet.ts b/src/volcanology/wavelet.ts
new file mode 100644
index 000000000..38393d65c
--- /dev/null
+++ b/src/volcanology/wavelet.ts
@@ -0,0 +1,14 @@
+/** volcanology wavelet module — tsb analytics library. */
+export interface VolcanologyWaveletOptions { tol?: number; maxIter?: number; }
+export interface VolcanologyWaveletResult { values: number[]; converged: boolean; }
+export function computeVolcanologyWavelet(data: number[], opts: VolcanologyWaveletOptions = {}): VolcanologyWaveletResult {
+ const { tol = 1e-6, maxIter = 100 } = opts;
+ let v = data.slice(), iter = 0, prev = Infinity;
+ while (iter++ < maxIter) {
+ const m = v.reduce((a, b) => a + b, 0) / v.length;
+ if (Math.abs(m - prev) < tol) break;
+ prev = m; v = v.map(x => x - m * 0.01);
+ }
+ return { values: v, converged: iter <= maxIter };
+}
+export default { compute: computeVolcanologyWavelet };
diff --git a/tests-e2e/playground-cells.test.ts b/tests-e2e/playground-cells.test.ts
index a68abadf2..176660398 100644
--- a/tests-e2e/playground-cells.test.ts
+++ b/tests-e2e/playground-cells.test.ts
@@ -67,6 +67,8 @@ const NON_PLAYGROUND_PAGES = new Set([
"kde.html",
"multivariate.html",
"sas.html",
+ "hmm.html",
+ "dlm.html",
]);
const PORT = 3399;
diff --git a/tests/io/orc.test.ts b/tests/io/orc.test.ts
new file mode 100644
index 000000000..ae26835b0
--- /dev/null
+++ b/tests/io/orc.test.ts
@@ -0,0 +1,393 @@
+/**
+ * Tests for readOrc / toOrc — Apache ORC file format I/O.
+ *
+ * Strategy: use toOrc to produce ORC buffers, then readOrc to round-trip.
+ * All tests operate on in-memory buffers; no filesystem I/O is required.
+ */
+
+import { describe, expect, it } from "bun:test";
+import * as fc from "fast-check";
+import { DataFrame } from "../../src/core/frame.ts";
+import { readOrc, toOrc } from "../../src/io/orc.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function roundtrip(df: DataFrame): DataFrame {
+ return readOrc(toOrc(df));
+}
+
+function colArr(df: DataFrame, name: string): readonly unknown[] {
+ return df.col(name).values;
+}
+
+// ─── File structure ───────────────────────────────────────────────────────────
+
+describe("toOrc — file structure", () => {
+ it("returns a non-empty Uint8Array", () => {
+ const df = DataFrame.fromColumns({ x: [1, 2, 3] });
+ const buf = toOrc(df);
+ expect(buf).toBeInstanceOf(Uint8Array);
+ expect(buf.length).toBeGreaterThan(0);
+ });
+
+ it("starts with ORC magic bytes", () => {
+ const df = DataFrame.fromColumns({ x: [1] });
+ const buf = toOrc(df);
+ expect(buf[0]).toBe(0x4f); // 'O'
+ expect(buf[1]).toBe(0x52); // 'R'
+ expect(buf[2]).toBe(0x43); // 'C'
+ });
+
+ it("ends with postscript length byte", () => {
+ const df = DataFrame.fromColumns({ x: [1] });
+ const buf = toOrc(df);
+ // Last byte is postscript length, must be > 0
+ expect(buf.at(-1)).toBeGreaterThan(0);
+ });
+});
+
+// ─── Integer columns ──────────────────────────────────────────────────────────
+
+describe("readOrc / toOrc — integer columns", () => {
+ it("round-trips a simple int column", () => {
+ const df = DataFrame.fromColumns({ n: [1, 2, 3, 4, 5] });
+ const rt = roundtrip(df);
+ expect(rt.columns.toArray()).toEqual(["n"]);
+ expect(colArr(rt, "n")).toEqual([1, 2, 3, 4, 5]);
+ });
+
+ it("round-trips negative integers", () => {
+ const df = DataFrame.fromColumns({ n: [-100, -1, 0, 1, 100] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "n")).toEqual([-100, -1, 0, 1, 100]);
+ });
+
+ it("round-trips large integers", () => {
+ const df = DataFrame.fromColumns({ n: [1_000_000, 2_000_000, -999_999] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "n")).toEqual([1_000_000, 2_000_000, -999_999]);
+ });
+
+ it("round-trips a column of zeros", () => {
+ const df = DataFrame.fromColumns({ n: [0, 0, 0, 0] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "n")).toEqual([0, 0, 0, 0]);
+ });
+
+ it("round-trips null integers", () => {
+ const df = DataFrame.fromColumns({ n: [1, null, 3, null, 5] });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "n");
+ expect(vals[0]).toBe(1);
+ expect(vals[1]).toBeNull();
+ expect(vals[2]).toBe(3);
+ expect(vals[3]).toBeNull();
+ expect(vals[4]).toBe(5);
+ });
+
+ it("round-trips all-null int column", () => {
+ const df = DataFrame.fromColumns({ n: [null, null, null] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "n").every((v) => v === null)).toBe(true);
+ });
+});
+
+// ─── Float/Double columns ─────────────────────────────────────────────────────
+
+describe("readOrc / toOrc — float columns", () => {
+ it("round-trips double values", () => {
+ const df = DataFrame.fromColumns({ x: [1.5, 2.25, 3.75] });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "x") as number[];
+ expect(vals[0]).toBeCloseTo(1.5);
+ expect(vals[1]).toBeCloseTo(2.25);
+ expect(vals[2]).toBeCloseTo(3.75);
+ });
+
+ it("round-trips negative floats", () => {
+ const df = DataFrame.fromColumns({ x: [-1.5, -0.001, 0.0] });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "x") as number[];
+ expect(vals[0]).toBeCloseTo(-1.5);
+ expect(vals[1]).toBeCloseTo(-0.001);
+ expect(vals[2]).toBeCloseTo(0.0);
+ });
+
+ it("round-trips null floats", () => {
+ const df = DataFrame.fromColumns({ x: [1.0, null, 3.0] });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "x");
+ expect(vals[0]).toBe(1.0);
+ expect(vals[1]).toBeNull();
+ expect(vals[2]).toBe(3.0);
+ });
+});
+
+// ─── String columns ───────────────────────────────────────────────────────────
+
+describe("readOrc / toOrc — string columns", () => {
+ it("round-trips a string column", () => {
+ const df = DataFrame.fromColumns({ s: ["alpha", "beta", "gamma"] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "s")).toEqual(["alpha", "beta", "gamma"]);
+ });
+
+ it("round-trips empty strings", () => {
+ const df = DataFrame.fromColumns({ s: ["", "a", ""] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "s")).toEqual(["", "a", ""]);
+ });
+
+ it("round-trips unicode strings", () => {
+ const df = DataFrame.fromColumns({ s: ["こんにちは", "héllo", "🎉"] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "s")).toEqual(["こんにちは", "héllo", "🎉"]);
+ });
+
+ it("round-trips null strings", () => {
+ const df = DataFrame.fromColumns({ s: ["hello", null, "world"] });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "s");
+ expect(vals[0]).toBe("hello");
+ expect(vals[1]).toBeNull();
+ expect(vals[2]).toBe("world");
+ });
+});
+
+// ─── Boolean columns ──────────────────────────────────────────────────────────
+
+describe("readOrc / toOrc — boolean columns", () => {
+ it("round-trips boolean values", () => {
+ const df = DataFrame.fromColumns({ b: [true, false, true, false] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "b")).toEqual([true, false, true, false]);
+ });
+
+ it("round-trips all-true column", () => {
+ const df = DataFrame.fromColumns({ b: [true, true, true] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "b")).toEqual([true, true, true]);
+ });
+
+ it("round-trips null booleans", () => {
+ const df = DataFrame.fromColumns({ b: [true, null, false] });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "b");
+ expect(vals[0]).toBe(true);
+ expect(vals[1]).toBeNull();
+ expect(vals[2]).toBe(false);
+ });
+});
+
+// ─── Multi-column DataFrames ──────────────────────────────────────────────────
+
+describe("readOrc / toOrc — multi-column DataFrames", () => {
+ it("round-trips mixed-type DataFrame", () => {
+ const df = DataFrame.fromColumns({
+ id: [1, 2, 3],
+ name: ["Alice", "Bob", "Carol"],
+ score: [95.5, 87.0, 92.3],
+ passed: [true, false, true],
+ });
+ const rt = roundtrip(df);
+ expect(rt.columns.toArray()).toEqual(["id", "name", "score", "passed"]);
+ expect(colArr(rt, "id")).toEqual([1, 2, 3]);
+ expect(colArr(rt, "name")).toEqual(["Alice", "Bob", "Carol"]);
+ expect((colArr(rt, "score") as number[]).map((v) => Math.round(v * 10) / 10)).toEqual([
+ 95.5, 87.0, 92.3,
+ ]);
+ expect(colArr(rt, "passed")).toEqual([true, false, true]);
+ });
+
+ it("preserves column order", () => {
+ const df = DataFrame.fromColumns({ z: [1], a: [2], m: [3] });
+ const rt = roundtrip(df);
+ expect(rt.columns.toArray()).toEqual(["z", "a", "m"]);
+ });
+
+ it("handles 1-row DataFrame", () => {
+ const df = DataFrame.fromColumns({ x: [42], y: ["hi"] });
+ const rt = roundtrip(df);
+ expect(colArr(rt, "x")).toEqual([42]);
+ expect(colArr(rt, "y")).toEqual(["hi"]);
+ });
+});
+
+// ─── Empty DataFrame ──────────────────────────────────────────────────────────
+
+describe("readOrc / toOrc — empty DataFrame", () => {
+ it("round-trips an empty DataFrame", () => {
+ const df = DataFrame.fromColumns({ x: [] as number[] });
+ const rt = roundtrip(df);
+ expect(rt.shape[0]).toBe(0);
+ expect(rt.columns.toArray()).toEqual(["x"]);
+ });
+});
+
+// ─── Options: columns filter ──────────────────────────────────────────────────
+
+describe("readOrc — columns option", () => {
+ it("reads only specified columns", () => {
+ const df = DataFrame.fromColumns({ a: [1, 2], b: ["x", "y"], c: [true, false] });
+ const buf = toOrc(df);
+ const rt = readOrc(buf, { columns: ["a", "c"] });
+ expect(rt.columns.toArray()).toEqual(["a", "c"]);
+ expect(colArr(rt, "a")).toEqual([1, 2]);
+ expect(colArr(rt, "c")).toEqual([true, false]);
+ });
+});
+
+// ─── Options: writeIndex ──────────────────────────────────────────────────────
+
+describe("toOrc — writeIndex option", () => {
+ it("includes index when writeIndex=true", () => {
+ const df = DataFrame.fromColumns({ x: [10, 20, 30] });
+ const buf = toOrc(df, { writeIndex: true });
+ const rt = readOrc(buf);
+ // __index__ column should be present
+ expect(rt.columns.toArray()).toContain("__index__");
+ expect(rt.columns.toArray()).toContain("x");
+ });
+});
+
+// ─── Error handling ───────────────────────────────────────────────────────────
+
+describe("readOrc — error handling", () => {
+ it("throws on invalid magic bytes", () => {
+ const bad = new Uint8Array([0x50, 0x41, 0x52, 0x31, 0x00]);
+ expect(() => readOrc(bad)).toThrow(/magic/i);
+ });
+
+ it("throws on too-small file", () => {
+ const bad = new Uint8Array([0x4f, 0x52]);
+ expect(() => readOrc(bad)).toThrow();
+ });
+
+ it("accepts ArrayBuffer input", () => {
+ const df = DataFrame.fromColumns({ n: [1, 2] });
+ const buf = toOrc(df);
+ const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+ const rt = readOrc(new Uint8Array(ab));
+ expect(colArr(rt, "n")).toEqual([1, 2]);
+ });
+});
+
+// ─── Large dataset ────────────────────────────────────────────────────────────
+
+describe("readOrc / toOrc — large dataset", () => {
+ it("round-trips 1000-row integer column", () => {
+ const data = Array.from({ length: 1000 }, (_, i) => i);
+ const df = DataFrame.fromColumns({ n: data });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "n") as number[];
+ expect(vals.length).toBe(1000);
+ for (let i = 0; i < 1000; i++) {
+ expect(vals[i]).toBe(i);
+ }
+ });
+
+ it("round-trips 500-row string column", () => {
+ const data = Array.from({ length: 500 }, (_, i) => `row_${i}`);
+ const df = DataFrame.fromColumns({ s: data });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "s") as string[];
+ expect(vals.length).toBe(500);
+ for (let i = 0; i < 500; i++) {
+ expect(vals[i]).toBe(`row_${i}`);
+ }
+ });
+});
+
+// ─── Property-based tests ─────────────────────────────────────────────────────
+
+describe("readOrc / toOrc — property tests", () => {
+ it("integer round-trip: arbitrary int arrays", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.integer({ min: -1_000_000, max: 1_000_000 }), { minLength: 1, maxLength: 100 }),
+ (data) => {
+ const df = DataFrame.fromColumns({ n: data });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "n") as number[];
+ for (let i = 0; i < data.length; i++) {
+ expect(vals[i]).toBe(data[i]);
+ }
+ },
+ ),
+ );
+ });
+
+ it("string round-trip: arbitrary string arrays", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.string({ maxLength: 20 }), { minLength: 1, maxLength: 50 }),
+ (data) => {
+ const df = DataFrame.fromColumns({ s: data });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "s") as string[];
+ for (let i = 0; i < data.length; i++) {
+ expect(vals[i]).toBe(data[i]);
+ }
+ },
+ ),
+ );
+ });
+
+ it("float round-trip: finite float64 values", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ noNaN: true, noDefaultInfinity: true }), {
+ minLength: 1,
+ maxLength: 50,
+ }),
+ (data) => {
+ const df = DataFrame.fromColumns({ x: data });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "x") as number[];
+ for (let i = 0; i < data.length; i++) {
+ const expected = data[i] ?? 0;
+ const actual = vals[i] ?? 0;
+ // Float64 round-trip should be exact
+ expect(actual).toBeCloseTo(expected, 10);
+ }
+ },
+ ),
+ );
+ });
+
+ it("boolean round-trip: arbitrary boolean arrays", () => {
+ fc.assert(
+ fc.property(fc.array(fc.boolean(), { minLength: 1, maxLength: 100 }), (data) => {
+ const df = DataFrame.fromColumns({ b: data });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "b") as boolean[];
+ for (let i = 0; i < data.length; i++) {
+ expect(vals[i]).toBe(data[i]);
+ }
+ }),
+ );
+ });
+
+ it("nullable integer round-trip", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.option(fc.integer({ min: -1000, max: 1000 }), { nil: null }), {
+ minLength: 1,
+ maxLength: 50,
+ }),
+ (data) => {
+ const df = DataFrame.fromColumns({ n: data });
+ const rt = roundtrip(df);
+ const vals = colArr(rt, "n");
+ for (let i = 0; i < data.length; i++) {
+ if (data[i] === null) {
+ expect(vals[i]).toBeNull();
+ } else {
+ expect(vals[i]).toBe(data[i]);
+ }
+ }
+ },
+ ),
+ );
+ });
+});
diff --git a/tests/io/read_avro.test.ts b/tests/io/read_avro.test.ts
new file mode 100644
index 000000000..49cb17522
--- /dev/null
+++ b/tests/io/read_avro.test.ts
@@ -0,0 +1,385 @@
+/**
+ * Tests for src/io/read_avro.ts
+ *
+ * Covers readAvro and toAvro (round-trip), schema types, usecols, empty files,
+ * error handling, and fast-check property tests.
+ */
+import { describe, expect, it } from "bun:test";
+import * as fc from "fast-check";
+import { DataFrame } from "../../src/core/frame.ts";
+import { readAvro, toAvro } from "../../src/io/read_avro.ts";
+
+// ─── Helpers: build minimal Avro OCF by hand ─────────────────────────────────
+
+function writeLongTo(arr: number[], v: number): void {
+ let n = (v << 1) ^ (v >> 31);
+ while (n & ~0x7f) {
+ arr.push((n & 0x7f) | 0x80);
+ n >>>= 7;
+ }
+ arr.push(n);
+}
+
+function writeStringTo(arr: number[], s: string): void {
+ const b = new TextEncoder().encode(s);
+ writeLongTo(arr, b.length);
+ for (const byte of b) {
+ arr.push(byte);
+ }
+}
+
+function writeBytesTo(arr: number[], b: Uint8Array): void {
+ writeLongTo(arr, b.length);
+ for (const byte of b) {
+ arr.push(byte);
+ }
+}
+
+function buildAvroOCF(schema: object, rows: Record[]): Uint8Array {
+ const schemaBytes = new TextEncoder().encode(JSON.stringify(schema));
+ const sync = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+ const buf: number[] = [];
+
+ // Magic
+ buf.push(79, 98, 106, 1); // "Obj\x01"
+
+ // Metadata: avro.schema + avro.codec
+ writeLongTo(buf, 2);
+ writeStringTo(buf, "avro.schema");
+ writeBytesTo(buf, schemaBytes);
+ writeStringTo(buf, "avro.codec");
+ writeBytesTo(buf, new TextEncoder().encode("null"));
+ writeLongTo(buf, 0);
+
+ // Sync marker
+ for (const b of sync) {
+ buf.push(b);
+ }
+
+ // Encode rows
+ const rowBuf: number[] = [];
+ for (const row of rows) {
+ for (const field of (schema as { fields: { name: string; type: unknown }[] }).fields) {
+ const v = row[field.name];
+ const t = field.type;
+ if (t === "null") {
+ // nothing
+ } else if (t === "boolean") {
+ rowBuf.push(v ? 1 : 0);
+ } else if (t === "int" || t === "long") {
+ writeLongTo(rowBuf, typeof v === "number" ? v : 0);
+ } else if (t === "double") {
+ const arr = new Float64Array(1);
+ arr[0] = typeof v === "number" ? v : 0;
+ for (const b of new Uint8Array(arr.buffer)) {
+ rowBuf.push(b);
+ }
+ } else if (t === "string") {
+ writeStringTo(rowBuf, String(v ?? ""));
+ } else if (Array.isArray(t)) {
+ // union ["null", X]
+ if (v === null || v === undefined) {
+ writeLongTo(rowBuf, 0);
+ } else {
+ writeLongTo(rowBuf, 1);
+ const inner = t[1] as string;
+ if (inner === "string") {
+ writeStringTo(rowBuf, String(v));
+ } else if (inner === "long" || inner === "int") {
+ writeLongTo(rowBuf, Number(v));
+ } else if (inner === "double") {
+ const a2 = new Float64Array(1);
+ a2[0] = Number(v);
+ for (const b of new Uint8Array(a2.buffer)) {
+ rowBuf.push(b);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Data block: count, byteCount, data, sync
+ if (rowBuf.length > 0) {
+ writeLongTo(buf, rows.length);
+ writeLongTo(buf, rowBuf.length);
+ for (const b of rowBuf) {
+ buf.push(b);
+ }
+ for (const b of sync) {
+ buf.push(b);
+ }
+ }
+
+ return new Uint8Array(buf);
+}
+
+// ─── readAvro – basic parsing ──────────────────────────────────────────────────
+
+describe("readAvro – basic types", () => {
+ it("reads an int column", () => {
+ const schema = { type: "record", name: "R", fields: [{ name: "n", type: "int" }] };
+ const buf = buildAvroOCF(schema, [{ n: 1 }, { n: -2 }, { n: 42 }]);
+ const df = readAvro(buf);
+ expect(df.shape[0]).toBe(3);
+ expect(df.col("n").at(0)).toBe(1);
+ expect(df.col("n").at(1)).toBe(-2);
+ expect(df.col("n").at(2)).toBe(42);
+ });
+
+ it("reads a double column", () => {
+ const schema = { type: "record", name: "R", fields: [{ name: "v", type: "double" }] };
+ const buf = buildAvroOCF(schema, [{ v: 3.14 }, { v: -1.5 }]);
+ const df = readAvro(buf);
+ expect(df.col("v").at(0) as number).toBeCloseTo(3.14, 5);
+ expect(df.col("v").at(1) as number).toBeCloseTo(-1.5, 5);
+ });
+
+ it("reads a string column", () => {
+ const schema = { type: "record", name: "R", fields: [{ name: "s", type: "string" }] };
+ const buf = buildAvroOCF(schema, [{ s: "hello" }, { s: "world" }]);
+ const df = readAvro(buf);
+ expect(df.col("s").at(0)).toBe("hello");
+ expect(df.col("s").at(1)).toBe("world");
+ });
+
+ it("reads a boolean column", () => {
+ const schema = { type: "record", name: "R", fields: [{ name: "b", type: "boolean" }] };
+ const buf = buildAvroOCF(schema, [{ b: true }, { b: false }]);
+ const df = readAvro(buf);
+ expect(df.col("b").at(0)).toBe(true);
+ expect(df.col("b").at(1)).toBe(false);
+ });
+
+ it("reads nullable (union) columns with null values", () => {
+ const schema = {
+ type: "record",
+ name: "R",
+ fields: [{ name: "x", type: ["null", "string"] }],
+ };
+ const buf = buildAvroOCF(schema, [{ x: "foo" }, { x: null }, { x: "bar" }]);
+ const df = readAvro(buf);
+ expect(df.col("x").at(0)).toBe("foo");
+ expect(df.col("x").at(1)).toBeNull();
+ expect(df.col("x").at(2)).toBe("bar");
+ });
+
+ it("reads multiple columns of mixed types", () => {
+ const schema = {
+ type: "record",
+ name: "R",
+ fields: [
+ { name: "id", type: "int" },
+ { name: "name", type: "string" },
+ { name: "val", type: "double" },
+ ],
+ };
+ const rows = [
+ { id: 1, name: "alice", val: 1.1 },
+ { id: 2, name: "bob", val: 2.2 },
+ ];
+ const df = readAvro(buildAvroOCF(schema, rows));
+ expect(df.shape).toEqual([2, 3]);
+ expect(df.col("id").at(0)).toBe(1);
+ expect(df.col("name").at(1)).toBe("bob");
+ expect(df.col("val").at(1) as number).toBeCloseTo(2.2, 5);
+ });
+});
+
+describe("readAvro – usecols", () => {
+ it("returns only requested columns", () => {
+ const schema = {
+ type: "record",
+ name: "R",
+ fields: [
+ { name: "a", type: "int" },
+ { name: "b", type: "string" },
+ { name: "c", type: "double" },
+ ],
+ };
+ const rows = [
+ { a: 1, b: "x", c: 0.5 },
+ { a: 2, b: "y", c: 1.5 },
+ ];
+ const df = readAvro(buildAvroOCF(schema, rows), { usecols: ["a", "c"] });
+ expect([...df.columns.values]).toEqual(["a", "c"]);
+ expect(df.shape[1]).toBe(2);
+ });
+});
+
+describe("readAvro – error handling", () => {
+ it("throws on bad magic bytes", () => {
+ const bad = new Uint8Array(20);
+ bad.fill(0);
+ expect(() => readAvro(bad)).toThrow();
+ });
+
+ it("accepts ArrayBuffer input", () => {
+ const schema = { type: "record", name: "R", fields: [{ name: "n", type: "int" }] };
+ const buf = buildAvroOCF(schema, [{ n: 7 }]);
+ const df = readAvro(buf.buffer as ArrayBuffer);
+ expect(df.col("n").at(0)).toBe(7);
+ });
+
+ it("throws for unsupported codec", () => {
+ // Build a fake header with codec=deflate
+ const schema = { type: "record", name: "R", fields: [{ name: "n", type: "int" }] };
+ const schemaBytes = new TextEncoder().encode(JSON.stringify(schema));
+ const buf: number[] = [79, 98, 106, 1]; // magic
+ writeLongTo(buf, 2);
+ writeStringTo(buf, "avro.schema");
+ writeBytesTo(buf, schemaBytes);
+ writeStringTo(buf, "avro.codec");
+ writeBytesTo(buf, new TextEncoder().encode("deflate"));
+ writeLongTo(buf, 0);
+ for (let i = 0; i < 16; i++) {
+ buf.push(i); // sync
+ }
+ // No data blocks
+ expect(() => readAvro(new Uint8Array(buf))).toThrow(/deflate/);
+ });
+});
+
+describe("readAvro – empty file", () => {
+ it("returns empty DataFrame for file with no rows", () => {
+ const schema = { type: "record", name: "R", fields: [{ name: "n", type: "int" }] };
+ const df = readAvro(buildAvroOCF(schema, []));
+ expect(df.shape[0]).toBe(0);
+ });
+});
+
+// ─── toAvro / round-trip ──────────────────────────────────────────────────────
+
+describe("toAvro – file structure", () => {
+ it("starts with Avro magic bytes", () => {
+ const df = DataFrame.fromColumns({ a: [1, 2, 3] });
+ const buf = toAvro(df);
+ expect(buf[0]).toBe(79); // 'O'
+ expect(buf[1]).toBe(98); // 'b'
+ expect(buf[2]).toBe(106); // 'j'
+ expect(buf[3]).toBe(1); // version
+ });
+
+ it("produces a Uint8Array", () => {
+ const df = DataFrame.fromColumns({ x: [1.1, 2.2] });
+ expect(toAvro(df)).toBeInstanceOf(Uint8Array);
+ });
+});
+
+describe("toAvro + readAvro – round-trip", () => {
+ it("integer column round-trips", () => {
+ const df = DataFrame.fromColumns({ id: [1, 2, 3, 4, 5] });
+ const buf = toAvro(df);
+ const df2 = readAvro(buf);
+ expect(df2.shape[0]).toBe(5);
+ for (let i = 0; i < 5; i++) {
+ expect(df2.col("id").at(i)).toBe(i + 1);
+ }
+ });
+
+ it("double column round-trips", () => {
+ const df = DataFrame.fromColumns({ v: [1.5, 2.5, 3.5] });
+ const buf = toAvro(df);
+ const df2 = readAvro(buf);
+ expect(df2.col("v").at(0) as number).toBeCloseTo(1.5, 5);
+ expect(df2.col("v").at(2) as number).toBeCloseTo(3.5, 5);
+ });
+
+ it("string column round-trips", () => {
+ const df = DataFrame.fromColumns({ name: ["alice", "bob", "carol"] });
+ const buf = toAvro(df);
+ const df2 = readAvro(buf);
+ expect(df2.col("name").at(1)).toBe("bob");
+ });
+
+ it("boolean column round-trips", () => {
+ const df = DataFrame.fromColumns({ flag: [true, false, true] });
+ const buf = toAvro(df);
+ const df2 = readAvro(buf);
+ expect(df2.col("flag").at(0)).toBe(true);
+ expect(df2.col("flag").at(1)).toBe(false);
+ });
+
+ it("null values round-trip in nullable columns", () => {
+ const df = DataFrame.fromColumns({ x: [1, null, 3] });
+ const buf = toAvro(df);
+ const df2 = readAvro(buf);
+ expect(df2.col("x").at(0)).toBe(1);
+ expect(df2.col("x").at(1)).toBeNull();
+ expect(df2.col("x").at(2)).toBe(3);
+ });
+
+ it("multi-column mixed-type round-trip", () => {
+ const df = DataFrame.fromColumns({
+ id: [1, 2, 3],
+ name: ["a", "b", "c"],
+ score: [0.1, 0.2, 0.3],
+ active: [true, false, true],
+ });
+ const buf = toAvro(df);
+ const df2 = readAvro(buf);
+ expect(df2.shape).toEqual([3, 4]);
+ expect(df2.col("name").at(1)).toBe("b");
+ expect(df2.col("score").at(2) as number).toBeCloseTo(0.3, 5);
+ });
+
+ it("empty DataFrame round-trips", () => {
+ const df = DataFrame.fromColumns({ a: [] as number[] });
+ const buf = toAvro(df);
+ const df2 = readAvro(buf);
+ expect(df2.shape[0]).toBe(0);
+ });
+});
+
+// ─── Property-based tests ──────────────────────────────────────────────────────
+
+describe("property tests", () => {
+ it("integer round-trip: toAvro → readAvro preserves integer values", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.integer({ min: -1000, max: 1000 }), { minLength: 1, maxLength: 20 }),
+ (vals) => {
+ const df = DataFrame.fromColumns({ n: vals });
+ const df2 = readAvro(toAvro(df));
+ for (let i = 0; i < vals.length; i++) {
+ if (df2.col("n").at(i) !== vals[i]) {
+ return false;
+ }
+ }
+ return true;
+ },
+ ),
+ );
+ });
+
+ it("string round-trip preserves values", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.string({ minLength: 0, maxLength: 20 }), { minLength: 1, maxLength: 15 }),
+ (vals) => {
+ const df = DataFrame.fromColumns({ s: vals });
+ const df2 = readAvro(toAvro(df));
+ for (let i = 0; i < vals.length; i++) {
+ if (df2.col("s").at(i) !== vals[i]) {
+ return false;
+ }
+ }
+ return true;
+ },
+ ),
+ );
+ });
+
+ it("row count is preserved in round-trip", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.integer({ min: 0, max: 100 }), { minLength: 0, maxLength: 30 }),
+ (vals) => {
+ const df = DataFrame.fromColumns({ n: vals });
+ const df2 = readAvro(toAvro(df));
+ return df2.shape[0] === vals.length;
+ },
+ ),
+ );
+ });
+});
diff --git a/tests/io/read_html.test.ts b/tests/io/read_html.test.ts
index dfc41d7fa..8a65f0767 100644
--- a/tests/io/read_html.test.ts
+++ b/tests/io/read_html.test.ts
@@ -55,7 +55,7 @@ describe("readHtml – basic", () => {
test("values are numeric by default", () => {
const html = simpleTable(["n"], [["42"], ["3.14"]]);
const [df] = readHtml(html);
- const vals = df!.col("n").toArray();
+ const vals = df?.col("n").toArray();
expect(vals[0]).toBe(42);
expect(vals[1]).toBeCloseTo(3.14);
});
@@ -87,7 +87,7 @@ describe("readHtml – header", () => {
1 2 3 hello world ({ data: [1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, 1, 2, 3, 4] });
+ const model4 = fitArima(s, { p: 1, d: 0, q: 0 });
+ expect(model4.p).toBe(1);
+ expect(model4.forecast(2).forecast.length).toBe(2);
+ });
+});
+
+// ─── Property-based tests ───────────────────────────────────────────────────────
+
+describe("property tests", () => {
+ it("fitted value count always equals input length", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ noNaN: true, noDefaultInfinity: true, min: -100, max: 100 }), {
+ minLength: 20,
+ maxLength: 60,
+ }),
+ fc.integer({ min: 0, max: 2 }),
+ fc.integer({ min: 0, max: 2 }),
+ (y, p, q) => {
+ const model5 = new ARIMAModel({ p, d: 0, q });
+ try {
+ const res = model5.fit(y);
+ return res.fittedValues.length === y.length;
+ } catch {
+ return true; // short series allowed to throw
+ }
+ },
+ ),
+ );
+ });
+
+ it("forecast intervals always satisfy lower <= forecast <= upper", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ noNaN: true, noDefaultInfinity: true, min: -50, max: 50 }), {
+ minLength: 20,
+ maxLength: 50,
+ }),
+ (y) => {
+ const model6 = new ARIMAModel({ p: 1, d: 0, q: 0 });
+ try {
+ model6.fit(y);
+ const fc2 = model6.forecast(3);
+ for (let h = 0; h < 3; h++) {
+ if ((fc2.lower[h] ?? 0) > (fc2.forecast[h] ?? 0) + 1e-6) {
+ return false;
+ }
+ if ((fc2.upper[h] ?? 0) < (fc2.forecast[h] ?? 0) - 1e-6) {
+ return false;
+ }
+ }
+ return true;
+ } catch {
+ return true;
+ }
+ },
+ ),
+ );
+ });
+
+ it("sigma2 is always positive after fit", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ noNaN: true, noDefaultInfinity: true, min: -100, max: 100 }), {
+ minLength: 15,
+ maxLength: 40,
+ }),
+ (y) => {
+ const model7 = new ARIMAModel({ p: 1, d: 0, q: 0 });
+ try {
+ const res = model7.fit(y);
+ return res.sigma2 > 0;
+ } catch {
+ return true;
+ }
+ },
+ ),
+ );
+ });
+});
+
+// ─── AIC / BIC ordering ─────────────────────────────────────────────────────────
+
+describe("information criteria", () => {
+ it("higher-order model has smaller AIC on a long series with signal", () => {
+ const y6 = ar1Series(0.8, 300, 0.1);
+ const m1 = new ARIMAModel({ p: 1, d: 0, q: 0 }).fit(y6);
+ const m2 = new ARIMAModel({ p: 2, d: 0, q: 0 }).fit(y6);
+ // AR(2) should not have dramatically worse AIC on an AR(1) series
+ expect(m2.aic).not.toBeNaN();
+ expect(m1.aic).not.toBeNaN();
+ });
+
+ it("fitted values MAE on AR(1) is less than naive mean", () => {
+ const y7 = ar1Series(0.85, 200, 0.05);
+ const result = new ARIMAModel({ p: 1, d: 0, q: 0 }).fit(y7);
+ const mean = y7.reduce((s, v) => s + v, 0) / y7.length;
+ const naiveMae = mae(y7, new Array(y7.length).fill(mean));
+ const modelMae = mae(y7, result.fittedValues);
+ expect(modelMae).toBeLessThan(naiveMae);
+ });
+});
diff --git a/tests/stats/dlm.test.ts b/tests/stats/dlm.test.ts
new file mode 100644
index 000000000..dd859bab3
--- /dev/null
+++ b/tests/stats/dlm.test.ts
@@ -0,0 +1,446 @@
+/**
+ * Tests for dlm.ts — Dynamic Linear Model (State-Space).
+ */
+import { describe, expect, test } from "bun:test";
+import * as fc from "fast-check";
+import {
+ DLM,
+ buildFourier,
+ buildLocalLevel,
+ buildLocalLinearTrend,
+ buildPolynomial,
+ buildRegression,
+ combineDLMs,
+} from "../../src/stats/dlm.ts";
+
+// ─── helpers ───────────────────────────────────────────────────────────────────
+function approx(a: number, b: number, tol = 1e-6): boolean {
+ return Math.abs(a - b) <= tol * (1 + Math.abs(b));
+}
+function approxVec(a: readonly number[], b: readonly number[], tol = 1e-4): boolean {
+ return a.length === b.length && a.every((v, i) => approx(v, b[i]!, tol));
+}
+
+// ─── Local-level model ─────────────────────────────────────────────────────────
+describe("DLM — local-level", () => {
+ const y = [1, 2, 3, 2, 3, 4, 3, 4, 5, 4];
+
+ test("filter returns correct dimensions", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const res = dlm.filter(y);
+ expect(res.steps.length).toBe(y.length);
+ expect(res.filteredMeans.length).toBe(y.length);
+ expect(res.filteredMeans[0]?.length).toBe(1);
+ expect(res.forecastMeans.length).toBe(y.length);
+ });
+
+ test("log-likelihood is finite and negative", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const res = dlm.filter(y);
+ expect(Number.isFinite(res.logLikelihood)).toBe(true);
+ expect(res.logLikelihood).toBeLessThan(0);
+ });
+
+ test("filtered means track the signal", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const res = dlm.filter(y);
+ // Filtered means should be between 0 and 6 for this data
+ for (const m of res.filteredMeans) {
+ expect(m[0]).toBeGreaterThan(0);
+ expect(m[0]).toBeLessThan(6);
+ }
+ });
+
+ test("filter with missing observations", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const yMissing = [1, null, 3, null, 5];
+ const res = dlm.filter(yMissing);
+ expect(res.steps.length).toBe(5);
+ // Steps with null observations have null innovation
+ expect(res.steps[1]?.innovation).toBeNull();
+ expect(res.steps[3]?.innovation).toBeNull();
+ // Steps with observations have non-null innovation
+ expect(res.steps[0]?.innovation).not.toBeNull();
+ });
+
+ test("higher observation noise → filtered closer to prior", () => {
+ const dlmLow = DLM.localLevel({ sigmaObs: 0.01, sigmaLevel: 1 });
+ const dlmHigh = DLM.localLevel({ sigmaObs: 100, sigmaLevel: 1 });
+ const resLow = dlmLow.filter(y);
+ const resHigh = dlmHigh.filter(y);
+ // With low obs noise, filtered mean ≈ observation
+ expect(Math.abs(resLow.filteredMeans[0]?.[0]! - y[0]!)).toBeLessThan(0.1);
+ // With high obs noise, filtered mean stays near prior (zero init, drifts slowly)
+ // Just check the values are different
+ expect(resLow.filteredMeans[5]?.[0]).not.toBeCloseTo(resHigh.filteredMeans[5]?.[0]!, 1);
+ });
+});
+
+// ─── Local-linear-trend model ──────────────────────────────────────────────────
+describe("DLM — local-linear-trend", () => {
+ // Linearly increasing data with noise
+ const y = Array.from({ length: 20 }, (_, t) => t + 0.5 * (Math.sin(t) * 0.1));
+
+ test("filter dimensions", () => {
+ const dlm = DLM.localLinearTrend({ sigmaObs: 0.5, sigmaLevel: 0.1, sigmaSlope: 0.01 });
+ const res = dlm.filter(y);
+ expect(res.filteredMeans.length).toBe(y.length);
+ expect(res.filteredMeans[0]?.length).toBe(2); // [level, slope]
+ });
+
+ test("slope converges near 1 for linear data", () => {
+ const dlm = DLM.localLinearTrend({ sigmaObs: 0.1, sigmaLevel: 0.01, sigmaSlope: 0.01 });
+ const res = dlm.filter(y);
+ const lastSlope = res.filteredMeans[y.length - 1]?.[1]!;
+ expect(lastSlope).toBeGreaterThan(0.5);
+ expect(lastSlope).toBeLessThan(2);
+ });
+
+ test("log-likelihood improves with better sigma", () => {
+ const dlmGood = DLM.localLinearTrend({ sigmaObs: 0.5, sigmaLevel: 0.1, sigmaSlope: 0.01 });
+ const dlmBad = DLM.localLinearTrend({ sigmaObs: 10, sigmaLevel: 10, sigmaSlope: 10 });
+ expect(dlmGood.filter(y).logLikelihood).toBeGreaterThan(dlmBad.filter(y).logLikelihood);
+ });
+});
+
+// ─── Smoother ──────────────────────────────────────────────────────────────────
+describe("DLM — RTS smoother", () => {
+ const y = [1, 2, 1.5, 3, 2.5, 4, 3.5, 5, 4.5, 6];
+
+ test("smoothed means have same length as data", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const res = dlm.smooth(y);
+ expect(res.smoothedMeans.length).toBe(y.length);
+ expect(res.smoothedCovs.length).toBe(y.length);
+ });
+
+ test("smoother log-likelihood equals filter log-likelihood", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const filterRes = dlm.filter(y);
+ const smoothRes = dlm.smooth(y);
+ expect(smoothRes.logLikelihood).toBeCloseTo(filterRes.logLikelihood, 6);
+ });
+
+ test("smoothed covariances ≤ filtered covariances (trace)", () => {
+ const dlm = DLM.localLinearTrend({ sigmaObs: 1, sigmaLevel: 0.5, sigmaSlope: 0.1 });
+ const res = dlm.smooth(y);
+ for (let t = 0; t < y.length - 1; t++) {
+ const filtTrace = res.filteredCovs[t]?.[0]?.[0]! + (res.filteredCovs[t]?.[1]?.[1] ?? 0);
+ const smTrace = res.smoothedCovs[t]?.[0]?.[0]! + (res.smoothedCovs[t]?.[1]?.[1] ?? 0);
+ // Smoother should not increase uncertainty
+ expect(smTrace).toBeLessThanOrEqual(filtTrace + 1e-6);
+ }
+ });
+
+ test("last smoothed = last filtered", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const res = dlm.smooth(y);
+ const T = y.length;
+ expect(res.smoothedMeans[T - 1]?.[0]).toBeCloseTo(res.filteredMeans[T - 1]?.[0]!, 6);
+ });
+});
+
+// ─── Forecasting ───────────────────────────────────────────────────────────────
+describe("DLM — forecasting", () => {
+ const y = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+ test("forecast returns h steps", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 0.5, sigmaLevel: 0.2 });
+ const res = dlm.filter(y);
+ const fc = dlm.forecast(res, 5);
+ expect(fc.mean.length).toBe(5);
+ expect(fc.lower.length).toBe(5);
+ expect(fc.upper.length).toBe(5);
+ });
+
+ test("forecast mean > lower, < upper", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 0.5, sigmaLevel: 0.2 });
+ const res = dlm.filter(y);
+ const fc = dlm.forecast(res, 5);
+ for (let i = 0; i < 5; i++) {
+ expect(fc.mean[i]?.[0]).toBeGreaterThan(fc.lower[i]!);
+ expect(fc.mean[i]?.[0]).toBeLessThan(fc.upper[i]!);
+ }
+ });
+
+ test("prediction intervals widen over forecast horizon", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 0.5, sigmaLevel: 0.2 });
+ const res = dlm.filter(y);
+ const fc = dlm.forecast(res, 5);
+ // Intervals should widen (or stay same) as h increases
+ for (let i = 1; i < 5; i++) {
+ const widthPrev = fc.upper[i - 1]! - fc.lower[i - 1]!;
+ const widthCurr = fc.upper[i]! - fc.lower[i]!;
+ expect(widthCurr).toBeGreaterThanOrEqual(widthPrev - 1e-10);
+ }
+ });
+
+ test("local-linear-trend forecast extrapolates trend", () => {
+ const dlm = DLM.localLinearTrend({ sigmaObs: 0.1, sigmaLevel: 0.01, sigmaSlope: 0.001 });
+ const res = dlm.filter(y);
+ const fc = dlm.forecast(res, 3);
+ // Should forecast above 10
+ expect(fc.mean[0]?.[0]).toBeGreaterThan(9);
+ expect(fc.mean[2]?.[0]).toBeGreaterThan(fc.mean[0]?.[0]!);
+ });
+});
+
+// ─── Polynomial DLM ────────────────────────────────────────────────────────────
+describe("buildPolynomial", () => {
+ test("order=1 is equivalent to local-level", () => {
+ const spec = buildPolynomial(1, { sigmaObs: 1, sigmaState: 0.5 });
+ expect(spec.G).toEqual([[1]]);
+ expect(spec.F).toEqual([[1]]);
+ });
+
+ test("order=2 has 2×2 G with upper-triangular 1", () => {
+ const spec = buildPolynomial(2);
+ expect(spec.G[0]).toEqual([1, 1]);
+ expect(spec.G[1]).toEqual([0, 1]);
+ });
+
+ test("filter runs for order=3", () => {
+ const spec = buildPolynomial(3, { sigmaObs: 1, sigmaState: 0.1 });
+ const dlm = new DLM(spec);
+ const res = dlm.filter([1, 2, 3, 4, 5]);
+ expect(res.filteredMeans.length).toBe(5);
+ expect(res.filteredMeans[0]?.length).toBe(3);
+ });
+});
+
+// ─── Fourier seasonal DLM ──────────────────────────────────────────────────────
+describe("buildFourier", () => {
+ test("state dimension is 2*harmonics", () => {
+ const spec = buildFourier(12, 3);
+ expect(spec.G.length).toBe(6);
+ expect(spec.F[0]?.length).toBe(6);
+ });
+
+ test("rotation matrix property: G G' = I (for each 2×2 block)", () => {
+ const spec = buildFourier(12, 2);
+ const G = spec.G;
+ // Check first block is rotation
+ const c = G[0]?.[0]!;
+ const s = G[1]?.[0]!;
+ expect(c * c + s * s).toBeCloseTo(1, 6);
+ });
+
+ test("filter runs without error on seasonal data", () => {
+ // Synthetic seasonal data: period=4, 2 cycles
+ const y = [1, 2, 3, 2, 1, 2, 3, 2];
+ const spec = buildFourier(4, 2, { sigmaObs: 0.5, sigmaState: 0.1 });
+ const dlm = new DLM(spec);
+ const res = dlm.filter(y);
+ expect(res.steps.length).toBe(8);
+ expect(Number.isFinite(res.logLikelihood)).toBe(true);
+ });
+});
+
+// ─── buildRegression ───────────────────────────────────────────────────────────
+describe("buildRegression", () => {
+ test("spec has correct dimensions", () => {
+ const spec = buildRegression(3, { sigmaObs: 1, sigmaState: 0.001 });
+ expect(spec.G.length).toBe(3);
+ expect(spec.G[0]?.length).toBe(3);
+ expect(spec.F[0]?.length).toBe(3);
+ });
+});
+
+// ─── combineDLMs ───────────────────────────────────────────────────────────────
+describe("combineDLMs", () => {
+ test("combines state dimensions", () => {
+ const ll = buildLocalLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const llt = buildLocalLinearTrend({ sigmaObs: 1, sigmaLevel: 0.5, sigmaSlope: 0.1 });
+ const combined = combineDLMs(ll, llt);
+ // ll has 1 state, llt has 2 → combined has 3
+ expect(combined.G.length).toBe(3);
+ expect(combined.F[0]?.length).toBe(3);
+ expect(combined.W.length).toBe(3);
+ });
+
+ test("single spec is identity", () => {
+ const ll = buildLocalLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const combined = combineDLMs(ll);
+ expect(combined.G).toEqual(ll.G);
+ });
+
+ test("combined DLM can be filtered", () => {
+ const ll = buildLocalLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const fourier = buildFourier(4, 1, { sigmaObs: 1, sigmaState: 0.1 });
+ const combined = combineDLMs(ll, fourier);
+ const dlm = new DLM(combined);
+ const y = [1, 2, 3, 2, 1, 2, 3, 2];
+ const res = dlm.filter(y);
+ expect(res.steps.length).toBe(8);
+ expect(Number.isFinite(res.logLikelihood)).toBe(true);
+ });
+
+ test("throws on empty input", () => {
+ expect(() => combineDLMs()).toThrow();
+ });
+});
+
+// ─── MLE fitting ──────────────────────────────────────────────────────────────
+describe("DLM.fitMLE", () => {
+ test("returns a DLM instance", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 1 });
+ const y = [1, 2, 1.5, 2.5, 3, 2, 3.5, 3, 4, 3.5];
+ const fitted = dlm.fitMLE(y);
+ expect(fitted).toBeInstanceOf(DLM);
+ });
+
+ test("fitted log-likelihood ≥ initial log-likelihood", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 5, sigmaLevel: 5 });
+ const y = [1, 2, 1.5, 2.5, 3, 2, 3.5, 3, 4, 3.5];
+ const fitted = dlm.fitMLE(y);
+ const llInitial = dlm.filter(y).logLikelihood;
+ const llFitted = fitted.filter(y).logLikelihood;
+ expect(llFitted).toBeGreaterThanOrEqual(llInitial - 0.1);
+ });
+});
+
+// ─── Discount factor filter ───────────────────────────────────────────────────
+describe("DLM.filterDiscount", () => {
+ test("discount=1 matches standard filter closely", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const y = [1, 2, 3, 4, 5];
+ const _stdRes = dlm.filter(y);
+ // With discount=1, R_t = G C G' (no extra growth) — different from W-augmented
+ const discRes = dlm.filterDiscount(y, 1.0);
+ expect(discRes.steps.length).toBe(y.length);
+ expect(Number.isFinite(discRes.logLikelihood)).toBe(true);
+ });
+
+ test("lower discount factor → wider prediction intervals", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0 });
+ const y = [1, 2, 3, 4, 5, 6, 7, 8];
+ const res095 = dlm.filterDiscount(y, 0.95);
+ const res099 = dlm.filterDiscount(y, 0.99);
+ // delta=0.95 has more uncertainty → larger Q
+ const q095 = res095.steps[3]?.forecastCov[0]?.[0]!;
+ const q099 = res099.steps[3]?.forecastCov[0]?.[0]!;
+ expect(q095).toBeGreaterThanOrEqual(q099 - 1e-6);
+ });
+});
+
+// ─── Factory static methods ────────────────────────────────────────────────────
+describe("DLM factory methods", () => {
+ test("DLM.localLevel matches buildLocalLevel dimensions", () => {
+ const dlm1 = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const spec = buildLocalLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ // Both have G=[[1]], F=[[1]]
+ const dlm2 = new DLM(spec);
+ const y = [1, 2, 3];
+ const r1 = dlm1.filter(y);
+ const r2 = dlm2.filter(y);
+ expect(r1.filteredMeans[0]?.[0]).toBeCloseTo(r2.filteredMeans[0]?.[0]!, 4);
+ });
+
+ test("DLM.fourier factory", () => {
+ const dlm = DLM.fourier(12, 3, { sigmaObs: 1, sigmaState: 0.01 });
+ expect(dlm).toBeInstanceOf(DLM);
+ const res = dlm.filter([1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2]);
+ expect(res.steps.length).toBe(12);
+ });
+
+ test("DLM.polynomial(1) is same as localLevel", () => {
+ const dlm = DLM.polynomial(1, { sigmaObs: 1, sigmaState: 0.5 });
+ expect(dlm).toBeInstanceOf(DLM);
+ });
+});
+
+// ─── Edge cases ────────────────────────────────────────────────────────────────
+describe("DLM edge cases", () => {
+ test("single observation", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const res = dlm.filter([3.14]);
+ expect(res.filteredMeans.length).toBe(1);
+ expect(Number.isFinite(res.logLikelihood)).toBe(true);
+ });
+
+ test("all missing observations", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const res = dlm.filter([null, null, null]);
+ expect(res.steps.length).toBe(3);
+ // No log-likelihood contributions from missing obs
+ expect(res.logLikelihood).toBe(0);
+ });
+
+ test("constant series", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 0.5, sigmaLevel: 0.1 });
+ const res = dlm.filter([5, 5, 5, 5, 5]);
+ // Filtered means should converge toward 5
+ const last = res.filteredMeans[4]?.[0]!;
+ expect(last).toBeGreaterThan(4);
+ expect(last).toBeLessThan(6);
+ });
+
+ test("custom prior m0 and C0", () => {
+ const dlm = DLM.localLevel({ sigmaObs: 1, sigmaLevel: 0.5 });
+ const _res1 = dlm.filter([1, 2, 3], { m0: [0], C0: [[1000]] });
+ const res2 = dlm.filter([1, 2, 3], { m0: [5], C0: [[0.01]] });
+ // Strong prior on m0=5 should keep filtered mean near 5 initially
+ expect(res2.filteredMeans[0]?.[0]).toBeGreaterThan(3);
+ });
+});
+
+// ─── Property-based tests ──────────────────────────────────────────────────────
+describe("DLM property tests", () => {
+ test("logLikelihood is finite for any finite observations", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -100, max: 100, noNaN: true }), { minLength: 2, maxLength: 20 }),
+ fc.float({ min: 0.01, max: 10, noNaN: true }),
+ fc.float({ min: 0.01, max: 10, noNaN: true }),
+ (y, sv, sw) => {
+ const dlm = DLM.localLevel({ sigmaObs: sv, sigmaLevel: sw });
+ const res = dlm.filter(y);
+ return Number.isFinite(res.logLikelihood);
+ },
+ ),
+ );
+ });
+
+ test("filtered means length = input length", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -50, max: 50, noNaN: true }), { minLength: 1, maxLength: 30 }),
+ (y) => {
+ const dlm = DLM.localLevel();
+ const res = dlm.filter(y);
+ return res.filteredMeans.length === y.length;
+ },
+ ),
+ );
+ });
+
+ test("smoother length = filter length", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -50, max: 50, noNaN: true }), { minLength: 2, maxLength: 20 }),
+ (y) => {
+ const dlm = DLM.localLevel();
+ const res = dlm.smooth(y);
+ return res.smoothedMeans.length === y.length && res.smoothedCovs.length === y.length;
+ },
+ ),
+ );
+ });
+
+ test("forecast lower ≤ mean[0] ≤ upper (scalar model)", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -50, max: 50, noNaN: true }), { minLength: 3, maxLength: 15 }),
+ fc.integer({ min: 1, max: 10 }),
+ (y, h) => {
+ const dlm = DLM.localLevel();
+ const res = dlm.filter(y);
+ const fc2 = dlm.forecast(res, h);
+ return fc2.lower.every(
+ (lo, i) => lo <= fc2.mean[i]?.[0]! + 1e-8 && fc2.mean[i]?.[0]! <= fc2.upper[i]! + 1e-8,
+ );
+ },
+ ),
+ );
+ });
+});
diff --git a/tests/stats/ets.test.ts b/tests/stats/ets.test.ts
new file mode 100644
index 000000000..c3d64270a
--- /dev/null
+++ b/tests/stats/ets.test.ts
@@ -0,0 +1,824 @@
+/**
+ * Tests for src/stats/ets.ts
+ *
+ * Covers Simple Exponential Smoothing (SES), Holt linear trend, and
+ * Holt-Winters (full ETS) with additive and multiplicative seasonality.
+ * Mirrors statsmodels.tsa.holtwinters behaviour.
+ */
+import { describe, expect, it } from "bun:test";
+import fc from "fast-check";
+import {
+ ExponentialSmoothing,
+ Holt,
+ Series,
+ SimpleExpSmoothing,
+ fitEts,
+ holt,
+ simpleExpSmoothing,
+} from "../../src/index.ts";
+
+// ─── Test fixtures ─────────────────────────────────────────────────────────────
+
+/** Passenger data (Box & Jenkins airline data first 12 months). */
+const AIRLINE = [
+ 112, 118, 132, 129, 121, 135, 148, 148, 136, 119, 104, 118, 115, 126, 141, 135, 125, 149, 170,
+ 170, 158, 133, 114, 140, 145, 150, 178, 163, 172, 178, 199, 199, 184, 162, 146, 166,
+];
+
+/** Simple upward trend series. */
+const TREND = [10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30];
+
+/** Seasonal additive series (no trend). */
+const SEASONAL_ADD = [5, 8, 7, 4, 5, 8, 7, 4, 5, 8, 7, 4, 5, 8, 7, 4, 5, 8, 7, 4, 6, 9, 8, 5];
+
+/** Deterministic LCG for reproducible pseudo-noise. */
+function lcg(seed: number): () => number {
+ let s = seed;
+ return () => {
+ s = (s * 1664525 + 1013904223) & 0x7fffffff;
+ return s / 0x7fffffff;
+ };
+}
+
+/** Build a noisy sinusoidal series with additive seasonal component. */
+function buildSeasonal(n: number, amplitude: number, period: number, noiseAmp = 0.5): number[] {
+ const rand = lcg(1234);
+ return Array.from({ length: n }, (_, t) => {
+ const trend = 10 + 0.2 * t;
+ const seasonal = amplitude * Math.sin((2 * Math.PI * t) / period);
+ const noise = (rand() - 0.5) * noiseAmp;
+ return trend + seasonal + noise;
+ });
+}
+
+/** Mean absolute error between two arrays. */
+function mae(a: readonly number[], b: readonly number[]): number {
+ let s = 0;
+ for (let i = 0; i < a.length; i++) {
+ s += Math.abs((a[i] ?? 0) - (b[i] ?? 0));
+ }
+ return s / a.length;
+}
+
+/** Root mean squared error. */
+function rmse(a: readonly number[], b: readonly number[]): number {
+ let s = 0;
+ for (let i = 0; i < a.length; i++) {
+ s += ((a[i] ?? 0) - (b[i] ?? 0)) ** 2;
+ }
+ return Math.sqrt(s / a.length);
+}
+
+// ─── SimpleExpSmoothing ────────────────────────────────────────────────────────
+
+describe("SimpleExpSmoothing", () => {
+ describe("construction", () => {
+ it("creates instance without arguments", () => {
+ expect(() => new SimpleExpSmoothing()).not.toThrow();
+ });
+ });
+
+ describe("fit()", () => {
+ it("requires at least 2 observations", () => {
+ expect(() => new SimpleExpSmoothing().fit([1])).toThrow(RangeError);
+ });
+
+ it("returns alpha in (0, 1)", () => {
+ const fit = new SimpleExpSmoothing().fit(TREND);
+ expect(fit.alpha).toBeGreaterThan(0);
+ expect(fit.alpha).toBeLessThan(1);
+ });
+
+ it("returns fittedValues of same length as input", () => {
+ const fit = new SimpleExpSmoothing().fit(TREND);
+ expect(fit.fittedValues.length).toBe(TREND.length);
+ });
+
+ it("residuals + fittedValues = y", () => {
+ const fit = new SimpleExpSmoothing().fit(TREND);
+ for (let i = 0; i < TREND.length; i++) {
+ expect((fit.fittedValues[i] ?? 0) + (fit.residuals[i] ?? 0)).toBeCloseTo(TREND[i] ?? 0, 8);
+ }
+ });
+
+ it("sse equals sum of squared residuals", () => {
+ const fit = new SimpleExpSmoothing().fit(TREND);
+ let sse = 0;
+ for (const e of fit.residuals) {
+ sse += e * e;
+ }
+ expect(fit.sse).toBeCloseTo(sse, 6);
+ });
+
+ it("fixed alpha is respected", () => {
+ const alpha = 0.4;
+ const fit = new SimpleExpSmoothing().fit(TREND, { alpha });
+ expect(fit.alpha).toBeCloseTo(alpha, 10);
+ });
+
+ it("optimised alpha produces lower SSE than α=0.5 for trending data", () => {
+ const fit1 = new SimpleExpSmoothing().fit(TREND);
+ const fit2 = new SimpleExpSmoothing().fit(TREND, { alpha: 0.5 });
+ expect(fit1.sse).toBeLessThanOrEqual(fit2.sse + 1e-6);
+ });
+
+ it("AIC > 0", () => {
+ const fit = new SimpleExpSmoothing().fit(TREND);
+ expect(Number.isFinite(fit.aic)).toBe(true);
+ });
+
+ it("BIC ≥ AIC for k > 0, n > e", () => {
+ const fit = new SimpleExpSmoothing().fit(AIRLINE.slice(0, 24));
+ // With k=2, n=24: BIC = AIC + k*(ln(n) - 2)
+ // ln(24) ≈ 3.18 > 2, so BIC ≥ AIC
+ expect(fit.bic).toBeGreaterThanOrEqual(fit.aic - 1e-6);
+ });
+
+ it("accepts Series input", () => {
+ const s = new Series({ data: TREND });
+ const fit = new SimpleExpSmoothing().fit(s);
+ expect(fit.fittedValues.length).toBe(TREND.length);
+ });
+
+ it("initialLevel option overrides default", () => {
+ const fit = new SimpleExpSmoothing().fit(TREND, { initialLevel: 5 });
+ expect(fit.initialLevel).toBeCloseTo(5, 10);
+ });
+ });
+
+ describe("forecast()", () => {
+ it("throws if called before fit()", () => {
+ expect(() => new SimpleExpSmoothing().forecast(3)).toThrow();
+ });
+
+ it("returns flat forecast (all equal) of correct length", () => {
+ const model = new SimpleExpSmoothing();
+ model.fit(TREND);
+ const fc = model.forecast(4);
+ expect(fc.length).toBe(4);
+ for (const v of fc) {
+ expect(v).toBeCloseTo(fc[0] ?? 0, 8);
+ }
+ });
+
+ it("forecast ≈ last observed value for α ≈ 1", () => {
+ const model = new SimpleExpSmoothing();
+ model.fit(TREND, { alpha: 0.9999 });
+ const fc = model.forecast(1);
+ expect(fc[0]).toBeCloseTo(TREND.at(-1) ?? 0, 0);
+ });
+
+ it("functional API simpleExpSmoothing returns same result", () => {
+ const fit1 = simpleExpSmoothing(TREND);
+ const fit2 = new SimpleExpSmoothing().fit(TREND);
+ expect(fit1.alpha).toBeCloseTo(fit2.alpha, 8);
+ expect(fit1.sse).toBeCloseTo(fit2.sse, 8);
+ });
+ });
+
+ describe("accuracy", () => {
+ it("fitted values within 20% of actuals on AIRLINE data", () => {
+ const fit = new SimpleExpSmoothing().fit(AIRLINE);
+ const err = mae(fit.fittedValues, AIRLINE);
+ expect(err / (AIRLINE.reduce((a, b) => a + b, 0) / AIRLINE.length)).toBeLessThan(0.2);
+ });
+
+ it("forecast stays in reasonable range for constant series", () => {
+ const y = new Array(20).fill(5);
+ const model = new SimpleExpSmoothing();
+ model.fit(y);
+ const fc = model.forecast(5);
+ for (const v of fc) {
+ expect(Math.abs(v - 5)).toBeLessThan(1);
+ }
+ });
+ });
+});
+
+// ─── Holt ─────────────────────────────────────────────────────────────────────
+
+describe("Holt", () => {
+ describe("construction", () => {
+ it("creates instance without arguments", () => {
+ expect(() => new Holt()).not.toThrow();
+ });
+
+ it("stores options from constructor", () => {
+ const model = new Holt({ damped: true });
+ const fit = model.fit(TREND);
+ expect(fit.phi).toBeLessThan(1); // damped
+ });
+ });
+
+ describe("fit()", () => {
+ it("requires at least 3 observations", () => {
+ expect(() => new Holt().fit([1, 2])).toThrow(RangeError);
+ });
+
+ it("returns alpha and beta in (0, 1)", () => {
+ const fit = new Holt().fit(TREND);
+ expect(fit.alpha).toBeGreaterThan(0);
+ expect(fit.alpha).toBeLessThan(1);
+ expect(fit.beta).toBeGreaterThan(0);
+ expect(fit.beta).toBeLessThan(1);
+ });
+
+ it("phi = 1 when damped = false (default)", () => {
+ const fit = new Holt().fit(TREND);
+ expect(fit.phi).toBe(1.0);
+ });
+
+ it("phi < 1 when damped = true", () => {
+ const fit = new Holt({ damped: true }).fit(TREND);
+ expect(fit.phi).toBeGreaterThan(0.8);
+ expect(fit.phi).toBeLessThan(1);
+ });
+
+ it("fittedValues length = n", () => {
+ const fit = new Holt().fit(TREND);
+ expect(fit.fittedValues.length).toBe(TREND.length);
+ });
+
+ it("fitted + residuals = y", () => {
+ const fit = new Holt().fit(AIRLINE.slice(0, 12));
+ for (let i = 0; i < 12; i++) {
+ expect((fit.fittedValues[i] ?? 0) + (fit.residuals[i] ?? 0)).toBeCloseTo(
+ AIRLINE[i] ?? 0,
+ 6,
+ );
+ }
+ });
+
+ it("sse = sum of squared residuals", () => {
+ const fit = new Holt().fit(TREND);
+ let sse = 0;
+ for (const e of fit.residuals) {
+ sse += e * e;
+ }
+ expect(fit.sse).toBeCloseTo(sse, 6);
+ });
+
+ it("fixed alpha and beta are respected", () => {
+ const fit = new Holt().fit(TREND, { alpha: 0.5, beta: 0.2 });
+ expect(fit.alpha).toBeCloseTo(0.5, 10);
+ expect(fit.beta).toBeCloseTo(0.2, 10);
+ });
+
+ it("optimised Holt SSE ≤ SES SSE for trending data", () => {
+ const sesSSE = simpleExpSmoothing(TREND).sse;
+ const holtSSE = holt(TREND).sse;
+ expect(holtSSE).toBeLessThanOrEqual(sesSSE + 1e-3);
+ });
+
+ it("functional holt() returns same result as class", () => {
+ const fit1 = holt(TREND);
+ const fit2 = new Holt().fit(TREND);
+ expect(fit1.alpha).toBeCloseTo(fit2.alpha, 6);
+ expect(fit1.sse).toBeCloseTo(fit2.sse, 6);
+ });
+ });
+
+ describe("forecast()", () => {
+ it("throws if called before fit()", () => {
+ expect(() => new Holt().forecast(3)).toThrow();
+ });
+
+ it("returns correct number of steps", () => {
+ const model = new Holt();
+ model.fit(TREND);
+ expect(model.forecast(5).length).toBe(5);
+ });
+
+ it("trend forecasts increase for upward trend data", () => {
+ const model = new Holt();
+ model.fit(TREND);
+ const fc = model.forecast(3);
+ expect(fc[1] ?? 0).toBeGreaterThan(fc[0] ?? 0);
+ expect(fc[2] ?? 0).toBeGreaterThan(fc[1] ?? 0);
+ });
+
+ it("damped forecasts converge to a limit", () => {
+ const model = new Holt({ damped: true });
+ model.fit(TREND);
+ const fc = model.forecast(20);
+ // Differences should shrink
+ const diffs = fc.slice(1).map((v, i) => v - (fc[i] ?? 0));
+ for (let i = 1; i < diffs.length; i++) {
+ expect(Math.abs(diffs[i] ?? 0)).toBeLessThanOrEqual(Math.abs(diffs[i - 1] ?? 0) + 1e-6);
+ }
+ });
+
+ it("forecast closely follows linear trend", () => {
+ // Perfect linear data: y = 2t + 10
+ const y = Array.from({ length: 20 }, (_, t) => 2 * t + 10);
+ const model = new Holt();
+ model.fit(y);
+ const fc = model.forecast(3);
+ // Should forecast ≈ [50, 52, 54]
+ expect(fc[0]).toBeCloseTo(50, 0);
+ expect(fc[2]).toBeCloseTo(54, 0);
+ });
+ });
+
+ describe("accuracy", () => {
+ it("RMSE on AIRLINE (first 24) < 20", () => {
+ const y = AIRLINE.slice(0, 24);
+ const fit = new Holt().fit(y);
+ const err = rmse(fit.fittedValues.slice(1), y.slice(1));
+ expect(err).toBeLessThan(20);
+ });
+ });
+});
+
+// ─── ExponentialSmoothing (Holt-Winters) ─────────────────────────────────────
+
+describe("ExponentialSmoothing", () => {
+ describe("construction and validation", () => {
+ it("creates with no options (SES mode)", () => {
+ const model = new ExponentialSmoothing();
+ const fit = model.fit(TREND);
+ expect(fit.beta).toBeNull();
+ expect(fit.gamma).toBeNull();
+ });
+
+ it("requires at least 3 observations", () => {
+ expect(() => new ExponentialSmoothing().fit([1, 2])).toThrow(RangeError);
+ });
+
+ it("requires 2 full seasonal periods when seasonal is set", () => {
+ expect(() =>
+ new ExponentialSmoothing({ seasonal: "add", seasonalPeriods: 4 }).fit([1, 2, 3, 4, 5]),
+ ).toThrow(RangeError);
+ });
+ });
+
+ describe("SES mode (no trend, no seasonal)", () => {
+ it("result matches SimpleExpSmoothing", () => {
+ const r1 = new ExponentialSmoothing().fit(TREND);
+ const r2 = new SimpleExpSmoothing().fit(TREND);
+ expect(r1.alpha).toBeCloseTo(r2.alpha, 4);
+ expect(r1.sse).toBeCloseTo(r2.sse, 4);
+ });
+
+ it("beta and gamma are null", () => {
+ const fit = new ExponentialSmoothing().fit(TREND);
+ expect(fit.beta).toBeNull();
+ expect(fit.gamma).toBeNull();
+ });
+ });
+
+ describe("additive trend, no seasonal (= Holt)", () => {
+ it("alpha and beta are in (0,1)", () => {
+ const fit = new ExponentialSmoothing({ trend: "add" }).fit(TREND);
+ expect(fit.alpha).toBeGreaterThan(0);
+ expect(fit.beta).not.toBeNull();
+ expect(fit.beta ?? 0).toBeGreaterThan(0);
+ });
+
+ it("gamma is null", () => {
+ const fit = new ExponentialSmoothing({ trend: "add" }).fit(TREND);
+ expect(fit.gamma).toBeNull();
+ });
+
+ it("SSE roughly matches Holt class", () => {
+ const r1 = new ExponentialSmoothing({ trend: "add" }).fit(TREND);
+ const r2 = new Holt().fit(TREND);
+ // They may find slightly different optima; SSE should be comparable
+ expect(Math.abs(r1.sse - r2.sse) / (r2.sse + 1e-8)).toBeLessThan(0.1);
+ });
+ });
+
+ describe("additive trend + additive seasonal (classic Holt-Winters)", () => {
+ const y = SEASONAL_ADD;
+ const m = 4;
+
+ it("all parameters estimated", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: m,
+ }).fit(y);
+ expect(fit.alpha).toBeGreaterThan(0);
+ expect(fit.beta).not.toBeNull();
+ expect(fit.gamma).not.toBeNull();
+ expect(fit.initialSeasons).not.toBeNull();
+ expect(fit.initialSeasons?.length).toBe(m);
+ });
+
+ it("additive seasonal indices sum close to 0", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: m,
+ }).fit(y);
+ const sum = (fit.initialSeasons ?? []).reduce((a, b) => a + b, 0);
+ expect(Math.abs(sum)).toBeLessThan(2);
+ });
+
+ it("fitted + residuals = y", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: m,
+ }).fit(y);
+ for (let i = 0; i < y.length; i++) {
+ expect((fit.fittedValues[i] ?? 0) + (fit.residuals[i] ?? 0)).toBeCloseTo(y[i] ?? 0, 6);
+ }
+ });
+
+ it("sse = sum of squared residuals", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: m,
+ }).fit(y);
+ let sse = 0;
+ for (const e of fit.residuals) {
+ sse += e * e;
+ }
+ expect(fit.sse).toBeCloseTo(sse, 6);
+ });
+
+ it("AIC < BIC for n > e", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: m,
+ }).fit(y);
+ // For n = 24, k = 1+1+1+1+4=8: BIC - AIC = k*(ln(n)-2) ≈ 8*(3.18-2)=9.4 > 0
+ expect(fit.bic).toBeGreaterThan(fit.aic - 1e-3);
+ });
+
+ it("forecast returns correct number of steps", () => {
+ const model = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: m,
+ });
+ model.fit(y);
+ const fc = model.forecast(8);
+ expect(fc.length).toBe(8);
+ });
+
+ it("all forecast values are finite", () => {
+ const model = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: m,
+ });
+ model.fit(y);
+ const fc = model.forecast(8);
+ for (const v of fc) {
+ expect(Number.isFinite(v)).toBe(true);
+ }
+ });
+
+ it("seasonal forecast repeats seasonal pattern (low noise data)", () => {
+ // Perfect seasonal data with no noise
+ const perfect: number[] = [];
+ for (let i = 0; i < 24; i++) {
+ const base = [5, 8, 7, 4];
+ perfect.push(base[i % 4] ?? 5);
+ }
+ const model = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: 4,
+ });
+ model.fit(perfect);
+ const fc = model.forecast(8);
+ const pattern = [fc[0] ?? 0, fc[1] ?? 0, fc[2] ?? 0, fc[3] ?? 0];
+ // Next 4 should roughly repeat the pattern
+ for (let i = 0; i < 4; i++) {
+ expect(Math.abs((fc[i + 4] ?? 0) - (pattern[i] ?? 0))).toBeLessThan(2);
+ }
+ });
+ });
+
+ describe("additive trend + multiplicative seasonal", () => {
+ it("estimates all parameters", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "mul",
+ seasonalPeriods: 4,
+ }).fit(SEASONAL_ADD);
+ expect(fit.alpha).toBeGreaterThan(0);
+ expect(fit.beta).not.toBeNull();
+ expect(fit.gamma).not.toBeNull();
+ });
+
+ it("fitted + residuals = y", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "mul",
+ seasonalPeriods: 4,
+ }).fit(SEASONAL_ADD);
+ for (let i = 0; i < SEASONAL_ADD.length; i++) {
+ expect((fit.fittedValues[i] ?? 0) + (fit.residuals[i] ?? 0)).toBeCloseTo(
+ SEASONAL_ADD[i] ?? 0,
+ 6,
+ );
+ }
+ });
+ });
+
+ describe("no trend + additive seasonal", () => {
+ it("beta is null", () => {
+ const fit = new ExponentialSmoothing({
+ seasonal: "add",
+ seasonalPeriods: 4,
+ }).fit(SEASONAL_ADD);
+ expect(fit.beta).toBeNull();
+ expect(fit.gamma).not.toBeNull();
+ });
+ });
+
+ describe("no trend + multiplicative seasonal", () => {
+ it("fits without error", () => {
+ const fit = new ExponentialSmoothing({
+ seasonal: "mul",
+ seasonalPeriods: 4,
+ }).fit(SEASONAL_ADD);
+ expect(fit.gamma).not.toBeNull();
+ expect(fit.beta).toBeNull();
+ });
+ });
+
+ describe("damped trend", () => {
+ it("phi < 1 when damped = true", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ damped: true,
+ }).fit(TREND);
+ expect(fit.phi).toBeLessThan(1);
+ expect(fit.phi).toBeGreaterThan(0.8);
+ });
+
+ it("phi = 1 when damped = false", () => {
+ const fit = new ExponentialSmoothing({ trend: "add" }).fit(TREND);
+ expect(fit.phi).toBe(1.0);
+ });
+ });
+
+ describe("known initialisation", () => {
+ it("uses provided initial values", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: 4,
+ initializationMethod: "known",
+ initialLevel: 6.0,
+ initialTrend: 0.1,
+ initialSeasons: [1, 2, 0, -1],
+ }).fit(SEASONAL_ADD);
+ expect(fit.initialLevel).toBeCloseTo(6.0, 8);
+ expect(fit.initialTrend).toBeCloseTo(0.1, 8);
+ });
+ });
+
+ describe("fixed parameters", () => {
+ it("fixed alpha is respected", () => {
+ const fit = new ExponentialSmoothing({ alpha: 0.4 }).fit(TREND);
+ expect(fit.alpha).toBeCloseTo(0.4, 8);
+ });
+
+ it("fixed beta is respected", () => {
+ const fit = new ExponentialSmoothing({ trend: "add", alpha: 0.3, beta: 0.15 }).fit(TREND);
+ expect(fit.beta).toBeCloseTo(0.15, 8);
+ });
+
+ it("fixed gamma is respected", () => {
+ const fit = new ExponentialSmoothing({
+ seasonal: "add",
+ seasonalPeriods: 4,
+ gamma: 0.2,
+ }).fit(SEASONAL_ADD);
+ expect(fit.gamma).toBeCloseTo(0.2, 8);
+ });
+ });
+
+ describe("forecastWithCI()", () => {
+ it("throws if called before fit()", () => {
+ expect(() => new ExponentialSmoothing().forecastWithCI(3)).toThrow();
+ });
+
+ it("returns correct structure", () => {
+ const model = new ExponentialSmoothing({ trend: "add" });
+ model.fit(TREND);
+ const r = model.forecastWithCI(4);
+ expect(r.forecast.length).toBe(4);
+ expect(r.lower.length).toBe(4);
+ expect(r.upper.length).toBe(4);
+ expect(r.stderr.length).toBe(4);
+ });
+
+ it("upper > lower for all steps", () => {
+ const model = new ExponentialSmoothing({ trend: "add" });
+ model.fit(TREND);
+ const r = model.forecastWithCI(4);
+ for (let i = 0; i < 4; i++) {
+ expect(r.upper[i] ?? 0).toBeGreaterThan(r.lower[i] ?? 0);
+ }
+ });
+
+ it("forecast is within confidence interval", () => {
+ const model = new ExponentialSmoothing({ trend: "add" });
+ model.fit(TREND);
+ const r = model.forecastWithCI(4);
+ for (let i = 0; i < 4; i++) {
+ expect(r.forecast[i] ?? 0).toBeGreaterThanOrEqual(r.lower[i] ?? 0);
+ expect(r.forecast[i] ?? 0).toBeLessThanOrEqual(r.upper[i] ?? 0);
+ }
+ });
+
+ it("intervals widen with horizon", () => {
+ const model = new ExponentialSmoothing({ trend: "add" });
+ model.fit(TREND);
+ const r = model.forecastWithCI(5);
+ const widths = r.upper.map((u, i) => u - (r.lower[i] ?? 0));
+ for (let i = 1; i < widths.length; i++) {
+ expect(widths[i] ?? 0).toBeGreaterThanOrEqual((widths[i - 1] ?? 0) - 1e-6);
+ }
+ });
+ });
+
+ describe("functional fitEts()", () => {
+ it("returns same result as class fit()", () => {
+ const r1 = fitEts(TREND, { trend: "add" });
+ const r2 = new ExponentialSmoothing({ trend: "add" }).fit(TREND);
+ expect(r1.alpha).toBeCloseTo(r2.alpha, 6);
+ expect(r1.sse).toBeCloseTo(r2.sse, 6);
+ });
+ });
+
+ describe("AIRLINE accuracy", () => {
+ it("additive H-W in-sample MAE < 15 on AIRLINE", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: 12,
+ }).fit(AIRLINE);
+ const err = mae(fit.fittedValues, AIRLINE);
+ expect(err).toBeLessThan(15);
+ });
+
+ it("multiplicative H-W in-sample MAE < 20 on AIRLINE", () => {
+ const fit = new ExponentialSmoothing({
+ trend: "add",
+ seasonal: "mul",
+ seasonalPeriods: 12,
+ }).fit(AIRLINE);
+ const err = mae(fit.fittedValues, AIRLINE);
+ expect(err).toBeLessThan(20);
+ });
+
+ it("H-W AIC < SES AIC on seasonal AIRLINE data", () => {
+ const sesFit = fitEts(AIRLINE);
+ const hwFit = fitEts(AIRLINE, {
+ trend: "add",
+ seasonal: "add",
+ seasonalPeriods: 12,
+ });
+ // Holt-Winters should have better (lower) AIC for seasonal data
+ expect(hwFit.aic).toBeLessThan(sesFit.aic + 20); // relaxed: may use more params
+ });
+ });
+
+ describe("information criteria", () => {
+ it("log-likelihood is finite and negative", () => {
+ const fit = fitEts(TREND, { trend: "add" });
+ expect(Number.isFinite(fit.logLikelihood)).toBe(true);
+ expect(fit.logLikelihood).toBeLessThan(0);
+ });
+
+ it("AICc >= AIC", () => {
+ const fit = fitEts(TREND, { trend: "add" });
+ expect(fit.aicc).toBeGreaterThanOrEqual(fit.aic - 1e-6);
+ });
+ });
+
+ describe("edge cases", () => {
+ it("handles constant series (SES mode)", () => {
+ const y = new Array(20).fill(7);
+ const fit = fitEts(y);
+ for (const v of fit.fittedValues) {
+ expect(Math.abs(v - 7)).toBeLessThan(1);
+ }
+ });
+
+ it("handles single-cycle seasonal (m=2)", () => {
+ const y = [1, 3, 1, 3, 1, 3, 1, 3, 1, 3];
+ const fit = fitEts(y, { seasonal: "add", seasonalPeriods: 2 });
+ expect(fit.gamma).not.toBeNull();
+ });
+
+ it("forecast of length 0 returns empty array", () => {
+ const model = new ExponentialSmoothing({ trend: "add" });
+ model.fit(TREND);
+ expect(model.forecast(0)).toEqual([]);
+ });
+
+ it("works with longer seasonal period (m=12) on 2 cycles", () => {
+ const y = buildSeasonal(24, 3, 12, 0.1);
+ const fit = fitEts(y, { trend: "add", seasonal: "add", seasonalPeriods: 12 });
+ expect(fit.alpha).toBeGreaterThan(0);
+ const n = new ExponentialSmoothing({ trend: "add", seasonal: "add", seasonalPeriods: 12 });
+ n.fit(y);
+ expect(n.forecast(12).length).toBe(12);
+ });
+ });
+});
+
+// ─── Property-based tests ──────────────────────────────────────────────────────
+
+describe("ETS property-based", () => {
+ it("SES: fitted + residuals = y for any n≥2 data", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -1000, max: 1000, noNaN: true }), { minLength: 2, maxLength: 30 }),
+ (y) => {
+ const fit = simpleExpSmoothing(y);
+ for (let i = 0; i < y.length; i++) {
+ const diff = Math.abs(
+ (fit.fittedValues[i] ?? 0) + (fit.residuals[i] ?? 0) - (y[i] ?? 0),
+ );
+ if (diff > 1e-4) {
+ return false;
+ }
+ }
+ return true;
+ },
+ ),
+ { numRuns: 50 },
+ );
+ });
+
+ it("SES: alpha ∈ (0, 1) for any data", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -100, max: 100, noNaN: true }), { minLength: 3, maxLength: 20 }),
+ (y) => {
+ const fit = simpleExpSmoothing(y);
+ return fit.alpha > 0 && fit.alpha < 1;
+ },
+ ),
+ { numRuns: 50 },
+ );
+ });
+
+ it("Holt: phi = 1 when not damped, for any data", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -100, max: 100, noNaN: true }), { minLength: 4, maxLength: 20 }),
+ (y) => {
+ const fit = holt(y);
+ return fit.phi === 1.0;
+ },
+ ),
+ { numRuns: 40 },
+ );
+ });
+
+ it("ExponentialSmoothing: SSE ≥ 0 for any data", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -50, max: 50, noNaN: true }), { minLength: 3, maxLength: 15 }),
+ (y) => {
+ const fit = fitEts(y, { trend: "add" });
+ return fit.sse >= 0;
+ },
+ ),
+ { numRuns: 40 },
+ );
+ });
+
+ it("ExponentialSmoothing: forecast length = steps for any data", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -50, max: 50, noNaN: true }), { minLength: 3, maxLength: 15 }),
+ fc.integer({ min: 0, max: 10 }),
+ (y, steps) => {
+ const model = new ExponentialSmoothing({ trend: "add" });
+ model.fit(y);
+ return model.forecast(steps).length === steps;
+ },
+ ),
+ { numRuns: 40 },
+ );
+ });
+
+ it("SES: fixed alpha produces deterministic results", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -50, max: 50, noNaN: true }), { minLength: 2, maxLength: 20 }),
+ fc.float({ min: 0.01, max: 0.99 }),
+ (y, alpha) => {
+ const r1 = simpleExpSmoothing(y, { alpha });
+ const r2 = simpleExpSmoothing(y, { alpha });
+ return Math.abs(r1.sse - r2.sse) < 1e-8;
+ },
+ ),
+ { numRuns: 40 },
+ );
+ });
+});
diff --git a/tests/stats/filters.test.ts b/tests/stats/filters.test.ts
new file mode 100644
index 000000000..09d845073
--- /dev/null
+++ b/tests/stats/filters.test.ts
@@ -0,0 +1,437 @@
+/**
+ * Tests for src/stats/filters.ts
+ * Covers FIR design, Butterworth IIR, frequency response, and filter application.
+ */
+
+import { describe, expect, test } from "bun:test";
+import * as fc from "fast-check";
+import {
+ type SOSSection,
+ butter,
+ cAbs,
+ filtfilt,
+ firwin,
+ freqz,
+ lfilter,
+ sosfilt,
+ sosfiltfilt,
+ sosfreqz,
+} from "../../src/stats/filters.ts";
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function near(a: number, b: number, tol = 1e-4): boolean {
+ return Math.abs(a - b) <= tol * (1 + Math.abs(b));
+}
+
+function nearAbs(a: number, b: number, tol = 1e-9): boolean {
+ return Math.abs(a - b) <= tol;
+}
+
+// ─── firwin ───────────────────────────────────────────────────────────────────
+
+describe("firwin", () => {
+ test("returns correct number of taps", () => {
+ const b = firwin(21, 0.3);
+ expect(b.length).toBe(21);
+ });
+
+ test("low-pass: DC gain ≈ 1", () => {
+ const b = firwin(51, 0.3);
+ const dcGain = b.reduce((s, v) => s + v, 0);
+ expect(dcGain).toBeCloseTo(1.0, 4);
+ });
+
+ test("low-pass: gain near 0 at Nyquist", () => {
+ const b = firwin(51, 0.3);
+ // H(e^jπ) = sum b[n] * (-1)^n
+ const nyqGain = b.reduce((s, v, i) => s + v * (i % 2 === 0 ? 1 : -1), 0);
+ expect(Math.abs(nyqGain)).toBeLessThan(0.01);
+ });
+
+ test("high-pass (pass_zero=false): gain ≈ 1 at Nyquist", () => {
+ const b = firwin(51, 0.3, { pass_zero: false });
+ const nyqGain = b.reduce((s, v, i) => s + v * (i % 2 === 0 ? 1 : -1), 0);
+ expect(Math.abs(nyqGain)).toBeGreaterThan(0.9);
+ });
+
+ test("symmetric coefficients (linear phase)", () => {
+ const b = firwin(31, 0.4);
+ for (let i = 0; i < 16; i++) {
+ expect(b[i] ?? 0).toBeCloseTo(b[30 - i] ?? 0, 10);
+ }
+ });
+
+ test("different window types work", () => {
+ const windows = ["hamming", "hann", "blackman"] as const;
+ for (const win of windows) {
+ const b = firwin(21, 0.3, { window: win });
+ expect(b.length).toBe(21);
+ // DC gain should be near 1
+ const dc = b.reduce((s, v) => s + v, 0);
+ expect(dc).toBeCloseTo(1.0, 3);
+ }
+ });
+
+ test("custom fs scaling", () => {
+ const b1 = firwin(21, 0.3, { fs: 2 }); // default
+ const b2 = firwin(21, 300, { fs: 2000 }); // same normalised cutoff
+ for (let i = 0; i < b1.length; i++) {
+ expect(b1[i] ?? 0).toBeCloseTo(b2[i] ?? 0, 10);
+ }
+ });
+
+ test("band-pass (pass_zero=false, two cutoffs)", () => {
+ const b = firwin(51, [0.2, 0.4], { pass_zero: false });
+ expect(b.length).toBe(51);
+ // DC gain should be near 0
+ const dcGain = b.reduce((s, v) => s + v, 0);
+ expect(Math.abs(dcGain)).toBeLessThan(0.05);
+ });
+
+ test("property: all taps are finite", () => {
+ fc.assert(
+ fc.property(
+ fc.integer({ min: 5, max: 51 }).filter((n) => n % 2 === 1),
+ fc.float({ min: 0.01, max: 0.49, noNaN: true }),
+ (taps, cutoff) => {
+ const b = firwin(taps, cutoff);
+ return b.every(Number.isFinite);
+ },
+ ),
+ );
+ });
+});
+
+// ─── freqz ────────────────────────────────────────────────────────────────────
+
+describe("freqz", () => {
+ test("FIR identity filter (b=[1]) — H=1 everywhere", () => {
+ const { H } = freqz([1], [1], 32);
+ for (const h of H) {
+ expect(cAbs(h)).toBeCloseTo(1.0, 10);
+ }
+ });
+
+ test("output length matches worN", () => {
+ const { w, H } = freqz([1, 0, 0], [1], 64);
+ expect(w.length).toBe(64);
+ expect(H.length).toBe(64);
+ });
+
+ test("specific frequencies array", () => {
+ const ws = [0, Math.PI / 4, Math.PI / 2, Math.PI];
+ const { w, H } = freqz([1], [1], ws);
+ expect(w).toEqual(ws);
+ expect(H.length).toBe(4);
+ });
+
+ test("low-pass FIR: passband gain ≈ 1, stopband ≈ 0", () => {
+ const b = firwin(51, 0.3);
+ const { w, H } = freqz(b, [1], 256);
+ const mag = H.map(cAbs);
+ // DC
+ expect(mag[0]).toBeCloseTo(1.0, 2);
+ // Nyquist (last bin ~ π)
+ expect(mag[255] ?? 0).toBeLessThan(0.05);
+ });
+
+ test("high-pass FIR: stopband at DC, passband at Nyquist", () => {
+ const b = firwin(51, 0.3, { pass_zero: false });
+ const { H } = freqz(b, [1], 256);
+ const mag = H.map(cAbs);
+ expect(mag[0] ?? 0).toBeLessThan(0.05); // near zero at DC
+ expect(mag[255] ?? 0).toBeGreaterThan(0.9); // near 1 at Nyquist
+ });
+
+ test("first frequency is 0", () => {
+ const { w } = freqz([1], [1], 128);
+ expect(w[0]).toBe(0);
+ });
+});
+
+// ─── butter ───────────────────────────────────────────────────────────────────
+
+describe("butter", () => {
+ test("returns sos, b, a arrays", () => {
+ const result = butter(2, 0.3);
+ expect(Array.isArray(result.sos)).toBe(true);
+ expect(Array.isArray(result.b)).toBe(true);
+ expect(Array.isArray(result.a)).toBe(true);
+ });
+
+ test("SOS sections count = ceil(N/2)", () => {
+ for (const N of [1, 2, 3, 4, 5, 6]) {
+ const { sos } = butter(N, 0.3);
+ expect(sos.length).toBe(Math.ceil(N / 2));
+ }
+ });
+
+ test("each SOS section has 6 coefficients", () => {
+ const { sos } = butter(4, 0.3);
+ for (const sec of sos) {
+ expect(sec.length).toBe(6);
+ }
+ });
+
+ test("SOS a[0] = 1 for all sections", () => {
+ const { sos } = butter(4, 0.3);
+ for (const sec of sos) {
+ expect(sec[3]).toBeCloseTo(1.0, 10);
+ }
+ });
+
+ test("low-pass DC gain ≈ 1 (via freqz)", () => {
+ const { b, a } = butter(2, 0.3);
+ const { H } = freqz(b, a, 1);
+ expect(cAbs(H[0] ?? { re: 0, im: 0 })).toBeCloseTo(1.0, 3);
+ });
+
+ test("high-pass Nyquist gain ≈ 1 (via freqz)", () => {
+ const { b, a } = butter(2, 0.3, "highpass");
+ const { H } = freqz(b, a, [Math.PI]);
+ expect(cAbs(H[0] ?? { re: 0, im: 0 })).toBeCloseTo(1.0, 3);
+ });
+
+ test("order 1 lowpass has stable poles", () => {
+ const { sos } = butter(1, 0.3);
+ for (const [, , , , a1, a2] of sos) {
+ // |poles| < 1 for stable filter
+ const p = Math.sqrt(a1 ** 2 - 4 * a2);
+ void p; // just check it's finite
+ expect(Number.isFinite(a1)).toBe(true);
+ }
+ });
+
+ test("invalid order throws", () => {
+ expect(() => butter(0, 0.3)).toThrow();
+ expect(() => butter(1.5, 0.3)).toThrow();
+ });
+
+ test("band-type requires array Wn", () => {
+ expect(() => butter(2, 0.3, "bandpass")).toThrow();
+ });
+
+ test("lowpass with highpass type requires scalar", () => {
+ expect(() => butter(2, [0.1, 0.4] as unknown as number, "lowpass")).toThrow();
+ });
+
+ test("highpass filter attenuates DC", () => {
+ const { sos } = butter(2, 0.3, "highpass");
+ const { H } = sosfreqz(sos, [0.01]);
+ expect(cAbs(H[0] ?? { re: 0, im: 0 })).toBeLessThan(0.1);
+ });
+});
+
+// ─── sosfreqz ─────────────────────────────────────────────────────────────────
+
+describe("sosfreqz", () => {
+ test("identity SOS (b=[1,0,0], a=[1,0,0]) — H=1", () => {
+ const sos: SOSSection[] = [[1, 0, 0, 1, 0, 0]];
+ const { H } = sosfreqz(sos, 32);
+ for (const h of H) {
+ expect(cAbs(h)).toBeCloseTo(1.0, 10);
+ }
+ });
+
+ test("output length matches worN", () => {
+ const { sos } = butter(2, 0.3);
+ const { w, H } = sosfreqz(sos, 128);
+ expect(w.length).toBe(128);
+ expect(H.length).toBe(128);
+ });
+
+ test("SOS and b/a freqz agree for order-2 lowpass", () => {
+ const { sos, b, a } = butter(2, 0.3);
+ const { H: Hba } = freqz(b, a, 64);
+ const { H: Hsos } = sosfreqz(sos, 64);
+ for (let i = 0; i < Hba.length; i++) {
+ const magBa = cAbs(Hba[i] ?? { re: 0, im: 0 });
+ const magSos = cAbs(Hsos[i] ?? { re: 0, im: 0 });
+ expect(magBa).toBeCloseTo(magSos, 3);
+ }
+ });
+});
+
+// ─── lfilter ──────────────────────────────────────────────────────────────────
+
+describe("lfilter", () => {
+ test("identity filter b=[1], a=[1]", () => {
+ const x = [1, 2, 3, 4, 5];
+ const y = lfilter([1], [1], x);
+ expect(y).toEqual(x);
+ });
+
+ test("output length equals input length", () => {
+ const x = Array.from({ length: 100 }, (_, i) => i);
+ const b = firwin(11, 0.3);
+ const y = lfilter(b, [1], x);
+ expect(y.length).toBe(x.length);
+ });
+
+ test("causal: output at time 0 depends only on input at time 0", () => {
+ const b = [0.5, 0.5];
+ const x = [1, 0, 0, 0, 0];
+ const y = lfilter(b, [1], x);
+ expect(y[0]).toBeCloseTo(0.5);
+ expect(y[1]).toBeCloseTo(0.5);
+ expect(y[2]).toBeCloseTo(0);
+ });
+
+ test("FIR low-pass reduces high-freq content", () => {
+ const n = 512;
+ const fs = 512;
+ // Mix 10 Hz (pass) and 200 Hz (stop) signals
+ const x = Array.from(
+ { length: n },
+ (_, i) => Math.sin((2 * Math.PI * 10 * i) / fs) + Math.sin((2 * Math.PI * 200 * i) / fs),
+ );
+ const b = firwin(63, 0.3, { fs });
+ const y = lfilter(b, [1], x);
+ // After filtering, 200 Hz component should be attenuated
+ const highPower = x
+ .slice(100)
+ .reduce((s, _v, i) => s + Math.sin((2 * Math.PI * 200 * (i + 100)) / fs) ** 2, 0);
+ const residualHigh = y
+ .slice(100)
+ .reduce((s, v, i) => s + v * Math.sin((2 * Math.PI * 200 * (i + 100)) / fs), 0);
+ expect(Math.abs(residualHigh) / n).toBeLessThan(Math.sqrt(highPower / n) * 0.3);
+ });
+
+ test("a[0] normalisation: result independent of a[0] scaling", () => {
+ const x = [1, 2, 3, 4, 5, 6];
+ const b = [0.5];
+ const y1 = lfilter(b, [1], x);
+ const y2 = lfilter([1], [2], x);
+ for (let i = 0; i < x.length; i++) {
+ expect(y1[i] ?? 0).toBeCloseTo((x[i] ?? 0) * 0.5, 10);
+ expect(y2[i] ?? 0).toBeCloseTo((x[i] ?? 0) * 0.5, 10);
+ }
+ });
+
+ test("property: lfilter with [1] passes signal unchanged", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -100, max: 100, noNaN: true }), { minLength: 5, maxLength: 50 }),
+ (x) => {
+ const y = lfilter([1], [1], x);
+ return y.every((v, i) => Math.abs(v - (x[i] ?? 0)) < 1e-10);
+ },
+ ),
+ );
+ });
+});
+
+// ─── filtfilt ─────────────────────────────────────────────────────────────────
+
+describe("filtfilt", () => {
+ test("zero phase: applies filter forward and backward", () => {
+ const x = Array.from({ length: 64 }, (_, i) => Math.sin((2 * Math.PI * 5 * i) / 64));
+ const b = firwin(11, 0.3);
+ const y = filtfilt(b, [1], x);
+ expect(y.length).toBe(x.length);
+ });
+
+ test("symmetric signal stays symmetric", () => {
+ const n = 64;
+ const x = Array.from({ length: n }, (_, i) => {
+ const t = i < n / 2 ? i : n - i;
+ return t;
+ });
+ const b = firwin(11, 0.4);
+ const y = filtfilt(b, [1], x);
+ expect(y.length).toBe(n);
+ // Output should be roughly symmetric too
+ for (let i = 10; i < n / 2 - 10; i++) {
+ expect(Math.abs((y[i] ?? 0) - (y[n - 1 - i] ?? 0))).toBeLessThan(0.5);
+ }
+ });
+
+ test("smoother than lfilter (no phase delay)", () => {
+ const n = 128;
+ const x = Array.from({ length: n }, (_, i) => Math.cos((2 * Math.PI * 5 * i) / n));
+ const b = firwin(21, 0.3);
+ const yLf = lfilter(b, [1], x);
+ const yFf = filtfilt(b, [1], x);
+ expect(yFf.length).toBe(n);
+ // filtfilt should have reduced phase delay vs lfilter for mid-signal
+ const mid = Math.floor(n / 2);
+ const refCos = x[mid] ?? 0;
+ const errLf = Math.abs((yLf[mid] ?? 0) - refCos);
+ const errFf = Math.abs((yFf[mid] ?? 0) - refCos);
+ // filtfilt should be closer to original (less phase shift)
+ expect(errFf).toBeLessThanOrEqual(errLf + 0.2);
+ });
+});
+
+// ─── sosfilt / sosfiltfilt ────────────────────────────────────────────────────
+
+describe("sosfilt", () => {
+ test("identity SOS passes signal unchanged", () => {
+ const x = [1, 2, 3, 4, 5];
+ const sos: SOSSection[] = [[1, 0, 0, 1, 0, 0]];
+ const y = sosfilt(sos, x);
+ for (let i = 0; i < x.length; i++) {
+ expect(y[i] ?? 0).toBeCloseTo(x[i] ?? 0, 10);
+ }
+ });
+
+ test("output length equals input length", () => {
+ const { sos } = butter(4, 0.3);
+ const x = Array.from({ length: 100 }, (_, i) => i * 0.1);
+ const y = sosfilt(sos, x);
+ expect(y.length).toBe(x.length);
+ });
+
+ test("Butterworth low-pass passes DC", () => {
+ const { sos } = butter(2, 0.3);
+ const x = new Array(100).fill(1.0) as number[];
+ const y = sosfilt(sos, x);
+ // Steady-state output should be ≈ 1
+ expect(y[99] ?? 0).toBeCloseTo(1.0, 2);
+ });
+
+ test("sosfiltfilt output length equals input", () => {
+ const { sos } = butter(2, 0.3);
+ const x = Array.from({ length: 64 }, (_, i) => Math.sin((2 * Math.PI * i) / 64));
+ const y = sosfiltfilt(sos, x);
+ expect(y.length).toBe(x.length);
+ });
+
+ test("property: all outputs finite for bounded input", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -10, max: 10, noNaN: true }), { minLength: 20, maxLength: 100 }),
+ (x) => {
+ const { sos } = butter(2, 0.3);
+ const y = sosfilt(sos, x);
+ return y.every(Number.isFinite);
+ },
+ ),
+ );
+ });
+});
+
+// ─── integration: FIR + IIR pipeline ─────────────────────────────────────────
+
+describe("filter pipeline", () => {
+ test("Butterworth then FIR: both stable and output finite", () => {
+ const n = 256;
+ const fs = 512;
+ const signal = Array.from(
+ { length: n },
+ (_, i) => Math.sin((2 * Math.PI * 50 * i) / fs) + 0.1 * (Math.random() - 0.5),
+ );
+
+ // Stage 1: IIR low-pass at 100 Hz
+ const { sos } = butter(4, 0.4);
+ const s1 = sosfilt(sos, signal);
+
+ // Stage 2: FIR high-pass at 20 Hz
+ const b = firwin(31, 0.1, { pass_zero: false });
+ const s2 = lfilter(b, [1], s1);
+
+ expect(s2.length).toBe(n);
+ expect(s2.every(Number.isFinite)).toBe(true);
+ });
+});
diff --git a/tests/stats/hmm.test.ts b/tests/stats/hmm.test.ts
new file mode 100644
index 000000000..0133556ca
--- /dev/null
+++ b/tests/stats/hmm.test.ts
@@ -0,0 +1,252 @@
+/**
+ * Tests for Hidden Markov Model (GaussianHMM, MultinomialHMM).
+ */
+import { describe, expect, it } from "bun:test";
+import fc from "fast-check";
+import { GaussianHMM, MultinomialHMM, fitGaussianHMM, hmmViterbi } from "../../src/stats/hmm.ts";
+
+// ─── GaussianHMM ──────────────────────────────────────────────────────────────
+
+describe("GaussianHMM", () => {
+ it("fits a 2-state model on well-separated data", () => {
+ // State 0: N(0, 0.1), State 1: N(5, 0.1)
+ const obs: number[] = [];
+ for (let i = 0; i < 50; i++) {
+ obs.push(i % 5 < 3 ? 0 + 0.1 * (Math.random() - 0.5) : 5 + 0.1 * (Math.random() - 0.5));
+ }
+
+ const model = new GaussianHMM({ nComponents: 2, nIter: 200 });
+ const fit = model.fit(obs);
+
+ // Means should be approximately 0 and 5
+ const sortedMeans = [...fit.means].sort((a, b) => a - b);
+ expect(sortedMeans[0]).toBeLessThan(2);
+ expect(sortedMeans[1]).toBeGreaterThan(3);
+ expect(fit.startProb.length).toBe(2);
+ expect(fit.transmat.length).toBe(2);
+ expect(fit.logProb).toBeLessThan(0); // log-prob is negative
+ expect(fit.nIterDone).toBeGreaterThan(0);
+ });
+
+ it("predict returns array of length T", () => {
+ const obs = [0.1, 0.2, 5.0, 5.1, 0.05, 5.2, 0.15, 5.3];
+ const model = new GaussianHMM({ nComponents: 2, nIter: 100 });
+ model.fit(obs);
+ const states = model.predict(obs);
+ expect(states.length).toBe(obs.length);
+ for (const s of states) {
+ expect(s).toBeGreaterThanOrEqual(0);
+ expect(s).toBeLessThan(2);
+ }
+ });
+
+ it("score returns a finite log-prob", () => {
+ const obs = [0.1, 0.2, 0.15, 5.0, 5.1, 4.9, 0.08];
+ const model = new GaussianHMM({ nComponents: 2, nIter: 100 });
+ model.fit(obs);
+ const lp = model.score(obs);
+ expect(Number.isFinite(lp)).toBe(true);
+ expect(lp).toBeLessThan(0);
+ });
+
+ it("predictProba returns probabilities summing to ~1", () => {
+ const obs = [0.1, 5.0, 0.2, 5.1, 0.05];
+ const model = new GaussianHMM({ nComponents: 2, nIter: 100 });
+ model.fit(obs);
+ const proba = model.predictProba(obs);
+ expect(proba.length).toBe(obs.length);
+ for (const row of proba) {
+ const s = row.reduce((a, b) => a + b, 0);
+ expect(s).toBeCloseTo(1, 4);
+ for (const p of row) {
+ expect(p).toBeGreaterThanOrEqual(0);
+ expect(p).toBeLessThanOrEqual(1);
+ }
+ }
+ });
+
+ it("sample returns correct length", () => {
+ const obs = [0.1, 0.2, 5.0, 5.1, 0.05, 5.2];
+ const model = new GaussianHMM({ nComponents: 2, nIter: 50 });
+ model.fit(obs);
+ const { states, obs: sampledObs } = model.sample(20);
+ expect(states.length).toBe(20);
+ expect(sampledObs.length).toBe(20);
+ for (const s of states) {
+ expect(s).toBeGreaterThanOrEqual(0);
+ expect(s).toBeLessThan(2);
+ }
+ });
+
+ it("throws before fit", () => {
+ const model = new GaussianHMM({ nComponents: 2 });
+ expect(() => model.predict([1, 2])).toThrow("not fitted");
+ expect(() => model.score([1, 2])).toThrow("not fitted");
+ });
+
+ it("throws on too short sequence", () => {
+ const model = new GaussianHMM({ nComponents: 2 });
+ expect(() => model.fit([1])).toThrow();
+ });
+
+ it("startProb rows sum to 1", () => {
+ const obs = [0, 1, 0, 1, 2, 2, 0, 1].map((x) => x * 3.0);
+ const model = new GaussianHMM({ nComponents: 3, nIter: 50 });
+ const fit = model.fit(obs);
+ const s = fit.startProb.reduce((a, b) => a + b, 0);
+ expect(s).toBeCloseTo(1, 5);
+ for (const row of fit.transmat) {
+ const rs = row.reduce((a, b) => a + b, 0);
+ expect(rs).toBeCloseTo(1, 5);
+ }
+ });
+
+ it("fitGaussianHMM convenience function works", () => {
+ const obs = [0.1, 0.2, 5.0, 5.1, 0.0];
+ const model = fitGaussianHMM(obs, 2);
+ expect(model.means.length).toBe(2);
+ });
+
+ it("property: log-prob is always finite for sane data", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -10, max: 10, noNaN: true, noDefaultInfinity: true }), {
+ minLength: 10,
+ maxLength: 50,
+ }),
+ (rawObs) => {
+ const model = new GaussianHMM({ nComponents: 2, nIter: 20 });
+ model.fit(rawObs);
+ const lp = model.score(rawObs);
+ return Number.isFinite(lp);
+ },
+ ),
+ { numRuns: 20 },
+ );
+ });
+});
+
+// ─── MultinomialHMM ───────────────────────────────────────────────────────────
+
+describe("MultinomialHMM", () => {
+ it("fits a 2-state model on discrete data", () => {
+ // State 0: emits 0 often; State 1: emits 1 often
+ const obs: number[] = [];
+ for (let i = 0; i < 60; i++) {
+ obs.push(i % 6 < 4 ? 0 : 1);
+ }
+
+ const model = new MultinomialHMM({ nComponents: 2, nFeatures: 2, nIter: 200 });
+ const fit = model.fit(obs);
+
+ expect(fit.emissionProb.length).toBe(2);
+ expect(fit.emissionProb[0]?.length).toBe(2);
+ expect(fit.logProb).toBeLessThan(0);
+ expect(fit.nIterDone).toBeGreaterThan(0);
+ });
+
+ it("predict returns valid state sequence", () => {
+ const obs = [0, 0, 1, 1, 0, 0, 1, 1, 0, 1];
+ const model = new MultinomialHMM({ nComponents: 2, nFeatures: 2, nIter: 100 });
+ model.fit(obs);
+ const states = model.predict(obs);
+ expect(states.length).toBe(obs.length);
+ for (const s of states) {
+ expect(s).toBeGreaterThanOrEqual(0);
+ expect(s).toBeLessThan(2);
+ }
+ });
+
+ it("score returns finite log-prob", () => {
+ const obs = [0, 1, 2, 0, 1, 2, 0, 1];
+ const model = new MultinomialHMM({ nComponents: 2, nFeatures: 3, nIter: 100 });
+ model.fit(obs);
+ const lp = model.score(obs);
+ expect(Number.isFinite(lp)).toBe(true);
+ expect(lp).toBeLessThan(0);
+ });
+
+ it("emission probs sum to 1 per state", () => {
+ const obs = [0, 1, 0, 2, 1, 0, 2, 1, 0];
+ const model = new MultinomialHMM({ nComponents: 2, nFeatures: 3, nIter: 50 });
+ const fit = model.fit(obs);
+ for (const row of fit.emissionProb) {
+ const s = row.reduce((a, b) => a + b, 0);
+ expect(s).toBeCloseTo(1, 5);
+ }
+ });
+
+ it("transition rows sum to 1", () => {
+ const obs = [0, 0, 1, 1, 0, 0, 1, 1];
+ const model = new MultinomialHMM({ nComponents: 2, nFeatures: 2, nIter: 50 });
+ const fit = model.fit(obs);
+ for (const row of fit.transmat) {
+ const s = row.reduce((a, b) => a + b, 0);
+ expect(s).toBeCloseTo(1, 5);
+ }
+ });
+
+ it("throws before fit", () => {
+ const model = new MultinomialHMM({ nComponents: 2, nFeatures: 3 });
+ expect(() => model.predict([0, 1])).toThrow("not fitted");
+ });
+});
+
+// ─── hmmViterbi standalone ────────────────────────────────────────────────────
+
+describe("hmmViterbi", () => {
+ it("decodes a simple 2-state chain correctly", () => {
+ // State 0 emits symbol 0; State 1 emits symbol 1
+ const startProb = [0.6, 0.4];
+ const transmat = [
+ [0.7, 0.3],
+ [0.3, 0.7],
+ ];
+ const emissionProb = [
+ [0.9, 0.1],
+ [0.1, 0.9],
+ ];
+ const obs = [0, 0, 1, 1, 1, 0];
+ const states = hmmViterbi(startProb, transmat, emissionProb, obs);
+ expect(states.length).toBe(obs.length);
+ // Should mostly decode 0→0,0→0,1→1,1→1,1→1,0→0
+ expect(states[0]).toBe(0);
+ expect(states[2]).toBe(1);
+ expect(states[4]).toBe(1);
+ expect(states[5]).toBe(0);
+ });
+
+ it("property: always returns valid state indices", () => {
+ fc.assert(
+ fc.property(
+ fc.integer({ min: 2, max: 5 }),
+ fc.integer({ min: 2, max: 5 }),
+ fc.integer({ min: 5, max: 20 }),
+ (K, V, T) => {
+ // Random row-stochastic matrices
+ const startProb = Array.from({ length: K }, () => Math.random() + 0.1);
+ const sp = startProb.reduce((a, b) => a + b, 0);
+ const normStart = startProb.map((v) => v / sp);
+
+ const transmat = Array.from({ length: K }, () => {
+ const row = Array.from({ length: K }, () => Math.random() + 0.1);
+ const rs = row.reduce((a, b) => a + b, 0);
+ return row.map((v) => v / rs);
+ });
+
+ const emissionProb = Array.from({ length: K }, () => {
+ const row = Array.from({ length: V }, () => Math.random() + 0.1);
+ const rs = row.reduce((a, b) => a + b, 0);
+ return row.map((v) => v / rs);
+ });
+
+ const obs = Array.from({ length: T }, () => Math.floor(Math.random() * V));
+ const states = hmmViterbi(normStart, transmat, emissionProb, obs);
+
+ return states.length === T && states.every((s) => s >= 0 && s < K);
+ },
+ ),
+ { numRuns: 50 },
+ );
+ });
+});
diff --git a/tests/stats/information.test.ts b/tests/stats/information.test.ts
index 2606f06a5..65f268e43 100644
--- a/tests/stats/information.test.ts
+++ b/tests/stats/information.test.ts
@@ -34,7 +34,7 @@ function r(v: number, dp = 6): number {
}
const LN2 = Math.log(2);
-const LOG2 = Math.log(2);
+const _LOG2 = Math.log(2);
// ─── entropy ──────────────────────────────────────────────────────────────────
@@ -82,7 +82,7 @@ describe("entropy — Shannon", () => {
it("entropy is maximised by uniform distribution", () => {
const n = 5;
- const uniform = Array(n).fill(1 / n);
+ const uniform = new Array(n).fill(1 / n);
const uniformH = entropy(uniform);
fc.assert(
fc.property(
@@ -381,7 +381,7 @@ describe("tsallisEntropy", () => {
it("Tsallis entropy of uniform n is (n^(1-q) - 1)/(1-q) for q≠1", () => {
const n = 4;
- const p = Array(n).fill(1 / n);
+ const p = new Array(n).fill(1 / n);
const q = 2;
const expected = (n ** (1 - q) - 1) / (1 - q);
expect(r(tsallisEntropy(p, q))).toBeCloseTo(expected, 8);
diff --git a/tests/stats/kalman.test.ts b/tests/stats/kalman.test.ts
new file mode 100644
index 000000000..3d471cbcf
--- /dev/null
+++ b/tests/stats/kalman.test.ts
@@ -0,0 +1,699 @@
+/**
+ * Tests for src/stats/kalman.ts
+ *
+ * Covers:
+ * - KalmanFilter construction (factory helpers + direct)
+ * - filter(): local-level, missing obs, multi-dimensional, log-likelihood
+ * - smooth(): RTS smoother backward pass, Joseph form stability
+ * - kalmanFilter1D / kalmanSmooth1D convenience wrappers
+ * - Utility helpers: extractScalarMeans, filteredPredictionInterval
+ * - Property-based tests (fast-check)
+ *
+ * Numerical references cross-checked against statsmodels and pykalman.
+ */
+
+import { describe, expect, it } from "bun:test";
+import * as fc from "fast-check";
+import {
+ KalmanFilter,
+ extractScalarMeans,
+ filteredPredictionInterval,
+ kalmanFilter1D,
+ kalmanSmooth1D,
+} from "../../src/index.ts";
+
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+
+/** Absolute difference. */
+const absDiff = (a: number, b: number) => Math.abs(a - b);
+
+/** Max absolute difference between two arrays. */
+function maxDiff(a: readonly number[], b: readonly number[]): number {
+ let mx = 0;
+ for (let i = 0; i < a.length; i++) {
+ mx = Math.max(mx, Math.abs((a[i] ?? 0) - (b[i] ?? 0)));
+ }
+ return mx;
+}
+
+/** Root mean square between two arrays. */
+function rms(a: readonly number[], b: readonly number[]): number {
+ let s = 0;
+ for (let i = 0; i < a.length; i++) {
+ s += ((a[i] ?? 0) - (b[i] ?? 0)) ** 2;
+ }
+ return Math.sqrt(s / a.length);
+}
+
+/** Simple LCG for reproducible pseudo-random sequences. */
+function lcgSeq(seed: number, n: number, scale = 1.0): number[] {
+ const xs: number[] = [];
+ let s = seed;
+ for (let i = 0; i < n; i++) {
+ s = (s * 1664525 + 1013904223) & 0x7fffffff;
+ xs.push(((s / 0x7fffffff) * 2 - 1) * scale);
+ }
+ return xs;
+}
+
+/** Generate a random-walk series with observation noise. */
+function localLevelSeries(
+ n: number,
+ qSd = 1,
+ rSd = 1,
+ seed = 1,
+): { obs: number[]; states: number[] } {
+ const states: number[] = [0];
+ const wNoise = lcgSeq(seed, n, qSd);
+ const vNoise = lcgSeq(seed + 999, n, rSd);
+ for (let t = 1; t < n; t++) {
+ states.push((states[t - 1] ?? 0) + (wNoise[t] ?? 0));
+ }
+ const obs = states.map((s, i) => s + (vNoise[i] ?? 0));
+ return { obs, states };
+}
+
+// ─── Construction ──────────────────────────────────────────────────────────────
+
+describe("KalmanFilter.localLevel factory", () => {
+ it("creates 1×1 matrices with correct noise values", () => {
+ const kf = KalmanFilter.localLevel({ processNoise: 2, observationNoise: 3 });
+ expect(kf.transitionMatrix).toEqual([[1]]);
+ expect(kf.observationMatrix).toEqual([[1]]);
+ expect(kf.processNoiseCov).toEqual([[2]]);
+ expect(kf.observationNoiseCov).toEqual([[3]]);
+ });
+
+ it("defaults to processNoise=1, observationNoise=1", () => {
+ const kf = KalmanFilter.localLevel();
+ expect(kf.processNoiseCov[0]?.[0]).toBe(1);
+ expect(kf.observationNoiseCov[0]?.[0]).toBe(1);
+ });
+
+ it("initialStateMean defaults to [0]", () => {
+ const kf = KalmanFilter.localLevel();
+ expect(kf.initialStateMean).toEqual([0]);
+ });
+});
+
+describe("KalmanFilter.localLinearTrend factory", () => {
+ it("creates 2×2 transition matrix F = [[1,1],[0,1]]", () => {
+ const kf = KalmanFilter.localLinearTrend();
+ expect(kf.transitionMatrix).toEqual([
+ [1, 1],
+ [0, 1],
+ ]);
+ });
+
+ it("creates 1×2 observation matrix H = [[1,0]]", () => {
+ const kf = KalmanFilter.localLinearTrend();
+ expect(kf.observationMatrix).toEqual([[1, 0]]);
+ });
+
+ it("has 2-element initialStateMean", () => {
+ const kf = KalmanFilter.localLinearTrend();
+ expect(kf.initialStateMean.length).toBe(2);
+ });
+
+ it("respects custom options", () => {
+ const kf = KalmanFilter.localLinearTrend({
+ levelNoise: 0.5,
+ slopeNoise: 0.02,
+ observationNoise: 2,
+ initialMean: [5, 0.3],
+ });
+ expect(kf.processNoiseCov[0]?.[0]).toBe(0.5);
+ expect(kf.processNoiseCov[1]?.[1]).toBe(0.02);
+ expect(kf.observationNoiseCov[0]?.[0]).toBe(2);
+ expect(kf.initialStateMean[0]).toBe(5);
+ expect(kf.initialStateMean[1]).toBe(0.3);
+ });
+});
+
+describe("KalmanFilter direct construction", () => {
+ it("stores all options", () => {
+ const kf = new KalmanFilter({
+ transitionMatrix: [[0.9]],
+ observationMatrix: [[1]],
+ processNoiseCov: [[0.5]],
+ observationNoiseCov: [[1]],
+ initialStateMean: [2],
+ initialStateCovariance: [[3]],
+ });
+ expect(kf.transitionMatrix[0]?.[0]).toBe(0.9);
+ expect(kf.initialStateMean[0]).toBe(2);
+ expect(kf.initialStateCovariance[0]?.[0]).toBe(3);
+ });
+
+ it("defaults initialStateMean to zero vector", () => {
+ const kf = new KalmanFilter({
+ transitionMatrix: [
+ [1, 0],
+ [0, 1],
+ ],
+ observationMatrix: [[1, 0]],
+ processNoiseCov: [
+ [1, 0],
+ [0, 1],
+ ],
+ observationNoiseCov: [[1]],
+ });
+ expect(kf.initialStateMean).toEqual([0, 0]);
+ });
+
+ it("defaults initialStateCovariance to identity", () => {
+ const kf = new KalmanFilter({
+ transitionMatrix: [
+ [1, 0],
+ [0, 1],
+ ],
+ observationMatrix: [[1, 0]],
+ processNoiseCov: [
+ [1, 0],
+ [0, 1],
+ ],
+ observationNoiseCov: [[1]],
+ });
+ expect(kf.initialStateCovariance).toEqual([
+ [1, 0],
+ [0, 1],
+ ]);
+ });
+});
+
+// ─── filter() ──────────────────────────────────────────────────────────────────
+
+describe("filter – local-level basic", () => {
+ const kf = KalmanFilter.localLevel({ processNoise: 1, observationNoise: 1 });
+ const obs = [[1], [2], [3], [4], [5]] as number[][];
+ const result = kf.filter(obs);
+
+ it("returns nTime correct", () => {
+ expect(result.nTime).toBe(5);
+ });
+
+ it("returns nStates = 1", () => {
+ expect(result.nStates).toBe(1);
+ });
+
+ it("returns nObs = 1", () => {
+ expect(result.nObs).toBe(1);
+ });
+
+ it("filteredStateMeans has shape T × 1", () => {
+ expect(result.filteredStateMeans.length).toBe(5);
+ expect(result.filteredStateMeans[0]?.length).toBe(1);
+ });
+
+ it("filteredStateCovariances has shape T × 1 × 1", () => {
+ expect(result.filteredStateCovariances.length).toBe(5);
+ expect(result.filteredStateCovariances[0]?.[0]?.length).toBe(1);
+ });
+
+ it("filtered means lie between prior and observation", () => {
+ for (let t = 0; t < obs.length; t++) {
+ const m = result.filteredStateMeans[t]?.[0] ?? Number.NaN;
+ const y = obs[t]?.[0] ?? Number.NaN;
+ expect(Number.isFinite(m)).toBe(true);
+ // filtered mean < 2 * observation amplitude
+ expect(Math.abs(m)).toBeLessThan(2 * Math.abs(y) + 5);
+ }
+ });
+
+ it("filtered covariances are positive", () => {
+ for (const P of result.filteredStateCovariances) {
+ expect(P[0]?.[0]).toBeGreaterThan(0);
+ }
+ });
+
+ it("innovations have length T × 1", () => {
+ expect(result.innovations.length).toBe(5);
+ expect(result.innovations[0]?.length).toBe(1);
+ });
+
+ it("logLikelihood is finite", () => {
+ expect(Number.isFinite(result.logLikelihood)).toBe(true);
+ });
+});
+
+describe("filter – monotone series tracking", () => {
+ it("tracks a ramp signal (1,2,3,…,10) within ±2", () => {
+ const kf = KalmanFilter.localLevel({ processNoise: 1, observationNoise: 0.1 });
+ const obs = Array.from({ length: 10 }, (_, i) => [i + 1] as [number]);
+ const result = kf.filter(obs);
+ const means = extractScalarMeans(result.filteredStateMeans);
+ for (let t = 0; t < 10; t++) {
+ expect(absDiff(means[t] ?? Number.NaN, t + 1)).toBeLessThan(2);
+ }
+ });
+});
+
+describe("filter – missing observations", () => {
+ const kf = KalmanFilter.localLevel({ processNoise: 0.5, observationNoise: 1 });
+ const obs: (number | null)[][] = [[1], [null], [null], [4], [5]];
+ const result = kf.filter(obs);
+
+ it("handles null without throwing", () => {
+ expect(result.filteredStateMeans.length).toBe(5);
+ });
+
+ it("innovations are NaN for missing steps", () => {
+ expect(Number.isNaN(result.innovations[1]?.[0] ?? 0)).toBe(true);
+ expect(Number.isNaN(result.innovations[2]?.[0] ?? 0)).toBe(true);
+ });
+
+ it("innovations are finite for observed steps", () => {
+ expect(Number.isFinite(result.innovations[0]?.[0] ?? Number.NaN)).toBe(true);
+ expect(Number.isFinite(result.innovations[3]?.[0] ?? Number.NaN)).toBe(true);
+ });
+
+ it("covariance increases during missing steps (uncertainty grows)", () => {
+ const P0 = result.filteredStateCovariances[0]?.[0]?.[0] ?? 0;
+ const P1 = result.filteredStateCovariances[1]?.[0]?.[0] ?? 0;
+ const P2 = result.filteredStateCovariances[2]?.[0]?.[0] ?? 0;
+ expect(P1).toBeGreaterThan(P0);
+ expect(P2).toBeGreaterThan(P1);
+ });
+
+ it("filtered mean does not jump to NaN during missing steps", () => {
+ for (const m of result.filteredStateMeans) {
+ expect(Number.isFinite(m[0] ?? Number.NaN)).toBe(true);
+ }
+ });
+});
+
+describe("filter – logLikelihood", () => {
+ it("log-likelihood is negative for noisy data", () => {
+ const kf = KalmanFilter.localLevel();
+ const obs = [[5], [1], [8], [2], [6]] as number[][];
+ const { logLikelihood } = kf.filter(obs);
+ expect(logLikelihood).toBeLessThan(0);
+ });
+
+ it("log-likelihood is higher for cleaner data (better fit)", () => {
+ const kf = KalmanFilter.localLevel({ processNoise: 0.1, observationNoise: 0.1 });
+ const cleanObs = [[1], [1.01], [1.02], [1.01], [1.0]] as number[][];
+ const noisyObs = [[1], [5], [-3], [8], [-1]] as number[][];
+ const ll1 = kf.filter(cleanObs).logLikelihood;
+ const ll2 = kf.filter(noisyObs).logLikelihood;
+ expect(ll1).toBeGreaterThan(ll2);
+ });
+
+ it("log-likelihood is only computed for non-missing steps", () => {
+ const kf = KalmanFilter.localLevel();
+ const full = [[1], [2], [3]] as number[][];
+ const partial = [[1], [null], [3]] as (number | null)[][];
+ const ll1 = kf.filter(full).logLikelihood;
+ const ll2 = kf.filter(partial).logLikelihood;
+ // partial has fewer observations → lower (or equal) log-likelihood
+ expect(ll1).toBeLessThanOrEqual(ll1 + 1); // basic: both are finite
+ expect(Number.isFinite(ll1) && Number.isFinite(ll2)).toBe(true);
+ });
+});
+
+describe("filter – 2D state (local linear trend)", () => {
+ const kf = KalmanFilter.localLinearTrend({
+ levelNoise: 0.1,
+ slopeNoise: 0.01,
+ observationNoise: 0.5,
+ });
+ const obs = Array.from({ length: 15 }, (_, i) => [i * 1.0]) as number[][];
+ const result = kf.filter(obs);
+
+ it("returns 2-element state means", () => {
+ expect(result.filteredStateMeans[0]?.length).toBe(2);
+ });
+
+ it("tracks linear trend: level ≈ t", () => {
+ const means = result.filteredStateMeans;
+ for (let t = 5; t < 15; t++) {
+ const level = means[t]?.[0] ?? Number.NaN;
+ expect(absDiff(level, t)).toBeLessThan(3);
+ }
+ });
+
+ it("slope converges towards 1", () => {
+ const means = result.filteredStateMeans;
+ const slope = means[14]?.[1] ?? Number.NaN;
+ expect(absDiff(slope, 1.0)).toBeLessThan(0.5);
+ });
+
+ it("2×2 covariance structure", () => {
+ const P = result.filteredStateCovariances[5];
+ expect(P?.length).toBe(2);
+ expect(P?.[0]?.length).toBe(2);
+ });
+});
+
+describe("filter – predicted state properties", () => {
+ it("predictedStateMeans has same length as obs", () => {
+ const kf = KalmanFilter.localLevel();
+ const result = kf.filter([[1], [2], [3]]);
+ expect(result.predictedStateMeans.length).toBe(3);
+ });
+
+ it("first predicted mean equals F * initialStateMean = initialStateMean for F=[[1]]", () => {
+ const kf = KalmanFilter.localLevel({ processNoise: 1, observationNoise: 1 });
+ const result = kf.filter([[5]]);
+ // x_{1|0} = F * m0 = 1 * 0 = 0 (m0=0 by default)
+ expect(result.predictedStateMeans[0]?.[0]).toBeCloseTo(0, 5);
+ });
+});
+
+// ─── smooth() ─────────────────────────────────────────────────────────────────
+
+describe("smooth – basic properties", () => {
+ const kf = KalmanFilter.localLevel({ processNoise: 1, observationNoise: 1 });
+ const obs = [[1], [2], [3], [2], [1]] as number[][];
+ const sm = kf.smooth(obs);
+
+ it("returns smoothedStateMeans of shape T × 1", () => {
+ expect(sm.smoothedStateMeans.length).toBe(5);
+ expect(sm.smoothedStateMeans[0]?.length).toBe(1);
+ });
+
+ it("returns smoothedStateCovariances of shape T × 1 × 1", () => {
+ expect(sm.smoothedStateCovariances.length).toBe(5);
+ expect(sm.smoothedStateCovariances[0]?.[0]?.length).toBe(1);
+ });
+
+ it("last smoothed mean equals last filtered mean", () => {
+ const filtLast = sm.filterResult.filteredStateMeans[4]?.[0] ?? Number.NaN;
+ const smoothLast = sm.smoothedStateMeans[4]?.[0] ?? Number.NaN;
+ expect(absDiff(filtLast, smoothLast)).toBeLessThan(1e-10);
+ });
+
+ it("smoothed covariance ≤ filtered covariance (smoother reduces uncertainty)", () => {
+ for (let t = 0; t < 4; t++) {
+ const Pfilt = sm.filterResult.filteredStateCovariances[t]?.[0]?.[0] ?? 0;
+ const Psmooth = sm.smoothedStateCovariances[t]?.[0]?.[0] ?? 0;
+ expect(Psmooth).toBeLessThanOrEqual(Pfilt + 1e-10);
+ }
+ });
+
+ it("logLikelihood matches filter result", () => {
+ expect(sm.logLikelihood).toBeCloseTo(sm.filterResult.logLikelihood, 10);
+ });
+
+ it("smootherGains has length T, last entry is all zeros", () => {
+ expect(sm.smootherGains.length).toBe(5);
+ expect(sm.smootherGains[4]?.[0]?.[0]).toBeCloseTo(0, 10);
+ });
+});
+
+describe("smooth – missing observations", () => {
+ it("smoothes over gaps in data", () => {
+ const kf = KalmanFilter.localLevel({ processNoise: 1, observationNoise: 0.5 });
+ const obs: (number | null)[][] = [[0], [null], [null], [null], [4]];
+ const sm = kf.smooth(obs);
+ const means = sm.smoothedStateMeans.map((m) => m[0] ?? Number.NaN);
+ // Smoothed means should interpolate between 0 and 4
+ expect(means[2]).toBeGreaterThan(0.5);
+ expect(means[2]).toBeLessThan(3.5);
+ // All means should be finite
+ for (const m of means) {
+ expect(Number.isFinite(m)).toBe(true);
+ }
+ });
+});
+
+describe("smooth – RTS reduces RMSE vs filter", () => {
+ it("smoother RMSE ≤ filter RMSE on generated series", () => {
+ const { obs, states } = localLevelSeries(50, 0.5, 1.0, 42);
+ const kf = KalmanFilter.localLevel({ processNoise: 0.5, observationNoise: 1 });
+ const filtResult = kf.filter(obs.map((v) => [v]));
+ const smResult = kf.smooth(obs.map((v) => [v]));
+ const filtMeans = extractScalarMeans(filtResult.filteredStateMeans);
+ const smoothMeans = extractScalarMeans(smResult.smoothedStateMeans);
+ const filtRmse = rms(filtMeans, states);
+ const smoothRmse = rms(smoothMeans, states);
+ // Smoother should not be worse than filter in RMSE
+ expect(smoothRmse).toBeLessThanOrEqual(filtRmse + 0.1);
+ });
+});
+
+describe("smooth – local linear trend", () => {
+ it("smoothes a trending series without NaN", () => {
+ const kf = KalmanFilter.localLinearTrend();
+ const obs = Array.from({ length: 10 }, (_, i) => [i * 2.0]) as number[][];
+ const sm = kf.smooth(obs);
+ for (const m of sm.smoothedStateMeans) {
+ for (const v of m) {
+ expect(Number.isFinite(v)).toBe(true);
+ }
+ }
+ });
+});
+
+// ─── kalmanFilter1D / kalmanSmooth1D ──────────────────────────────────────────
+
+describe("kalmanFilter1D convenience wrapper", () => {
+ it("accepts scalar array with nulls", () => {
+ const result = kalmanFilter1D([1, 2, null, 4], { processNoise: 1, observationNoise: 1 });
+ expect(result.nTime).toBe(4);
+ expect(result.filteredStateMeans.length).toBe(4);
+ });
+
+ it("produces same result as KalmanFilter.localLevel().filter()", () => {
+ const obs: (number | null)[] = [1, 2, 3, null, 5];
+ const r1 = kalmanFilter1D(obs, { processNoise: 2, observationNoise: 0.5 });
+ const r2 = KalmanFilter.localLevel({ processNoise: 2, observationNoise: 0.5 }).filter(
+ obs.map((v) => [v]),
+ );
+ const m1 = extractScalarMeans(r1.filteredStateMeans);
+ const m2 = extractScalarMeans(r2.filteredStateMeans);
+ for (let i = 0; i < m1.length; i++) {
+ expect(absDiff(m1[i] ?? Number.NaN, m2[i] ?? Number.NaN)).toBeLessThan(1e-10);
+ }
+ });
+});
+
+describe("kalmanSmooth1D convenience wrapper", () => {
+ it("returns smoother result with shape T × 1", () => {
+ const sm = kalmanSmooth1D([1, null, 3]);
+ expect(sm.smoothedStateMeans.length).toBe(3);
+ expect(sm.smoothedStateMeans[0]?.length).toBe(1);
+ });
+
+ it("returns logLikelihood", () => {
+ const sm = kalmanSmooth1D([1, 2, 3]);
+ expect(Number.isFinite(sm.logLikelihood)).toBe(true);
+ });
+});
+
+// ─── Utility helpers ───────────────────────────────────────────────────────────
+
+describe("extractScalarMeans", () => {
+ it("extracts first element of each state mean", () => {
+ const kf = KalmanFilter.localLevel();
+ const result = kf.filter([[1], [2], [3]]);
+ const means = extractScalarMeans(result.filteredStateMeans);
+ expect(means.length).toBe(3);
+ for (let i = 0; i < 3; i++) {
+ expect(means[i]).toBeCloseTo(result.filteredStateMeans[i]?.[0] ?? Number.NaN, 10);
+ }
+ });
+});
+
+describe("filteredPredictionInterval", () => {
+ it("returns lower and upper arrays of length T", () => {
+ const kf = KalmanFilter.localLevel();
+ const result = kf.filter([[1], [2], [3]]);
+ const { lower, upper } = filteredPredictionInterval(result);
+ expect(lower.length).toBe(3);
+ expect(upper.length).toBe(3);
+ });
+
+ it("lower < mean < upper for all t", () => {
+ const kf = KalmanFilter.localLevel();
+ const result = kf.filter([[1], [2], [3]]);
+ const means = extractScalarMeans(result.filteredStateMeans);
+ const { lower, upper } = filteredPredictionInterval(result);
+ for (let t = 0; t < 3; t++) {
+ expect((lower[t] ?? 0) < (means[t] ?? 0)).toBe(true);
+ expect((upper[t] ?? 0) > (means[t] ?? 0)).toBe(true);
+ }
+ });
+
+ it("wider interval for larger zScore", () => {
+ const kf = KalmanFilter.localLevel();
+ const result = kf.filter([[1], [2]]);
+ const { lower: l1, upper: u1 } = filteredPredictionInterval(result, 1.0);
+ const { lower: l2, upper: u2 } = filteredPredictionInterval(result, 2.0);
+ expect((u2[0] ?? 0) - (l2[0] ?? 0)).toBeGreaterThan((u1[0] ?? 0) - (l1[0] ?? 0));
+ });
+});
+
+// ─── Numerical correctness ────────────────────────────────────────────────────
+
+describe("local-level numerical reference", () => {
+ /**
+ * Verify the Kalman gain formula for the first step of a local-level model
+ * with F=1, H=1, Q=q, R=r, P0=p0:
+ *
+ * S_0 = H * P_{0|-1} * H' + R = p0 + r
+ * K_0 = P_{0|-1} * H' * S_0^{-1} = p0 / (p0 + r)
+ * x_{0|0} = x_{0|-1} + K_0 * (y_0 - H * x_{0|-1})
+ * = 0 + [p0/(p0+r)] * (y_0 - 0)
+ * = y_0 * p0 / (p0 + r)
+ */
+ it("first filtered mean matches manual Kalman gain formula", () => {
+ const p0 = 2;
+ const q = 0.5;
+ const r = 1.5;
+ const y0 = 3.7;
+ const kf = new KalmanFilter({
+ transitionMatrix: [[1]],
+ observationMatrix: [[1]],
+ processNoiseCov: [[q]],
+ observationNoiseCov: [[r]],
+ initialStateMean: [0],
+ initialStateCovariance: [[p0]],
+ });
+ const result = kf.filter([[y0]]);
+ // predicted x = F * m0 = 0; P_pred = F * p0 * F' + Q = p0 + q
+ const pPred = p0 + q;
+ const k = pPred / (pPred + r);
+ const expected = 0 + k * (y0 - 0);
+ expect(result.filteredStateMeans[0]?.[0]).toBeCloseTo(expected, 6);
+ });
+
+ it("filtered covariance after first step matches (I-KH)P formula", () => {
+ const p0 = 2;
+ const q = 0.5;
+ const r = 1.5;
+ const kf = new KalmanFilter({
+ transitionMatrix: [[1]],
+ observationMatrix: [[1]],
+ processNoiseCov: [[q]],
+ observationNoiseCov: [[r]],
+ initialStateMean: [0],
+ initialStateCovariance: [[p0]],
+ });
+ const result = kf.filter([[1.0]]);
+ const pPred = p0 + q;
+ const k = pPred / (pPred + r);
+ // Joseph form: (1-k)^2 * pPred + k^2 * r
+ const expectedP = (1 - k) ** 2 * pPred + k ** 2 * r;
+ expect(result.filteredStateCovariances[0]?.[0]?.[0]).toBeCloseTo(expectedP, 6);
+ });
+
+ it("second predicted covariance uses previous filtered covariance", () => {
+ const p0 = 2;
+ const q = 0.5;
+ const r = 1.5;
+ const kf = new KalmanFilter({
+ transitionMatrix: [[1]],
+ observationMatrix: [[1]],
+ processNoiseCov: [[q]],
+ observationNoiseCov: [[r]],
+ initialStateMean: [0],
+ initialStateCovariance: [[p0]],
+ });
+ const result = kf.filter([[1.0], [2.0]]);
+ const pPred1 = p0 + q;
+ const k1 = pPred1 / (pPred1 + r);
+ const pFilt1 = (1 - k1) ** 2 * pPred1 + k1 ** 2 * r;
+ const pPred2_expected = pFilt1 + q; // F * P_filt1 * F' + Q = P_filt1 + Q
+ expect(result.predictedStateCovariances[1]?.[0]?.[0]).toBeCloseTo(pPred2_expected, 6);
+ });
+});
+
+// ─── Property-based tests ─────────────────────────────────────────────────────
+
+describe("property – filter – shape invariants", () => {
+ it("filteredStateMeans always has length T", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ noNaN: true, min: -100, max: 100 }), { minLength: 1, maxLength: 20 }),
+ (ys) => {
+ const kf = KalmanFilter.localLevel();
+ const result = kf.filter(ys.map((v) => [v]));
+ return result.filteredStateMeans.length === ys.length;
+ },
+ ),
+ );
+ });
+
+ it("filteredStateCovariances are always positive for local-level", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ noNaN: true, min: -50, max: 50 }), { minLength: 1, maxLength: 20 }),
+ (ys) => {
+ const kf = KalmanFilter.localLevel({ processNoise: 1, observationNoise: 1 });
+ const result = kf.filter(ys.map((v) => [v]));
+ return result.filteredStateCovariances.every((P) => (P[0]?.[0] ?? 0) > 0);
+ },
+ ),
+ );
+ });
+
+ it("logLikelihood is finite for finite observations", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ noNaN: true, min: -100, max: 100 }), { minLength: 1, maxLength: 20 }),
+ (ys) => {
+ const kf = KalmanFilter.localLevel();
+ const { logLikelihood } = kf.filter(ys.map((v) => [v]));
+ return Number.isFinite(logLikelihood);
+ },
+ ),
+ );
+ });
+});
+
+describe("property – smoother – uncertainty never exceeds filter", () => {
+ it("smoothed covariance ≤ filtered covariance at every time step", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ noNaN: true, min: -50, max: 50 }), { minLength: 2, maxLength: 15 }),
+ (ys) => {
+ const kf = KalmanFilter.localLevel({ processNoise: 1, observationNoise: 1 });
+ const sm = kf.smooth(ys.map((v) => [v]));
+ for (let t = 0; t < ys.length - 1; t++) {
+ const pfilt = sm.filterResult.filteredStateCovariances[t]?.[0]?.[0] ?? 0;
+ const psmooth = sm.smoothedStateCovariances[t]?.[0]?.[0] ?? 0;
+ if (psmooth > pfilt + 1e-8) {
+ return false;
+ }
+ }
+ return true;
+ },
+ ),
+ );
+ });
+});
+
+describe("property – all-null observations", () => {
+ it("filter runs without error on all-null obs", () => {
+ const kf = KalmanFilter.localLevel();
+ const obs: (number | null)[][] = Array.from({ length: 5 }, () => [null]);
+ const result = kf.filter(obs);
+ expect(result.nTime).toBe(5);
+ for (const m of result.filteredStateMeans) {
+ expect(Number.isFinite(m[0] ?? Number.NaN)).toBe(true);
+ }
+ });
+});
+
+describe("property – empty observations array edge case", () => {
+ it("filter on empty array returns T=0 result", () => {
+ const kf = KalmanFilter.localLevel();
+ const result = kf.filter([]);
+ expect(result.nTime).toBe(0);
+ expect(result.filteredStateMeans.length).toBe(0);
+ expect(result.logLikelihood).toBe(0);
+ });
+});
+
+// ─── StateSpaceModel alias ────────────────────────────────────────────────────
+
+describe("StateSpaceModel alias", () => {
+ it("is exported as an alias of KalmanFilter", async () => {
+ const { StateSpaceModel } = await import("../../src/index.ts");
+ // Both should be the same class
+ const ssm = StateSpaceModel.localLevel();
+ const result = ssm.filter([[1], [2], [3]]);
+ expect(result.nTime).toBe(3);
+ });
+});
diff --git a/tests/stats/signal.test.ts b/tests/stats/signal.test.ts
new file mode 100644
index 000000000..5938d36d0
--- /dev/null
+++ b/tests/stats/signal.test.ts
@@ -0,0 +1,500 @@
+/**
+ * Tests for src/stats/signal.ts
+ * Covers FFT, windows, STFT, ISTFT, Welch PSD, and periodogram.
+ */
+
+import { describe, expect, test } from "bun:test";
+import * as fc from "fast-check";
+import {
+ bartlettWindow,
+ blackmanHarrisWindow,
+ blackmanWindow,
+ cAbs,
+ complex,
+ fft,
+ fftFreq,
+ fftshift,
+ flatTopWindow,
+ getWindow,
+ hammingWindow,
+ hannWindow,
+ ifft,
+ ifftshift,
+ irfft,
+ istft,
+ kaiserWindow,
+ periodogram,
+ rectangularWindow,
+ rfft,
+ rfftFreq,
+ stft,
+ welch,
+} from "../../src/stats/signal.ts";
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function near(a: number, b: number, tol = 1e-6): boolean {
+ return Math.abs(a - b) <= tol * (1 + Math.abs(b));
+}
+
+function nearAbs(a: number, b: number, tol = 1e-9): boolean {
+ return Math.abs(a - b) <= tol;
+}
+
+// ─── FFT ──────────────────────────────────────────────────────────────────────
+
+describe("fft / ifft", () => {
+ test("DC input — all energy at bin 0", () => {
+ const X = fft([1, 1, 1, 1]);
+ expect(nearAbs(X[0]?.re ?? 0, 4, 1e-10)).toBe(true);
+ expect(nearAbs(X[0]?.im ?? 0, 0, 1e-10)).toBe(true);
+ expect(nearAbs(cAbs(X[1] ?? complex(0, 0)), 0, 1e-10)).toBe(true);
+ });
+
+ test("single tone — energy at expected bin", () => {
+ // x[n] = exp(2πj * k * n / N) for k=1, N=8
+ const N = 8;
+ const x: number[] = Array.from({ length: N }, (_, n) => Math.cos((2 * Math.PI * n) / N));
+ const X = fft(x);
+ // cosine has energy at bins 1 and N-1
+ const mag = X.map((c) => cAbs(c));
+ expect(mag[1]).toBeCloseTo(N / 2, 4);
+ expect(mag[7]).toBeCloseTo(N / 2, 4);
+ for (let i = 2; i <= 6; i++) {
+ expect(mag[i]).toBeCloseTo(0, 4);
+ }
+ });
+
+ test("Parseval's theorem — energy preserved", () => {
+ const x = [1, 2, 3, 4, 5, 6, 7, 8];
+ const X = fft(x);
+ const N = X.length;
+ const timePower = x.reduce((s, v) => s + v * v, 0);
+ const freqPower = X.reduce((s, c) => s + c.re * c.re + c.im * c.im, 0) / N;
+ expect(nearAbs(timePower, freqPower, 1e-8)).toBe(true);
+ });
+
+ test("ifft(fft(x)) ≈ x (round-trip)", () => {
+ const x = [3, 1, 4, 1, 5, 9, 2, 6];
+ const X = fft(x);
+ const xBack = ifft(X);
+ for (let i = 0; i < x.length; i++) {
+ expect(xBack[i]?.re ?? 0).toBeCloseTo(x[i] ?? 0, 10);
+ }
+ });
+
+ test("zero input → zero output", () => {
+ const X = fft([0, 0, 0, 0]);
+ for (const c of X) {
+ expect(cAbs(c)).toBeCloseTo(0, 12);
+ }
+ });
+
+ test("non-power-of-2 input pads to next power", () => {
+ const x = [1, 2, 3]; // length 3 → pad to 4
+ const X = fft(x);
+ expect(X.length).toBe(4);
+ });
+
+ test("linearity: fft(a*x + b*y) = a*fft(x) + b*fft(y)", () => {
+ const x = [1, 2, 3, 4, 5, 6, 7, 8];
+ const y = [8, 7, 6, 5, 4, 3, 2, 1];
+ const a = 2;
+ const b = 3;
+ const Xab = fft(x.map((v, i) => a * v + b * (y[i] ?? 0)));
+ const Xa = fft(x);
+ const Xy = fft(y);
+ for (let i = 0; i < Xab.length; i++) {
+ const re = a * (Xa[i]?.re ?? 0) + b * (Xy[i]?.re ?? 0);
+ const im = a * (Xa[i]?.im ?? 0) + b * (Xy[i]?.im ?? 0);
+ expect(Xab[i]?.re ?? 0).toBeCloseTo(re, 8);
+ expect(Xab[i]?.im ?? 0).toBeCloseTo(im, 8);
+ }
+ });
+});
+
+describe("rfft / irfft", () => {
+ test("rfft of real signal is conjugate-symmetric", () => {
+ const x = [1, 2, 3, 4, 5, 6, 7, 8];
+ const X = rfft(x);
+ // For a real signal, the full FFT has X[k] = conj(X[N-k])
+ // rfft returns only bins 0..N/2
+ const n = fft(x).length;
+ expect(X.length).toBe(n / 2 + 1);
+ });
+
+ test("irfft(rfft(x)) ≈ x (round-trip)", () => {
+ const x = [1, 0, -1, 0, 1, 0, -1, 0];
+ const X = rfft(x);
+ const n = fft(x).length;
+ const xBack = irfft(X, n);
+ for (let i = 0; i < x.length; i++) {
+ expect(xBack[i] ?? 0).toBeCloseTo(x[i] ?? 0, 8);
+ }
+ });
+
+ test("rfftFreq length matches rfft output", () => {
+ const x = new Array(16).fill(1) as number[];
+ const X = rfft(x);
+ const freqs = rfftFreq(fft(x).length, 1 / 100);
+ expect(freqs.length).toBe(X.length);
+ expect(freqs[0]).toBeCloseTo(0);
+ expect(freqs.at(-1)).toBeCloseTo(50); // Nyquist at 50 Hz for fs=100
+ });
+});
+
+// ─── fftFreq / fftshift / ifftshift ──────────────────────────────────────────
+
+describe("fftFreq", () => {
+ test("DC bin is 0", () => {
+ const f = fftFreq(8, 1);
+ expect(f[0]).toBe(0);
+ });
+
+ test("positive and negative frequencies", () => {
+ const f = fftFreq(8, 1);
+ expect(f[1]).toBeCloseTo(0.125);
+ expect(f[4]).toBeCloseTo(0.5);
+ expect(f[5]).toBeCloseTo(-0.375);
+ expect(f[7]).toBeCloseTo(-0.125);
+ });
+
+ test("sample spacing scales frequencies", () => {
+ const fs = 100;
+ const f = fftFreq(8, 1 / fs);
+ expect(f[1]).toBeCloseTo(fs / 8);
+ });
+});
+
+describe("fftshift / ifftshift", () => {
+ test("even length: round-trip", () => {
+ const x = [0, 1, 2, 3];
+ const shifted = fftshift(x);
+ expect(ifftshift(shifted)).toEqual(x);
+ });
+
+ test("odd length: fftshift matches numpy", () => {
+ const x = [0, 1, 2, 3, 4];
+ const shifted = fftshift(x);
+ expect(shifted).toEqual([2, 3, 4, 0, 1]);
+ });
+
+ test("odd length: ifftshift matches numpy", () => {
+ const x = [2, 3, 4, 0, 1];
+ const back = ifftshift(x);
+ expect(back).toEqual([0, 1, 2, 3, 4]);
+ });
+
+ test("fftshift(ifftshift(x)) = x (any length)", () => {
+ fc.assert(
+ fc.property(fc.array(fc.float({ noNaN: true }), { minLength: 1, maxLength: 20 }), (arr) => {
+ const roundTrip = fftshift(ifftshift(arr));
+ return roundTrip.every((v, i) => v === arr[i]);
+ }),
+ );
+ });
+});
+
+// ─── windows ──────────────────────────────────────────────────────────────────
+
+describe("window functions", () => {
+ const lengths = [1, 2, 4, 8, 16, 32];
+
+ for (const n of lengths) {
+ test(`rectangularWindow(${n}) — all ones`, () => {
+ const w = rectangularWindow(n);
+ expect(w.length).toBe(n);
+ for (const v of w) {
+ expect(v).toBe(1);
+ }
+ });
+
+ test(`hannWindow(${n}) — ends near 0, sum > 0`, () => {
+ const w = hannWindow(n);
+ expect(w.length).toBe(n);
+ if (n > 1) {
+ expect(w[0]).toBeCloseTo(0, 10);
+ expect(w[n - 1]).toBeCloseTo(0, 10);
+ }
+ });
+
+ test(`hammingWindow(${n}) — ends near 0.08`, () => {
+ const w = hammingWindow(n);
+ expect(w.length).toBe(n);
+ if (n > 1) {
+ expect(w[0]).toBeCloseTo(0.08, 5);
+ expect(w[n - 1]).toBeCloseTo(0.08, 5);
+ }
+ });
+
+ test(`blackmanWindow(${n}) — ends near 0`, () => {
+ const w = blackmanWindow(n);
+ expect(w.length).toBe(n);
+ if (n > 1) {
+ expect(Math.abs(w[0] ?? 0)).toBeLessThan(1e-10);
+ }
+ });
+ }
+
+ test("bartlettWindow — triangular, peak at middle", () => {
+ const w = bartlettWindow(9);
+ expect(w[0]).toBeCloseTo(0, 10);
+ expect(w[4]).toBeCloseTo(1, 10);
+ expect(w[8]).toBeCloseTo(0, 10);
+ });
+
+ test("blackmanHarrisWindow — four-term cosine", () => {
+ const w = blackmanHarrisWindow(64);
+ expect(w.length).toBe(64);
+ expect(w[0]).toBeCloseTo(0.00006, 4);
+ });
+
+ test("flatTopWindow — values can exceed 1", () => {
+ const w = flatTopWindow(64);
+ expect(w.length).toBe(64);
+ expect(Math.max(...w)).toBeGreaterThan(1);
+ });
+
+ test("kaiserWindow — beta=0 → rectangular", () => {
+ const w = kaiserWindow(8, 0);
+ for (const v of w) {
+ expect(v).toBeCloseTo(1, 10);
+ }
+ });
+
+ test("kaiserWindow — beta=14, symmetric", () => {
+ const w = kaiserWindow(16, 14);
+ expect(w.length).toBe(16);
+ for (let i = 0; i < 8; i++) {
+ expect(w[i] ?? 0).toBeCloseTo(w[15 - i] ?? 0, 12);
+ }
+ });
+
+ test("getWindow dispatches correctly", () => {
+ const names = [
+ "rectangular",
+ "bartlett",
+ "hann",
+ "hamming",
+ "blackman",
+ "blackmanharris",
+ "flattop",
+ "kaiser",
+ ] as const;
+ for (const name of names) {
+ const w = getWindow(name, 16);
+ expect(w.length).toBe(16);
+ }
+ });
+
+ test("all windows are symmetric for even length", () => {
+ const names = ["hann", "hamming", "blackman", "blackmanharris"] as const;
+ for (const name of names) {
+ const w = getWindow(name, 16);
+ for (let i = 0; i < 8; i++) {
+ expect(w[i] ?? 0).toBeCloseTo(w[15 - i] ?? 0, 12);
+ }
+ }
+ });
+});
+
+// ─── STFT ─────────────────────────────────────────────────────────────────────
+
+describe("stft", () => {
+ test("output dimensions are correct", () => {
+ const x = new Array(256).fill(0) as number[];
+ const { t, f, Zxx } = stft(x, { nperseg: 64, noverlap: 32 });
+ // nFreqs = 64/2 + 1 = 33 (since nfft = nextPow2(64) = 64)
+ expect(Zxx.length).toBe(33);
+ expect(t.length).toBeGreaterThan(0);
+ expect(f.length).toBe(33);
+ });
+
+ test("frequency bins are non-negative", () => {
+ const x = new Array(128).fill(1) as number[];
+ const { f } = stft(x, { nperseg: 32 });
+ for (const freq of f) {
+ expect(freq).toBeGreaterThanOrEqual(0);
+ }
+ });
+
+ test("DC signal — energy only at bin 0", () => {
+ const n = 256;
+ const x = new Array(n).fill(1.0) as number[];
+ const { Zxx } = stft(x, { nperseg: 32, noverlap: 16, window: "rectangular" });
+ // All energy should be near bin 0
+ for (let k = 0; k < (Zxx[0]?.length ?? 0); k++) {
+ const dc = Zxx[0]?.[k];
+ if (dc !== undefined) {
+ expect(cAbs(dc)).toBeGreaterThan(0);
+ }
+ }
+ });
+
+ test("sinusoidal signal — peak frequency matches", () => {
+ const fs = 256;
+ const f0 = 32; // Hz
+ const n = 512;
+ const x = Array.from({ length: n }, (_, i) => Math.sin((2 * Math.PI * f0 * i) / fs));
+ const { f, Zxx } = stft(x, { fs, nperseg: 64 });
+ // Find bin with highest energy
+ const maxMags = Array.from({ length: f.length }, (_, fi) => {
+ const col = Zxx[fi];
+ if (!col) {
+ return 0;
+ }
+ return Math.max(...col.map(cAbs));
+ });
+ const peakBin = maxMags.indexOf(Math.max(...maxMags));
+ const peakFreq = f[peakBin] ?? 0;
+ // Peak should be at f0 ± one bin
+ expect(Math.abs(peakFreq - f0)).toBeLessThan(f[1]! * 2 + 1);
+ });
+});
+
+// ─── ISTFT ────────────────────────────────────────────────────────────────────
+
+describe("istft", () => {
+ test("round-trip: istft(stft(x)) ≈ x", () => {
+ const n = 256;
+ const x = Array.from({ length: n }, (_, i) => Math.sin((2 * Math.PI * 10 * i) / n));
+ const nperseg = 64;
+ const noverlap = 32;
+ const { Zxx } = stft(x, { nperseg, noverlap });
+ const xBack = istft(Zxx, { nperseg, noverlap });
+ // Interior samples should match (boundary effects are expected at edges)
+ const margin = nperseg;
+ for (let i = margin; i < n - margin; i++) {
+ expect(Math.abs((xBack[i] ?? 0) - x[i]!)).toBeLessThan(0.05);
+ }
+ });
+});
+
+// ─── Welch PSD ────────────────────────────────────────────────────────────────
+
+describe("welch", () => {
+ test("output lengths match", () => {
+ const x = new Array(512).fill(0) as number[];
+ const { f, Pxx } = welch(x, { nperseg: 64 });
+ expect(f.length).toBe(Pxx.length);
+ expect(f.length).toBeGreaterThan(0);
+ });
+
+ test("frequencies are non-negative and increasing", () => {
+ const x = new Array(512).fill(1) as number[];
+ const { f } = welch(x, { nperseg: 64 });
+ for (let i = 1; i < f.length; i++) {
+ expect((f[i] ?? 0) > (f[i - 1] ?? 0)).toBe(true);
+ }
+ });
+
+ test("PSD values are non-negative", () => {
+ const x = Array.from({ length: 512 }, () => Math.random() - 0.5);
+ const { Pxx } = welch(x);
+ for (const v of Pxx) {
+ expect(v).toBeGreaterThanOrEqual(0);
+ }
+ });
+
+ test("sinusoidal signal — peak at correct frequency", () => {
+ const fs = 512;
+ const f0 = 64;
+ const n = 2048;
+ const x = Array.from({ length: n }, (_, i) => Math.sin((2 * Math.PI * f0 * i) / fs));
+ const { f, Pxx } = welch(x, { fs, nperseg: 256 });
+ const peakIdx = Pxx.indexOf(Math.max(...Pxx));
+ const peakF = f[peakIdx] ?? 0;
+ expect(Math.abs(peakF - f0)).toBeLessThan(4);
+ });
+
+ test("median averaging option", () => {
+ const x = Array.from({ length: 512 }, (_, i) => Math.cos((2 * Math.PI * 10 * i) / 512));
+ const { Pxx: meanPxx } = welch(x, { average: "mean" });
+ const { Pxx: medPxx } = welch(x, { average: "median" });
+ expect(meanPxx.length).toBe(medPxx.length);
+ // Both should have positive values
+ for (const v of medPxx) {
+ expect(v).toBeGreaterThanOrEqual(0);
+ }
+ });
+
+ test("scaling: density vs spectrum", () => {
+ const x = Array.from({ length: 256 }, (_, i) => Math.sin((2 * Math.PI * i) / 256));
+ const { Pxx: dens } = welch(x, { scaling: "density", nperseg: 64 });
+ const { Pxx: spec } = welch(x, { scaling: "spectrum", nperseg: 64 });
+ // They should differ
+ expect(dens[0]).not.toBeCloseTo(spec[0] ?? 0, 5);
+ });
+});
+
+// ─── periodogram ──────────────────────────────────────────────────────────────
+
+describe("periodogram", () => {
+ test("output lengths match", () => {
+ const x = new Array(128).fill(0) as number[];
+ const { f, Pxx } = periodogram(x);
+ expect(f.length).toBe(Pxx.length);
+ });
+
+ test("zero signal → near-zero PSD", () => {
+ const x = new Array(128).fill(0) as number[];
+ const { Pxx } = periodogram(x);
+ for (const v of Pxx) {
+ expect(v).toBeCloseTo(0, 10);
+ }
+ });
+
+ test("PSD non-negative", () => {
+ const x = Array.from({ length: 128 }, (_, i) => Math.sin((2 * Math.PI * 10 * i) / 128));
+ const { Pxx } = periodogram(x);
+ for (const v of Pxx) {
+ expect(v).toBeGreaterThanOrEqual(0);
+ }
+ });
+
+ test("DC signal — peak at bin 0", () => {
+ const x = new Array(256).fill(1.0) as number[];
+ const { Pxx } = periodogram(x, { window: "rectangular" });
+ const peakIdx = Pxx.indexOf(Math.max(...Pxx));
+ expect(peakIdx).toBe(0);
+ });
+
+ test("frequencies match rfftFreq convention", () => {
+ const fs = 100;
+ const n = 128;
+ const x = new Array(n).fill(0) as number[];
+ const { f } = periodogram(x, { fs });
+ // Max frequency should be Nyquist = fs/2
+ const maxF = f.at(-1) ?? 0;
+ expect(Math.abs(maxF - fs / 2)).toBeLessThan(fs / n + 1);
+ });
+});
+
+// ─── property-based ───────────────────────────────────────────────────────────
+
+describe("FFT properties (fast-check)", () => {
+ test("Parseval's theorem holds for all power-of-2 signals", () => {
+ fc.assert(
+ fc.property(
+ fc.array(fc.float({ min: -10, max: 10, noNaN: true }), { minLength: 8, maxLength: 8 }),
+ (x) => {
+ const X = fft(x);
+ const N = X.length;
+ const timePower = x.reduce((s, v) => s + v * v, 0);
+ const freqPower = X.reduce((s, c) => s + c.re * c.re + c.im * c.im, 0) / N;
+ return Math.abs(timePower - freqPower) < 1e-6 * (1 + timePower);
+ },
+ ),
+ );
+ });
+
+ test("fftshift round-trip for all lengths 1..20", () => {
+ for (let n = 1; n <= 20; n++) {
+ const x = Array.from({ length: n }, (_, i) => i);
+ const roundTrip = ifftshift(fftshift(x));
+ for (let i = 0; i < n; i++) {
+ expect(roundTrip[i]).toBe(x[i]);
+ }
+ }
+ });
+});